dd-trace 5.65.0 → 5.67.0

package/index.d.ts

@@ -2566,6 +2566,25 @@ declare namespace tracer {
       annotate (options: llmobs.AnnotationOptions): void
       annotate (span: tracer.Span | undefined, options: llmobs.AnnotationOptions): void
 
+      /**
+       * Register a processor to be called on each LLMObs span.
+       *
+       * This can be used to modify the span before it is sent to LLMObs. For example, you can modify the input/output.
+       * You can also return `null` to omit the span entirely from being sent to LLM Observability.
+       *
+       * Otherwise, if the return value from the processor is not an instance of `LLMObservabilitySpan`, the span will be dropped.
+       *
+       * To deregister the processor, call `llmobs.deregisterProcessor()`
+       * @param processor A function that will be called for each span.
+       * @throws {Error} If a processor is already registered.
+       */
+      registerProcessor (processor: ((span: LLMObservabilitySpan) => LLMObservabilitySpan | null)): void
+
+      /**
+       * Deregister a processor.
+       */
+      deregisterProcessor (): void
+
       /**
        * Submits a custom evaluation metric for a given span ID and trace ID.
        * @param spanContext The span context of the span to submit the evaluation metric for.
@@ -2579,6 +2598,25 @@ declare namespace tracer {
       flush (): void
     }
 
+    interface LLMObservabilitySpan {
+      /**
+       * The input content associated with the span.
+       */
+      input: { content: string, role?: string }[]
+
+      /**
+       * The output content associated with the span.
+       */
+      output: { content: string, role?: string }[]
+
+      /**
+       * Get a tag from the span.
+       * @param key The key of the tag to get.
+       * @returns The value of the tag, or `undefined` if the tag does not exist.
+       */
+      getTag (key: string): string | undefined
+    }
+
     interface EvaluationOptions {
       /**
        * The name of the evaluation metric

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.65.0",
+  "version": "5.67.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -12,8 +12,8 @@
     "dependencies:dedupe": "yarn-deduplicate yarn.lock",
     "type:doc": "cd docs && yarn && yarn build",
     "type:test": "cd docs && yarn && yarn test",
-    "lint": "node scripts/check_licenses.js && eslint . --max-warnings 0",
-    "lint:fix": "node scripts/check_licenses.js && eslint . --max-warnings 0 --fix",
+    "lint": "node scripts/check_licenses.js && eslint . --concurrency=auto --max-warnings 0",
+    "lint:fix": "node scripts/check_licenses.js && eslint . --concurrency=auto --max-warnings 0 --fix",
     "lint:inspect": "npx @eslint/config-inspector@latest",
     "release:proposal": "node scripts/release/proposal",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
@@ -25,7 +25,7 @@
     "test:debugger": "mocha -r 'packages/dd-trace/test/setup/mocha.js' 'packages/dd-trace/test/debugger/**/*.spec.js'",
     "test:debugger:ci": "nyc --no-clean --include 'packages/dd-trace/src/debugger/**/*.js' -- npm run test:debugger",
     "test:eslint-rules": "node eslint-rules/*.test.mjs",
-    "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,datastreams,encode,exporters,opentelemetry,opentracing,plugins,remote_config,service-naming,standalone,telemetry}/**/*.spec.js\"",
+    "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,datastreams,encode,exporters,opentelemetry,opentracing,plugins,remote_config,service-naming,standalone,telemetry,external-logger}/**/*.spec.js\"",
     "test:trace:core:ci": "npm run test:trace:core -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/**/*.js\"",
     "test:trace:guardrails": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/dd-trace/test/guardrails/**/*.spec.js\"",
     "test:trace:guardrails:ci": "nyc --no-clean --include \"packages/dd-trace/src/guardrails/**/*.js\" -- npm run test:trace:guardrails",
@@ -114,10 +114,10 @@
   ],
   "dependencies": {
     "@datadog/libdatadog": "0.7.0",
-    "@datadog/native-appsec": "10.1.0",
+    "@datadog/native-appsec": "10.2.1",
     "@datadog/native-iast-taint-tracking": "4.0.0",
     "@datadog/native-metrics": "3.1.1",
-    "@datadog/pprof": "5.9.0",
+    "@datadog/pprof": "5.10.0",
     "@datadog/sketches-js": "2.1.1",
     "@datadog/wasm-js-rewriter": "4.0.1",
     "@isaacs/ttlcache": "^1.4.1",
@@ -138,7 +138,7 @@
     "mutexify": "^1.4.0",
     "opentracing": ">=0.14.7",
     "path-to-regexp": "^0.1.12",
-    "pprof-format": "^2.1.0",
+    "pprof-format": "^2.1.1",
     "protobufjs": "^7.5.3",
     "retry": "^0.13.1",
     "rfdc": "^1.4.1",
@@ -177,7 +177,7 @@
     "nock": "^13.5.6",
     "nyc": "^15.1.0",
     "octokit": "^5.0.3",
-    "proxyquire": "^1.8.0",
+    "proxyquire": "^2.1.3",
     "rimraf": "^3.0.2",
     "semver": "^7.7.2",
     "sinon": "^18.0.1",

package/packages/datadog-instrumentations/src/express.js

@@ -67,6 +67,9 @@ addHook({ name: 'express', versions: ['>=4'] }, express => {
   return express
 })
 
+// Express 5 does not rely on router in the same way as v4 and should not be instrumented anymore.
+// It would otherwise produce spans for router and express, and so duplicating them.
+// We now fall back to router instrumentation
 addHook({ name: 'express', versions: ['4'] }, express => {
   shimmer.wrap(express.Router, 'use', wrapRouterMethod)
   shimmer.wrap(express.Router, 'route', wrapRouterMethod)
@@ -74,13 +77,6 @@ addHook({ name: 'express', versions: ['4'] }, express => {
   return express
 })
 
-addHook({ name: 'express', versions: ['>=5.0.0'] }, express => {
-  shimmer.wrap(express.Router.prototype, 'use', wrapRouterMethod)
-  shimmer.wrap(express.Router.prototype, 'route', wrapRouterMethod)
-
-  return express
-})
-
 const queryParserReadCh = channel('datadog:query:read:finish')
 
 function publishQueryParsedAndNext (req, res, next) {

package/packages/datadog-instrumentations/src/graphql.js

@@ -235,14 +235,18 @@ function callInAsyncScope (fn, thisArg, args, abortController, cb) {
   try {
     const result = fn.apply(thisArg, args)
     if (result && typeof result.then === 'function') {
-      // bind callback to this scope
-      result.then(
-        res => cb(null, res),
-        err => cb(err)
+      return result.then(
+        res => {
+          cb(null, res)
+          return res
+        },
+        err => {
+          cb(err)
+          throw err
+        }
       )
-    } else {
-      cb(null, result)
     }
+    cb(null, result)
     return result
   } catch (err) {
     cb(err)

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -136,5 +136,6 @@ module.exports = {
   vm: () => require('../vm'),
   when: () => require('../when'),
   winston: () => require('../winston'),
-  workerpool: () => require('../mocha')
+  workerpool: () => require('../mocha'),
+  ws: () => require('../ws')
 }

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -146,7 +146,11 @@ for (const packageName of names) {
               `error_type:${e.constructor.name}`,
               `integration:${name}`,
               `integration_version:${version}`
-            ])
+            ], {
+              result: 'error',
+              result_class: 'internal_error',
+              result_reason: `Error during instrumentation of ${name}@${version}: ${e.message}`
+            })
           }
           namesAndSuccesses[`${name}@${version}`] = true
         }
@@ -160,7 +164,11 @@ for (const packageName of names) {
         telemetry('abort.integration', [
           `integration:${name}`,
           `integration_version:${version}`
-        ])
+        ], {
+          result: 'abort',
+          result_class: 'incompatible_library',
+          result_reason: `Incompatible integration version: ${name}@${version}`
+        })
         log.info('Found incompatible integration version: %s', nameVersion)
         seenCombo.add(nameVersion)
       }

