dd-trace 5.106.0 → 5.107.0

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

@@ -206,6 +206,32 @@ function wrapConnection (Connection, version) {
     })
   }
 }
+/**
+ * mysql2 defers a busy pool's `getConnection` callback and runs it in the releasing connection's
+ * async context; capture the caller's context and restore it around the callback so spans created
+ * by the queued query attach to the caller rather than the previous query that freed the connection.
+ *
+ * @param {Function} Pool
+ * @returns {Function}
+ */
+function wrapGetConnection (Pool) {
+  const connectionStartCh = channel('apm:mysql2:connection:start')
+  const connectionFinishCh = channel('apm:mysql2:connection:finish')
+
+  shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
+    const ctx = {}
+    arguments[0] = function (...args) {
+      return connectionFinishCh.runStores(ctx, cb, this, ...args)
+    }
+
+    connectionStartCh.publish(ctx)
+
+    return getConnection.apply(this, arguments)
+  })
+
+  return Pool
+}
+
 /**
  * @param {Function} Pool
  * @param {string} version
@@ -215,6 +241,8 @@ function wrapPool (Pool, version) {
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
   const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
 
+  wrapGetConnection(Pool)
+
   shimmer.wrap(Pool.prototype, 'query', query => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)
 
@@ -373,6 +401,12 @@ addHook(
   /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapPool)
 )
 
+// mysql2 >=3.11.5 moved the pool onto BasePool in lib/base/pool.js.
+addHook(
+  { name: 'mysql2', file: 'lib/base/pool.js', versions: ['>=3.11.5'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapGetConnection)
+)
+
 // PoolNamespace.prototype.query does not exist in mysql2<2.3.0
 addHook(
   { name: 'mysql2', file: 'lib/pool_cluster.js', versions: ['2.3.0 - 3.11.4'] },

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

@@ -49,20 +49,22 @@ addHook({ name: 'net' }, (net) => {
 
       const emit = this.emit
       let pendingReadyEvents = 2
-      this.emit = shimmer.wrapFunction(emit, emit => function (eventName) {
+      // Named `emit`/arity-1 mirrors the socket method so the per-socket wrap
+      // skips its name/length rewrite.
+      this.emit = shimmer.wrapFunction(emit, originalEmit => function emit (eventName) {
         switch (eventName) {
           case 'ready':
           case 'connect':
-            if (--pendingReadyEvents === 0) this.emit = emit
+            if (--pendingReadyEvents === 0) this.emit = originalEmit
             return readyCh.runStores(ctx, () => {
-              return emit.apply(this, arguments)
+              return Reflect.apply(originalEmit, this, arguments)
             })
           case 'error':
           case 'close':
-            this.emit = emit
-            return emit.apply(this, arguments)
+            this.emit = originalEmit
+            return Reflect.apply(originalEmit, this, arguments)
           default:
-            return emit.apply(this, arguments)
+            return Reflect.apply(originalEmit, this, arguments)
         }
       })
 

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

@@ -240,6 +240,10 @@ for (const extension of extensions) {
           }
 
           return ch.start.runStores(ctx, () => {
+            // Explicit childOf rather than async-context: the _thenUnwrap/parse path
+            // decouples the lazy evaluation from the active scope at call time.
+            if (guard) guard.parentSpan = ctx.currentStore?.span
+
             const apiProm = methodFn.apply(this, args)
 
             if (baseResource === 'chat.completions' && typeof apiProm._thenUnwrap === 'function') {
@@ -300,23 +304,31 @@ function handleUnwrappedAPIPromise (apiProm, ctx, stream, guard) {
         return body
       }
 
-      finish(ctx, {
+      const responseData = {
         headers: response.headers,
         data: body,
         request: {
           path: response.url,
           method: options.method,
         },
-      })
+      }
 
-      if (!guard) return body
+      if (!guard) {
+        finish(ctx, responseData)
+        return body
+      }
 
-      return aiGuard.evaluateOutput(guard, body).then(() => body)
+      // Finish after evaluation so a block propagates the error to openai.request
+      // and the span wraps its ai_guard child instead of closing before it.
+      return aiGuard.evaluateOutput(guard, body).then(() => {
+        finish(ctx, responseData)
+        return body
+      })
     })
     .catch(error => {
-      // ctx.result is set inside finish(); if absent, finish never ran (sync throw in
-      // success branch, before-model block, or openai error) — record the error now.
-      // If finish already ran successfully (after-model block), don't double-publish.
+      // ctx.result is set inside finish(); if absent, finish never ran (sync throw in the success
+      // branch, Before Model block, After Model block, or openai error) — record the error now so
+      // the openai.request span is marked errored. If finish already ran, don't double-publish.
       if (!ctx.result) finish(ctx, undefined, error)
       throw error
     })

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

@@ -15,6 +15,9 @@ const errorCh = channel('apm:pg:query:error')
 const startPoolQueryCh = channel('datadog:pg:pool:query:start')
 const finishPoolQueryCh = channel('datadog:pg:pool:query:finish')
 
+const poolConnectStartCh = channel('apm:pg:pool:connect:start')
+const poolConnectFinishCh = channel('apm:pg:pool:connect:finish')
+
 // Drivers like pg-promise reuse the same prepared-statement query object across executions; cache
 // the un-injected `text` so the wrap doesn't capture a previous DBM injection as the new original.
 const originalTextCache = new WeakMap()
@@ -30,6 +33,22 @@ addHook({ name: 'pg', versions: ['>=8.0.3'], file: 'lib/client.js' }, Client =>
 })
 
 addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
+  // pg defers a busy pool's connect callback and runs it in the releasing query's async context;
+  // capture the caller's context and restore it around the callback so spans attach to the caller.
+  shimmer.wrap(pg.Pool.prototype, 'connect', connect => function (cb) {
+    if (typeof cb !== 'function' || !poolConnectStartCh.hasSubscribers) {
+      return connect.apply(this, arguments)
+    }
+
+    const ctx = {}
+    arguments[0] = function (...args) {
+      return poolConnectFinishCh.runStores(ctx, cb, this, ...args)
+    }
+
+    poolConnectStartCh.publish(ctx)
+
+    return connect.apply(this, arguments)
+  })
   shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
   return pg
 })

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

@@ -157,9 +157,9 @@ function createWrapRouterMethod (name, compile) {
   }
 
   function wrapNext (req, originalNext) {
-    // Per layer dispatch, N per request. `shimmer.wrapCallback` preserves
-    // only `name` + `length`; see its JSDoc for the full contract.
-    return shimmer.wrapCallback(originalNext, next => function (error) {
+    // Per layer dispatch, N per request. Named `next`/arity-1 mirrors the
+    // router continuation so wrapCallback skips its name/length rewrite.
+    return shimmer.wrapCallback(originalNext, original => function next (error) {
       if (error && error !== 'route' && error !== 'router') {
         errorChannel.publish({ req, error })
       }
@@ -167,7 +167,7 @@ function createWrapRouterMethod (name, compile) {
       nextChannel.publish({ req })
       finishChannel.publish({ req })
 
-      next.apply(this, arguments)
+      original.apply(this, arguments)
     })
   }
 
@@ -328,7 +328,8 @@ const routerParamStartCh = channel('datadog:router:param:start')
 const visitedParams = new WeakSet()
 
 function wrapHandleRequest (original) {
-  return function wrappedHandleRequest (req, res, next) {
+  return function wrappedHandleRequest (...args) {
+    const req = args[0]
     if (routerParamStartCh.hasSubscribers && !visitedParams.has(req.params) && Object.keys(req.params).length) {
       visitedParams.add(req.params)
 
@@ -336,7 +337,7 @@ function wrapHandleRequest (original) {
 
       routerParamStartCh.publish({
         req,
-        res,
+        res: args[1],
         params: req?.params,
         abortController,
       })
@@ -344,7 +345,7 @@ function wrapHandleRequest (original) {
       if (abortController.signal.aborted) return
     }
 
-    return original.apply(this, arguments)
+    return Reflect.apply(original, this, args)
   }
 }
 
@@ -358,7 +359,8 @@ addHook({
 function wrapParam (original) {
   return function wrappedProcessParams (...args) {
     args[1] = shimmer.wrapFunction(args[1], (originalFn) => {
-      return function wrappedFn (req, res) {
+      return function wrappedFn (...fnArgs) {
+        const req = fnArgs[0]
         if (routerParamStartCh.hasSubscribers && Object.keys(req.params).length && !visitedParams.has(req.params)) {
           visitedParams.add(req.params)
 
@@ -366,7 +368,7 @@ function wrapParam (original) {
 
           routerParamStartCh.publish({
             req,
-            res,
+            res: fnArgs[1],
             params: req?.params,
             abortController,
           })
@@ -374,7 +376,7 @@ function wrapParam (original) {
           if (abortController.signal.aborted) return
         }
 
-        return originalFn.apply(this, arguments)
+        return Reflect.apply(originalFn, this, fnArgs)
       }
     })
 

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

@@ -57,6 +57,7 @@ const codeCoverageReportCh = channel('ci:vitest:coverage-report')
 
 const taskToCtx = new WeakMap()
 const taskToStatuses = new WeakMap()
+const taskToReportedErrorCount = new WeakMap()
 const attemptToFixTaskToStatuses = new WeakMap()
 const originalHookFns = new WeakMap()
 const newTasks = new WeakSet()
@@ -316,6 +317,27 @@ function recordFinalAttemptToFixExecution (task, status, providedContext) {
   })
 }
 
+function disableFrameworkRetries (task) {
+  task.retry = 0
+}
+
+/**
+ * Vitest accumulates retry and repeat errors on one task result. The first error added since
+ * the last reported attempt is the primary error for the failed attempt currently being reported.
+ *
+ * @param {object} task
+ * @param {Array<object> | undefined} errors
+ * @returns {object | undefined}
+ */
+function getCurrentAttemptTestError (task, errors) {
+  if (!errors?.length) return
+
+  const previousErrorCount = taskToReportedErrorCount.get(task) ?? 0
+  const testError = errors[previousErrorCount] ?? errors[0]
+  taskToReportedErrorCount.set(task, errors.length)
+  return testError
+}
+
 /**
  * Wraps a function so it runs inside the current test span context.
  * @param {object} task
@@ -801,6 +823,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
         onDone: (isAttemptToFix) => {
           if (isAttemptToFix) {
             isRetryReasonAttemptToFix = task.repeats !== testManagementAttemptToFixRetries
+            disableFrameworkRetries(task)
             task.repeats = testManagementAttemptToFixRetries
             attemptToFixTasks.add(task)
             attemptToFixTaskToStatuses.set(task, [])
@@ -831,6 +854,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
           if (isImpacted) {
             if (isEarlyFlakeDetectionEnabled) {
               isRetryReasonEfd = true
+              disableFrameworkRetries(task)
               task.repeats = numRepeats
             }
             modifiedTasks.add(task)
@@ -849,6 +873,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
           if (isNew && !attemptToFixTasks.has(task)) {
             if (isEarlyFlakeDetectionEnabled && !modifiedTasks.has(task)) {
               isRetryReasonEfd = true
+              disableFrameworkRetries(task)
               task.repeats = numRepeats
             }
             newTasks.add(task)
@@ -986,7 +1011,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
       const promises = {}
       const shouldSetProbe = isDiEnabled && numAttempt === 1
       const ctx = taskToCtx.get(task)
-      const testError = task.result?.errors?.[0]
+      const testError = getCurrentAttemptTestError(task, task.result?.errors)
       if (ctx) {
         testErrorCh.publish({
           error: testError,
@@ -1016,7 +1041,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
       const ctx = taskToCtx.get(task)
       if (ctx) {
         if (lastExecutionStatus === 'fail') {
-          const testError = task.result?.errors?.[0]
+          const testError = getCurrentAttemptTestError(task, task.result?.errors)
           testErrorCh.publish({ error: testError, ...ctx.currentStore })
         } else {
           testPassCh.publish({ task, ...ctx.currentStore })
@@ -1040,7 +1065,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
 
       const ctx = taskToCtx.get(task)
       if (lastExecutionStatus === 'fail') {
-        const testError = task.result?.errors?.[0]
+        const testError = getCurrentAttemptTestError(task, task.result?.errors)
         testErrorCh.publish({ error: testError, ...ctx.currentStore })
       } else {
         testPassCh.publish({ task, ...ctx.currentStore })
@@ -1389,7 +1414,7 @@ addHook({
 
       if (result) {
         const { state, duration, errors } = result
-        const testError = errors?.[0]
+        const testError = getCurrentAttemptTestError(task, errors)
         if (attemptToFixTasks.has(task)) {
           const status = getFinalAttemptToFixStatus(task, state, isSwitchedStatus, testCtx)
           recordFinalAttemptToFixExecution(task, status, providedContext)

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

@@ -1,6 +1,5 @@
 'use strict'
 
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
 const { storage } = require('../../datadog-core')
 const { tagsFromRequest, tagsFromResponse } = require('../../dd-trace/src/payload-tagging')
@@ -113,8 +112,6 @@ class BaseAwsSdkPlugin extends ClientPlugin {
         integrationName: 'aws-sdk',
       }, ctx)
 
-      analyticsSampler.sample(span, this.config.measured)
-
       storage('legacy').run(ctx.currentStore, () => {
         this.requestInject(span, request)
       })

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

@@ -5,6 +5,43 @@ const BaseAwsSdkPlugin = require('../base')
 const { DsmPathwayCodec, getHeadersSize } = require('../../../dd-trace/src/datastreams')
 const { extractQueueMetadata, isEmpty } = require('../util')
 
+/**
+ * @typedef {{
+ *   'detail-type'?: string,
+ *   detail?: { _datadog?: Record<string, string> },
+ *   Type?: string,
+ *   Message?: string
+ * }} ParsedSqsBody
+ */
+
+/**
+ * Resolve the EventBridge `_datadog` text map from a parsed SQS body — for both
+ * EventBridge -> SQS (`body.detail._datadog`) and EventBridge -> SNS -> SQS (the
+ * envelope is the SNS `Notification`'s stringified `Message`). Keyed off
+ * `detail-type`, the marker AWS sets on every PutEvents delivery. Relies on the
+ * default SQS-target shape; a target InputTransformer can drop `detail`.
+ *
+ * @param {ParsedSqsBody} [parsedBody]
+ * @returns {Record<string, string> | undefined}
+ */
+function getEventBridgeContext (parsedBody) {
+  let envelope
+  if (parsedBody?.['detail-type'] !== undefined) {
+    envelope = parsedBody // EventBridge -> SQS
+  } else if (parsedBody?.Type === 'Notification' && typeof parsedBody.Message === 'string') {
+    // EventBridge -> SNS -> SQS
+    try {
+      const innerEnvelope = JSON.parse(parsedBody.Message)
+      if (innerEnvelope?.['detail-type'] !== undefined) {
+        envelope = innerEnvelope
+      }
+    } catch {
+      // SNS `Message` not JSON
+    }
+  }
+  return envelope?.detail?._datadog
+}
+
 class Sqs extends BaseAwsSdkPlugin {
   static id = 'sqs'
   static peerServicePrecursors = ['queuename']
@@ -149,17 +186,28 @@ class Sqs extends BaseAwsSdkPlugin {
       }
     }
 
