feat: add injection metadata fields to telemetry forwarder (#6203)

Author: sydney-tung

integration-tests/helpers/index.js

@@ -113,7 +113,10 @@ function assertTelemetryPoints (pid, msgs, expectedTelemetryPoints) {
       runtime_name: 'nodejs',
       runtime_version: process.versions.node,
       tracer_version: require('../../package.json').version,
-      pid: Number(pid)
+      pid: Number(pid),
+      result: 'unknown',
+      result_reason: 'unknown',
+      result_class: 'unknown'
     }
   }
 }

packages/dd-trace/src/guardrails/telemetry.js

@@ -22,7 +22,10 @@ var metadata = {
   runtime_name: 'nodejs',
   runtime_version: process.versions.node,
   tracer_version: tracerVersion,
-  pid: process.pid
+  pid: process.pid,
+  result: 'unknown',
+  result_reason: 'unknown',
+  result_class: 'unknown'
 }
 
 var seen = {}
@@ -64,14 +67,27 @@ function sendTelemetry (name, tags) {
   })
   proc.on('error', function () {
     log.error('Failed to spawn telemetry forwarder')
+    metadata.result = 'error'
+    metadata.result_class = 'internal_error'
+    metadata.result_reason = 'Failed to spawn telemetry forwarder'
   })
   proc.on('exit', function (code) {
-    if (code !== 0) {
+    if (code === 0) {
+      metadata.result = 'success'
+      metadata.result_class = 'success'
+      metadata.result_reason = 'Successfully configured ddtrace package'
+    } else {
       log.error('Telemetry forwarder exited with code', code)
+      metadata.result = 'error'
+      metadata.result_class = 'internal_error'
+      metadata.result_reason = 'Telemetry forwarder exited with code ' + code
     }
   })
   proc.stdin.on('error', function () {
     log.error('Failed to write telemetry data to telemetry forwarder')
+    metadata.result = 'error'
+    metadata.result_class = 'internal_error'
+    metadata.result_reason = 'Failed to write telemetry data to telemetry forwarder'
   })
   proc.stdin.end(JSON.stringify({ metadata: metadata, points: points }))
 }

packages/dd-trace/test/guardrails/telemetry.spec.js

@@ -2,6 +2,8 @@
 
 process.env.DD_INJECTION_ENABLED = 'true'
 
+const proxyquire = require('proxyquire')
+const { EventEmitter } = require('events')
 const { telemetryForwarder, assertTelemetryPoints } = require('../../../../integration-tests/helpers')
 
 describe('sendTelemetry', () => {
@@ -16,7 +18,7 @@ describe('sendTelemetry', () => {
 
   beforeEach(() => {
     cleanup = telemetryForwarder()
-    sendTelemetry = proxyquire('../src/guardrails/telemetry', {})
+    sendTelemetry = proxyquire('../../src/guardrails/telemetry', {})
   })
 
   it('should send telemetry', async () => {
@@ -68,4 +70,99 @@ describe('sendTelemetry', () => {
       assertTelemetryPoints(process.pid, msgs, ['abort.integration', '1'])
     })
   })
+
+  describe('Error scenarios and metadata', () => {
+    let mockProc, telemetryModule, capturedStdinData
+
+    function createMockProcess () {
+      const proc = new EventEmitter()
+      proc.stdin = new EventEmitter()
+      proc.stdin.end = (data) => {
+        capturedStdinData = data
+      }
+      return proc
+    }
+
+    function loadTelemetryModuleWithMockProc () {
+      return proxyquire('../../src/guardrails/telemetry', {
+        child_process: { spawn: () => mockProc }
+      })
+    }
+
+    function runTelemetry (eventType, value) {
+      const originalStringify = JSON.stringify
+      JSON.stringify = function (obj) {
+        if (obj && obj.metadata && obj.points) {
+          if (eventType === 'spawn-error') {
+            mockProc.emit('error', new Error(value))
+          } else if (eventType === 'exit') {
+            mockProc.emit('exit', value)
+          } else if (eventType === 'stdin-error') {
+            mockProc.stdin.emit('error', new Error(value))
+          }
+        }
+        return originalStringify.apply(this, arguments)
+      }
+
+      try {
+        telemetryModule([{ name: 'test', tags: [] }])
+      } finally {
+        JSON.stringify = originalStringify
+      }
+    }
+
+    function assertStdinMetadata (expected) {
+      expect(capturedStdinData).to.exist
+      const parsed = JSON.parse(capturedStdinData)
+      expect(parsed.metadata.result).to.equal(expected.result)
+      expect(parsed.metadata.result_class).to.equal(expected.result_class)
+      expect(parsed.metadata.result_reason).to.equal(expected.result_reason)
+    }
+
+    beforeEach(() => {
+      mockProc = createMockProcess()
+      capturedStdinData = null
+      telemetryModule = loadTelemetryModuleWithMockProc()
+    })
+
+    it('should set error metadata when telemetry forwarder fails to spawn', () => {
+      runTelemetry('spawn-error', 'Spawn failed')
+
+      assertStdinMetadata({
+        result: 'error',
+        result_class: 'internal_error',
+        result_reason: 'Failed to spawn telemetry forwarder'
+      })
+    })
+
+    it('should set error metadata when telemetry forwarder exits with non-zero code', () => {
+      runTelemetry('exit', 1)
+
+      assertStdinMetadata({
+        result: 'error',
+        result_class: 'internal_error',
+        result_reason: 'Telemetry forwarder exited with code 1'
+      })
+    })
+
+    it('should set error metadata when writing to telemetry forwarder fails', () => {
+      runTelemetry('stdin-error', 'Write failed')
+
+      assertStdinMetadata({
+        result: 'error',
+        result_class: 'internal_error',
+        result_reason: 'Failed to write telemetry data to telemetry forwarder'
+      })
+    })
+
+    it('should set success metadata when telemetry forwarder exits successfully', () => {
+      runTelemetry('exit', 0)
+
+      assertStdinMetadata({
+        result: 'success',
+        result_class: 'success',
+        result_reason: 'Successfully configured ddtrace package'
+      })
+    })
+  })
 })