dd-trace 6.3.0 → 6.4.0

package/index.electron.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./packages/dd-trace/index.electron')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -12,7 +12,9 @@
     "bench:e2e:test-optimization": "node benchmark/e2e-test-optimization/benchmark-run.js",
     "dependencies:dedupe": "yarn-deduplicate yarn.lock",
     "generate:config:types": "node scripts/generate-config-types.js",
+    "generate:electron-package": "node scripts/generate-electron-package.js",
     "verify:config:types": "node scripts/generate-config-types.js --check",
+    "verify:electron-package": "node scripts/generate-electron-package.js --check",
     "generate:supported-integrations": "node scripts/generate-supported-integrations.js",
     "verify:supported-integrations": "node scripts/generate-supported-integrations.js --check",
     "type:check": "tsc --noEmit -p tsconfig.dev.json",
@@ -142,6 +144,7 @@
     "webpack.js",
     "ext/**/*",
     "index.d.ts",
+    "index.electron.js",
     "index.js",
     "init.js",
     "initialize.mjs",
@@ -151,6 +154,7 @@
     "LICENSE.BSD3",
     "loader-hook.mjs",
     "packages/*/index.js",
+    "packages/*/index.electron.js",
     "packages/*/lib/**/*",
     "packages/*/src/**/*",
     "packages/datadog-instrumentations/orchestrion.yml",
@@ -205,7 +209,7 @@
     "eslint-plugin-mocha": "^11.3.0",
     "eslint-plugin-n": "^18.2.1",
     "eslint-plugin-promise": "^7.3.0",
-    "eslint-plugin-sonarjs": "^4.1.0",
+    "eslint-plugin-sonarjs": "^4.2.0",
     "eslint-plugin-unicorn": "^64.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",

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

