dd-trace 5.61.1 → 5.63.0

package/README.md

@@ -22,11 +22,6 @@ Most of the documentation for `dd-trace` is available on these webpages:
 
 ## Version Release Lines and Maintenance
 
-> **Node.js v24 Notice**: We're currently adding compatibility for Node.js v24. To use the tracer with your application either continue to use Node.js v22 (LTS), or do both of the following as a workaround:
-> * Install v5.52.0 (or newer) of the tracer
-> * Set `--no-async-context-frame` either using a CLI argument or via `NODE_OPTIONS`
-> Once support for Node.js v24 is complete this flag will no longer be needed.
-
 | Release Line                                             | Latest Version                                                                                         | Node.js  | [SSI](https://docs.datadoghq.com/tracing/trace_collection/automatic_instrumentation/single-step-apm/?tab=linuxhostorvm) | [K8s Injection](https://docs.datadoghq.com/tracing/trace_collection/library_injection_local/?tab=kubernetes) |Status          |Initial Release | End of Life |
 | :---:                                                    | :---:                                                                                                  | :---:    | :---:  | :---:  | :---:           | :---:          | :---:       |
 | [`v1`](https://github.com/DataDog/dd-trace-js/tree/v1.x) | ![npm v1](https://img.shields.io/npm/v/dd-trace/legacy-v1?color=white&label=%20&style=flat-square)     | `>= v12` | NO | NO | **EOL** | 2021-07-13     | 2022-02-25  |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.61.1",
+  "version": "5.63.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -114,7 +114,7 @@
   ],
   "dependencies": {
     "@datadog/libdatadog": "0.7.0",
-    "@datadog/native-appsec": "10.0.1",
+    "@datadog/native-appsec": "10.1.0",
     "@datadog/native-iast-taint-tracking": "4.0.0",
     "@datadog/native-metrics": "3.1.1",
     "@datadog/pprof": "5.9.0",

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

@@ -0,0 +1,140 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const { channel, tracingChannel } = require('dc-polyfill')
+const toolCreationChannel = channel('dd-trace:vercel-ai:tool')
+
+const TRACED_FUNCTIONS = {
+  generateText: wrapWithTracer,
+  streamText: wrapWithTracer,
+  generateObject: wrapWithTracer,
+  streamObject: wrapWithTracer,
+  embed: wrapWithTracer,
+  embedMany: wrapWithTracer,
+  tool: wrapTool
+}
+
+const vercelAiTracingChannel = tracingChannel('dd-trace:vercel-ai')
+const vercelAiSpanSetAttributesChannel = channel('dd-trace:vercel-ai:span:setAttributes')
+
+const noopTracer = {
+  startActiveSpan () {
+    const fn = arguments[arguments.length - 1]
+
+    const span = {
+      spanContext () { return { traceId: '', spanId: '', traceFlags: 0 } },
+      setAttribute () { return this },
+      setAttributes () { return this },
+      addEvent () { return this },
+      addLink () { return this },
+      addLinks () { return this },
+      setStatus () { return this },
+      updateName () { return this },
+      end () { return this },
+      isRecording () { return false },
+      recordException () { return this }
+    }
+
+    return fn(span)
+  }
+}
+
+function wrapTracer (tracer) {
+  if (Object.hasOwn(tracer, Symbol.for('_dd.wrapped'))) return
+
+  shimmer.wrap(tracer, 'startActiveSpan', function (startActiveSpan) {
+    return function () {
+      const name = arguments[0]
+      const options = arguments.length > 2 ? (arguments[1] ?? {}) : {} // startActiveSpan(name, fn)
+      const cb = arguments[arguments.length - 1]
+
+      const ctx = {
+        name,
+        attributes: options.attributes ?? {}
+      }
+
+      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, function (originalCb) {
+        return function (span) {
+          shimmer.wrap(span, 'end', function (spanEnd) {
+            return function () {
+              vercelAiTracingChannel.asyncEnd.publish(ctx)
+              return spanEnd.apply(this, arguments)
+            }
+          })
+
+          shimmer.wrap(span, 'setAttributes', function (setAttributes) {
+            return function (attributes) {
+              vercelAiSpanSetAttributesChannel.publish({ ctx, attributes })
+              return setAttributes.apply(this, arguments)
+            }
+          })
+
+          shimmer.wrap(span, 'recordException', function (recordException) {
+            return function (exception) {
+              ctx.error = exception
+              vercelAiTracingChannel.error.publish(ctx)
+              return recordException.apply(this, arguments)
+            }
+          })
+
+          return originalCb.apply(this, arguments)
+        }
+      })
+
+      return vercelAiTracingChannel.start.runStores(ctx, () => {
+        const result = startActiveSpan.apply(this, arguments)
+        vercelAiTracingChannel.end.publish(ctx)
+        return result
+      })
+    }
+  })
+
+  Object.defineProperty(tracer, Symbol.for('_dd.wrapped'), { value: true })
+}
+
+function wrapWithTracer (fn) {
+  return function () {
+    const options = arguments[0]
+
+    options.experimental_telemetry ??= { isEnabled: true, tracer: noopTracer }
+    wrapTracer(options.experimental_telemetry.tracer)
+
+    return fn.apply(this, arguments)
+  }
+}
+
+function wrapTool (tool) {
+  return function () {
+    const args = arguments[0]
+    toolCreationChannel.publish(args)
+
+    return tool.apply(this, arguments)
+  }
+}
+
+// CJS exports
+addHook({
+  name: 'ai',
+  versions: ['>=4.0.0'],
+}, exports => {
+  for (const [fnName, patchingFn] of Object.entries(TRACED_FUNCTIONS)) {
+    exports = shimmer.wrap(exports, fnName, patchingFn, { replaceGetter: true })
+  }
+
+  return exports
+})
+
+// ESM exports
+addHook({
+  name: 'ai',
+  versions: ['>=4.0.0'],
+  file: 'dist/index.mjs'
+}, exports => {
+  for (const [fnName, patchingFn] of Object.entries(TRACED_FUNCTIONS)) {
+    exports = shimmer.wrap(exports, fnName, patchingFn, { replaceGetter: true })
+  }
+
+  return exports
+})

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

@@ -6,6 +6,7 @@ const { addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 const graphqlMiddlewareChannel = dc.tracingChannel('datadog:apollo:middleware')
+const apolloHttpServerChannel = dc.tracingChannel('datadog:apollo:httpserver')
 
 const requestChannel = dc.tracingChannel('datadog:apollo:request')
 
@@ -77,17 +78,58 @@ function apolloServerHook (apolloServer) {
   return apolloServer
 }
 
-addHook(
-  { name: '@apollo/server', file: 'dist/cjs/ApolloServer.js', versions: ['>=4.0.0 <5.0.0'] },
-  apolloServerHook
-)
+function wrapEmit (emit) {
+  return function wrappedEmit (event, req, res) {
+    if (event === 'request' && req && res && apolloHttpServerChannel.start.hasSubscribers) {
+      return apolloHttpServerChannel.traceSync(emit, { req }, this, ...arguments)
+    }
+
+    return emit.apply(this, arguments)
+  }
+}
+
+function wrapListen (originalListen) {
+  return function wrappedListen () {
+    shimmer.wrap(this, 'emit', wrapEmit)
+
+    return originalListen.apply(this, arguments)
+  }
+}
+
+function wrapHttpServer (original) {
+  return function wrappedHttpServer (options) {
+    if (options.httpServer && typeof options.httpServer.listen === 'function') {
+      shimmer.wrap(options.httpServer, 'listen', wrapListen)
+    }
+
+    return original.apply(this, arguments)
+  }
+}
+
+function apolloDrainHttpServerHook (drainModule) {
+  shimmer.wrap(drainModule, 'ApolloServerPluginDrainHttpServer', wrapHttpServer)
+
+  return drainModule
+}
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/ApolloServer.js', versions: ['4'] }, apolloServerHook)
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/express4/index.js', versions: ['4'] }, apolloExpress4Hook)
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/utils/HeaderMap.js', versions: ['4'] }, apolloHeaderMapHook)
 
 addHook(
-  { name: '@apollo/server', file: 'dist/cjs/express4/index.js', versions: ['>=4.0.0 <5.0.0'] },
-  apolloExpress4Hook
+  { name: '@apollo/server', file: 'dist/cjs/plugin/drainHttpServer/index.js', versions: ['>=5.0.0'] },
+  apolloDrainHttpServerHook
 )
 
 addHook(
-  { name: '@apollo/server', file: 'dist/cjs/utils/HeaderMap.js', versions: ['>=4.0.0 <5.0.0'] },
-  apolloHeaderMapHook
+  { name: '@apollo/server', file: 'dist/cjs/runHttpQuery.js', versions: ['>=5.0.0'] },
+  (runHttpQueryModule) => {
+    shimmer.wrap(runHttpQueryModule, 'runHttpQuery', function wrapRunHttpQuery (originalRunHttpQuery) {
+      return wrapExecuteHTTPGraphQLRequest(originalRunHttpQuery)
+    })
+
+    return runHttpQueryModule
+  }
 )

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -1,10 +1,6 @@
 'use strict'
 
-const {
-  channel,
-  addHook,
-  AsyncResource
-} = require('./helpers/instrument')
+const { channel, addHook } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 
 function wrapRequest (send) {
@@ -15,28 +11,26 @@ function wrapRequest (send) {
     const channelSuffix = getChannelSuffix(serviceIdentifier)
     const startCh = channel(`apm:aws:request:start:${channelSuffix}`)
     if (!startCh.hasSubscribers) return send.apply(this, arguments)
-    const innerAr = new AsyncResource('apm:aws:request:inner')
-    const outerAr = new AsyncResource('apm:aws:request:outer')
-
-    return innerAr.runInAsyncScope(() => {
-      this.on('complete', innerAr.bind(response => {
-        const cbExists = typeof cb === 'function'
-        channel(`apm:aws:request:complete:${channelSuffix}`).publish({ response, cbExists })
-      }))
-
-      startCh.publish({
-        serviceIdentifier,
-        operation: this.operation,
-        awsRegion: this.service.config && this.service.config.region,
-        awsService: this.service.api && this.service.api.className,
-        request: this
-      })
 
-      if (typeof cb === 'function') {
-        arguments[0] = wrapCb(cb, channelSuffix, this, outerAr)
-      }
-      return send.apply(this, arguments)
+    const ctx = {
+      serviceIdentifier,
+      operation: this.operation,
+      awsRegion: this.service.config && this.service.config.region,
+      awsService: this.service.api && this.service.api.className,
+      request: this,
+      cbExists: typeof cb === 'function'
+    }
+
+    this.on('complete', response => {
+      ctx.response = response
+      channel(`apm:aws:request:complete:${channelSuffix}`).publish(ctx)
     })
+
+    if (ctx.cbExists) {
+      arguments[0] = wrapCb(cb, channelSuffix, ctx)
+    }
+
+    return startCh.runStores(ctx, send, this, ...arguments)
   }
 }
 
@@ -55,8 +49,6 @@ function wrapDeserialize (deserialize, channelSuffix) {
 function wrapSmithySend (send) {
   return function (command, ...args) {
     const cb = args.at(-1)
-    const innerAr = new AsyncResource('apm:aws:request:inner')
-    const outerAr = new AsyncResource('apm:aws:request:outer')
     const serviceIdentifier = this.config.serviceId.toLowerCase()
     const channelSuffix = getChannelSuffix(serviceIdentifier)
     const commandName = command.constructor.name
@@ -77,46 +69,45 @@ function wrapSmithySend (send) {
       shimmer.wrap(command, 'deserialize', deserialize => wrapDeserialize(deserialize, channelSuffix))
     }
 
-    return innerAr.runInAsyncScope(() => {
-      startCh.publish({
-        serviceIdentifier,
-        operation,
-        awsService: clientName,
-        request
-      })
+    const ctx = {
+      serviceIdentifier,
+      operation,
+      awsService: clientName,
+      request
+    }
 
+    return startCh.runStores(ctx, () => {
       // When the region is not set this never resolves so we can't await.
       this.config.region().then(region => {
-        regionCh.publish(region)
+        ctx.region = region
+        regionCh.publish(ctx)
       })
 
       if (typeof cb === 'function') {
         args[args.length - 1] = shimmer.wrapFunction(cb, cb => function (err, result) {
-          const message = getMessage(request, err, result)
+          addResponse(ctx, err, result)
 
-          completeChannel.publish(message)
+          completeChannel.publish(ctx)
 
-          outerAr.runInAsyncScope(() => {
-            responseStartChannel.publish(message)
+          const responseCtx = { request, response: ctx.response }
 
+          responseStartChannel.runStores(responseCtx, () => {
             cb.apply(this, arguments)
 
-            if (message.needsFinish) {
-              responseFinishChannel.publish(message.response.error)
-            }
+            responseFinishChannel.publish(responseCtx)
           })
         })
       } else { // always a promise
         return send.call(this, command, ...args)
           .then(
             result => {
-              const message = getMessage(request, null, result)
-              completeChannel.publish(message)
+              addResponse(ctx, null, result)
+              completeChannel.publish(ctx)
               return result
             },
             error => {
-              const message = getMessage(request, error)
-              completeChannel.publish(message)
+              addResponse(ctx, error)
+              completeChannel.publish(ctx)
               throw error
             }
           )
@@ -127,47 +118,45 @@ function wrapSmithySend (send) {
   }
 }
 
-function wrapCb (cb, serviceName, request, ar) {
+function wrapCb (cb, serviceName, ctx) {
   // eslint-disable-next-line n/handle-callback-err
   return shimmer.wrapFunction(cb, cb => function wrappedCb (err, response) {
-    const obj = { request, response }
-    return ar.runInAsyncScope(() => {
-      channel(`apm:aws:response:start:${serviceName}`).publish(obj)
-      // TODO(bengl) make this work without needing a needsFinish property added to the object
-      if (!obj.needsFinish) {
-        return cb.apply(this, arguments)
-      }
+    ctx = { request: ctx.request, response }
+    return channel(`apm:aws:response:start:${serviceName}`).runStores(ctx, () => {
       const finishChannel = channel(`apm:aws:response:finish:${serviceName}`)
       try {
         let result = cb.apply(this, arguments)
         if (result && result.then) {
           result = result.then(x => {
-            finishChannel.publish()
+            finishChannel.publish(ctx)
             return x
           }, e => {
-            finishChannel.publish(e)
+            ctx.error = e
+            finishChannel.publish(ctx)
             throw e
           })
         } else {
-          finishChannel.publish()
+          finishChannel.publish(ctx)
         }
         return result
       } catch (e) {
-        finishChannel.publish(e)
+        ctx.error = e
+        finishChannel.publish(ctx)
         throw e
       }
     })
   })
 }
 
-function getMessage (request, error, result) {
+function addResponse (ctx, error, result) {
+  const request = ctx.request
   const response = { request, error, ...result }
 
   if (result && result.$metadata) {
     response.requestId = result.$metadata.requestId
   }
 
-  return { request, response }
+  ctx.response = response
 }
 
 function getChannelSuffix (name) {