dd-trace 5.60.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.60.0",
+  "version": "5.61.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -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,11 +165,11 @@
     "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",
@@ -187,8 +187,5 @@
     "workerpool": "^9.2.0",
     "yaml": "^2.8.0",
     "yarn-deduplicate": "^6.0.2"
-  },
-  "resolutions": {
-    "eslint-plugin-unicorn/@eslint/plugin-kit": "0.3.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/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/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

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

@@ -1,7 +1,6 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
-const { storage } = require('../../datadog-core')
 const serverless = require('../../dd-trace/src/plugins/util/serverless')
 const web = require('../../dd-trace/src/plugins/util/web')
 
@@ -11,7 +10,9 @@ const triggerMap = {
   get: 'Http',
   patch: 'Http',
   post: 'Http',
-  put: 'Http'
+  put: 'Http',
+  serviceBusQueue: 'ServiceBus',
+  serviceBusTopic: 'ServiceBus',
 }
 
 class AzureFunctionsPlugin extends TracingPlugin {
@@ -22,24 +23,16 @@ class AzureFunctionsPlugin extends TracingPlugin {
   static get prefix () { return 'tracing:datadog:azure:functions:invoke' }
 
   bindStart (ctx) {
-    const { functionName, methodName, httpRequest } = ctx
-    const store = storage('legacy').getStore()
-    // httpRequest.headers is a map
-    const childOf = this._tracer.extract('http_headers', Object.fromEntries(httpRequest.headers))
+    const childOf = extractTraceContext(this._tracer, ctx)
+    const meta = getMetaForTrigger(ctx)
     const span = this.startSpan(this.operationName(), {
       childOf,
       service: this.serviceName(),
       type: 'serverless',
-      meta: {
-        'aas.function.name': functionName,
-        'aas.function.trigger': mapTriggerTag(methodName)
-      }
-    }, false)
+      meta,
+    }, ctx)
 
     ctx.span = span
-    ctx.parentStore = store
-    ctx.currentStore = { ...store, span }
-
     return ctx.currentStore
   }
 
@@ -49,21 +42,26 @@ class AzureFunctionsPlugin extends TracingPlugin {
   }
 
   asyncEnd (ctx) {
-    const { httpRequest, result = {} } = ctx
-    const path = (new URL(httpRequest.url)).pathname
-    const req = {
-      method: httpRequest.method,
-      headers: Object.fromEntries(httpRequest.headers),
-      url: path
-    }
-
-    const context = web.patch(req)
-    context.config = this.config
-    context.paths = [path]
-    context.res = { statusCode: result.status }
-    context.span = ctx.currentStore.span
+    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
+      }
+      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)
+      serverless.finishSpan(context)
+    // Fallback for other trigger types
+    } else {
+      super.finish()
+    }
   }
 
   configure (config) {
@@ -71,8 +69,39 @@ class AzureFunctionsPlugin extends TracingPlugin {
   }
 }
 
+function getMetaForTrigger ({ functionName, methodName, invocationContext }) {
+  let meta = {
+    'aas.function.name': functionName,
+    'aas.function.trigger': mapTriggerTag(methodName)
+  }
+
+  if (triggerMap[methodName] === 'ServiceBus') {
+    const triggerEntity = invocationContext.options.trigger.queueName || invocationContext.options.trigger.topicName
+    meta = {
+      ...meta,
+      'messaging.message_id': invocationContext.triggerMetadata.messageId,
+      'messaging.operation': 'receive',
+      'messaging.system': 'servicebus',
+      'messaging.destination.name': triggerEntity,
+      'resource.name': `ServiceBus ${functionName}`,
+      'span.kind': 'consumer'
+    }
+  }
+
+  return meta
+}
+
 function mapTriggerTag (methodName) {
   return triggerMap[methodName] || 'Unknown'
 }
 
+function extractTraceContext (tracer, ctx) {
+  switch (String(triggerMap[ctx.methodName])) {
+    case 'Http':
+      return tracer.extract('http_headers', Object.fromEntries(ctx.httpRequest.headers))
+    case 'ServiceBus':
+      return tracer.extract('text_map', ctx.invocationContext.triggerMetadata.applicationProperties)
+  }
+}
+
 module.exports = AzureFunctionsPlugin

package/packages/datadog-plugin-azure-service-bus/src/index.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const ProducerPlugin = require('./producer')
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+
+class AzureServiceBusPlugin extends CompositePlugin {
+  static get id () { return 'azure-service-bus' }
+  static get plugins () {
+    return {
+      producer: ProducerPlugin
+    }
+  }
+}
+
+module.exports = AzureServiceBusPlugin

