collect and propagate process tags in first span of each chunk (#6733)

- collects basic process tags
- tag serializer
- send in first chunk span every time we send traces to the agent
- create DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED=false to configure
- TODO: as a follow-up this should only add tags to the first span of the first chunk of a network request

Author: tlhunter

packages/dd-trace/src/config.js

@@ -454,6 +454,7 @@ class Config {
       DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS,
       DD_ENV,
       DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED,
+      DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED,
       DD_PROFILING_ENABLED,
       DD_GRPC_CLIENT_ERROR_STATUSES,
       DD_GRPC_SERVER_ERROR_STATUSES,
@@ -658,6 +659,7 @@ class Config {
       DD_APM_TRACING_ENABLED ??
         (DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED && isFalse(DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED))
     )
+    this.#setBoolean(target, 'propagateProcessTags.enabled', DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED)
     this.#setString(target, 'appKey', DD_APP_KEY)
     this.#setBoolean(target, 'appsec.apiSecurity.enabled', DD_API_SECURITY_ENABLED && isTrue(DD_API_SECURITY_ENABLED))
     target['appsec.apiSecurity.sampleDelay'] = maybeFloat(DD_API_SECURITY_SAMPLE_DELAY)

packages/dd-trace/src/config_defaults.js

@@ -161,6 +161,7 @@ module.exports = {
   plugins: true,
   port: '8126',
   'profiling.enabled': undefined,
+  'propagateProcessTags.enabled': undefined,
   'profiling.exporters': 'agent',
   'profiling.sourceMap': true,
   'profiling.longLivedThreshold': undefined,

packages/dd-trace/src/process-tags/index.js

@@ -0,0 +1,81 @@
+'use strict'
+
+const path = require('node:path')
+const pkg = require('../pkg')
+
+const CURRENT_WORKING_DIRECTORY = process.cwd()
+const ENTRYPOINT_PATH = require.main?.filename || ''
+
+const TRACING_FIELD_NAME = '_dd.tags.process'
+const DSM_FIELD_NAME = 'ProcessTags'
+const PROFILING_FIELD_NAME = 'process_tags'
+
+module.exports.TRACING_FIELD_NAME = TRACING_FIELD_NAME
+module.exports.DSM_FIELD_NAME = DSM_FIELD_NAME
+module.exports.PROFILING_FIELD_NAME = PROFILING_FIELD_NAME
+
+// TODO CRASH_TRACKING_FIELD_NAME /process_tags /application/process_tags
+// TODO: TELEMETRY_FIELD_NAME /application/process_tags
+// TODO: DYNAMIC_INSTRUMENTATION_FIELD_NAME process_tags
+// TODO: CLIENT_TRACE_STATISTICS_FIELD_NAME process_tags
+// TODO: REMOTE_CONFIG_FIELD_NAME process_tags
+
+// $ cd /foo/bar && node baz/banana.js
+// entrypoint.workdir = bar
+// entrypoint.name = banana
+// entrypoint.type = script
+// entrypoint.basedir = baz
+// package.json.name = <from package.json>
+
+module.exports = function getProcessTags () {
+  // this list is sorted alphabetically for consistent serialization
+  const tags = [
+    // the parent directory name of the entrypoint script, e.g. /foo/bar/baz/banana.js -> baz
+    ['entrypoint.basedir', ENTRYPOINT_PATH === '' ? undefined : path.basename(path.dirname(ENTRYPOINT_PATH))],
+
+    // the entrypoint script filename without the extension, e.g. /foo/bar/baz/banana.js -> banana
+    ['entrypoint.name', path.basename(ENTRYPOINT_PATH, path.extname(ENTRYPOINT_PATH)) || undefined],
+
+    // always script for JavaScript applications
+    ['entrypoint.type', 'script'],
+
+    // last segment of the current working directory, e.g. /foo/bar/baz/ -> baz
+    ['entrypoint.workdir', path.basename(CURRENT_WORKING_DIRECTORY) || undefined],
+
+    // the .name field from the application's package.json
+    ['package.json.name', pkg.name || undefined]
+  ]
+
+  const serialized = serialize(tags)
+
+  return {
+    tags,
+    serialized
+  }
+}
+
+function serialize (tags) {
+  const intermediary = []
+  for (const [name, value] of tags) {
+    // if we don't have a value we should send nothing at all
+    if (value === undefined) continue
+    intermediary.push(`${name}:${sanitize(value)}`)
+  }
+  return intermediary.join(',')
+}
+
+module.exports.serialize = serialize
+
+/**
+ * Sanitize a process tag value
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function sanitize (value) {
+  return String(value)
+    .toLowerCase()
+    .replaceAll(/[^a-zA-Z0-9/_.-]+/g, '_')
+}
+
+module.exports.sanitize = sanitize

packages/dd-trace/src/span_format.js

@@ -5,6 +5,7 @@ const tags = require('../../../ext/tags')
 const id = require('./id')
 const { isError } = require('./util')
 const { registerExtraService } = require('./service-naming/extra-services')
+const { TRACING_FIELD_NAME } = require('./process-tags')
 
 const SAMPLING_PRIORITY_KEY = constants.SAMPLING_PRIORITY_KEY
 const SAMPLING_RULE_DECISION = constants.SAMPLING_RULE_DECISION
@@ -32,13 +33,13 @@ const map = {
   'resource.name': 'resource'
 }
 
-function format (span, isChunkRoot) {
+function format (span, isFirstSpanInChunk = false, tagForFirstSpanInChunk = false) {
   const formatted = formatSpan(span)
 
   extractSpanLinks(formatted, span)
   extractSpanEvents(formatted, span)
   extractRootTags(formatted, span)
-  extractChunkTags(formatted, span, isChunkRoot)
+  extractChunkTags(formatted, span, isFirstSpanInChunk, tagForFirstSpanInChunk)
   extractTags(formatted, span)
 
   return formatted
@@ -192,10 +193,14 @@ function extractRootTags (formattedSpan, span) {
   addTag({}, formattedSpan.metrics, TOP_LEVEL_KEY, 1)
 }
 
-function extractChunkTags (formattedSpan, span, isChunkRoot) {
+function extractChunkTags (formattedSpan, span, isFirstSpanInChunk, tagForFirstSpanInChunk) {
   const context = span.context()
 
-  if (!isChunkRoot) return
+  if (!isFirstSpanInChunk) return
+
+  if (tagForFirstSpanInChunk) {
+    addTag(formattedSpan.meta, formattedSpan.metrics, TRACING_FIELD_NAME, tagForFirstSpanInChunk)
+  }
 
   for (const [key, value] of Object.entries(context._trace.tags)) {
     addTag(formattedSpan.meta, formattedSpan.metrics, key, value)

packages/dd-trace/src/span_processor.js

@@ -5,6 +5,7 @@ const spanFormat = require('./span_format')
 const SpanSampler = require('./span_sampler')
 const GitMetadataTagger = require('./git_metadata_tagger')
 const { getEnvironmentVariable } = require('./config-helper')
+const getProcessTags = require('./process-tags')
 
 const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
@@ -24,6 +25,10 @@ class SpanProcessor {
 
     this._spanSampler = new SpanSampler(config.sampler)
     this._gitMetadataTagger = new GitMetadataTagger(config)
+
+    this._processTags = config.propagateProcessTags?.enabled
+      ? getProcessTags().serialized
+      : false
   }
 
   sample (span) {
@@ -49,14 +54,14 @@ class SpanProcessor {
       this.sample(span)
       this._gitMetadataTagger.tagGitMetadata(spanContext)
 
-      let isChunkRoot = true
+      let isFirstSpanInChunk = true
 
       for (const span of started) {
         if (span._duration === undefined) {
           active.push(span)
         } else {
-          const formattedSpan = spanFormat(span, isChunkRoot)
-          isChunkRoot = false
+          const formattedSpan = spanFormat(span, isFirstSpanInChunk, this._processTags)
+          isFirstSpanInChunk = false
           this._stats?.onSpanFinished(formattedSpan)
           formatted.push(formattedSpan)
         }

packages/dd-trace/src/supported-configurations.json

@@ -71,6 +71,7 @@
     "DD_ENV": ["A"],
     "DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED": ["A"],
     "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED": ["A"],
+    "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED": ["A"],
     "DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_ENABLED": ["A"],
     "DD_EXPERIMENTAL_TEST_OPT_GIT_CACHE_DIR": ["A"],
     "DD_EXTERNAL_ENV": ["A"],