dd-trace 5.86.0 → 5.87.0

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

@@ -6,6 +6,22 @@ const shimmer = require('../../datadog-shimmer')
 const satisfies = require('../../../vendor/dist/semifies')
 const { channel, addHook } = require('./helpers/instrument')
 
+/** @type {WeakMap<object, Function>} */
+const wrappedOnResult = new WeakMap()
+
+/**
+ * @param {unknown} sql
+ * @returns {string|undefined}
+ */
+function resolveSqlString (sql) {
+  return typeof sql === 'string' ? sql : /** @type {{ sql?: string }} */ (sql)?.sql
+}
+
+/**
+ * @param {Function} Connection
+ * @param {string} version
+ * @returns {Function}
+ */
 function wrapConnection (Connection, version) {
   const startCh = channel('apm:mysql2:query:start')
   const finishCh = channel('apm:mysql2:query:finish')
@@ -19,15 +35,27 @@ function wrapConnection (Connection, version) {
   shimmer.wrap(Connection.prototype, 'addCommand', addCommand => function (cmd) {
     if (!startCh.hasSubscribers) return addCommand.apply(this, arguments)
 
-    const name = cmd && cmd.constructor && cmd.constructor.name
-    const isCommand = typeof cmd.execute === 'function'
-    const isQuery = isCommand && (name === 'Execute' || name === 'Query')
+    const command = /** @type {{ execute?: Function, constructor?: { name?: string } }} */ (cmd)
+    if (typeof command.execute !== 'function') return addCommand.apply(this, arguments)
+
+    const name = command.constructor?.name
+    const isQuery = name === 'Execute' || name === 'Query'
     const ctx = {}
 
-    // TODO: consider supporting all commands and not just queries
-    cmd.execute = isQuery
-      ? wrapExecute(cmd, cmd.execute, ctx, this.config)
-      : bindExecute(cmd.execute, ctx)
+    if (isQuery) {
+      command.execute = wrapExecute(command, command.execute, ctx, this.config)
+
+      return commandAddCh.runStores(ctx, addCommand, this, ...arguments)
+    }
+
+    wrapCommandOnResult(command, ctx)
+
+    command.execute = shimmer.wrapFunction(
+      command.execute,
+      execute => function executeWithTrace (_packet_, _connection_) {
+        return commandStartCh.runStores(ctx, execute, this, ...arguments)
+      }
+    )
 
     return commandAddCh.runStores(ctx, addCommand, this, ...arguments)
   })
@@ -35,12 +63,11 @@ function wrapConnection (Connection, version) {
   shimmer.wrap(Connection.prototype, 'query', query => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)
 
-    if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-    if (!sql) return query.apply(this, arguments)
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return query.apply(this, arguments)
 
     const abortController = new AbortController()
-    startOuterQueryCh.publish({ sql, abortController })
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
     if (abortController.signal.aborted) {
       const addCommand = this.addCommand
@@ -56,7 +83,7 @@ function wrapConnection (Connection, version) {
       cb = queryCommand.onResult
 
       process.nextTick(() => {
-        if (cb) {
+        if (typeof cb === 'function') {
           cb(abortController.signal.reason)
         } else {
           queryCommand.emit('error', abortController.signal.reason)
@@ -76,12 +103,11 @@ function wrapConnection (Connection, version) {
   shimmer.wrap(Connection.prototype, 'execute', execute => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return execute.apply(this, arguments)
 
-    if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-    if (!sql) return execute.apply(this, arguments)
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return execute.apply(this, arguments)
 
     const abortController = new AbortController()
-    startOuterQueryCh.publish({ sql, abortController })
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
     if (abortController.signal.aborted) {
       const addCommand = this.addCommand
@@ -94,7 +120,9 @@ function wrapConnection (Connection, version) {
         this.addCommand = addCommand
       }
 
-      result?.onResult(abortController.signal.reason)
+      if (typeof result?.onResult === 'function') {
+        result.onResult(abortController.signal.reason)
+      }
 
       return result
     }
@@ -104,33 +132,48 @@ function wrapConnection (Connection, version) {
 
   return Connection
 
-  function bindExecute (execute, ctx) {
-    return shimmer.wrapFunction(execute, execute => function executeWithTrace (packet, connection) {
-      const onResult = this.onResult
+  /**
+   * @param {object} cmd
+   * @param {object} ctx
+   * @returns {void}
+   */
+  function wrapCommandOnResult (cmd, ctx) {
+    const onResult = cmd?.onResult
+    if (typeof onResult !== 'function') return
 
-      if (onResult) {
-        this.onResult = function () {
-          return commandFinishCh.runStores(ctx, onResult, this, ...arguments)
-        }
-      }
+    const cached = wrappedOnResult.get(cmd)
 
-      return commandStartCh.runStores(ctx, execute, this, ...arguments)
-    })
+    if (cached === onResult) return
+
+    const wrapped = function () {
+      return commandFinishCh.runStores(ctx, onResult, this, ...arguments)
+    }
+
+    wrappedOnResult.set(cmd, wrapped)
+    cmd.onResult = wrapped
   }
 
+  /**
+   * @param {object} cmd
+   * @param {Function} execute
+   * @param {object} ctx
+   * @param {object} config
+   * @returns {Function}
+   */
   function wrapExecute (cmd, execute, ctx, config) {
     return shimmer.wrapFunction(execute, execute => function executeWithTrace (packet, connection) {
-      ctx.sql = cmd.statement ? cmd.statement.query : cmd.sql
+      const command = /** @type {{ statement?: { query?: unknown }, sql?: unknown }} */ (cmd)
+      ctx.sql = command.statement ? command.statement.query : command.sql
       ctx.conf = config
 
       return startCh.runStores(ctx, () => {
-        if (cmd.statement) {
-          cmd.statement.query = ctx.sql
+        if (command.statement) {
+          command.statement.query = ctx.sql
         } else {
-          cmd.sql = ctx.sql
+          command.sql = ctx.sql
         }
 
-        if (this.onResult) {
+        if (typeof this.onResult === 'function') {
           const onResult = this.onResult
 
           this.onResult = shimmer.wrapFunction(onResult, onResult => function (error) {
@@ -141,11 +184,14 @@ function wrapConnection (Connection, version) {
             finishCh.runStores(ctx, onResult, this, ...arguments)
           })
         } else {
-          this.once(errorMonitor, error => {
-            ctx.error = error
-            errorCh.publish(ctx)
-          })
-          this.once('end', () => finishCh.publish(ctx))
+          const command = /** @type {{ once?: Function }} */ (this)
+          if (typeof command.once === 'function') {
+            command.once(errorMonitor, error => {
+              ctx.error = error
+              errorCh.publish(ctx)
+            })
+            command.once('end', () => finishCh.publish(ctx))
+          }
         }
 
         this.execute = execute
@@ -157,9 +203,14 @@ function wrapConnection (Connection, version) {
           errorCh.publish(ctx)
         }
       })
-    }, cmd)
+    })
   }
 }
+/**
+ * @param {Function} Pool
+ * @param {string} version
+ * @returns {Function}
+ */
 function wrapPool (Pool, version) {
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
   const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
@@ -167,12 +218,11 @@ function wrapPool (Pool, version) {
   shimmer.wrap(Pool.prototype, 'query', query => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)
 
-    if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-    if (!sql) return query.apply(this, arguments)
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return query.apply(this, arguments)
 
     const abortController = new AbortController()
-    startOuterQueryCh.publish({ sql, abortController })
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
     if (abortController.signal.aborted) {
       const getConnection = this.getConnection
@@ -206,21 +256,22 @@ function wrapPool (Pool, version) {
   shimmer.wrap(Pool.prototype, 'execute', execute => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return execute.apply(this, arguments)
 
-    if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-    if (!sql) return execute.apply(this, arguments)
+    const resolvedSql = resolveSqlString(sql)
+    if (resolvedSql === undefined) return execute.apply(this, arguments)
 
     const abortController = new AbortController()
-    startOuterQueryCh.publish({ sql, abortController })
+    startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
     if (abortController.signal.aborted) {
       if (typeof values === 'function') {
         cb = values
       }
 
-      process.nextTick(() => {
-        cb(abortController.signal.reason)
-      })
+      if (typeof cb === 'function') {
+        process.nextTick(() => {
+          /** @type {Function} */ (cb)(abortController.signal.reason)
+        })
+      }
       return
     }
 
@@ -230,6 +281,10 @@ function wrapPool (Pool, version) {
   return Pool
 }
 
+/**
+ * @param {Function} PoolCluster
+ * @returns {Function}
+ */
 function wrapPoolCluster (PoolCluster) {
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
   const wrappedPoolNamespaces = new WeakSet()
@@ -239,12 +294,11 @@ function wrapPoolCluster (PoolCluster) {
 
     if (startOuterQueryCh.hasSubscribers && !wrappedPoolNamespaces.has(poolNamespace)) {
       shimmer.wrap(poolNamespace, 'query', query => function (sql, values, cb) {
-        if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-        if (!sql) return query.apply(this, arguments)
+        const resolvedSql = resolveSqlString(sql)
+        if (resolvedSql === undefined) return query.apply(this, arguments)
 
         const abortController = new AbortController()
-        startOuterQueryCh.publish({ sql, abortController })
+        startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
         if (abortController.signal.aborted) {
           const getConnection = this.getConnection
@@ -274,21 +328,22 @@ function wrapPoolCluster (PoolCluster) {
       })
 
       shimmer.wrap(poolNamespace, 'execute', execute => function (sql, values, cb) {
-        if (sql !== null && typeof sql === 'object') sql = sql.sql
-
-        if (!sql) return execute.apply(this, arguments)
+        const resolvedSql = resolveSqlString(sql)
+        if (resolvedSql === undefined) return execute.apply(this, arguments)
 
         const abortController = new AbortController()
-        startOuterQueryCh.publish({ sql, abortController })
+        startOuterQueryCh.publish({ sql: resolvedSql, abortController })
 
         if (abortController.signal.aborted) {
           if (typeof values === 'function') {
             cb = values
           }
 
-          process.nextTick(() => {
-            cb(abortController.signal.reason)
-          })
+          if (typeof cb === 'function') {
+            process.nextTick(() => {
+              /** @type {Function} */ (cb)(abortController.signal.reason)
+            })
+          }
 
           return
         }
@@ -305,9 +360,21 @@ function wrapPoolCluster (PoolCluster) {
   return PoolCluster
 }
 
-addHook({ name: 'mysql2', file: 'lib/base/connection.js', versions: ['>=3.11.5'] }, wrapConnection)
-addHook({ name: 'mysql2', file: 'lib/connection.js', versions: ['1 - 3.11.4'] }, wrapConnection)
-addHook({ name: 'mysql2', file: 'lib/pool.js', versions: ['1 - 3.11.4'] }, wrapPool)
+addHook(
+  { name: 'mysql2', file: 'lib/base/connection.js', versions: ['>=3.11.5'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapConnection)
+)
+addHook(
+  { name: 'mysql2', file: 'lib/connection.js', versions: ['1 - 3.11.4'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapConnection)
+)
+addHook(
+  { name: 'mysql2', file: 'lib/pool.js', versions: ['1 - 3.11.4'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapPool)
+)
 
 // 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'] }, wrapPoolCluster)
+addHook(
+  { name: 'mysql2', file: 'lib/pool_cluster.js', versions: ['2.3.0 - 3.11.4'] },
+  /** @type {(moduleExports: unknown, version: string) => unknown} */ (wrapPoolCluster)
+)

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

@@ -396,6 +396,14 @@ function testEndHandler ({
     }
   }
 
+  // Check if all EFD retries failed
+  if (testStatuses.length === earlyFlakeDetectionNumRetries + 1 &&
+    (test._ddIsNew || test._ddIsModified) &&
+    test._ddIsEfdRetry &&
+    testStatuses.every(status => status === 'fail')) {
+    test._ddHasFailedAllRetries = true
+  }
+
   // this handles tests that do not go through the worker process (because they're skipped)
   if (shouldCreateTestSpan) {
     const testResult = results.at(-1)

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

@@ -0,0 +1,92 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel, addHook } = require('./helpers/instrument')
+
+const checkoutSessionCreateFinishCh = channel('datadog:stripe:checkoutSession:create:finish')
+const paymentIntentCreateFinishCh = channel('datadog:stripe:paymentIntent:create:finish')
+const constructEventFinishCh = channel('datadog:stripe:constructEvent:finish')
+
+function wrapSessionCreate (create) {
+  return function wrappedSessionCreate () {
+    const promise = create.apply(this, arguments)
+
+    if (!checkoutSessionCreateFinishCh.hasSubscribers) return promise
+
+    return promise.then((result) => {
+      checkoutSessionCreateFinishCh.publish(result)
+      return result
+    })
+  }
+}
+
+function wrapPaymentIntentCreate (create) {
+  return function wrappedPaymentIntentCreate () {
+    const promise = create.apply(this, arguments)
+
+    if (!paymentIntentCreateFinishCh.hasSubscribers) return promise
+
+    return promise.then((result) => {
+      paymentIntentCreateFinishCh.publish(result)
+      return result
+    })
+  }
+}
+
+function wrapConstructEvent (constructEvent) {
+  return function wrappedConstructEvent () {
+    const result = constructEvent.apply(this, arguments)
+
+    // no need to check for hasSubscribers,
+    // if it's false, the publish function will be noop
+    constructEventFinishCh.publish(result)
+
+    return result
+  }
+}
+
+function wrapConstructEventAsync (constructEventAsync) {
+  return function wrappedConstructEventAsync () {
+    const promise = constructEventAsync.apply(this, arguments)
+
+    if (!constructEventFinishCh.hasSubscribers) return promise
+
+    return promise.then((result) => {
+      constructEventFinishCh.publish(result)
+      return result
+    })
+  }
+}
+
+function wrapStripe (Stripe) {
+  return function wrappedStripe () {
+    let stripe = Stripe.apply(this, arguments)
+
+    // to support both with and without "new" operator syntax
+    if (this instanceof Stripe) {
+      stripe = this
+    }
+
+    if (typeof stripe.checkout?.sessions?.create === 'function') {
+      shimmer.wrap(stripe.checkout.sessions, 'create', wrapSessionCreate)
+    }
+    if (typeof stripe.paymentIntents?.create === 'function') {
+      shimmer.wrap(stripe.paymentIntents, 'create', wrapPaymentIntentCreate)
+    }
+    if (typeof stripe.webhooks?.constructEvent === 'function') {
+      shimmer.wrap(stripe.webhooks, 'constructEvent', wrapConstructEvent)
+    }
+    if (typeof stripe.webhooks?.constructEventAsync === 'function') {
+      shimmer.wrap(stripe.webhooks, 'constructEventAsync', wrapConstructEventAsync)
+    }
+
+    return stripe
+  }
+}
+
+addHook({
+  name: 'stripe',
+  versions: ['9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '>=20.0.0'],
+}, Stripe => {
+  return shimmer.wrapFunction(Stripe, wrapStripe)
+})

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

@@ -1036,6 +1036,17 @@ addHook({
             }
           }
 
+          // Check if all EFD retries failed
+          const providedContext = getProvidedContext()
+          if (providedContext.isEarlyFlakeDetectionEnabled && (newTasks.has(task) || modifiedTasks.has(task))) {
+            const statuses = taskToStatuses.get(task)
+            // statuses only includes repetitions (not the initial run), so we check against numRepeats (not +1)
+            if (statuses && statuses.length === providedContext.numRepeats &&
+              statuses.every(status => status === 'fail')) {
+              hasFailedAllRetries = true
+            }
+          }
+
           if (testCtx) {
             const isRetry = task.result?.retryCount > 0
             // `duration` is the duration of all the retries, so it can't be used if there are retries

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

@@ -1,7 +1,6 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
-const serverless = require('../../dd-trace/src/plugins/util/serverless')
 const web = require('../../dd-trace/src/plugins/util/web')
 
 const triggerMap = {
@@ -26,19 +25,51 @@ class AzureFunctionsPlugin extends TracingPlugin {
   bindStart (ctx) {
     const meta = getMetaForTrigger(ctx)
     const triggerType = triggerMap[ctx.methodName]
+    const isHttpTrigger = triggerType === 'Http'
     const isMessagingService = (triggerType === 'ServiceBus' || triggerType === 'EventHubs')
-    const childOf = isMessagingService ? null : extractTraceContext(this._tracer, ctx)
-    const span = this.startSpan(this.operationName(), {
-      childOf,
-      service: this.serviceName(),
-      type: 'serverless',
-      meta,
-    }, ctx)
-
-    if (isMessagingService) {
-      setSpanLinks(triggerType, this.tracer, span, ctx)
-    }
 
+    let span
+
+    if (isHttpTrigger) {
+      const { httpRequest } = ctx
+      const path = (new URL(httpRequest.url)).pathname
+      const req = {
+        method: httpRequest.method,
+        headers: Object.fromEntries(httpRequest.headers),
+        url: path,
+      }
+      // Patch the request to create web context
+      const webContext = web.patch(req)
+      webContext.config = this.config
+      webContext.tracer = this.tracer
+      webContext.paths = [path]
+      // Creates a standard span and an inferred proxy span if headers are present
+      span = web.startServerlessSpanWithInferredProxy(
+        this.tracer,
+        this.config,
+        this.operationName(),
+        req,
+        ctx
+      )
+
+      span._integrationName = 'azure-functions'
+      span.context()._tags.component = 'azure-functions'
+      span.addTags(meta)
+      webContext.span = span
+      webContext.azureFunctionCtx = ctx
+      ctx.webContext = webContext
+    } else {
+      // For non-HTTP triggers, use standard flow
+      span = this.startSpan(this.operationName(), {
+        service: this.serviceName(),
+        type: 'serverless',
+        meta,
+      }, ctx)
+
+      if (isMessagingService) {
+        setSpanLinks(triggerType, this.tracer, span, ctx)
+      }
+    }
     ctx.span = span
     return ctx.currentStore
   }
@@ -48,24 +79,16 @@ class AzureFunctionsPlugin extends TracingPlugin {
     ctx.currentStore.span.setTag('error.message', ctx.error)
   }
 
-  asyncEnd (ctx) {
-    const { httpRequest, methodName, result = {} } = ctx
-    if (triggerMap[methodName] === 'Http') {
-      // If the method is an HTTP trigger, we need to patch the request and finish the span
-      const path = (new URL(httpRequest.url)).pathname
-      const req = {
-        method: httpRequest.method,
-        headers: Object.fromEntries(httpRequest.headers),
-        url: path,
+  asyncStart (ctx) {
+    const { methodName, result = {}, webContext } = ctx
+    const triggerType = triggerMap[methodName]
+
+    // For HTTP triggers, use web utilities to finish all spans (including inferred proxy)
+    if (triggerType === 'Http') {
+      if (webContext) {
+        webContext.res = { statusCode: result.status }
+        web.finishAll(webContext, 'serverless')
       }
-      const context = web.patch(req)
-      context.config = this.config
-      context.paths = [path]
-      context.res = { statusCode: result.status }
-      context.span = ctx.currentStore.span
-
-      serverless.finishSpan(context)
-    // Fallback for other trigger types
     } else {
       super.finish()
     }
@@ -80,6 +103,7 @@ function getMetaForTrigger ({ functionName, methodName, invocationContext }) {
   let meta = {
     'aas.function.name': functionName,
     'aas.function.trigger': mapTriggerTag(methodName),
+    'span.type': 'serverless',
   }
 
   if (triggerMap[methodName] === 'ServiceBus') {
@@ -112,14 +136,6 @@ function mapTriggerTag (methodName) {
   return triggerMap[methodName] || 'Unknown'
 }
 
-function extractTraceContext (tracer, ctx) {
-  if (triggerMap[ctx.methodName] === 'Http') {
-    return tracer.extract('http_headers', Object.fromEntries(ctx.httpRequest.headers))
-  }
-  // Returning null indicates that the span is a root span
-  return null
-}
-
 // message & messages & batch with cardinality of 1 == applicationProperties
 // messages with cardinality of many == applicationPropertiesArray
 function setSpanLinks (triggerType, tracer, span, ctx) {

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

@@ -937,6 +937,13 @@ class CypressPlugin {
             this.activeTestSpan.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.efd)
           }
         }
+        // Check if all EFD retries failed
+        if ((isNew || isModified) && this.earlyFlakeDetectionNumRetries > 0) {
+          const isLastEfdAttempt = testStatuses.length === this.earlyFlakeDetectionNumRetries + 1
+          if (isLastEfdAttempt && testStatuses.every(status => status === 'fail')) {
+            this.activeTestSpan.setTag(TEST_HAS_FAILED_ALL_RETRIES, 'true')
+          }
+        }
         if (isAttemptToFix) {
           this.activeTestSpan.setTag(TEST_MANAGEMENT_IS_ATTEMPT_TO_FIX, 'true')
           if (testStatuses.length > 1) {

package/packages/dd-trace/src/appsec/addresses.js

@@ -27,6 +27,12 @@ module.exports = {
   WAF_CONTEXT_PROCESSOR: 'waf.context.processor',
 
   HTTP_OUTGOING_URL: 'server.io.net.url',
+  HTTP_OUTGOING_METHOD: 'server.io.net.request.method',
+  HTTP_OUTGOING_HEADERS: 'server.io.net.request.headers',
+  HTTP_OUTGOING_RESPONSE_STATUS: 'server.io.net.response.status',
+  HTTP_OUTGOING_RESPONSE_HEADERS: 'server.io.net.response.headers',
+  HTTP_OUTGOING_RESPONSE_BODY: 'server.io.net.response.body',
+
   FS_OPERATION_PATH: 'server.io.fs.file',
 
   DB_STATEMENT: 'server.db.statement',
@@ -37,4 +43,9 @@ module.exports = {
 
   LOGIN_SUCCESS: 'server.business_logic.users.login.success',
   LOGIN_FAILURE: 'server.business_logic.users.login.failure',
+
+  PAYMENT_CREATION: 'server.business_logic.payment.creation',
+  PAYMENT_SUCCESS: 'server.business_logic.payment.success',
+  PAYMENT_FAILURE: 'server.business_logic.payment.failure',
+  PAYMENT_CANCELLATION: 'server.business_logic.payment.cancellation',
 }

package/packages/dd-trace/src/appsec/channels.js

@@ -23,6 +23,7 @@ module.exports = {
   fsOperationStart: dc.channel('apm:fs:operation:start'),
   graphqlMiddlewareChannel: dc.tracingChannel('datadog:apollo:middleware'),
   httpClientRequestStart: dc.channel('apm:http:client:request:start'),
+  httpClientResponseFinish: dc.channel('apm:http:client:response:finish'),
   incomingHttpRequestEnd: dc.channel('dd-trace:incomingHttpRequestEnd'),
   incomingHttpRequestStart: dc.channel('dd-trace:incomingHttpRequestStart'),
   multerParser: dc.channel('datadog:multer:read:finish'),
@@ -37,10 +38,13 @@ module.exports = {
   responseBody: dc.channel('datadog:express:response:json:start'),
   responseSetHeader: dc.channel('datadog:http:server:response:set-header:start'),
   responseWriteHead: dc.channel('apm:http:server:response:writeHead:start'),
-  routerParam: dc.channel('datadog:router:param:start'),
   routerMiddlewareError: dc.channel('apm:router:middleware:error'),
+  routerParam: dc.channel('datadog:router:param:start'),
   setCookieChannel: dc.channel('datadog:iast:set-cookie'),
   setUncaughtExceptionCaptureCallbackStart: dc.channel('datadog:process:setUncaughtExceptionCaptureCallback:start'),
   startGraphqlResolve: dc.channel('datadog:graphql:resolver:start'),
+  stripeCheckoutSessionCreate: dc.channel('datadog:stripe:checkoutSession:create:finish'),
+  stripeConstructEvent: dc.channel('datadog:stripe:constructEvent:finish'),
+  stripePaymentIntentCreate: dc.channel('datadog:stripe:paymentIntent:create:finish'),
   wafRunFinished: dc.channel('datadog:waf:run:finish'),
 }