dd-trace 5.25.0 → 5.27.0

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

@@ -1,6 +1,9 @@
 'use strict'
 
 const BaseAwsSdkPlugin = require('../base')
+const log = require('../../../dd-trace/src/log')
+const { generatePointerHash } = require('../../../dd-trace/src/util')
+const { S3_PTR_KIND, SPAN_POINTER_DIRECTION } = require('../../../dd-trace/src/constants')
 
 class S3 extends BaseAwsSdkPlugin {
   static get id () { return 's3' }
@@ -18,6 +21,37 @@ class S3 extends BaseAwsSdkPlugin {
       bucketname: params.Bucket
     })
   }
+
+  addSpanPointers (span, response) {
+    const request = response?.request
+    const operationName = request?.operation
+    if (!['putObject', 'copyObject', 'completeMultipartUpload'].includes(operationName)) {
+      // We don't create span links for other S3 operations.
+      return
+    }
+
+    // AWS v2: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html
+    // AWS v3: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/
+    const bucketName = request?.params?.Bucket
+    const objectKey = request?.params?.Key
+    let eTag =
+      response?.ETag || // v3 PutObject & CompleteMultipartUpload
+      response?.CopyObjectResult?.ETag || // v3 CopyObject
+      response?.data?.ETag || // v2 PutObject & CompleteMultipartUpload
+      response?.data?.CopyObjectResult?.ETag // v2 CopyObject
+
+    if (!bucketName || !objectKey || !eTag) {
+      log.debug('Unable to calculate span pointer hash because of missing parameters.')
+      return
+    }
+
+    // https://github.com/DataDog/dd-span-pointer-rules/blob/main/AWS/S3/Object/README.md
+    if (eTag.startsWith('"') && eTag.endsWith('"')) {
+      eTag = eTag.slice(1, -1)
+    }
+    const pointerHash = generatePointerHash([bucketName, objectKey, eTag])
+    span.addSpanPointer(S3_PTR_KIND, SPAN_POINTER_DIRECTION.DOWNSTREAM, pointerHash)
+  }
 }
 
 module.exports = S3

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

@@ -42,7 +42,7 @@ class Sqs extends BaseAwsSdkPlugin {
       // extract DSM context after as we might not have a parent-child but may have a DSM context
 
       this.responseExtractDSMContext(
-        request.operation, request.params, response, span || null, { parsedMessageAttributes }
+        request.operation, request.params, response, span || null, { parsedAttributes: parsedMessageAttributes }
       )
     })
 
@@ -195,16 +195,16 @@ class Sqs extends BaseAwsSdkPlugin {
           parsedAttributes = this.parseDatadogAttributes(message.MessageAttributes._datadog)
         }
       }
+      const payloadSize = getHeadersSize({
+        Body: message.Body,
+        MessageAttributes: message.MessageAttributes
+      })
+      const queue = params.QueueUrl.split('/').pop()
       if (parsedAttributes) {
-        const payloadSize = getHeadersSize({
-          Body: message.Body,
-          MessageAttributes: message.MessageAttributes
-        })
-        const queue = params.QueueUrl.split('/').pop()
         this.tracer.decodeDataStreamsContext(parsedAttributes)
-        this.tracer
-          .setCheckpoint(['direction:in', `topic:${queue}`, 'type:sqs'], span, payloadSize)
       }
+      this.tracer
+        .setCheckpoint(['direction:in', `topic:${queue}`, 'type:sqs'], span, payloadSize)
     })
   }
 

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

