dd-trace 5.104.0 → 5.105.0

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

@@ -8,7 +8,6 @@ const { getCompileToRegexp } = require('./path-to-regexp')
 const {
   getRouterMountPaths,
   joinPath,
-  getLayerMatchers,
   setLayerMatchers,
   isAppMounted,
   setRouterMountPath,
@@ -42,34 +41,47 @@ function createWrapRouterMethod (name, compile) {
   const nextChannel = channel(`apm:${name}:middleware:next`)
   const routeAddedChannel = channel(`apm:${name}:route:added`)
 
-  function wrapLayerHandle (layer, original) {
-    original._name = original._name || layer.name
+  function wrapLayerHandle (layer, original, matchers) {
+    // Resolve `name` once at wrap time: cached on the original for any code
+    // that reads `_name`, captured in the closure so the per-call body avoids
+    // the property-lookup / `||` fallback.
+    const name = original._name || layer.name || original.name
+    original._name = name
+
+    // Wrap-time matcher analysis. The single-pattern case yields a constant
+    // route; only multi-pattern stacks need a per-request layer.path match.
+    let captureRoute
+    let needMultiMatch = false
+    if (matchers.length !== 0 && !isFastStar(layer, matchers) && !isFastSlash(layer, matchers)) {
+      if (matchers.length === 1) {
+        captureRoute = matchers[0].path
+      } else {
+        needMultiMatch = true
+      }
+    }
 
-    return shimmer.wrapFunction(original, original => function (...args) {
-      if (!enterChannel.hasSubscribers) return original.apply(this, args)
+    // Split by arity: router only ever dispatches 3-arg request handlers
+    // through `Layer.handleRequest` and 4-arg error handlers through
+    // `Layer.handleError`. Specialising lets the per-call body use named
+    // parameters and `.call`, avoiding the rest-spread Array allocation that
+    // the unified shape forced on every middleware invocation.
+    return original.length === 4
+      ? shimmer.wrapFunction(original, errorHandlerLayerWrap(layer, name, captureRoute, needMultiMatch, matchers))
+      : shimmer.wrapFunction(original, requestHandlerLayerWrap(layer, name, captureRoute, needMultiMatch, matchers))
+  }
 
-      const matchers = getLayerMatchers(layer)
-      const lastIndex = args.length - 1
-      const name = original._name || original.name
-      const req = args[args.length > 3 ? 1 : 0]
-      const next = args[lastIndex]
+  function requestHandlerLayerWrap (layer, name, captureRoute, needMultiMatch, matchers) {
+    return original => function (req, res, next) {
+      if (!enterChannel.hasSubscribers) return original.call(this, req, res, next)
 
-      if (typeof next === 'function') {
-        args[lastIndex] = wrapNext(req, next)
-      }
+      const wrappedNext = typeof next === 'function' ? wrapNext(req, next) : next
 
-      let route
-
-      if (matchers?.length && !isFastStar(layer, matchers) && !isFastSlash(layer, matchers)) {
-        if (matchers.length === 1) {
-          // The host already matched this layer; the lone pattern is the route.
-          route = matchers[0].path
-        } else {
-          for (const matcher of matchers) {
-            if (matcher.regex?.test(layer.path)) {
-              route = matcher.path
-              break
-            }
+      let route = captureRoute
+      if (needMultiMatch) {
+        for (const matcher of matchers) {
+          if (matcher.regex?.test(layer.path)) {
+            route = matcher.path
+            break
           }
         }
       }
@@ -77,7 +89,7 @@ function createWrapRouterMethod (name, compile) {
       enterChannel.publish({ name, req, route, layer })
 
       try {
-        return original.apply(this, args)
+        return original.call(this, req, res, wrappedNext)
       } catch (error) {
         errorChannel.publish({ req, error })
         nextChannel.publish({ req })
@@ -87,15 +99,47 @@ function createWrapRouterMethod (name, compile) {
       } finally {
         exitChannel.publish({ req })
       }
-    })
+    }
+  }
+
+  function errorHandlerLayerWrap (layer, name, captureRoute, needMultiMatch, matchers) {
+    return original => function (error, req, res, next) {
+      if (!enterChannel.hasSubscribers) return original.call(this, error, req, res, next)
+
+      const wrappedNext = typeof next === 'function' ? wrapNext(req, next) : next
+
+      let route = captureRoute
+      if (needMultiMatch) {
+        for (const matcher of matchers) {
+          if (matcher.regex?.test(layer.path)) {
+            route = matcher.path
+            break
+          }
+        }
+      }
+
+      enterChannel.publish({ name, req, route, layer })
+
+      try {
+        return original.call(this, error, req, res, wrappedNext)
+      } catch (caught) {
+        errorChannel.publish({ req, error: caught })
+        nextChannel.publish({ req })
+        finishChannel.publish({ req })
+
+        throw caught
+      } finally {
+        exitChannel.publish({ req })
+      }
+    }
   }
 
   function wrapStack (layers, matchers) {
     for (const layer of layers) {
       if (layer.__handle) { // express-async-errors
-        layer.__handle = wrapLayerHandle(layer, layer.__handle)
+        layer.__handle = wrapLayerHandle(layer, layer.__handle, matchers)
       } else {
-        layer.handle = wrapLayerHandle(layer, layer.handle)
+        layer.handle = wrapLayerHandle(layer, layer.handle, matchers)
       }
 
       setLayerMatchers(layer, matchers)
@@ -258,15 +302,15 @@ addHook({ name: 'router', versions: ['>=2'] }, Router => {
 
       shimmer.wrap(router, 'handle', function wrapHandle (originalHandle) {
         return function wrappedHandle (req, res, next) {
-          const abortController = new AbortController()
-
           if (queryParserReadCh.hasSubscribers && req) {
+            const abortController = new AbortController()
+
             queryParserReadCh.publish({ req, res, query: req.query, abortController })
 
             if (abortController.signal.aborted) return
           }
 
-          return originalHandle.apply(this, arguments)
+          return originalHandle.call(this, req, res, next)
         }
       })
 

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

@@ -97,7 +97,7 @@ function wrapStripe (Stripe) {
 
 addHook({
   name: 'stripe',
-  versions: ['9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '>=20.0.0 <22'],
+  versions: ['>=9 <22'],
 }, Stripe => shimmer.wrapFunction(Stripe, wrapLegacyStripe))
 
 addHook({

package/packages/datadog-plugin-avsc/src/schema_iterator.js

@@ -140,7 +140,7 @@ class SchemaExtractor {
       return
     }
 
-    if (span.context()._tags[SCHEMA_TYPE] && operation === 'serialization') {
+    if (span.context().getTag(SCHEMA_TYPE) && operation === 'serialization') {
       // we have already added a schema to this span, this call is an encode of nested schema types
       return
     }

package/packages/datadog-plugin-azure-cosmos/src/index.js

@@ -0,0 +1,144 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+
+class AzureCosmosPlugin extends DatabasePlugin {
+  static id = 'azure-cosmos'
+  // Channel prefix determines how the plugin subscribes to instrumentation events.
+  // Three patterns exist — set `static prefix` explicitly based on instrumentation type:
+  //
+  // Orchestrion:              static prefix = 'tracing:orchestrion:<npm-package>:<channelName>'
+  // Shimmer + tracingChannel: static prefix = 'tracing:apm:<name>:<operation>'
+  // Shimmer + manual channels: omit prefix — defaults to `apm:${id}:${operation}`
+  static prefix = 'tracing:orchestrion:@azure/cosmos:executePlugins'
+  static peerServicePrecursors = ['db.name']
+
+  operationName () {
+    return 'cosmosdb.query'
+  }
+
+  asyncEnd (ctx) {
+    if (!ctx.span) return
+    const span = ctx.currentStore?.span
+    if (span) {
+      const result = ctx.result
+      if (result?.code) span.setTag('db.response.status_code', (result.code).toString())
+      if (result?.substatus) span.setTag('cosmosdb.response.sub_status_code', result.substatus)
+      span.finish()
+    }
+  }
+
+  error (ctx) {
+    if (!ctx.span) return
+    const span = ctx.currentStore?.span
+    if (span) {
+      const error = ctx.error
+      this.addError(error, span)
+      if (error?.code) span.setTag('db.response.status_code', (error.code).toString())
+      if (error?.substatus) span.setTag('cosmosdb.response.sub_status_code', error.substatus)
+    }
+  }
+
+  bindStart (ctx) {
+    const requestContext = ctx.arguments[1]
+    const resource = this.getResource(requestContext)
+    const { dbName, containerName } = this.getDbInfo(requestContext)
+    const connectionMode = this.getConnectionMode(requestContext)
+    const { outHost, userAgent } = this.getHttpInfo(requestContext)
+    const pluginOn = ctx.arguments[3]
+
+    if (pluginOn != null && requestContext.operationType != null && requestContext.resourceType != null) {
+      const operationType = requestContext.operationType
+      const resourceType = requestContext.resourceType
+      // only trace operations not requests (pluginOn)
+      // trace requests only if they are read or query operations not on docs
+      // prevents doubled read spans for createIfNotExists calls
+      if (pluginOn === 'request' && ((operationType !== 'read' && operationType !== 'query') ||
+        (operationType === 'read' && resourceType !== 'docs'))) {
+        return storage('legacy').getStore()
+      }
+
+      // separately, skip tracing read requests without a path, these don't
+      // represent CRUD operations on a resource we care about
+      // not returning current store because we don't want the child http.request spans
+      // to be created
+      if (operationType === 'read' && requestContext.path === '') {
+        return { noop: true }
+      }
+    }
+
+    const span = this.startSpan(this.operationName(), {
+      resource,
+      type: 'cosmosdb',
+      kind: 'client',
+      meta: {
+        component: 'azure_cosmos',
+        'db.system': 'cosmosdb',
+        'db.name': dbName,
+        'cosmosdb.container': containerName,
+        'cosmosdb.connection.mode': connectionMode,
+        'http.useragent': userAgent,
+        'out.host': outHost,
+      },
+    }, ctx)
+
+    ctx.span = span
+    return ctx.currentStore
+  }
+
+  getResource (requestContext) {
+    const path = requestContext.path
+    const parts = path.split('/')
+    let modified = false
+    for (let i = 2; i < parts.length; i += 2) {
+      if (parts[i].length > 0 && parts[i - 1] !== 'dbs' && parts[i - 1] !== 'colls') {
+        parts[i] = '?'
+        modified = true
+      }
+    }
+
+    return `${requestContext.operationType} ${modified ? parts.join('/') : path}`
+  }
+
+  getDbInfo (requestContext) {
+    let dbName = null
+    let containerName = null
+
+    if (requestContext.operationType === 'create' && requestContext.resourceType === 'dbs' &&
+      requestContext.body != null && requestContext.body.id != null) {
+      dbName = requestContext.body.id
+    }
+
+    let resourceLink = requestContext.path
+    if (resourceLink?.length > 1 && resourceLink.startsWith('/')) {
+      resourceLink = resourceLink.slice(1)
+      const parts = resourceLink.split('/')
+      if (parts.length > 0 && parts[0].toLowerCase() === 'dbs' && parts.length >= 2) {
+        dbName = parts[1]
+        if (parts.length >= 4 && parts[2].toLowerCase() === 'colls' && parts[3] !== '') {
+          containerName = parts[3]
+        }
+      }
+    }
+
+    return { dbName, containerName }
+  }
+
+  getConnectionMode (requestContext) {
+    const mode = requestContext.client?.connectionPolicy?.connectionMode
+    if (mode === 0) {
+      return 'gateway'
+    }
+    return 'direct'
+  }
+
+  getHttpInfo (requestContext) {
+    const outHost = requestContext.client?.cosmosClientOptions?.endpoint
+    const userAgent = requestContext.headers?.['User-Agent']
+    return { outHost, userAgent }
+  }
+}
+
+module.exports = AzureCosmosPlugin

package/packages/datadog-plugin-azure-event-hubs/src/producer.js

@@ -62,7 +62,7 @@ class AzureEventHubsProducerPlugin extends ProducerPlugin {
         const contexts = spanContexts.get(eventData)
         if (contexts) {
           for (const spanContext of contexts) {
-            span.addLink(spanContext)
+            span.addLink({ context: spanContext })
           }
         }
       }

package/packages/datadog-plugin-azure-functions/src/index.js

@@ -13,6 +13,7 @@ const triggerMap = {
   serviceBusQueue: 'ServiceBus',
   serviceBusTopic: 'ServiceBus',
   eventHub: 'EventHubs',
+  cosmosDB: 'CosmosDB',
 }
 
 class AzureFunctionsPlugin extends TracingPlugin {
@@ -53,7 +54,7 @@ class AzureFunctionsPlugin extends TracingPlugin {
       )
 
       span._integrationName = 'azure-functions'
-      span.context()._tags.component = 'azure-functions'
+      span.context().setTag('component', 'azure-functions')
       span.addTags(meta)
       webContext.span = span
       webContext.azureFunctionCtx = ctx
@@ -127,6 +128,8 @@ function getMetaForTrigger ({ functionName, methodName, invocationContext }) {
       'resource.name': `EventHubs ${functionName}`,
       'span.kind': 'consumer',
     }
+  } else if (triggerMap[methodName] === 'CosmosDB') {
+    meta['resource.name'] = `CosmosDB ${functionName}`
   }
 
   return meta
@@ -155,7 +158,7 @@ function setSpanLinks (triggerType, tracer, span, ctx) {
     if (!props || Object.keys(props).length === 0) return
     const spanContext = tracer.extract('text_map', props)
     if (spanContext) {
-      span.addLink(spanContext)
+      span.addLink({ context: spanContext })
     }
   }
 

package/packages/datadog-plugin-azure-service-bus/src/producer.js

@@ -56,7 +56,7 @@ class AzureServiceBusProducerPlugin extends ProducerPlugin {
           const contexts = spanContexts.get(messages)
           if (contexts) {
             for (const spanContext of contexts) {
-              span.addLink(spanContext)
+              span.addLink({ context: spanContext })
             }
           }
         }

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

@@ -1,8 +1,36 @@
 'use strict'
 
+const { buildLogHolder } = require('../../dd-trace/src/plugins/log_injection')
 const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
 
 class BunyanPlugin extends LogPlugin {
   static id = 'bunyan'
+
+  constructor (...args) {
+    super(...args)
+    this.addSub('apm:bunyan:log', (arg) => this.handleLog(arg))
+  }
+
+  /**
+   * Inject `dd` directly on the record bunyan hands us. bunyan builds the
+   * record inside `mkRecord` via `objCopy(log.fields)` and then copies the
+   * caller's fields onto the result, so the `rec` object that flows
+   * through `_emit` is always bunyan-owned, has `Object.prototype` for its
+   * prototype, and is never the caller's input directly. Mutating it adds
+   * `dd` for every consumer (JSON streams via `JSON.stringify(rec)`, raw
+   * streams via the record reference) without paying for a Proxy view.
+   *
+   * @param {{ message: object }} arg
+   */
+  handleLog (arg) {
+    const rec = arg.message
+    if (rec === null || typeof rec !== 'object' || Object.hasOwn(rec, 'dd')) return
+
+    const logHolder = buildLogHolder(this.tracer)
+    if (!logHolder) return
+
+    rec.dd = logHolder.dd
+  }
 }
+
 module.exports = BunyanPlugin

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

@@ -11,6 +11,7 @@ const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const {
   addIntelligentTestRunnerSpanTags,
   finishAllTraceSpans,
+  getRelativeCoverageFiles,
   getTestEndLine,
   getTestSuiteCommonTags,
   getTestSuitePath,
@@ -71,6 +72,7 @@ class CucumberPlugin extends CiPlugin {
       isSuitesSkipped,
       numSkippedSuites,
       testCodeCoverageLinesTotal,
+      testSessionCoverageFiles,
       hasUnskippableSuites,
       hasForcedToRunSuites,
       isEarlyFlakeDetectionEnabled,
@@ -78,7 +80,11 @@ class CucumberPlugin extends CiPlugin {
       isTestManagementTestsEnabled,
       isParallel,
     }) => {
-      const { isSuitesSkippingEnabled, isCodeCoverageEnabled } = this.libraryConfig || {}
+      const {
+        isSuitesSkippingEnabled,
+        isCodeCoverageEnabled,
+        isCoverageReportUploadEnabled,
+      } = this.libraryConfig || {}
       addIntelligentTestRunnerSpanTags(
         this.testSessionSpan,
         this.testModuleSpan,
@@ -93,6 +99,12 @@ class CucumberPlugin extends CiPlugin {
           hasForcedToRunSuites,
         }
       )
+      if (testSessionCoverageFiles?.length && isCoverageReportUploadEnabled) {
+        this.tracer._exporter.exportCoverage({
+          sessionId: this.testSessionSpan.context()._traceId,
+          files: testSessionCoverageFiles,
+        })
+      }
       if (isEarlyFlakeDetectionEnabled) {
         this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
       }
@@ -197,8 +209,10 @@ class CucumberPlugin extends CiPlugin {
       }
       const testSuiteSpan = this._testSuiteSpansByTestSuite.get(testSuitePath)
 
-      const relativeCoverageFiles = [...coverageFiles, suiteFile]
-        .map(filename => getTestSuitePath(filename, this.repositoryRoot))
+      const relativeCoverageFiles = [
+        ...getRelativeCoverageFiles(coverageFiles, this.repositoryRoot),
+        getTestSuitePath(suiteFile, this.repositoryRoot),
+      ]
 
       this.telemetry.distribution(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, relativeCoverageFiles.length)