dd-trace 5.59.0 → 5.61.0

package/index.d.ts

@@ -167,6 +167,7 @@ interface Plugins {
   "avsc": tracer.plugins.avsc;
   "aws-sdk": tracer.plugins.aws_sdk;
   "azure-functions": tracer.plugins.azure_functions;
+  "azure-service-bus": tracer.plugins.azure_service_bus;
   "bunyan": tracer.plugins.bunyan;
   "cassandra-driver": tracer.plugins.cassandra_driver;
   "child_process": tracer.plugins.child_process;
@@ -1381,6 +1382,11 @@ declare namespace tracer {
     */
     interface azure_functions extends Instrumentation {}
 
+    /**
+     * This plugin automatically instruments the
+     * @azure/service-bus module
+     */
+    interface azure_service_bus extends Integration {}
     /**
      * This plugin patches the [bunyan](https://github.com/trentm/node-bunyan)
      * to automatically inject trace identifiers in log records when the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.59.0",
+  "version": "5.61.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.0",
+    "@datadog/native-appsec": "10.0.1",
     "@datadog/native-iast-taint-tracking": "4.0.0",
     "@datadog/native-metrics": "3.1.1",
     "@datadog/pprof": "5.9.0",
@@ -124,7 +124,7 @@
     "@opentelemetry/api": "1.8.0",
     "@opentelemetry/core": "^1.14.0",
     "crypto-randomuuid": "^1.0.0",
-    "dc-polyfill": "^0.1.9",
+    "dc-polyfill": "^0.1.10",
     "ignore": "^7.0.5",
     "import-in-the-middle": "^1.14.2",
     "istanbul-lib-coverage": "^3.2.2",
@@ -155,7 +155,7 @@
     "@msgpack/msgpack": "^3.1.2",
     "@stylistic/eslint-plugin": "^5.0.0",
     "@types/node": "^18.19.106",
-    "axios": "^1.10.0",
+    "axios": "^1.11.0",
     "benchmark": "^2.1.4",
     "body-parser": "^2.2.0",
     "chai": "^4.5.0",
@@ -165,15 +165,15 @@
     "eslint-plugin-mocha": "^10.5.0",
     "eslint-plugin-n": "^17.20.0",
     "eslint-plugin-promise": "^7.2.1",
-    "eslint-plugin-unicorn": "^59.0.1",
+    "eslint-plugin-unicorn": "^60.0.0",
     "express": "^5.1.0",
     "get-port": "^5.1.1",
     "glob": "^7.2.3",
-    "globals": "^15.15.0",
+    "globals": "^16.3.0",
     "graphql": "*",
     "jszip": "^3.10.1",
     "mocha": "^11.6.0",
-    "multer": "^2.0.1",
+    "multer": "^2.0.2",
     "nock": "^11.9.1",
     "nyc": "^15.1.0",
     "octokit": "^5.0.3",

package/packages/datadog-code-origin/index.js

@@ -38,9 +38,12 @@ function exitTags (topOfStackFunc) {
 function tag (type, topOfStackFunc, limit) {
   // The `Error.prepareStackTrace` API doesn't support resolving source maps.
   // Fall back to manually parsing the stack trace.
+  const originalLimit = Error.stackTraceLimit
+  Error.stackTraceLimit = Infinity
   const dummy = {}
   Error.captureStackTrace(dummy, topOfStackFunc)
   const frames = parseUserLandFrames(dummy.stack, limit)
+  Error.stackTraceLimit = originalLimit
 
   const tags = {
     '_dd.code_origin.type': type

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

@@ -77,6 +77,17 @@ function apolloServerHook (apolloServer) {
   return apolloServer
 }
 
-addHook({ name: '@apollo/server', file: 'dist/cjs/ApolloServer.js', versions: ['>=4.0.0'] }, apolloServerHook)
-addHook({ name: '@apollo/server', file: 'dist/cjs/express4/index.js', versions: ['>=4.0.0'] }, apolloExpress4Hook)
-addHook({ name: '@apollo/server', file: 'dist/cjs/utils/HeaderMap.js', versions: ['>=4.0.0'] }, apolloHeaderMapHook)
+addHook(
+  { name: '@apollo/server', file: 'dist/cjs/ApolloServer.js', versions: ['>=4.0.0 <5.0.0'] },
+  apolloServerHook
+)
+
+addHook(
+  { name: '@apollo/server', file: 'dist/cjs/express4/index.js', versions: ['>=4.0.0 <5.0.0'] },
+  apolloExpress4Hook
+)
+
+addHook(
+  { name: '@apollo/server', file: 'dist/cjs/utils/HeaderMap.js', versions: ['>=4.0.0 <5.0.0'] },
+  apolloHeaderMapHook
+)

package/packages/datadog-instrumentations/src/azure-functions.js

@@ -11,6 +11,7 @@ const azureFunctionsChannel = dc.tracingChannel('datadog:azure:functions:invoke'
 addHook({ name: '@azure/functions', versions: ['>=4'] }, azureFunction => {
   const { app } = azureFunction
 
+  // Http triggers
   shimmer.wrap(app, 'deleteRequest', wrapHandler)
   shimmer.wrap(app, 'http', wrapHandler)
   shimmer.wrap(app, 'get', wrapHandler)
@@ -18,6 +19,10 @@ addHook({ name: '@azure/functions', versions: ['>=4'] }, azureFunction => {
   shimmer.wrap(app, 'post', wrapHandler)
   shimmer.wrap(app, 'put', wrapHandler)
 
+  // Service Bus triggers
+  shimmer.wrap(app, 'serviceBusQueue', wrapHandler)
+  shimmer.wrap(app, 'serviceBusTopic', wrapHandler)
+
   return azureFunction
 })
 

package/packages/datadog-instrumentations/src/azure-service-bus.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const {
+  channel,
+  addHook
+} = require('./helpers/instrument')
+
+const shimmer = require('../../datadog-shimmer')
+
+const producerStartCh = channel('apm:azure-service-bus:send:start')
+const producerErrorCh = channel('apm:azure-service-bus:send:error')
+const producerFinishCh = channel('apm:azure-service-bus:send:finish')
+
+addHook({ name: '@azure/service-bus', versions: ['>=7.9.2'] }, (obj) => {
+  const ServiceBusClient = obj.ServiceBusClient
+  shimmer.wrap(ServiceBusClient.prototype, 'createSender', createSender => function (queueOrTopicName) {
+    const sender = createSender.apply(this, arguments)
+    shimmer.wrap(sender._sender, 'send', send => function (msg) {
+      const ctx = { sender, msg }
+      return producerStartCh.runStores(ctx, () => {
+        return send.apply(this, arguments)
+          .then(
+            response => {
+              producerFinishCh.publish(ctx)
+            },
+            error => {
+              ctx.error = error
+              producerErrorCh.publish(ctx)
+              producerFinishCh.publish(ctx)
+              throw error
+            }
+          )
+      })
+    })
+    return sender
+  })
+  return obj
+})

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

@@ -11,6 +11,7 @@ const queryParamsReadCh = channel('datadog:fastify:query-params:finish')
 const cookieParserReadCh = channel('datadog:fastify-cookie:read:finish')
 const responsePayloadReadCh = channel('datadog:fastify:response:finish')
 const pathParamsReadCh = channel('datadog:fastify:path-params:finish')
+const finishSetHeaderCh = channel('datadog:fastify:set-header:finish')
 
 const parsingResources = new WeakMap()
 const cookiesPublished = new WeakSet()
@@ -275,3 +276,19 @@ addHook({ name: 'fastify', versions: ['2'] }, fastify => {
 addHook({ name: 'fastify', versions: ['1'] }, fastify => {
   return shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, false))
 })
+
+function wrapReplyHeader (Reply) {
+  shimmer.wrap(Reply.prototype, 'header', header => function (key, value) {
+    const result = header.apply(this, arguments)
+
+    if (finishSetHeaderCh.hasSubscribers && key && value) {
+      finishSetHeaderCh.publish({ name: key, value, res: getRes(this) })
+    }
+
+    return result
+  })
+
+  return Reply
+}
+
+addHook({ name: 'fastify', file: 'lib/reply.js', versions: ['1', '2', '>=3'] }, wrapReplyHeader)

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -6,6 +6,7 @@ module.exports = {
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@azure/functions': () => require('../azure-functions'),
+  '@azure/service-bus': () => require('../azure-service-bus'),
   '@cucumber/cucumber': () => require('../cucumber'),
   '@playwright/test': () => require('../playwright'),
   '@elastic/elasticsearch': () => require('../elasticsearch'),

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

@@ -141,6 +141,20 @@ function instrument (req, res, handler, error) {
   requests.add(req)
 
   const ctx = { req, res }
+  // Parse query parameters from request URL
+  if (queryParsedChannel.hasSubscribers && req.url) {
+    // req.url is only the relative path (/foo?bar=baz) and new URL() needs a full URL
+    // so we give it a dummy base
+    const { searchParams } = new URL(req.url, 'http://dummy')
+    const query = {}
+    for (const key of searchParams.keys()) {
+      if (!query[key]) {
+        query[key] = searchParams.getAll(key)
+      }
+    }
+
+    queryParsedChannel.publish({ query })
+  }
 
   return startChannel.runStores(ctx, () => {
     try {
@@ -280,24 +294,9 @@ addHook({
   versions: ['>=13'],
   file: 'dist/server/web/spec-extension/request.js'
 }, request => {
-  shimmer.wrap(request.NextRequest.prototype, 'nextUrl', function (originalGet) {
-    return function wrappedGet () {
-      const nextUrl = originalGet.apply(this, arguments)
-      if (queryParsedChannel.hasSubscribers) {
-        const query = {}
-        for (const key of nextUrl.searchParams.keys()) {
-          if (!query[key]) {
-            query[key] = nextUrl.searchParams.getAll(key)
-          }
-        }
-
-        queryParsedChannel.publish({ query })
-      }
-      return nextUrl
-    }
-  })
+  const requestProto = Object.getPrototypeOf(request.NextRequest.prototype)
 
-  shimmer.massWrap(request.NextRequest.prototype, ['text', 'json'], function (originalMethod) {
+  shimmer.massWrap(requestProto, ['text', 'json'], function (originalMethod) {
     return async function wrappedJson () {
       const body = await originalMethod.apply(this, arguments)
 
@@ -307,7 +306,7 @@ addHook({
     }
   })
 
-  shimmer.wrap(request.NextRequest.prototype, 'formData', function (originalFormData) {
+  shimmer.wrap(requestProto, 'formData', function (originalFormData) {
     return async function wrappedFormData () {
       const body = await originalFormData.apply(this, arguments)
 

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

@@ -5,6 +5,7 @@ const shimmer = require('../../datadog-shimmer')
 
 const dc = require('dc-polyfill')
 const ch = dc.tracingChannel('apm:openai:request')
+const onStreamedChunkCh = dc.channel('apm:openai:request:chunk')
 
 const V4_PACKAGE_SHIMS = [
   {
@@ -160,79 +161,12 @@ addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, expor
   return exports
 })
 
-function addStreamedChunk (content, chunk) {
-  content.usage = chunk.usage // add usage if it was specified to be returned
-  for (const choice of chunk.choices) {
-    const choiceIdx = choice.index
-    const oldChoice = content.choices.find(choice => choice?.index === choiceIdx)
-    if (oldChoice) {
-      if (!oldChoice.finish_reason) {
-        oldChoice.finish_reason = choice.finish_reason
-      }
-
-      // delta exists on chat completions
-      const delta = choice.delta
-
-      if (delta) {
-        const content = delta.content
-        if (content) {
-          if (oldChoice.delta.content) { // we don't want to append to undefined
-            oldChoice.delta.content += content
-          } else {
-            oldChoice.delta.content = content
-          }
-        }
-      } else {
-        const text = choice.text
-        if (text) {
-          if (oldChoice.text) {
-            oldChoice.text += text
-          } else {
-            oldChoice.text = text
-          }
-        }
-      }
-
-      // tools only exist on chat completions
-      const tools = delta && choice.delta.tool_calls
-
-      if (tools) {
-        oldChoice.delta.tool_calls = tools.map((newTool, toolIdx) => {
-          const oldTool = oldChoice.delta.tool_calls?.[toolIdx]
-
-          if (oldTool) {
-            oldTool.function.arguments += newTool.function.arguments
-            return oldTool
-          }
-
-          return newTool
-        })
-      }
-    } else {
-      // we don't know which choices arrive in which order
-      content.choices[choiceIdx] = choice
-    }
-  }
-}
-
-function convertBufferstoObjects (chunks) {
-  return Buffer
-    .concat(chunks) // combine the buffers
-    .toString() // stringify
-    .split(/(?=data:)/) // split on "data:"
-    .map(chunk => chunk.replaceAll('\n', '').slice(6)) // remove newlines and 'data: ' from the front
-    .slice(0, -1) // remove the last [DONE] message
-    .map(JSON.parse) // parse all of the returned objects
-}
-
 /**
  * For streamed responses, we need to accumulate all of the content in
  * the chunks, and let the combined content be the final response.
  * This way, spans look the same as when not streamed.
  */
-function wrapStreamIterator (response, options, n, ctx) {
-  let processChunksAsBuffers = false
-  let chunks = []
+function wrapStreamIterator (response, options, ctx) {
   return function (itr) {
     return function () {
       const iterator = itr.apply(this, arguments)
@@ -240,39 +174,11 @@ function wrapStreamIterator (response, options, n, ctx) {
         return next.apply(this, arguments)
           .then(res => {
             const { done, value: chunk } = res
-
-            if (chunk) {
-              chunks.push(chunk)
-              // TODO(BridgeAR): It likely depends on the options being passed
-              // through if the stream returns buffers or not. By reading that,
-              // we don't have to do the instanceof check anymore, which is
-              // relatively expensive.
-              if (chunk instanceof Buffer) {
-                // this operation should be safe
-                // if one chunk is a buffer (versus a plain object), the rest should be as well
-                processChunksAsBuffers = true
-              }
-            }
+            onStreamedChunkCh.publish({ ctx, chunk, done })
 
             if (done) {
-              let body = {}
-              if (processChunksAsBuffers) {
-                chunks = convertBufferstoObjects(chunks)
-              }
-
-              if (chunks.length) {
-                // Define the initial body having all the content outside of choices from the first chunk
-                // this will include import data like created, id, model, etc.
-                body = { ...chunks[0], choices: Array.from({ length: n }) }
-                // Start from the first chunk, and add its choices into the body
-                for (const chunk_ of chunks) {
-                  addStreamedChunk(body, chunk_)
-                }
-              }
-
               finish(ctx, {
                 headers: response.headers,
-                data: body,
                 request: {
                   path: response.url,
                   method: options.method
@@ -312,17 +218,6 @@ for (const extension of extensions) {
           // chat.completions and completions
           const stream = streamedResponse && getOption(arguments, 'stream', false)
 
-          // we need to compute how many prompts we are sending in streamed cases for completions
-          // not applicable for chat completiond
-          let n
-          if (stream) {
-            n = getOption(arguments, 'n', 1)
-            const prompt = getOption(arguments, 'prompt')
-            if (Array.isArray(prompt) && typeof prompt[0] !== 'number') {
-              n *= prompt.length
-            }
-          }
-
           const client = this._client || this.client
 
           const ctx = {
@@ -348,7 +243,7 @@ for (const extension of extensions) {
                   const parsedPromise = origApiPromParse.apply(this, arguments)
                     .then(body => Promise.all([this.responsePromise, body]))
 
-                  return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, n)
+                  return handleUnwrappedAPIPromise(parsedPromise, ctx, stream)
                 })
 
                 return unwrappedPromise
@@ -361,7 +256,7 @@ for (const extension of extensions) {
               const parsedPromise = origApiPromParse.apply(this, arguments)
                 .then(body => Promise.all([this.responsePromise, body]))
 
-              return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, n)
+              return handleUnwrappedAPIPromise(parsedPromise, ctx, stream)
             })
 
             ch.end.publish(ctx)
@@ -375,15 +270,15 @@ for (const extension of extensions) {
   }
 }
 
-function handleUnwrappedAPIPromise (apiProm, ctx, stream, n) {
+function handleUnwrappedAPIPromise (apiProm, ctx, stream) {
   return apiProm
     .then(([{ response, options }, body]) => {
       if (stream) {
         if (body.iterator) {
-          shimmer.wrap(body, 'iterator', wrapStreamIterator(response, options, n, ctx))
+          shimmer.wrap(body, 'iterator', wrapStreamIterator(response, options, ctx))
         } else {
           shimmer.wrap(
-            body.response.body, Symbol.asyncIterator, wrapStreamIterator(response, options, n, ctx)
+            body.response.body, Symbol.asyncIterator, wrapStreamIterator(response, options, ctx)
           )
         }
       } else {
@@ -412,7 +307,11 @@ function finish (ctx, response, error) {
     ch.error.publish(ctx)
   }
 
-  ctx.result = response
+  // for successful streamed responses, we've already set the result on ctx.body,
+  // so we don't want to override it here
+  ctx.result ??= {}
+  Object.assign(ctx.result, response)
+
   ch.asyncEnd.publish(ctx)
 }
 

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

@@ -2,8 +2,7 @@
 
 const {
   channel,
-  addHook,
-  AsyncResource
+  addHook
 } = require('./helpers/instrument')
 
 const shimmer = require('../../datadog-shimmer')
@@ -18,8 +17,6 @@ addHook({ name: 'sequelize', versions: ['>=4'] }, Sequelize => {
         return query.apply(this, arguments)
       }
 
-      const asyncResource = new AsyncResource('bound-anonymous-fn')
-
       let dialect
       if (this.options && this.options.dialect) {
         dialect = this.options.dialect
@@ -33,22 +30,15 @@ addHook({ name: 'sequelize', versions: ['>=4'] }, Sequelize => {
           result = result[0]
         }
 
-        asyncResource.bind(function () {
-          finishCh.publish({ result })
-        }, this).apply(this)
+        finishCh.runStores({ result }, () => {})
       }
 
-      return asyncResource.bind(function () {
-        startCh.publish({
-          sql,
-          dialect
-        })
-
+      return startCh.runStores({ sql, dialect }, () => {
         const promise = query.apply(this, arguments)
         promise.then(onFinish, () => { onFinish() })
 
         return promise
-      }, this).apply(this, arguments)
+      })
     }
   })
 

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const BaseAwsSdkPlugin = require('../../base')
-const { parseModelId, extractRequestParams, extractTextAndResponseReason } = require('./utils')
+const { parseModelId } = require('./utils')
 
 const enabledOperations = new Set(['invokeModel'])
 
@@ -20,44 +20,12 @@ class BedrockRuntime extends BaseAwsSdkPlugin {
   generateTags (params, operation, response) {
     const { modelProvider, modelName } = parseModelId(params.modelId)
 
-    const requestParams = extractRequestParams(params, modelProvider)
-    const textAndResponseReason = extractTextAndResponseReason(response, modelProvider, modelName)
-
-    const tags = buildTagsFromParams(requestParams, textAndResponseReason, modelProvider, modelName, operation)
-
-    return tags
-  }
-}
-
-function buildTagsFromParams (requestParams, textAndResponseReason, modelProvider, modelName, operation) {
-  const tags = {}
-
-  // add request tags
-  tags['resource.name'] = operation
-  tags['aws.bedrock.request.model'] = modelName
-  tags['aws.bedrock.request.model_provider'] = modelProvider.toLowerCase()
-  tags['aws.bedrock.request.prompt'] = requestParams.prompt
-  tags['aws.bedrock.request.temperature'] = requestParams.temperature
-  tags['aws.bedrock.request.top_p'] = requestParams.topP
-  tags['aws.bedrock.request.top_k'] = requestParams.topK
-  tags['aws.bedrock.request.max_tokens'] = requestParams.maxTokens
-  tags['aws.bedrock.request.stop_sequences'] = requestParams.stopSequences
-  tags['aws.bedrock.request.input_type'] = requestParams.inputType
-  tags['aws.bedrock.request.truncate'] = requestParams.truncate
-  tags['aws.bedrock.request.stream'] = requestParams.stream
-  tags['aws.bedrock.request.n'] = requestParams.n
-
-  // add response tags
-  if (modelName.includes('embed')) {
-    tags['aws.bedrock.response.embedding_length'] = textAndResponseReason.message.length
-  }
-  if (textAndResponseReason.choiceId) {
-    tags['aws.bedrock.response.choices.id'] = textAndResponseReason.choiceId
+    return {
+      'resource.name': operation,
+      'aws.bedrock.request.model': modelName,
+      'aws.bedrock.request.model_provider': modelProvider.toLowerCase()
+    }
   }
-  tags['aws.bedrock.response.choices.text'] = textAndResponseReason.message
-  tags['aws.bedrock.response.choices.finish_reason'] = textAndResponseReason.finishReason
-
-  return tags
 }
 
 module.exports = BedrockRuntime