@@ -654,55 +654,69 @@ class CypressPlugin {
         return this.activeTestSpan ? { traceId: this.activeTestSpan.context().toTraceId() } : {}
       },
       'dd:afterEach': ({ test, coverage }) => {
-        const { state, error, isRUMActive, testSourceLine, testSuite, testName, isNew, isEfdRetry } = test
-        if (this.activeTestSpan) {
-          if (coverage && this.isCodeCoverageEnabled && this.tracer._tracer._exporter?.exportCoverage) {
-            const coverageFiles = getCoveredFilenamesFromCoverage(coverage)
-            const relativeCoverageFiles = coverageFiles.map(file => getTestSuitePath(file, this.rootDir))
-            if (!relativeCoverageFiles.length) {
-              incrementCountMetric(TELEMETRY_CODE_COVERAGE_EMPTY)
-            }
-            distributionMetric(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, relativeCoverageFiles.length)
-            const { _traceId, _spanId } = this.testSuiteSpan.context()
-            const formattedCoverage = {
-              sessionId: _traceId,
-              suiteId: _spanId,
-              testId: this.activeTestSpan.context()._spanId,
-              files: relativeCoverageFiles
-            }
-            this.tracer._tracer._exporter.exportCoverage(formattedCoverage)
-          }
-          const testStatus = CYPRESS_STATUS_TO_TEST_STATUS[state]
-          this.activeTestSpan.setTag(TEST_STATUS, testStatus)
-
-          if (error) {
-            this.activeTestSpan.setTag('error', error)
-          }
-          if (isRUMActive) {
-            this.activeTestSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
-          }
-          if (testSourceLine) {
-            this.activeTestSpan.setTag(TEST_SOURCE_START, testSourceLine)
-          }
-          if (isNew) {
-            this.activeTestSpan.setTag(TEST_IS_NEW, 'true')
-            if (isEfdRetry) {
-              this.activeTestSpan.setTag(TEST_IS_RETRY, 'true')
-            }
+        if (!this.activeTestSpan) {
+          log.warn('There is no active test span in dd:afterEach handler')
+          return null
+        }
+        const {
+          state,
+          error,
+          isRUMActive,
+          testSourceLine,
+          testSuite,
+          testSuiteAbsolutePath,
+          testName,
+          isNew,
+          isEfdRetry
+        } = test
+        if (coverage && this.isCodeCoverageEnabled && this.tracer._tracer._exporter?.exportCoverage) {
+          const coverageFiles = getCoveredFilenamesFromCoverage(coverage)
+          const relativeCoverageFiles = [...coverageFiles, testSuiteAbsolutePath].map(
+            file => getTestSuitePath(file, this.repositoryRoot || this.rootDir)
+          )
+          if (!relativeCoverageFiles.length) {
+            incrementCountMetric(TELEMETRY_CODE_COVERAGE_EMPTY)
           }
-          const finishedTest = {
-            testName,
-            testStatus,
-            finishTime: this.activeTestSpan._getTime(), // we store the finish time here
-            testSpan: this.activeTestSpan
+          distributionMetric(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, relativeCoverageFiles.length)
+          const { _traceId, _spanId } = this.testSuiteSpan.context()
+          const formattedCoverage = {
+            sessionId: _traceId,
+            suiteId: _spanId,
+            testId: this.activeTestSpan.context()._spanId,
+            files: relativeCoverageFiles
           }
-          if (this.finishedTestsByFile[testSuite]) {
-            this.finishedTestsByFile[testSuite].push(finishedTest)
-          } else {
-            this.finishedTestsByFile[testSuite] = [finishedTest]
+          this.tracer._tracer._exporter.exportCoverage(formattedCoverage)
+        }
+        const testStatus = CYPRESS_STATUS_TO_TEST_STATUS[state]
+        this.activeTestSpan.setTag(TEST_STATUS, testStatus)
+
+        if (error) {
+          this.activeTestSpan.setTag('error', error)
+        }
+        if (isRUMActive) {
+          this.activeTestSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
+        }
+        if (testSourceLine) {
+          this.activeTestSpan.setTag(TEST_SOURCE_START, testSourceLine)
+        }
+        if (isNew) {
+          this.activeTestSpan.setTag(TEST_IS_NEW, 'true')
+          if (isEfdRetry) {
+            this.activeTestSpan.setTag(TEST_IS_RETRY, 'true')
           }
-          // test spans are finished at after:spec
         }
+        const finishedTest = {
+          testName,
+          testStatus,
+          finishTime: this.activeTestSpan._getTime(), // we store the finish time here
+          testSpan: this.activeTestSpan
+        }
+        if (this.finishedTestsByFile[testSuite]) {
+          this.finishedTestsByFile[testSuite].push(finishedTest)
+        } else {
+          this.finishedTestsByFile[testSuite] = [finishedTest]
+        }
+        // test spans are finished at after:spec
         this.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', {
           hasCodeOwners: !!this.activeTestSpan.context()._tags[TEST_CODE_OWNERS],
           isNew,

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

@@ -88,6 +88,7 @@ afterEach(function () {
     const testInfo = {
       testName: currentTest.fullTitle(),
       testSuite: Cypress.mocha.getRootSuite().file,
+      testSuiteAbsolutePath: Cypress.spec && Cypress.spec.absolute,
       state: currentTest.state,
       error: currentTest.err,
       isNew: currentTest._ddIsNew,

package/packages/datadog-plugin-http/src/client.js

@@ -58,7 +58,7 @@ class HttpClientPlugin extends ClientPlugin {
       span._spanContext._trace.record = false
     }
 
-    if (this.config.propagationFilter(uri)) {
+    if (this.shouldInjectTraceHeaders(options, uri)) {
       this.tracer.inject(span, HTTP_HEADERS, options.headers)
     }
 
@@ -71,6 +71,18 @@ class HttpClientPlugin extends ClientPlugin {
     return message.currentStore
   }
 
+  shouldInjectTraceHeaders (options, uri) {
+    if (hasAmazonSignature(options) && !this.config.enablePropagationWithAmazonHeaders) {
+      return false
+    }
+
+    if (!this.config.propagationFilter(uri)) {
+      return false
+    }
+
+    return true
+  }
+
   bindAsyncStart ({ parentStore }) {
     return parentStore
   }
@@ -200,6 +212,31 @@ function getHooks (config) {
   return { request }
 }
 
+function hasAmazonSignature (options) {
+  if (!options) {
+    return false
+  }
+
+  if (options.headers) {
+    const headers = Object.keys(options.headers)
+      .reduce((prev, next) => Object.assign(prev, {
+        [next.toLowerCase()]: options.headers[next]
+      }), {})
+
+    if (headers['x-amz-signature']) {
+      return true
+    }
+
+    if ([].concat(headers.authorization).some(startsWith('AWS4-HMAC-SHA256'))) {
+      return true
+    }
+  }
+
+  const search = options.search || options.path
+
+  return search && search.toLowerCase().indexOf('x-amz-signature=') !== -1
+}
+
 function extractSessionDetails (options) {
   if (typeof options === 'string') {
     return new URL(options).host
@@ -211,4 +248,8 @@ function extractSessionDetails (options) {
   return { host, port }
 }
 
+function startsWith (searchString) {
+  return value => String(value).startsWith(searchString)
+}
+
 module.exports = HttpClientPlugin

package/packages/datadog-plugin-http2/src/client.js

@@ -62,7 +62,9 @@ class Http2ClientPlugin extends ClientPlugin {
 
     addHeaderTags(span, headers, HTTP_REQUEST_HEADERS, this.config)
 
-    this.tracer.inject(span, HTTP_HEADERS, headers)
+    if (!hasAmazonSignature(headers, path)) {
+      this.tracer.inject(span, HTTP_HEADERS, headers)
+    }
 
     message.parentStore = store
     message.currentStore = { ...store, span }
@@ -132,6 +134,29 @@ function extractSessionDetails (authority, options) {
   return { protocol, port, host }
 }
 
+function hasAmazonSignature (headers, path) {
+  if (headers) {
+    headers = Object.keys(headers)
+      .reduce((prev, next) => Object.assign(prev, {
+        [next.toLowerCase()]: headers[next]
+      }), {})
+
+    if (headers['x-amz-signature']) {
+      return true
+    }
+
+    if ([].concat(headers.authorization).some(startsWith('AWS4-HMAC-SHA256'))) {
+      return true
+    }
+  }
+
+  return path && path.toLowerCase().indexOf('x-amz-signature=') !== -1
+}
+
+function startsWith (searchString) {
+  return value => String(value).startsWith(searchString)
+}
+
 function getStatusValidator (config) {
   if (typeof config.validateStatus === 'function') {
     return config.validateStatus

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

@@ -0,0 +1,50 @@
+'use strict'
+
+const LangChainHandler = require('./default')
+
+class LangChainChainHandler extends LangChainHandler {
+  getSpanStartTags (ctx) {
+    const tags = {}
+
+    if (!this.isPromptCompletionSampled()) return tags
+
+    let inputs = ctx.args?.[0]
+    inputs = Array.isArray(inputs) ? inputs : [inputs]
+
+    for (const idx in inputs) {
+      const input = inputs[idx]
+      if (typeof input !== 'object') {
+        tags[`langchain.request.inputs.${idx}`] = this.normalize(input)
+      } else {
+        for (const [key, value] of Object.entries(input)) {
+        // these are mappings to the python client names, ie lc_kwargs
+        // only present on BaseMessage types
+          if (key.includes('lc_')) continue
+          tags[`langchain.request.inputs.${idx}.${key}`] = this.normalize(value)
+        }
+      }
+    }
+
+    return tags
+  }
+
+  getSpanEndTags (ctx) {
+    const tags = {}
+
+    if (!this.isPromptCompletionSampled()) return tags
+
+    let outputs = ctx.result
+    outputs = Array.isArray(outputs) ? outputs : [outputs]
+
+    for (const idx in outputs) {
+      const output = outputs[idx]
+      tags[`langchain.response.outputs.${idx}`] = this.normalize(
+        typeof output === 'string' ? output : JSON.stringify(output)
+      )
+    }
+
+    return tags
+  }
+}
+
+module.exports = LangChainChainHandler

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

@@ -0,0 +1,53 @@
+'use strict'
+
+const Sampler = require('../../../dd-trace/src/sampler')
+
+const RE_NEWLINE = /\n/g
+const RE_TAB = /\t/g
+
+// TODO: should probably refactor the OpenAI integration to use a shared LLMTracingPlugin base class
+// This logic isn't particular to LangChain
+class LangChainHandler {
+  constructor (config) {
+    this.config = config
+    this.sampler = new Sampler(config.spanPromptCompletionSampleRate)
+  }
+
+  // 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) {}
+
+  // no-op for default handler
+  extractModel (instance) {}
+
+  normalize (text) {
+    if (!text) return
+    if (typeof text !== 'string' || !text || (typeof text === 'string' && text.length === 0)) return
+
+    const max = this.config.spanCharLimit
+
+    text = text
+      .replace(RE_NEWLINE, '\\n')
+      .replace(RE_TAB, '\\t')
+
+    if (text.length > max) {
+      return text.substring(0, max) + '...'
+    }
+
+    return text
+  }
+
+  isPromptCompletionSampled () {
+    return this.sampler.isSampled()
+  }
+}
+
+module.exports = LangChainHandler

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

@@ -0,0 +1,63 @@
+'use strict'
+
+const LangChainHandler = require('./default')
+
+class LangChainEmbeddingHandler extends LangChainHandler {
+  getSpanStartTags (ctx) {
+    const tags = {}
+
+    const inputTexts = ctx.args?.[0]
+
+    const sampled = this.isPromptCompletionSampled()
+    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
+    if (!apiKey || apiKey.length < 4) return ''
+    return `...${apiKey.slice(-4)}`
+  }
+
+  extractProvider (instance) {
+    return instance.constructor.name.split('Embeddings')[0].toLowerCase()
+  }
+
+  extractModel (instance) {
+    for (const attr of ['model', 'modelName', 'modelId', 'modelKey', 'repoId']) {
+      const modelName = instance[attr]
+      if (modelName) return modelName
+    }
+  }
+}
+
+module.exports = LangChainEmbeddingHandler

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

@@ -0,0 +1,99 @@
+'use strict'
+
+const LangChainLanguageModelHandler = require('.')
+
+const COMPLETIONS = 'langchain.response.completions'
+
+class LangChainChatModelHandler extends LangChainLanguageModelHandler {
+  getSpanStartTags (ctx, provider) {
+    const tags = {}
+
+    const inputs = ctx.args?.[0]
+
+    for (const messageSetIndex in inputs) {
+      const messageSet = inputs[messageSetIndex]
+
+      for (const messageIndex in messageSet) {
+        const message = messageSet[messageIndex]
+        if (this.isPromptCompletionSampled()) {
+          tags[`langchain.request.messages.${messageSetIndex}.${messageIndex}.content`] =
+            this.normalize(message.content) || ''
+        }
+        tags[`langchain.request.messages.${messageSetIndex}.${messageIndex}.message_type`] = message.constructor.name
+      }
+    }
+
+    const instance = ctx.instance
+    const identifyingParams = (typeof instance._identifyingParams === 'function' && instance._identifyingParams()) || {}
+    for (const [param, val] of Object.entries(identifyingParams)) {
+      if (param.toLowerCase().includes('apikey') || param.toLowerCase().includes('apitoken')) continue
+      if (typeof val === 'object') {
+        for (const [key, value] of Object.entries(val)) {
+          tags[`langchain.request.${provider}.parameters.${param}.${key}`] = value
+        }
+      } else {
+        tags[`langchain.request.${provider}.parameters.${param}`] = val
+      }
+    }
+
+    return tags
+  }
+
+  getSpanEndTags (ctx) {
+    const { result } = ctx
+
+    const tags = {}
+
+    this.extractTokenMetrics(ctx.currentStore?.span, result)
+
+    for (const messageSetIdx in result.generations) {
+      const messageSet = result.generations[messageSetIdx]
+
+      for (const chatCompletionIdx in messageSet) {
+        const chatCompletion = messageSet[chatCompletionIdx]
+
+        const text = chatCompletion.text
+        const message = chatCompletion.message
+        let toolCalls = message.tool_calls
+
+        if (text && this.isPromptCompletionSampled()) {
+          tags[
+          `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.content`
+          ] = this.normalize(text)
+        }
+
+        tags[
+        `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.message_type`
+        ] = message.constructor.name
+
+        if (toolCalls) {
+          if (!Array.isArray(toolCalls)) {
+            toolCalls = [toolCalls]
+          }
+
+          for (const toolCallIndex in toolCalls) {
+            const toolCall = toolCalls[toolCallIndex]
+
+            tags[
+            `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.tool_calls.${toolCallIndex}.id`
+            ] = toolCall.id
+            tags[
+            `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.tool_calls.${toolCallIndex}.name`
+            ] = toolCall.name
+
+            const args = toolCall.args || {}
+            for (const [name, value] of Object.entries(args)) {
+              tags[
+              `${COMPLETIONS}.${messageSetIdx}.${chatCompletionIdx}.tool_calls.${toolCallIndex}.args.${name}`
+              ] = this.normalize(value)
+            }
+          }
+        }
+      }
+    }
+
+    return tags
+  }
+}
+
+module.exports = LangChainChatModelHandler

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

@@ -0,0 +1,48 @@
+'use strict'
+
+const { getTokensFromLlmOutput } = require('../../tokens')
+const LangChainHandler = require('../default')
+
+class LangChainLanguageModelHandler extends LangChainHandler {
+  extractApiKey (instance) {
+    const key = Object.keys(instance)
+      .find(key => {
+        const lower = key.toLowerCase()
+        return lower.includes('apikey') || lower.includes('apitoken')
+      })
+
+    let apiKey = instance[key]
+    if (apiKey?.secretValue && typeof apiKey.secretValue === 'function') {
+      apiKey = apiKey.secretValue()
+    }
+    if (!apiKey || apiKey.length < 4) return ''
+    return `...${apiKey.slice(-4)}`
+  }
+
+  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
+    }
+  }
+
+  extractTokenMetrics (span, result) {
+    if (!span || !result) return
+
+    // we do not tag token metrics for non-openai providers
+    const provider = span.context()._tags['langchain.request.provider']
+    if (provider !== 'openai') return
+
+    const tokens = getTokensFromLlmOutput(result)
+
+    for (const [tokenKey, tokenCount] of Object.entries(tokens)) {
+      span.setTag(`langchain.tokens.${tokenKey}_tokens`, tokenCount)
+    }
+  }
+}
+
+module.exports = LangChainLanguageModelHandler

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

@@ -0,0 +1,57 @@
+'use strict'
+
+const LangChainLanguageModelHandler = require('.')
+
+class LangChainLLMHandler extends LangChainLanguageModelHandler {
+  getSpanStartTags (ctx, provider) {
+    const tags = {}
+
+    const prompts = ctx.args?.[0]
+    for (const promptIdx in prompts) {
+      if (!this.isPromptCompletionSampled()) continue
+
+      const prompt = prompts[promptIdx]
+      tags[`langchain.request.prompts.${promptIdx}.content`] = this.normalize(prompt) || ''
+    }
+
+    const instance = ctx.instance
+    const identifyingParams = (typeof instance._identifyingParams === 'function' && instance._identifyingParams()) || {}
+    for (const [param, val] of Object.entries(identifyingParams)) {
+      if (param.toLowerCase().includes('apikey') || param.toLowerCase().includes('apitoken')) continue
+      if (typeof val === 'object') {
+        for (const [key, value] of Object.entries(val)) {
+          tags[`langchain.request.${provider}.parameters.${param}.${key}`] = value
+        }
+      } else {
+        tags[`langchain.request.${provider}.parameters.${param}`] = val
+      }
+    }
+
+    return tags
+  }
+
+  getSpanEndTags (ctx) {
+    const { result } = ctx
+
+    const tags = {}
+
+    this.extractTokenMetrics(ctx.currentStore?.span, result)
+
+    for (const completionIdx in result.generations) {
+      const completion = result.generations[completionIdx]
+      if (this.isPromptCompletionSampled()) {
+        tags[`langchain.response.completions.${completionIdx}.text`] = this.normalize(completion[0].text) || ''
+      }
+
+      if (completion && completion[0].generationInfo) {
+        const generationInfo = completion[0].generationInfo
+        tags[`langchain.response.completions.${completionIdx}.finish_reason`] = generationInfo.finishReason
+        tags[`langchain.response.completions.${completionIdx}.logprobs`] = generationInfo.logprobs
+      }
+    }
+
+    return tags
+  }
+}
+
+module.exports = LangChainLLMHandler