-    if (!message.MessageAttributes || !message.MessageAttributes._datadog) {
-      return { parsedBody, bodyChecked: true }
+    // Check MessageAttributes first (common direct-SQS/SNS path): avoids parsing
+    // the body (e.g. a large SNS `Message`) just to rule out an EventBridge
+    // envelope. Precedence matches responseExtractDSMContext.
+    const datadogAttribute = message.MessageAttributes?._datadog
+    if (datadogAttribute) {
+      const parsedAttributes = this.parseDatadogAttributes(datadogAttribute)
+      if (parsedAttributes) {
+        return {
+          datadogContext: this.tracer.extract('text_map', parsedAttributes),
+          parsedAttributes,
+          parsedBody,
+          bodyChecked: true,
+        }
+      }
     }
 
-    const datadogAttribute = message.MessageAttributes._datadog
-
-    const parsedAttributes = this.parseDatadogAttributes(datadogAttribute)
-    if (parsedAttributes) {
+    // Then the EventBridge envelope (optionally via SNS); see getEventBridgeContext.
+    const eventBridgeContext = getEventBridgeContext(parsedBody)
+    if (eventBridgeContext) {
       return {
-        datadogContext: this.tracer.extract('text_map', parsedAttributes),
-        parsedAttributes,
+        datadogContext: this.tracer.extract('text_map', eventBridgeContext),
+        parsedAttributes: eventBridgeContext,
         parsedBody,
         bodyChecked: true,
       }
@@ -213,15 +261,18 @@ class Sqs extends BaseAwsSdkPlugin {
         if (body?.Type === 'Notification') {
           message = body
         }
-        if (message.MessageAttributes && message.MessageAttributes._datadog) {
-          parsedAttributes = this.parseDatadogAttributes(message.MessageAttributes._datadog)
-        }
+        // MessageAttributes for direct SQS/SNS; else the EventBridge envelope.
+        parsedAttributes = message.MessageAttributes?._datadog
+          ? this.parseDatadogAttributes(message.MessageAttributes._datadog)
+          : getEventBridgeContext(body)
       }
       const payloadSize = getHeadersSize({
         Body: message.Body,
         MessageAttributes: message.MessageAttributes,
       })
       if (parsedAttributes) {
+        // Inert for EventBridge until its producer emits a pathway (separate
+        // change) — no `dd-pathway-ctx-base64` to decode yet; SQS/SNS decode now.
         this.tracer.decodeDataStreamsContext(parsedAttributes)
       }
       this.tracer

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

@@ -80,6 +80,7 @@ class CucumberPlugin extends CiPlugin {
       isTestManagementTestsEnabled,
       isParallel,
     }) => {
+      this._exportPendingWorkerTraces()
       const {
         isSuitesSkippingEnabled,
         isCodeCoverageEnabled,
@@ -186,6 +187,7 @@ class CucumberPlugin extends CiPlugin {
         integrationName: this.constructor.id,
       })
       this._testSuiteSpansByTestSuite.set(testSuitePath, testSuiteSpan)
+      this._exportPendingWorkerTracesForTestSuite(testSuitePath)
 
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
       if (this.libraryConfig?.isCodeCoverageEnabled) {

package/packages/datadog-plugin-cypress/src/support.js

@@ -136,6 +136,7 @@ function getRetriedTests (test, numRetries, tags) {
     // TODO: signal in framework logs that this is a retry.
     // TODO: Change it so these tests are allowed to fail.
     const clonedTest = test.clone()
+    disableFrameworkRetries(clonedTest)
     if (tags.includes('_ddIsEfdRetry')) {
       clonedTest._ddEfdRetryIndex = retryIndex + 1
     }
@@ -149,6 +150,19 @@ function getRetriedTests (test, numRetries, tags) {
   return retriedTests
 }
 
+function disableFrameworkRetries (test) {
+  test._retries = 0
+}
+
+function shouldDisableFrameworkRetries (test) {
+  return test && (
+    test._ddIsAttemptToFix ||
+    (isTestIsolationEnabled &&
+      isEarlyFlakeDetectionEnabled &&
+      (test._ddIsNew || test._ddIsModified))
+  )
+}
+
 const oldRunTests = Cypress.mocha.getRunner().runTests
 Cypress.mocha.getRunner().runTests = function (suite, fn) {
   if (!isKnownTestsEnabled && !isTestManagementEnabled && !isImpactedTestsEnabled) {
@@ -188,9 +202,11 @@ Cypress.mocha.getRunner().runTests = function (suite, fn) {
     let retryMessage = ''
     if (isAtemptToFix) {
       test._ddIsAttemptToFix = true
+      disableFrameworkRetries(test)
       retryMessage = 'because it is an attempt to fix'
       retriedTests = getRetriedTests(test, testManagementAttemptToFixRetries, ['_ddIsAttemptToFix'])
     } else if (isModified && isEarlyFlakeDetectionEnabled) {
+      disableFrameworkRetries(test)
       retryMessage = 'to detect flakes because it is modified'
       retriedTests = getRetriedTests(test, earlyFlakeDetectionNumRetries, [
         '_ddIsModified',
@@ -198,6 +214,7 @@ Cypress.mocha.getRunner().runTests = function (suite, fn) {
         isKnownTestsEnabled && isNewTest(test) && '_ddIsNew',
       ])
     } else if (isNew && isEarlyFlakeDetectionEnabled) {
+      disableFrameworkRetries(test)
       retryMessage = 'to detect flakes because it is new'
       retriedTests = getRetriedTests(test, earlyFlakeDetectionNumRetries, ['_ddIsNew', '_ddIsEfdRetry'])
     }
@@ -214,8 +231,21 @@ Cypress.mocha.getRunner().runTests = function (suite, fn) {
   return oldRunTests.apply(this, [suite, fn])
 }
 
+Cypress.on('test:before:run', (attributes, test) => {
+  if (shouldDisableFrameworkRetries(test)) {
+    disableFrameworkRetries(test)
+  }
+})
+
+Cypress.on('test:before:run:async', (attributes, test) => {
+  if (shouldDisableFrameworkRetries(test)) {
+    disableFrameworkRetries(test)
+  }
+})
+
 beforeEach(function () {
-  const testName = Cypress.mocha.getRunner().suite.ctx.currentTest.fullTitle()
+  const currentTest = Cypress.mocha.getRunner().suite.ctx.currentTest
+  const testName = currentTest.fullTitle()
 
   const retryMessage = retryReasonsByTestName.get(testName)
   if (retryMessage) {

package/packages/datadog-plugin-http/src/client.js

@@ -5,7 +5,6 @@ const { URL } = require('url')
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
 const { storage } = require('../../datadog-core')
 const tags = require('../../../ext/tags')
-const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
 const formats = require('../../../ext/formats')
 const HTTP_HEADERS = formats.HTTP_HEADERS
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
@@ -69,8 +68,6 @@ class HttpClientPlugin extends ClientPlugin {
       this.tracer.inject(span, HTTP_HEADERS, options.headers)
     }
 
-    analyticsSampler.sample(span, this.config.measured)
-
     message.span = span
     message.parentStore = store
     message.currentStore = { ...store, span }

package/packages/datadog-plugin-http/src/server.js

@@ -34,6 +34,11 @@ class HttpServerPlugin extends ServerPlugin {
     if (this.#startConfig === undefined) {
       this.#refreshStartCache()
     }
+    // A fresh request has no span yet; web.startSpan creates and enters one.
+    // A reused context (HTTP/2 stream, serverless re-entry) returns the
+    // existing span without entering, so the explicit enter below is the only
+    // one in that case.
+    const spanCreated = !web.getContext(req)?.span
     const span = web.startSpan(
       this.tracer,
       this.#startConfig,
@@ -57,7 +62,12 @@ class HttpServerPlugin extends ServerPlugin {
       store = withRequest(store, req)
     }
 
-    this.enter(span, store)
+    // Skip the re-enter when web.startSpan already entered { ...store, span }
+    // and AppSec did not rebuild the store with req: the bind would be
+    // identical to the one startSpan just made.
+    if (!spanCreated || appsecActive) {
+      this.enter(span, store)
+    }
 
     if (!context.instrumented) {
       context.res.writeHead = web.wrapWriteHead(context)

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

@@ -150,6 +150,7 @@ class MochaPlugin extends CiPlugin {
       ctx.parentStore = store
       ctx.currentStore = { ...store, testSuiteSpan }
       this._testSuiteSpansByTestSuite.set(testSuite, testSuiteSpan)
+      this._exportPendingWorkerTracesForTestSuite(testSuite)
     })
 
     this.addSub('ci:mocha:test-suite:finish', ({ testSuiteSpan, status }) => {
@@ -365,6 +366,7 @@ class MochaPlugin extends CiPlugin {
       isTestManagementEnabled,
       isParallel,
     }) => {
+      this._exportPendingWorkerTraces()
       if (this.testSessionSpan) {
         const {
           isSuitesSkippingEnabled,

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const { storage } = require('../../datadog-core')
 const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 
@@ -8,6 +9,15 @@ class PGPlugin extends DatabasePlugin {
   static operation = 'query'
   static system = 'postgres'
 
+  constructor () {
+    super(...arguments)
+
+    this.addSub('apm:pg:pool:connect:start', ctx => {
+      ctx.parentStore = storage('legacy').getStore()
+    })
+    this.addBind('apm:pg:pool:connect:finish', ctx => ctx.parentStore)
+  }
+
   bindStart (ctx) {
     const { params = {}, query, originalText, processId, stream } = ctx
     const service = this.serviceName({ pluginConfig: this.config, params })