[DI] add process tags to dynamic instrumentation

Author: tlhunter

integration-tests/debugger/basic.spec.js

@@ -800,6 +800,58 @@ describe('Dynamic Instrumentation', function () {
       )
     })
   })
+
+  describe('DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED=true', function () {
+    const t = setup({
+      env: { DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED: 'true' },
+      dependencies: ['fastify']
+    })
+
+    describe('input messages', function () {
+      it('should include process_tags in snapshot when enabled', function (done) {
+        t.agent.on('debugger-input', ({ payload }) => {
+          const snapshot = payload[0].debugger.snapshot
+
+          // Assert that process_tags are present
+          assert.ok(snapshot.process_tags)
+          assert.strictEqual(typeof snapshot.process_tags, 'object')
+
+          // Check for expected process tags keys
+          assert.ok(snapshot.process_tags['entrypoint.name'])
+          assert.ok(snapshot.process_tags['entrypoint.type'])
+          assert.strictEqual(snapshot.process_tags['entrypoint.type'], 'script')
+
+          done()
+        })
+
+        t.triggerBreakpoint()
+        t.agent.addRemoteConfig(t.rcConfig)
+      })
+    })
+  })
+
+  describe('DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED=false', function () {
+    const t = setup({
+      env: { DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED: 'false' },
+      dependencies: ['fastify']
+    })
+
+    describe('input messages', function () {
+      it('should not include process_tags in snapshot when disabled', function (done) {
+        t.agent.on('debugger-input', ({ payload }) => {
+          const snapshot = payload[0].debugger.snapshot
+
+          // Assert that process_tags are not present
+          assert.strictEqual(snapshot.process_tags, undefined)
+
+          done()
+        })
+
+        t.triggerBreakpoint()
+        t.agent.addRemoteConfig(t.rcConfig)
+      })
+    })
+  })
 })
 
 function testBasicInput (t, done) {

packages/dd-trace/src/ci-visibility/dynamic-instrumentation/worker/index.js

@@ -2,6 +2,7 @@
 
 const {
   workerData: {
+    config,
     breakpointSetChannel,
     breakpointHitChannel,
     breakpointRemoveChannel
@@ -21,6 +22,7 @@ const {
   getStackFromCallFrames
 } = require('../../../debugger/devtools_client/state')
 const log = require('../../../log')
+const processTags = require('../../../process-tags')
 
 let sessionStarted = false
 
@@ -55,6 +57,10 @@ session.on('Debugger.paused', async ({ params: { hitBreakpoints: [hitBreakpoint]
     language: 'javascript'
   }
 
+  if (config.propagateProcessTags?.enabled) {
+    snapshot[processTags.DYNAMIC_INSTRUMENTATION_FIELD_NAME] = processTags.tagsObject
+  }
+
   breakpointHitChannel.postMessage({ snapshot })
 })
 

packages/dd-trace/src/debugger/config.js

@@ -8,6 +8,7 @@ module.exports = function getDebuggerConfig (config) {
     hostname: config.hostname,
     logLevel: config.logLevel,
     port: config.port,
+    propagateProcessTags: config.propagateProcessTags,
     repositoryUrl: config.repositoryUrl,
     runtimeId: config.tags['runtime-id'],
     service: config.service,

packages/dd-trace/src/debugger/devtools_client/index.js

@@ -12,6 +12,7 @@ const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./defaults')
 const log = require('./log')
 const { version } = require('../../../../../package.json')
 const { NODE_MAJOR } = require('../../../../../version')
+const processTags = require('../../process-tags')
 
 require('./remote_config')
 
@@ -215,6 +216,10 @@ session.on('Debugger.paused', async ({ params }) => {
       language: 'javascript'
     }
 
+    if (config.propagateProcessTags?.enabled) {
+      snapshot[processTags.DYNAMIC_INSTRUMENTATION_FIELD_NAME] = processTags.tagsObject
+    }
+
     if (probe.captureSnapshot) {
       if (captureErrors?.length > 0) {
         // There was an error collecting the snapshot for this probe, let's not try again

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

@@ -1,33 +1,22 @@
 '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 () {
+// process tags are constant throughout the lifetime of a process
+function getProcessTags () {
+  // Lazy load pkg to avoid issues with require.main during test initialization
+  const pkg = require('../pkg')
+
   // 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
@@ -48,16 +37,36 @@ module.exports = function getProcessTags () {
 
   const serialized = serialize(tags)
 
+  const tagsObject = tags.reduce((acc, [key, value]) => {
+    if (value !== undefined) {
+      acc[key] = value
+    }
+    return acc
+  }, {})
+
   return {
     tags,
-    serialized
+    serialized,
+    tagsObject
   }
 }
 
+// Export the singleton
+module.exports = getProcessTags()
+
+module.exports.TRACING_FIELD_NAME = '_dd.tags.process'
+module.exports.DSM_FIELD_NAME = 'ProcessTags'
+module.exports.PROFILING_FIELD_NAME = 'process_tags'
+module.exports.DYNAMIC_INSTRUMENTATION_FIELD_NAME = 'process_tags'
+
+// TODO: CRASH_TRACKING_FIELD_NAME /process_tags /application/process_tags
+// TODO: TELEMETRY_FIELD_NAME /application/process_tags
+// TODO: CLIENT_TRACE_STATISTICS_FIELD_NAME process_tags
+// TODO: REMOTE_CONFIG_FIELD_NAME process_tags
+
 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)}`)
   }

packages/dd-trace/src/span_processor.js

@@ -5,7 +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 processTags = require('./process-tags')
 
 const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
@@ -27,7 +27,7 @@ class SpanProcessor {
     this._gitMetadataTagger = new GitMetadataTagger(config)
 
     this._processTags = config.propagateProcessTags?.enabled
-      ? getProcessTags().serialized
+      ? processTags.serialized
       : false
   }
 

packages/dd-trace/test/debugger/config.spec.js

@@ -21,6 +21,7 @@ describe('getDebuggerConfig', function () {
       'hostname',
       'logLevel',
       'port',
+      'propagateProcessTags',
       'repositoryUrl',
       'runtimeId',
       'service',

packages/dd-trace/test/process-tags.spec.js

@@ -7,22 +7,34 @@ const { describe, it, beforeEach, afterEach } = require('tap').mocha
 require('./setup/core')
 
 describe('process-tags', () => {
-  const getProcessTags = require('../src/process-tags')
+  const processTags = require('../src/process-tags')
   const { serialize, sanitize } = require('../src/process-tags')
 
-  describe('getProcessTags', () => {
-    it('should return an object with tags and serialized properties', () => {
-      const result = getProcessTags()
+  describe('processTags', () => {
+    it('should return an object with tags, serialized, and tagsObject properties', () => {
+      assert.ok(Object.hasOwn(processTags, 'tags'))
+      assert.ok(Object.hasOwn(processTags, 'serialized'))
+      assert.ok(Object.hasOwn(processTags, 'tagsObject'))
+      assert.ok(Array.isArray(processTags.tags))
+      assert.strictEqual(typeof processTags.serialized, 'string')
+      assert.strictEqual(typeof processTags.tagsObject, 'object')
+    })
+
+    it('should have tagsObject with only defined values', () => {
+      const { tagsObject } = processTags
+
+      // All values in tagsObject should be defined
+      Object.values(tagsObject).forEach(value => {
+        assert.notStrictEqual(value, undefined)
+      })
 
-      assert.ok(Object.hasOwn(result, 'tags'))
-      assert.ok(Object.hasOwn(result, 'serialized'))
-      assert.ok(Array.isArray(result.tags))
-      assert.strictEqual(typeof result.serialized, 'string')
+      // tagsObject should have the same keys as defined tags
+      const definedTags = processTags.tags.filter(([, value]) => value !== undefined)
+      assert.strictEqual(Object.keys(tagsObject).length, definedTags.length)
     })
 
     it('should include all expected tag names', () => {
-      const result = getProcessTags()
-      const tagNames = result.tags.map(([name]) => name).sort()
+      const tagNames = processTags.tags.map(([name]) => name)
 
       assertObjectContains(
         tagNames,
@@ -37,41 +49,56 @@ describe('process-tags', () => {
     })
 
     it('should have entrypoint.type set to "script"', () => {
-      const result = getProcessTags()
-      const typeTag = result.tags.find(([name]) => name === 'entrypoint.type')
+      const typeTag = processTags.tags.find(([name]) => name === 'entrypoint.type')
 
       assert.ok(Array.isArray(typeTag))
       assert.strictEqual(typeTag[1], 'script')
     })
 
     it('should set entrypoint.workdir to the basename of cwd', () => {
-      const result = getProcessTags()
-      const workdirTag = result.tags.find(([name]) => name === 'entrypoint.workdir')
+      const workdirTag = processTags.tags.find(([name]) => name === 'entrypoint.workdir')
 
       assert.ok(Array.isArray(workdirTag))
       assert.strictEqual(typeof workdirTag[1], 'string')
       assert.doesNotMatch(workdirTag[1], /\//)
     })
 
-    // note that these tests may fail if the tracer folder structure changes
-    it('should set sensible values based on tracer project structure and be sorted alphabetically', () => {
-      const result = getProcessTags()
+    it('should set sensible values', () => {
+      const basedirTag = processTags.tags.find(([name]) => name === 'entrypoint.basedir')
+      const nameTag = processTags.tags.find(([name]) => name === 'entrypoint.name')
+      const typeTag = processTags.tags.find(([name]) => name === 'entrypoint.type')
+      const workdirTag = processTags.tags.find(([name]) => name === 'entrypoint.workdir')
+      const packageNameTag = processTags.tags.find(([name]) => name === 'package.json.name')
+
+      // Entrypoint values should be set (may vary depending on test runner)
+      assert.ok(basedirTag)
+      assert.strictEqual(typeof basedirTag[1], 'string')
+      assert.ok(nameTag)
+      assert.strictEqual(typeof nameTag[1], 'string')
+
+      assert.ok(typeTag)
+      assert.strictEqual(typeTag[1], 'script')
+
+      assert.ok(workdirTag)
+      assert.strictEqual(workdirTag[1], 'dd-trace-js')
 
-      assert.deepStrictEqual(result.tags, [
-        ['entrypoint.basedir', 'test'],
-        ['entrypoint.name', 'process-tags.spec'],
-        ['entrypoint.type', 'script'],
-        ['entrypoint.workdir', 'dd-trace-js'],
-        ['package.json.name', 'dd-trace'],
-      ])
+      // Package name should exist but may vary depending on test runner
+      assert.ok(packageNameTag)
+      assert.strictEqual(typeof packageNameTag[1], 'string')
     })
 
-    it('should serialize tags correctly', () => {
-      const result = getProcessTags()
+    it('should sort tags alphabetically', () => {
+      assert.strictEqual(processTags.tags[0][0], 'entrypoint.basedir')
+      assert.strictEqual(processTags.tags[1][0], 'entrypoint.name')
+      assert.strictEqual(processTags.tags[2][0], 'entrypoint.type')
+      assert.strictEqual(processTags.tags[3][0], 'entrypoint.workdir')
+      assert.strictEqual(processTags.tags[4][0], 'package.json.name')
+    })
 
+    it('should serialize tags correctly', () => {
       // serialized should be comma-separated and not include undefined values
-      if (result.serialized) {
-        const parts = result.serialized.split(',')
+      if (processTags.serialized) {
+        const parts = processTags.serialized.split(',')
         assert.ok(parts.length > 0)
         parts.forEach(part => {
           assert.match(part, /:/)
@@ -280,11 +307,16 @@ describe('process-tags', () => {
       process.env = env
       delete require.cache[require.resolve('../src/config')]
       delete require.cache[require.resolve('../src/span_processor')]
+      delete require.cache[require.resolve('../src/process-tags')]
     })
 
     it('should enable process tags propagation when set to true', () => {
       process.env.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED = 'true'
 
+      // Need to reload config first, then process-tags (which reads from config)
+      delete require.cache[require.resolve('../src/config')]
+      delete require.cache[require.resolve('../src/process-tags')]
+
       getConfig = require('../src/config')
       const config = getConfig()