@@ -136,33 +136,38 @@ function wrapTracer (tracer) {
 
       args[args.length - 1] = shimmer.wrapFunction(cb, function (originalCb) {
         return function (span) {
-          // the below is necessary in the case that the span is vercel ai's noopSpan.
-          // while we don't want to patch the noopSpan more than once, we do want to treat each as a
-          // fresh instance. However, this is really not necessary for non-noop spans, but not sure
-          // how to differentiate.
-          const freshSpan = Object.create(span) // TODO: does this cause memory leaks?
-
-          shimmer.wrap(freshSpan, 'end', function (spanEnd) {
-            return function (...args) {
-              vercelAiTracingChannel.asyncEnd.publish(ctx)
-              return spanEnd.apply(this, args)
-            }
-          })
-
-          shimmer.wrap(freshSpan, 'setAttributes', function (setAttributes) {
-            return function (attributes) {
+          // A plain delegating wrapper is used instead of Object.create(span) because
+          // Object.create (and Proxy) cannot cross private-field brand checks — any span
+          // method that reads a private field (e.g. BridgeSpanBase#statusCode) would throw
+          // "Cannot read private member" on a prototype clone. Every method here calls
+          // through to the real span instance so private fields always resolve correctly.
+          const freshSpan = {
+            spanContext () { return span.spanContext() },
+            setAttribute (key, value) { span.setAttribute(key, value); return freshSpan },
+            setAttributes (attributes) {
               vercelAiSpanSetAttributesChannel.publish({ ctx, attributes })
-              return setAttributes.apply(this, arguments)
-            }
-          })
-
-          shimmer.wrap(freshSpan, 'recordException', function (recordException) {
-            return function (exception) {
+              span.setAttributes(attributes)
+              return freshSpan
+            },
+            addEvent (name, attributesOrStartTime, startTime) {
+              span.addEvent(name, attributesOrStartTime, startTime)
+              return freshSpan
+            },
+            addLink (link, attrs) { span.addLink(link, attrs); return freshSpan },
+            addLinks (links) { span.addLinks(links); return freshSpan },
+            setStatus (status) { span.setStatus(status); return freshSpan },
+            updateName (spanName) { span.updateName(spanName); return freshSpan },
+            isRecording () { return span.isRecording() },
+            recordException (exception, timeInput) {
               ctx.error = exception
               vercelAiTracingChannel.error.publish(ctx)
-              return recordException.apply(this, arguments)
-            }
-          })
+              span.recordException(exception, timeInput)
+            },
+            end (...endArgs) {
+              vercelAiTracingChannel.asyncEnd.publish(ctx)
+              span.end(...endArgs)
+            },
+          }
 
           return originalCb.call(this, freshSpan)
         }

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

@@ -180,7 +180,7 @@ function getSuiteStatusFromTestStatuses (testStatuses) {
 
 function getConfiguredEfdRetryCount () {
   const maxSlowTestRetryCount = getMaxEfdRetryCount(earlyFlakeDetectionSlowTestRetries)
-  return maxSlowTestRetryCount || earlyFlakeDetectionNumRetries
+  return maxSlowTestRetryCount ?? earlyFlakeDetectionNumRetries
 }
 
 function publishWorkerEfdRetryCount (pickle, retryCount) {
@@ -1178,7 +1178,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
     }
 
-    const success = await start.apply(this, arguments)
+    const result = await start.apply(this, arguments)
+    const success = satisfies(frameworkVersion, '>=13.1.0') ? result.success : result
 
     let untestedCoverage
     if (getCodeCoverageCh.hasSubscribers) {
@@ -1228,7 +1229,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     logTestOptimizationSummary({ attemptToFixExecutions })
     loggedAttemptToFixTests.clear()
     eventDataCollector = null
-    return success
+    return result
   }
 }
 

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { createWrapRouterMethod } = require('./router')
+const { createWrapRouterMethod, createLayerDispatchWrappers } = require('./router')
 const { addHook, channel, tracingChannel } = require('./helpers/instrument')
 const { getCompileToRegexp } = require('./path-to-regexp')
 const {
@@ -164,7 +164,10 @@ addHook({ name: 'express', versions: ['>=4'], file: 'lib/express.js' }, express
 // 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'], file: 'lib/express.js' }, express => {
-  const wrapRouterMethod = createWrapRouterMethod('express', getCompileToRegexp())
+  // `wrapLegacyHandle` only fires for express <4.6.0 layers, which have no
+  // prototype dispatch; 4.6.0+ keeps `handle` pristine (wrapped below).
+  const { wrapLegacyHandle } = createLayerDispatchWrappers('express')
+  const wrapRouterMethod = createWrapRouterMethod('express', getCompileToRegexp(), wrapLegacyHandle)
 
   shimmer.wrap(express.Router, 'use', wrapRouterMethod)
   shimmer.wrap(express.Router, 'route', wrapRouterMethod)
@@ -172,6 +175,21 @@ addHook({ name: 'express', versions: ['4'], file: 'lib/express.js' }, express =>
   return express
 })
 
+// Express 4 bundles its own Layer; express 5 delegates to the `router` package
+// (wrapped in router.js). Both keep `layer.handle` the user's function and trace
+// via the prototype dispatch. express <4.6.0 has no such dispatch and is traced
+// by the legacy handle wrap instead.
+addHook({ name: 'express', file: 'lib/router/layer.js', versions: ['4'] }, Layer => {
+  if (typeof Layer.prototype.handle_request !== 'function') return Layer
+
+  const { wrapLayerRequest, wrapLayerError } = createLayerDispatchWrappers('express')
+
+  shimmer.wrap(Layer.prototype, 'handle_request', wrapLayerRequest)
+  shimmer.wrap(Layer.prototype, 'handle_error', wrapLayerError)
+
+  return Layer
+})
+
 const queryParserReadCh = channel('datadog:query:read:finish')
 
 function publishQueryParsedAndNext (req, res, next) {

package/packages/datadog-instrumentations/src/grpc/server.js

@@ -2,6 +2,7 @@
 
 const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { FOREIGN_HTTP2_SERVER } = require('../../../dd-trace/src/constants')
 const types = require('./types')
 
 const startChannel = channel('apm:grpc:server:request:start')
@@ -76,6 +77,22 @@ function wrapRegister (register) {
   }
 }
 
+function wrapSetupHandlers (setupHandlers) {
+  return function (http2Server) {
+    // gRPC builds its transport on a core Node `Http2Server` and drives every
+    // call through its own span lifecycle over the raw 'stream' event. Mark the
+    // server so the http2 server instrumentation leaves it untraced; otherwise
+    // its re-enabled 'stream' path would wrap every gRPC call in a second
+    // web.request span and become the top frame. `_setupHandlers` is the single
+    // server-creation funnel across all supported versions (the older
+    // `createHttp2Server` does not exist), and it runs at bind time, before any
+    // request reaches the wrapped `emit`.
+    if (http2Server) http2Server[FOREIGN_HTTP2_SERVER] = true
+
+    return setupHandlers.apply(this, arguments)
+  }
+}
+
 function createWrapEmit (call, ctx, onCancel) {
   return function wrapEmit (emit) {
     return function (event, arg1) {
@@ -149,6 +166,7 @@ function isEmitter (obj) {
 
 addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3'], file: 'build/src/server.js' }, server => {
   shimmer.wrap(server.Server.prototype, 'register', wrapRegister)
+  shimmer.wrap(server.Server.prototype, '_setupHandlers', wrapSetupHandlers)
 
   return server
 })

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

@@ -4,7 +4,7 @@ const shimmer = require('../../../datadog-shimmer')
 const { channel } = require('./instrument')
 
 const routerMountPaths = new WeakMap() // to track mount paths for router instances
-const layerMatchers = new WeakMap() // to store layer matchers
+const layerMeta = new WeakMap() // per-layer middleware dispatch metadata (resolved name + route matchers)
 const appMountedRouters = new WeakSet() // to track routers mounted via app.use()
 
 const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
@@ -70,7 +70,7 @@ function collectRoutesFromRouter (router, prefix) {
       // Extract mount path from layer
       const mountPath = typeof layer.path === 'string'
         ? layer.path
-        : getLayerMatchers(layer)?.[0]?.path || ''
+        : getLayerMeta(layer)?.matchers?.[0]?.path || ''
 
       const nestedPrefix = joinPath(prefix, mountPath)
       if (nestedPrefix === null) continue
@@ -121,12 +121,12 @@ function getRouterMountPaths (router) {
   return [...paths]
 }
 
-function setLayerMatchers (layer, matchers) {
-  layerMatchers.set(layer, matchers)
+function setLayerMeta (layer, meta) {
+  layerMeta.set(layer, meta)
 }
 
-function getLayerMatchers (layer) {
-  return layerMatchers.get(layer)
+function getLayerMeta (layer) {
+  return layerMeta.get(layer)
 }
 
 function normalizeMethodName (method) {
@@ -224,8 +224,8 @@ module.exports = {
   setRouterMountPath,
   getRouterMountPaths,
   joinPath,
-  setLayerMatchers,
-  getLayerMatchers,
+  setLayerMeta,
+  getLayerMeta,
   markAppMounted,
   isAppMounted,
   normalizeRoutePath,

package/packages/datadog-instrumentations/src/http2/server.js

@@ -1,18 +1,26 @@
 'use strict'
 
-// Old instrumentation temporarily replaced with compatibility mode only instrumentation.
-// See https://github.com/DataDog/dd-trace-js/issues/312
-
 const {
   channel,
   addHook,
 } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { FOREIGN_HTTP2_SERVER } = require('../../../dd-trace/src/constants')
 
 const startServerCh = channel('apm:http2:server:request:start')
 const errorServerCh = channel('apm:http2:server:request:error')
+const adoptServerCh = channel('apm:http2:server:request:adopt')
 const emitCh = channel('apm:http2:server:response:emit')
 
+const HTTP2_HEADER_METHOD = ':method'
+const HTTP2_HEADER_PATH = ':path'
+const HTTP2_HEADER_STATUS = ':status'
+
+// Streams whose server span was already created from the 'stream' event. The
+// compatibility layer synthesizes 'request' from that same stream, so the
+// 'request' branch consults this set to avoid creating a second span.
+const tracedStreams = new WeakSet()
+
 addHook({ name: 'http2' }, http2 => {
   shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
   shimmer.wrap(http2, 'createServer', wrapCreateServer)
@@ -36,34 +44,152 @@ function wrapResponseEmit (originalEmit, ctx) {
   }
 }
 
+function wrapStreamEmit (originalEmit, ctx) {
+  // Named `emit`/arity-1 mirrors the stream method so the per-stream wrap skips
+  // its name/length rewrite. `this` is the Http2Stream; the plugin finishes on
+  // 'close', the same finish signal as the compatibility response.
+  return function emit (eventName) {
+    ctx.eventName = eventName
+    return emitCh.runStores(ctx, originalEmit, this, ...arguments)
+  }
+}
+
 function wrapEmit (originalEmit) {
   // Named `emit` mirrors the server method so the one-time wrap skips its name
   // rewrite; rest params keep the per-event forwarding allocation-free.
   return function emit (...args) {
-    if (!startServerCh.hasSubscribers) {
+    // A server owned by another instrumentation (e.g. @grpc/grpc-js) drives its
+    // own span lifecycle over the raw 'stream' API, so tracing it here would add
+    // a spurious web.request span on top of that integration's span and steal
+    // the top frame. Skip it entirely; the mark is set at server creation, so
+    // this is one property read on servers we do trace.
+    if (!startServerCh.hasSubscribers || this[FOREIGN_HTTP2_SERVER]) {
       return Reflect.apply(originalEmit, this, args)
     }
 
     const eventName = args[0]
-    if (eventName === 'request') {
+    if (eventName === 'stream') {
+      // The compatibility layer synthesizes 'request' from an internal 'stream'
+      // listener it registers exactly once when a 'request' listener is added,
+      // so `listenerCount('stream')` exceeds one only when the application also
+      // registered a raw-stream listener. Owning the span here for that case
+      // keeps it active while the application's stream listener runs; the
+      // synthesized 'request' that fires nested below then reuses it. A
+      // request-only server (no raw-stream listener) is left to the 'request'
+      // branch so the compatibility response keeps its richer req/res.
+      const requestListenerCount = this.listenerCount('request')
+      if (requestListenerCount === 0 || this.listenerCount('stream') > 1) {
+        const stream = args[1]
+        const headers = args[2]
+        const ctx = createStreamAdapter(stream, headers)
+        // Only a mixed server (a 'request' listener is present) synthesizes a
+        // real request off this stream and adopts the span later, so only then
+        // does the context need keying on the stream. A raw-stream-only server
+        // never adopts; leaving the flag unset keeps the stream->context write
+        // off its hot path.
+        ctx.adoptable = requestListenerCount !== 0
+        tracedStreams.add(stream)
+
+        return traceServerRequest(ctx, () => {
+          shimmer.wrap(stream, 'emit', emit => wrapStreamEmit(emit, ctx))
+          return Reflect.apply(originalEmit, this, args)
+        })
+      }
+    } else if (eventName === 'request') {
       const req = args[1]
       const res = args[2]
       res.req = req
 
-      const ctx = { req, res }
-      return startServerCh.runStores(ctx, () => {
-        shimmer.wrap(res, 'emit', emit => wrapResponseEmit(emit, ctx))
-
-        try {
+      // A mixed server (raw-stream + 'request' listeners) already created the
+      // span from the 'stream' event above; the stream's single 'close' is the
+      // sole finish source, so skip creating a second span. The synthesized
+      // request/response are the real objects a user's 'request' handler and
+      // the finish `hooks.request` expect, so hand them to the existing
+      // stream-backed context rather than leaving it on the throwaway adapter.
+      if (tracedStreams.has(req.stream)) {
+        adoptServerCh.publish({ req, res })
+      } else {
+        const ctx = { req, res }
+        return traceServerRequest(ctx, () => {
+          shimmer.wrap(res, 'emit', emit => wrapResponseEmit(emit, ctx))
           return Reflect.apply(originalEmit, this, args)
-        } catch (error) {
-          ctx.error = error
-          errorServerCh.publish(ctx)
-
-          throw error
-        }
-      })
+        })
+      }
     }
+
     return Reflect.apply(originalEmit, this, args)
   }
 }
+
+// Enter the request context and run `emitEvent` (the original `emit`, wrapped to
+// publish per-event for the matching response/stream), publishing any synchronous
+// throw from a user handler before letting it propagate.
+/**
+ * @param {StreamRequestContext | { req: object, res: object }} ctx
+ * @param {() => unknown} emitEvent
+ */
+function traceServerRequest (ctx, emitEvent) {
+  return startServerCh.runStores(ctx, () => {
+    try {
+      return emitEvent()
+    } catch (error) {
+      ctx.error = error
+      errorServerCh.publish(ctx)
+      throw error
+    }
+  })
+}
+
+/**
+ * The minimal req/res pair the shared web lifecycle (`web.js`) keys on, built
+ * from a core-API `Http2Stream`. The fields below are exactly the surface
+ * `web.js` / `url.js` / `ip_extractor.js` read for a stream-backed request; a
+ * new read added there must be mirrored here or it resolves to `undefined` on
+ * the core path only.
+ *
+ * @typedef {object} StreamRequestContext
+ * @property {object} req
+ * @property {import('node:http2').ServerHttp2Stream} req.stream branch key in `web.js`/`url.js`
+ * @property {import('node:http2').IncomingHttpHeaders} req.headers raw pseudo-header map
+ * @property {string} [req.method]
+ * @property {string} [req.url]
+ * @property {import('node:net').Socket} [req.socket] peer address source (OTel)
+ * @property {object} res
+ * @property {object} res.req back-reference used by `wrapResponseEmit`/finish
+ * @property {number} res.statusCode read at finish from `stream.sentHeaders`
+ * @property {(name: string) => string | number | string[] | undefined} res.getHeader response-header tagging
+ */
+
+// Present the core-API stream + pseudo-header map as the minimal req/res pair
+// the shared web lifecycle (`web.js`) consumes. The response status and headers
+// are getters because `stream.sentHeaders` is empty until `stream.respond()`
+// runs in the user handler; a snapshot taken here would always be `undefined`.
+/**
+ * @param {import('node:http2').ServerHttp2Stream} stream
+ * @param {import('node:http2').IncomingHttpHeaders} headers
+ * @returns {StreamRequestContext}
+ */
+function createStreamAdapter (stream, headers) {
+  const req = {
+    stream,
+    headers,
+    method: headers[HTTP2_HEADER_METHOD],
+    url: headers[HTTP2_HEADER_PATH],
+    socket: stream.session?.socket,
+  }
+  const res = {
+    req,
+    get statusCode () {
+      // A stream aborted before `stream.respond()` has no `:status`. The
+      // compatibility `Http2ServerResponse.statusCode` defaults to 200 in that
+      // case, so match it rather than report `undefined` (which `validateStatus`
+      // would treat as an error and which drops the `http.status_code` tag).
+      return stream.sentHeaders?.[HTTP2_HEADER_STATUS] ?? 200
+    },
+    getHeader (name) {
+      return stream.sentHeaders?.[name]
+    },
+  }
+
+  return { req, res }
+}

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

@@ -1861,10 +1861,16 @@ function resetSuiteSkippingRunState () {
 function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
   if (!isItrEnabled || !isSuitesSkippingEnabled) return originalTests
 
-  const suitePathRoot = getRepositoryRootFromTest(originalTests[0], rootDir)
-  const jestSuitesToRun = getJestSuitesToRun(skippableSuites, originalTests, suitePathRoot)
+  const repositoryRoot = getRepositoryRootFromTest(originalTests[0], rootDir)
+  const jestSuitesToRun = getJestSuitesToRun(skippableSuites, originalTests, repositoryRoot, rootDir)
   hasFilteredSkippableSuites = true
-  log.debug('%d out of %d suites are going to run.', jestSuitesToRun.suitesToRun.length, originalTests.length)
+  log.debug(
+    'Jest discovered %d suites; skipped %d using %d skippable candidates; %d suites will run.',
+    originalTests.length,
+    jestSuitesToRun.skippedSuites.length,
+    skippableSuites.length,
+    jestSuitesToRun.suitesToRun.length
+  )
   hasUnskippableSuites = jestSuitesToRun.hasUnskippableSuites
   hasForcedToRunSuites = jestSuitesToRun.hasForcedToRunSuites
 
@@ -1877,7 +1883,7 @@ function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
     ? getTestContexts(originalTests)
     : undefined
   coverageBackfillFiles = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
-    ? getCoverageBackfillFiles(skippableSuitesCoverage, suitePathRoot, getTestSuitePath)
+    ? getCoverageBackfillFiles(skippableSuitesCoverage, repositoryRoot, getTestSuitePath)
     : undefined
 
   itrSkippedSuitesCh.publish({ skippedSuites: jestSuitesToRun.skippedSuites, frameworkVersion })