dd-trace 5.59.0 → 5.61.0

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-google-cloud-vertexai/src/tracing.js

@@ -7,7 +7,6 @@ const makeUtilities = require('../../dd-trace/src/plugins/util/llm')
 
 const {
   extractModel,
-  extractSystemInstructions
 } = require('./utils')
 
 class GoogleCloudVertexAITracingPlugin extends TracingPlugin {
@@ -23,20 +22,18 @@ class GoogleCloudVertexAITracingPlugin extends TracingPlugin {
   }
 
   bindStart (ctx) {
-    const { instance, request, resource, stream } = ctx
+    const { instance, resource } = ctx
 
     const span = this.startSpan('vertexai.request', {
       service: this.config.service,
       resource,
       kind: 'client',
       meta: {
-        [MEASURED]: 1
+        [MEASURED]: 1,
+        'vertexai.request.model': extractModel(instance)
       }
     }, false)
 
-    const tags = this.tagRequest(request, instance, stream, span)
-    span.addTags(tags)
-
     const store = storage('legacy').getStore() || {}
     ctx.currentStore = { ...store, span }
 
@@ -47,157 +44,8 @@ class GoogleCloudVertexAITracingPlugin extends TracingPlugin {
     const span = ctx.currentStore?.span
     if (!span) return
 
-    const { result } = ctx
-
-    const response = result?.response
-    if (response) {
-      const tags = this.tagResponse(response, span)
-      span.addTags(tags)
-    }
-
     span.finish()
   }
-
-  /**
-   * Generate the request tags.
-   *
-   * @param {Object} request
-   * @param {Object} instance
-   * @param {boolean} stream
-   * @param {Span} span
-   * @returns {Object}
-   */
-  tagRequest (request, instance, stream, span) {
-    const model = extractModel(instance)
-    const tags = {
-      'vertexai.request.model': model
-    }
-
-    const history = instance.historyInternal
-
-    let contents = typeof request === 'string' || Array.isArray(request) ? request : request.contents
-    if (history) {
-      contents = [...history, ...(Array.isArray(contents) ? contents : [contents])]
-    }
-
-    const generationConfig = instance.generationConfig || {}
-    for (const key of Object.keys(generationConfig)) {
-      const transformedKey = key.replaceAll(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase()
-      tags[`vertexai.request.generation_config.${transformedKey}`] = JSON.stringify(generationConfig[key])
-    }
-
-    if (stream) {
-      tags['vertexai.request.stream'] = true
-    }
-
-    if (!this.isPromptCompletionSampled(span)) return tags
-
-    const systemInstructions = extractSystemInstructions(instance)
-
-    for (const [idx, systemInstruction] of systemInstructions.entries()) {
-      tags[`vertexai.request.system_instruction.${idx}.text`] = systemInstruction
-    }
-
-    if (typeof contents === 'string') {
-      tags['vertexai.request.contents.0.text'] = contents
-      return tags
-    }
-
-    for (const [contentIdx, content] of contents.entries()) {
-      this.tagRequestContent(tags, content, contentIdx)
-    }
-
-    return tags
-  }
-
-  tagRequestPart (part, tags, partIdx, contentIdx) {
-    tags[`vertexai.request.contents.${contentIdx}.parts.${partIdx}.text`] = this.normalize(part.text)
-
-    const functionCall = part.functionCall
-    const functionResponse = part.functionResponse
-
-    if (functionCall) {
-      tags[`vertexai.request.contents.${contentIdx}.parts.${partIdx}.function_call.name`] = functionCall.name
-      tags[`vertexai.request.contents.${contentIdx}.parts.${partIdx}.function_call.args`] =
-              this.normalize(JSON.stringify(functionCall.args))
-    }
-    if (functionResponse) {
-      tags[`vertexai.request.contents.${contentIdx}.parts.${partIdx}.function_response.name`] =
-              functionResponse.name
-      tags[`vertexai.request.contents.${contentIdx}.parts.${partIdx}.function_response.response`] =
-              this.normalize(JSON.stringify(functionResponse.response))
-    }
-  }
-
-  tagRequestContent (tags, content, contentIdx) {
-    if (typeof content === 'string') {
-      tags[`vertexai.request.contents.${contentIdx}.text`] = this.normalize(content)
-      return
-    }
-
-    if (content.text || content.functionCall || content.functionResponse) {
-      this.tagRequestPart(content, tags, 0, contentIdx)
-      return
-    }
-
-    const { role, parts } = content
-    if (role) {
-      tags[`vertexai.request.contents.${contentIdx}.role`] = role
-    }
-
-    for (const [partIdx, part] of parts.entries()) {
-      this.tagRequestPart(part, tags, partIdx, contentIdx)
-    }
-  }
-
-  /**
-   * Generate the response tags.
-   *
-   * @param {Object} response
-   * @param {Span} span
-   * @returns {Object}
-   */
-  tagResponse (response, span) {
-    const tags = {}
-    const isSampled = this.isPromptCompletionSampled(span)
-
-    const candidates = response.candidates
-    for (const [candidateIdx, candidate] of candidates.entries()) {
-      const finishReason = candidate.finishReason
-      if (finishReason) {
-        tags[`vertexai.response.candidates.${candidateIdx}.finish_reason`] = finishReason
-      }
-      const candidateContent = candidate.content
-      const role = candidateContent.role
-      tags[`vertexai.response.candidates.${candidateIdx}.content.role`] = role
-
-      if (!isSampled) continue
-
-      const parts = candidateContent.parts
-      for (const [partIdx, part] of parts.entries()) {
-        const text = part.text
-        tags[`vertexai.response.candidates.${candidateIdx}.content.parts.${partIdx}.text`] =
-          this.normalize(String(text))
-
-        const functionCall = part.functionCall
-        if (!functionCall) continue
-
-        tags[`vertexai.response.candidates.${candidateIdx}.content.parts.${partIdx}.function_call.name`] =
-          functionCall.name
-        tags[`vertexai.response.candidates.${candidateIdx}.content.parts.${partIdx}.function_call.args`] =
-          this.normalize(JSON.stringify(functionCall.args))
-      }
-    }
-
-    const tokenCounts = response.usageMetadata
-    if (tokenCounts) {
-      tags['vertexai.response.usage.prompt_tokens'] = tokenCounts.promptTokenCount
-      tags['vertexai.response.usage.completion_tokens'] = tokenCounts.candidatesTokenCount
-      tags['vertexai.response.usage.total_tokens'] = tokenCounts.totalTokenCount
-    }
-
-    return tags
-  }
 }
 
 module.exports = GoogleCloudVertexAITracingPlugin

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()
   }

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

@@ -0,0 +1,18 @@
+'use strict'
+
+const LangChainHandler = require('./default')
+
+class LangChainLanguageModelHandler extends LangChainHandler {
+  extractProvider (instance) {
+    return typeof instance._llmType === 'function' && instance._llmType().split('-')[0]
+  }
+
+  extractModel (instance) {
+    for (const attr of ['model', 'modelName', 'modelId', 'modelKey', 'repoId']) {
+      const modelName = instance[attr]
+      if (modelName) return modelName
+    }
+  }
+}
+
+module.exports = LangChainLanguageModelHandler

package/packages/datadog-plugin-langchain/src/tracing.js

@@ -4,15 +4,12 @@ const { MEASURED } = require('../../../ext/tags')
 const { storage } = require('../../datadog-core')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 
-const API_KEY = 'langchain.request.api_key'
 const MODEL = 'langchain.request.model'
 const PROVIDER = 'langchain.request.provider'
 const TYPE = 'langchain.request.type'
 
 const LangChainHandler = require('./handlers/default')
-const LangChainChatModelHandler = require('./handlers/language_models/chat_model')
-const LangChainLLMHandler = require('./handlers/language_models/llm')
-const LangChainChainHandler = require('./handlers/chain')
+const LangChainLanguageModelHandler = require('./handlers/language_models')
 const LangChainEmbeddingHandler = require('./handlers/embedding')
 
 class BaseLangChainTracingPlugin extends TracingPlugin {
@@ -24,9 +21,9 @@ class BaseLangChainTracingPlugin extends TracingPlugin {
     super(...arguments)
 
     this.handlers = {
-      chain: new LangChainChainHandler(this._tracerConfig),
-      chat_model: new LangChainChatModelHandler(this._tracerConfig),
-      llm: new LangChainLLMHandler(this._tracerConfig),
+      chain: new LangChainHandler(this._tracerConfig),
+      chat_model: new LangChainLanguageModelHandler(this._tracerConfig),
+      llm: new LangChainLanguageModelHandler(this._tracerConfig),
       embedding: new LangChainEmbeddingHandler(this._tracerConfig),
       default: new LangChainHandler(this._tracerConfig)
     }
@@ -50,7 +47,6 @@ class BaseLangChainTracingPlugin extends TracingPlugin {
     const handler = this.handlers[type] || this.handlers.default
 
     const instance = ctx.instance
-    const apiKey = handler.extractApiKey(instance)
     const provider = handler.extractProvider(instance)
     const model = handler.extractModel(instance)
 
@@ -63,9 +59,8 @@ class BaseLangChainTracingPlugin extends TracingPlugin {
       }
     }, false)
 
-    const tags = handler.getSpanStartTags(ctx, provider, span) || []
+    const tags = {}
 
-    if (apiKey) tags[API_KEY] = apiKey
     if (provider) tags[PROVIDER] = provider
     if (model) tags[MODEL] = model
     if (type) tags[TYPE] = type
@@ -81,13 +76,6 @@ class BaseLangChainTracingPlugin extends TracingPlugin {
   asyncEnd (ctx) {
     const span = ctx.currentStore.span
 
-    const { type } = ctx
-
-    const handler = this.handlers[type] || this.handlers.default
-    const tags = handler.getSpanEndTags(ctx, span) || {}
-
-    span.addTags(tags)
-
     span.finish()
   }