package/packages/datadog-plugin-azure-service-bus/src/producer.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+
+class AzureServiceBusProducerPlugin extends ProducerPlugin {
+  static get id () { return 'azure-service-bus' }
+  static get operation () { return 'send' }
+
+  bindStart (ctx) {
+    const { sender, msg } = ctx
+    const qualifiedSenderNamespace = sender._sender.audience.replace('sb://', '')
+    const span = this.startSpan({
+      resource: sender.entityPath,
+      type: 'messaging',
+      meta: {
+        component: 'azure-service-bus',
+        'messaging.destination.name': sender.entityPath,
+        'messaging.operation': 'send',
+        'messaging.system': 'servicebus',
+        'network.destination.name': qualifiedSenderNamespace,
+      }
+    }, ctx)
+
+    // This is the correct key for injecting trace context into Azure Service Bus messages
+    // It may not be present in the message properties, so we ensure it exists
+    if (!msg.applicationProperties) {
+      msg.applicationProperties = {}
+    }
+
+    this.tracer.inject(span, 'text_map', msg.applicationProperties)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = AzureServiceBusProducerPlugin

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

@@ -223,10 +223,31 @@ function getSuiteStatus (suiteStats) {
 }
 
 class CypressPlugin {
-  constructor () {
-    this._isInit = false
-    this.testEnvironmentMetadata = getTestEnvironmentMetadata(TEST_FRAMEWORK_NAME)
+  _isInit = false
+  testEnvironmentMetadata = getTestEnvironmentMetadata(TEST_FRAMEWORK_NAME)
+
+  finishedTestsByFile = {}
+  testStatuses = {}
+
+  isTestsSkipped = false
+  isSuitesSkippingEnabled = false
+  isCodeCoverageEnabled = false
+  isFlakyTestRetriesEnabled = false
+  isEarlyFlakeDetectionEnabled = false
+  isKnownTestsEnabled = false
+  earlyFlakeDetectionNumRetries = 0
+  testsToSkip = []
+  skippedTests = []
+  hasForcedToRunSuites = false
+  hasUnskippableSuites = false
+  unskippableSuites = []
+  knownTests = []
+  isTestManagementTestsEnabled = false
+  testManagementAttemptToFixRetries = 0
+  isImpactedTestsEnabled = false
+  modifiedTests = []
 
+  constructor () {
     const {
       [GIT_REPOSITORY_URL]: repositoryUrl,
       [GIT_COMMIT_SHA]: sha,
@@ -265,26 +286,6 @@ class CypressPlugin {
       commitHeadSha,
       commitHeadMessage
     }
-    this.finishedTestsByFile = {}
-    this.testStatuses = {}
-
-    this.isTestsSkipped = false
-    this.isSuitesSkippingEnabled = false
-    this.isCodeCoverageEnabled = false
-    this.isFlakyTestRetriesEnabled = false
-    this.isEarlyFlakeDetectionEnabled = false
-    this.isKnownTestsEnabled = false
-    this.earlyFlakeDetectionNumRetries = 0
-    this.testsToSkip = []
-    this.skippedTests = []
-    this.hasForcedToRunSuites = false
-    this.hasUnskippableSuites = false
-    this.unskippableSuites = []
-    this.knownTests = []
-    this.isTestManagementTestsEnabled = false
-    this.testManagementAttemptToFixRetries = 0
-    this.isImpactedTestsEnabled = false
-    this.modifiedTests = []
   }
 
   // Init function returns a promise that resolves with the Cypress configuration

package/packages/datadog-plugin-langchain/src/handlers/default.js

@@ -1,24 +1,6 @@
 'use strict'
 
-const makeUtilities = require('../../../dd-trace/src/plugins/util/llm')
-
 class LangChainHandler {
-  constructor (tracerConfig) {
-    const utilities = makeUtilities('langchain', tracerConfig)
-
-    this.normalize = utilities.normalize
-    this.isPromptCompletionSampled = utilities.isPromptCompletionSampled
-  }
-
-  // no-op for default handler
-  getSpanStartTags (ctx) {}
-
-  // no-op for default handler
-  getSpanEndTags (ctx) {}
-
-  // no-op for default handler
-  extractApiKey (instance) {}
-
   // no-op for default handler
   extractProvider (instance) {}
 

package/packages/datadog-plugin-langchain/src/handlers/embedding.js

@@ -3,54 +3,6 @@
 const LangChainHandler = require('./default')
 
 class LangChainEmbeddingHandler extends LangChainHandler {
-  getSpanStartTags (ctx, provider, span) {
-    const tags = {}
-
-    const inputTexts = ctx.args?.[0]
-
-    const sampled = this.isPromptCompletionSampled(span)
-    if (typeof inputTexts === 'string') {
-      // embed query
-      if (sampled) {
-        tags['langchain.request.inputs.0.text'] = this.normalize(inputTexts)
-      }
-      tags['langchain.request.input_counts'] = 1
-    } else {
-      // embed documents
-      if (sampled) {
-        for (const idx in inputTexts) {
-          const inputText = inputTexts[idx]
-          tags[`langchain.request.inputs.${idx}.text`] = this.normalize(inputText)
-        }
-      }
-      tags['langchain.request.input_counts'] = inputTexts.length
-    }
-
-    return tags
-  }
-
-  getSpanEndTags (ctx) {
-    const tags = {}
-
-    const { result } = ctx
-    if (!Array.isArray(result)) return
-
-    tags['langchain.response.outputs.embedding_length'] = (
-      Array.isArray(result[0]) ? result[0] : result
-    ).length
-
-    return tags
-  }
-
-  extractApiKey (instance) {
-    const apiKey =
-      instance.clientConfig?.apiKey ||
-      instance.apiKey ||
-      instance.client?.apiKey
-    if (!apiKey || apiKey.length < 4) return ''
-    return `...${apiKey.slice(-4)}`
-  }
-
   extractProvider (instance) {
     return instance.constructor.name.split('Embeddings')[0].toLowerCase()
   }