[Code Origin] Take source maps into account in stack traces (#6070)

Ensure that the stack traces reported via Code Origin for Spans are
resolved using source maps, if Node.js is running with the
`--enable-source-maps` flag.

Author: watson

eslint.config.mjs

@@ -43,6 +43,7 @@ export default [
       '**/versions', // This is effectively a node_modules tree.
       '**/acmeair-nodejs', // We don't own this.
       '**/vendor', // Generally, we didn't author this code.
+      'integration-tests/code-origin/typescript.js', // Generated
       'integration-tests/debugger/target-app/source-map-support/bundle.js', // Generated
       'integration-tests/debugger/target-app/source-map-support/hello/world.js', // Generated
       'integration-tests/debugger/target-app/source-map-support/minify.min.js', // Generated

integration-tests/code-origin.spec.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const assert = require('node:assert')
+const path = require('node:path')
+const Axios = require('axios')
+const { FakeAgent, spawnProc, createSandbox } = require('./helpers')
+
+describe('Code Origin for Spans', function () {
+  let sandbox, cwd, appFile, agent, proc, axios
+
+  before(async () => {
+    sandbox = await createSandbox(['fastify'])
+    cwd = sandbox.folder
+    appFile = path.join(cwd, 'code-origin', 'typescript.js')
+  })
+
+  after(async () => {
+    await sandbox?.remove()
+  })
+
+  beforeEach(async () => {
+    agent = await new FakeAgent().start()
+    proc = await spawnProc(appFile, {
+      cwd,
+      env: {
+        NODE_OPTIONS: '--enable-source-maps',
+        DD_TRACE_AGENT_URL: `http://localhost:${agent.port}`
+      },
+      stdio: 'pipe',
+    })
+    axios = Axios.create({ baseURL: proc.url })
+  })
+
+  afterEach(async () => {
+    proc?.kill()
+    await agent?.stop()
+  })
+
+  describe('source map support', function () {
+    it('should support source maps', async () => {
+      await Promise.all([
+        agent.assertMessageReceived(({ payload }) => {
+          const [span] = payload.flatMap(p => p.filter(span => span.name === 'fastify.request'))
+          assert.strictEqual(span.meta['_dd.code_origin.type'], 'entry')
+          assert.ok(span.meta['_dd.code_origin.frames.0.file'].endsWith(`${cwd}/code-origin/typescript.ts`))
+          assert.strictEqual(span.meta['_dd.code_origin.frames.0.line'], '10')
+          assert.strictEqual(span.meta['_dd.code_origin.frames.0.column'], '5')
+          assert.strictEqual(span.meta['_dd.code_origin.frames.0.method'], '<anonymous>')
+          assert.strictEqual(span.meta['_dd.code_origin.frames.0.type'], 'Object')
+        }, 2_500),
+        await axios.get('/')
+      ])
+    })
+  })
+})

integration-tests/code-origin/scripts/build-typescript.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env sh
+
+npx --package=typescript -- tsc --sourceMap integration-tests/code-origin/typescript.ts

integration-tests/code-origin/typescript.js

@@ -0,0 +1,17 @@
+require('dd-trace/init')
+
+// @ts-ignore - fastify will be available at runtime
+import Fastify from 'fastify'
+
+const app = Fastify({
+  logger: true
+})
+
+app.get('/', async function handler () {
+  return { hello: 'world' }
+})
+
+app.listen({ port: process.env.APP_PORT || 0 }, (err) => {
+  if (err) throw err
+  process.send?.({ port: app.server.address().port })
+})

integration-tests/code-origin/typescript.js.map

@@ -1,6 +1,6 @@
 'use strict'
 
-const { getUserLandFrames } = require('../dd-trace/src/plugins/util/stacktrace')
+const { parseUserLandFrames } = require('../dd-trace/src/plugins/util/stacktrace')
 
 const ENTRY_SPAN_STACK_FRAMES_LIMIT = 1
 const EXIT_SPAN_STACK_FRAMES_LIMIT = Number(process.env._DD_CODE_ORIGIN_FOR_SPANS_EXIT_SPAN_MAX_USER_FRAMES) || 8
@@ -36,20 +36,25 @@ function exitTags (topOfStackFunc) {
  * @returns {Record<string, string>}
  */
 function tag (type, topOfStackFunc, limit) {
-  const frames = getUserLandFrames(topOfStackFunc, limit)
+  // The `Error.prepareStackTrace` API doesn't support resolving source maps.
+  // Fall back to manually parsing the stack trace.
+  const dummy = {}
+  Error.captureStackTrace(dummy, topOfStackFunc)
+  const frames = parseUserLandFrames(dummy.stack, limit)
+
   const tags = {
     '_dd.code_origin.type': type
   }
   for (let i = 0; i < frames.length; i++) {
     const frame = frames[i]
-    tags[`_dd.code_origin.frames.${i}.file`] = frame.file
-    tags[`_dd.code_origin.frames.${i}.line`] = String(frame.line)
-    tags[`_dd.code_origin.frames.${i}.column`] = String(frame.column)
-    if (frame.method) {
-      tags[`_dd.code_origin.frames.${i}.method`] = frame.method
+    tags[`_dd.code_origin.frames.${i}.file`] = frame.fileName
+    tags[`_dd.code_origin.frames.${i}.line`] = frame.lineNumber
+    tags[`_dd.code_origin.frames.${i}.column`] = frame.columnNumber
+    if (frame.methodName || frame.functionName) {
+      tags[`_dd.code_origin.frames.${i}.method`] = frame.methodName || frame.functionName
     }
-    if (frame.type) {
-      tags[`_dd.code_origin.frames.${i}.type`] = frame.type
+    if (frame.typeName) {
+      tags[`_dd.code_origin.frames.${i}.type`] = frame.typeName
     }
   }
   return tags