package/packages/datadog-instrumentations/src/playwright.js

@@ -60,9 +60,15 @@ let testManagementTests = {}
 let isImpactedTestsEnabled = false
 let modifiedTests = {}
 const quarantinedOrDisabledTestsAttemptToFix = []
+let quarantinedButNotAttemptToFixFqns = new Set()
 let rootDir = ''
 const MINIMUM_SUPPORTED_VERSION_RANGE_EFD = '>=1.38.0' // TODO: remove this once we drop support for v5
 
+function getTestFullyQualifiedName (test) {
+  const fullname = getTestFullname(test)
+  return `${test._requireFile} ${fullname}`
+}
+
 function getTestProperties (test) {
   const testName = getTestFullname(test)
   const testSuite = getTestSuitePath(test._requireFile, rootDir)
@@ -327,8 +333,7 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout, isMain
     return
   }
 
-  const testFullName = getTestFullname(test)
-  const testFqn = `${testSuiteAbsolutePath} ${testFullName}`
+  const testFqn = getTestFullyQualifiedName(test)
   const testStatuses = testsToTestStatuses.get(testFqn) || []
 
   if (testStatuses.length === 0) {
@@ -618,19 +623,25 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     if (isTestManagementTestsEnabled && sessionStatus === 'failed') {
       let totalFailedTestCount = 0
       let totalAttemptToFixFailedTestCount = 0
+      let totalPureQuarantinedFailedTestCount = 0
 
-      for (const testStatuses of testsToTestStatuses.values()) {
-        totalFailedTestCount += testStatuses.filter(status => status === 'fail').length
+      for (const [fqn, testStatuses] of testsToTestStatuses.entries()) {
+        const failedCount = testStatuses.filter(status => status === 'fail').length
+        totalFailedTestCount += failedCount
+        if (quarantinedButNotAttemptToFixFqns.has(fqn)) {
+          totalPureQuarantinedFailedTestCount += failedCount
+        }
       }
 
       for (const test of quarantinedOrDisabledTestsAttemptToFix) {
-        const fullname = getTestFullname(test)
-        const fqn = `${test._requireFile} ${fullname}`
-        const testStatuses = testsToTestStatuses.get(fqn)
+        const testFqn = getTestFullyQualifiedName(test)
+        const testStatuses = testsToTestStatuses.get(testFqn)
         totalAttemptToFixFailedTestCount += testStatuses.filter(status => status === 'fail').length
       }
 
-      if (totalFailedTestCount > 0 && totalFailedTestCount === totalAttemptToFixFailedTestCount) {
+      const totalIgnorableFailures = totalAttemptToFixFailedTestCount + totalPureQuarantinedFailedTestCount
+
+      if (totalFailedTestCount > 0 && totalFailedTestCount === totalIgnorableFailures) {
         runAllTestsReturn = 'passed'
       }
     }
@@ -648,6 +659,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
 
     startedSuites = []
     remainingTestsByFile = {}
+    quarantinedButNotAttemptToFixFqns = new Set()
 
     // TODO: we can trick playwright into thinking the session passed by returning
     // 'passed' here. We might be able to use this for both EFD and Test Management tests.
@@ -776,8 +788,12 @@ addHook({
           if (testProperties.disabled || testProperties.quarantined) {
             quarantinedOrDisabledTestsAttemptToFix.push(test)
           }
-        } else if (testProperties.disabled || testProperties.quarantined) {
+        } else if (testProperties.disabled) {
           test.expectedStatus = 'skipped'
+        } else if (testProperties.quarantined) {
+          // Do not skip quarantined tests, let them run and overwrite results post-run if they fail
+          const testFqn = getTestFullyQualifiedName(test)
+          quarantinedButNotAttemptToFixFqns.add(testFqn)
         }
       }
     }

package/packages/datadog-instrumentations/src/prisma.js

@@ -66,23 +66,21 @@ class TracingHelper {
 addHook({ name: '@prisma/client', versions: ['>=6.1.0'] }, (prisma, version) => {
   const tracingHelper = new TracingHelper()
 
-  /*
-    * This is a custom PrismaClient that extends the original PrismaClient
-    * This allows us to grab additional information from the PrismaClient such as DB connection strings
-  */
-  class PrismaClient extends prisma.PrismaClient {
-    constructor (...args) {
-      super(...args)
-
-      const datasources = this._engine?.config.inlineDatasources?.db.url?.value
+  // we need to patch the prototype to get db config since this works for ESM and CJS alike.
+  const originalRequest = prisma.PrismaClient.prototype._request
+  prisma.PrismaClient.prototype._request = function () {
+    if (!tracingHelper.dbConfig) {
+      const inlineDatasources = this._engine?.config.inlineDatasources
+      const overrideDatasources = this._engine?.config.overrideDatasources
+      const datasources = inlineDatasources?.db.url?.value ?? overrideDatasources?.db?.url
       if (datasources) {
         const result = parseDBString(datasources)
         tracingHelper.setDbString(result)
       }
     }
+    return originalRequest.apply(this, arguments)
   }
 
-  prisma.PrismaClient = PrismaClient
   /*
     * This is taking advantage of the built in tracing support from Prisma.
     * The below variable is setting a global tracing helper that Prisma uses

package/packages/datadog-instrumentations/src/ws.js

@@ -0,0 +1,136 @@
+'use strict'
+
+const {
+  addHook,
+  channel
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const tracingChannel = require('dc-polyfill').tracingChannel
+const serverCh = tracingChannel('ws:server:connect')
+const producerCh = tracingChannel('ws:send')
+const receiverCh = tracingChannel('ws:receive')
+const closeCh = tracingChannel('ws:close')
+const emitCh = channel('tracing:ws:server:connect:emit')
+
+function wrapHandleUpgrade (handleUpgrade) {
+  return function () {
+    const [req, socket, , cb] = arguments
+    if (!serverCh.start.hasSubscribers || typeof cb !== 'function') {
+      return handleUpgrade.apply(this, arguments)
+    }
+
+    const ctx = { req, socket }
+
+    arguments[3] = function () {
+      return serverCh.asyncStart.runStores(ctx, () => {
+        try {
+          return cb.apply(this, arguments)
+        } finally {
+          serverCh.asyncEnd.publish(ctx)
+        }
+      }, this, ...arguments)
+    }
+    return serverCh.traceSync(handleUpgrade, ctx, this, ...arguments)
+  }
+}
+
+function wrapSend (send) {
+  return function wrappedSend (...args) {
+    if (!producerCh.start.hasSubscribers) return send.apply(this, arguments)
+
+    const [data, options, cb] = arguments
+
+    const ctx = { data, socket: this._sender._socket }
+
+    return typeof cb === 'function'
+      ? producerCh.traceCallback(send, undefined, ctx, this, data, options, cb)
+      : producerCh.traceSync(send, ctx, this, data, options, cb)
+  }
+}
+
+function createWrapEmit (emit) {
+  return function (title, headers, req) {
+    if (!serverCh.start.hasSubscribers || title !== 'headers') return emit.apply(this, arguments)
+
+    const ctx = { req }
+    ctx.req.resStatus = headers[0].split(' ')[1]
+
+    emitCh.runStores(ctx, () => {
+      try {
+        return emit.apply(this, arguments)
+      } finally {
+        emitCh.publish(ctx)
+      }
+    })
+  }
+}
+
+function createWrappedHandler (handler) {
+  return function wrappedMessageHandler (data, binary) {
+    const byteLength = dataLength(data)
+
+    const ctx = { data, binary, socket: this._sender._socket, byteLength }
+
+    return receiverCh.traceSync(handler, ctx, this, data, binary)
+  }
+}
+
+function wrapListener (originalOn) {
+  return function (eventName, handler) {
+    if (eventName === 'message') {
+      return originalOn.call(this, eventName, createWrappedHandler(handler))
+    }
+    return originalOn.apply(this, arguments)
+  }
+}
+
+function wrapClose (close) {
+  return function (code, data) {
+    // _closeFrameReceived is set to true when receiver receives a close frame from a peer
+    // _closeFrameSent is set to true when a close frame is sent
+    // in the case that a close frame is received and not yet sent then connection is closed by peer
+    // if both are true then the self is sending the close event
+    const isPeerClose = this._closeFrameReceived === true && this._closeFrameSent === false
+
+    const ctx = { code, data, socket: this._sender._socket, isPeerClose }
+
+    return closeCh.traceSync(close, ctx, this, ...arguments)
+  }
+}
+
+addHook({
+  name: 'ws',
+  file: 'lib/websocket-server.js',
+  versions: ['>=8.0.0']
+}, ws => {
+  shimmer.wrap(ws.prototype, 'handleUpgrade', wrapHandleUpgrade)
+  shimmer.wrap(ws.prototype, 'emit', createWrapEmit)
+  return ws
+})
+
+addHook({
+  name: 'ws',
+  file: 'lib/websocket.js',
+  versions: ['>=8.0.0']
+}, ws => {
+  shimmer.wrap(ws.prototype, 'send', wrapSend)
+  shimmer.wrap(ws.prototype, 'on', wrapListener)
+  shimmer.wrap(ws.prototype, 'close', wrapClose)
+  return ws
+})
+
+function detectType (data) {
+  if (typeof Blob !== 'undefined' && data instanceof Blob) return 'Blob'
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) return 'Buffer'
+  if (typeof data === 'string') return 'string'
+  return 'Unknown'
+}
+
+function dataLength (data) {
+  const type = detectType(data)
+  if (type === 'Blob') return data.size
+  if (type === 'Buffer') return data.length
+  if (type === 'string') return Buffer.byteLength(data)
+  return 0
+}

package/packages/datadog-plugin-aws-sdk/src/services/bedrockruntime/utils.js

@@ -149,12 +149,24 @@ function extractRequestParams (params, provider) {
       })
     }
     case PROVIDER.ANTHROPIC: {
-      const prompt = requestBody.prompt || requestBody.messages
+      let prompt = requestBody.prompt
+      if (Array.isArray(requestBody.messages)) { // newer claude models
+        for (let idx = requestBody.messages.length - 1; idx >= 0; idx--) {
+          const message = requestBody.messages[idx]
+          if (message.role === 'user') {
+            prompt = message.content?.filter(block => block.type === 'text')
+              .map(block => block.text)
+              .join('')
+            break
+          }
+        }
+      }
+
       return new RequestParams({
         prompt,
         temperature: requestBody.temperature,
         topP: requestBody.top_p,
-        maxTokens: requestBody.max_tokens_to_sample,
+        maxTokens: requestBody.max_tokens_to_sample ?? requestBody.max_tokens,
         stopSequences: requestBody.stop_sequences
       })
     }
@@ -253,7 +265,13 @@ function extractTextAndResponseReason (response, provider, modelName) {
         break
       }
       case PROVIDER.ANTHROPIC: {
-        return new Generation({ message: body.completion || body.content, finishReason: body.stop_reason })
+        let message = body.completion
+        if (Array.isArray(body.content)) { // newer claude models
+          message = body.content.find(item => item.type === 'text')?.text ?? body.content
+        } else if (body.content) {
+          message = body.content
+        }
+        return new Generation({ message, finishReason: body.stop_reason })
       }
       case PROVIDER.COHERE: {
         if (modelName.includes('embed')) {
@@ -262,6 +280,15 @@ function extractTextAndResponseReason (response, provider, modelName) {
             return new Generation({ message: embeddings[0] })
           }
         }
+
+        if (body.text) {
+          return new Generation({
+            message: body.text,
+            finishReason: body.finish_reason,
+            choiceId: shouldSetChoiceIds ? body.response_id : undefined
+          })
+        }
+
         const generations = body.generations || []
         if (generations.length > 0) {
           const generation = generations[0]

package/packages/datadog-plugin-aws-sdk/src/services/sqs.js

@@ -3,6 +3,7 @@
 const log = require('../../../dd-trace/src/log')
 const BaseAwsSdkPlugin = require('../base')
 const { DsmPathwayCodec, getHeadersSize } = require('../../../dd-trace/src/datastreams')
+const { extractQueueMetadata } = require('../util')
 
 class Sqs extends BaseAwsSdkPlugin {
   static id = 'sqs'
@@ -92,16 +93,18 @@ class Sqs extends BaseAwsSdkPlugin {
 
   generateTags (params, operation, response) {
     if (!params || (!params.QueueName && !params.QueueUrl)) return {}
-    // 'https://sqs.us-east-1.amazonaws.com/123456789012/my-queue';
-    let queueName = params.QueueName
-    if (params.QueueUrl) {
-      queueName = params.QueueUrl.split('/').at(-1)
-    }
+
+    const queueMetadata = extractQueueMetadata(params.QueueUrl)
+    const queueName = queueMetadata?.queueName || params.QueueName
 
     const tags = {
       'resource.name': `${operation} ${params.QueueName || params.QueueUrl}`,
       'aws.sqs.queue_name': params.QueueName || params.QueueUrl,
-      queuename: queueName
+      queuename: queueName,
+    }
+
+    if (queueMetadata?.arn) {
+      tags['cloud.resource_id'] = queueMetadata.arn
     }
 
     switch (operation) {

package/packages/datadog-plugin-aws-sdk/src/util.js

@@ -84,8 +84,68 @@ const extractPrimaryKeys = (keyNames, keyValuePairs) => {
   }
 }
 
+/**
+ * Extracts queue metadata from an SQS queue URL for span tagging.
+ * Handles modern and legacy AWS endpoint formats, with or without schemes.
+ * Automatically detects AWS partitions (standard, China, GovCloud) from region.
+ *
+ * @param {string} queueURL - SQS queue URL in any supported format
+ * @returns {Object|null} Object with queueName and arn, or null if URL format is invalid
+ *
+ * @example
+ * // Modern AWS SQS URLs
+ * extractQueueMetadata('https://sqs.us-east-1.amazonaws.com/123456789012/my-queue')
+ * // Returns { queueName: 'my-queue', arn: 'arn:aws:sqs:us-east-1:123456789012:my-queue' }
+ *
+ * extractQueueMetadata('sqs.eu-west-1.amazonaws.com/123456789012/my-queue') // no scheme
+ * // Returns { queueName: 'my-queue', arn: 'arn:aws:sqs:eu-west-1:123456789012:my-queue' }
+ *
+ * // Legacy AWS SQS URLs
+ * extractQueueMetadata('https://us-west-2.queue.amazonaws.com/123456789012/legacy-queue')
+ * // Returns { queueName: 'legacy-queue', arn: 'arn:aws:sqs:us-west-2:123456789012:legacy-queue' }
+ *
+ * extractQueueMetadata('https://queue.amazonaws.com/123456789012/global-legacy-queue')
+ * // Returns { queueName: 'global-legacy-queue', arn: 'arn:aws:sqs:us-east-1:123456789012:global-legacy-queue' }
+ */
+const extractQueueMetadata = queueURL => {
+  if (!queueURL) {
+    return null
+  }
+
+  const parts = queueURL.split('/').filter(Boolean)
+
+  // Check if URL has scheme
+  const hasScheme = Boolean(parts[0]?.startsWith('http'))
+  const minParts = hasScheme ? 4 : 3
+
+  if (parts.length < minParts) return null
+
+  const accountId = parts[parts.length - 2]
+  const queueName = parts[parts.length - 1]
+  const host = hasScheme ? parts[1] : parts[0]
+
+  let region = 'us-east-1' // Default region if not found in URL
+  if (host.includes('.amazonaws.com') && !host.startsWith('queue')) {
+    // sqs.{region}.amazonaws.com or {region}.queue.amazonaws.com
+    const startFrom = host.startsWith('sqs.') ? 4 : 0
+    const nextDot = host.indexOf('.', startFrom)
+    region = host.slice(startFrom, nextDot)
+  }
+
+  let partition = 'aws'
+  if (region.startsWith('cn-')) {
+    partition = 'aws-cn'
+  } else if (region.startsWith('us-gov')) {
+    partition = 'aws-us-gov'
+  }
+
+  const arn = `arn:${partition}:sqs:${region}:${accountId}:${queueName}`
+  return { queueName, arn }
+}
+
 module.exports = {
   generatePointerHash,
   encodeValue,
-  extractPrimaryKeys
+  extractPrimaryKeys,
+  extractQueueMetadata
 }

package/packages/datadog-plugin-express/src/code_origin.js

@@ -22,6 +22,17 @@ class ExpressCodeOriginForSpansPlugin extends Plugin {
       if (layerTags.has(layer)) return
       layerTags.set(layer, entryTags(topOfStackFunc))
     })
+
+    this.addSub('apm:router:middleware:enter', ({ req, layer }) => {
+      const tags = layerTags.get(layer)
+      if (!tags) return
+      web.getContext(req).span?.addTags(tags)
+    })
+
+    this.addSub('apm:router:route:added', ({ topOfStackFunc, layer }) => {
+      if (layerTags.has(layer)) return
+      layerTags.set(layer, entryTags(topOfStackFunc))
+    })
   }
 }
 

package/packages/datadog-plugin-graphql/src/index.js

@@ -19,6 +19,9 @@ class GraphQLPlugin extends CompositePlugin {
     }
   }
 
+  /**
+   * @override
+   */
   configure (config) {
     return super.configure(validateConfig(config))
   }