@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,125 @@
+'use strict'
+const { DsmPathwayCodec, getHeadersSize } = require('../../../dd-trace/src/datastreams')
+const log = require('../../../dd-trace/src/log')
+const BaseAwsSdkPlugin = require('../base')
+
+class Sns extends BaseAwsSdkPlugin {
+  static id = 'sns'
+  static peerServicePrecursors = ['topicname']
+  static isPayloadReporter = true
+
+  generateTags (params, operation, response) {
+    if (!params) return {}
+
+    if (!params.TopicArn && !(response.data && response.data.TopicArn)) return {}
+    const TopicArn = params.TopicArn || response.data.TopicArn
+
+    // Split the ARN into its parts
+    // ex.'arn:aws:sns:us-east-1:123456789012:my-topic'
+    const arnParts = TopicArn.split(':')
+
+    // Get the topic name from the last part of the ARN
+    const topicName = arnParts.at(-1)
+
+    return {
+      'resource.name': `${operation} ${params.TopicArn || response.data.TopicArn}`,
+      'aws.sns.topic_arn': TopicArn,
+      topicname: topicName,
+    }
+
+    // TODO: should arn be sanitized or quantized in some way here,
+    // for example if it contains a phone number?
+  }
+
+  operationFromRequest (request) {
+    switch (request.operation) {
+      case 'publish':
+      case 'publishBatch':
+        return this.operationName({
+          type: 'messaging',
+          kind: 'producer',
+        })
+    }
+
+    return this.operationName({
+      id: 'aws',
+      type: 'web',
+      kind: 'client',
+      awsService: 'sns',
+    })
+  }
+
+  requestInject (span, request) {
+    const { operation, params } = request
+
+    if (!params) return
+
+    switch (operation) {
+      case 'publish':
+        this.injectToMessage(span, params, params.TopicArn, true)
+        break
+      case 'publishBatch':
+        for (let i = 0; i < params.PublishBatchRequestEntries.length; i++) {
+          this.injectToMessage(
+            span,
+            params.PublishBatchRequestEntries[i],
+            params.TopicArn,
+            i === 0 || (this.config.batchPropagationEnabled)
+          )
+        }
+        break
+    }
+  }
+
+  injectToMessage (span, params, topicArn, injectTraceContext) {
+    if (!params.MessageAttributes) {
+      params.MessageAttributes = {}
+    } else if (Object.keys(params.MessageAttributes).length >= 10) { // SNS quota
+      log.info('Message attributes full, skipping trace context injection')
+      return
+    }
+
+    const ddInfo = {}
+    // for now, we only want to inject to the first message, this may change for batches in the future
+    if (injectTraceContext) {
+      this.tracer.inject(span, 'text_map', ddInfo)
+      // add ddInfo before checking DSM so we can include DD attributes in payload size
+      params.MessageAttributes._datadog = {
+        DataType: 'Binary',
+        BinaryValue: ddInfo,
+      }
+    }
+
+    if (this.config.dsmEnabled) {
+      if (!params.MessageAttributes._datadog) {
+        params.MessageAttributes._datadog = {
+          DataType: 'Binary',
+          BinaryValue: ddInfo,
+        }
+      }
+
+      const dataStreamsContext = this.setDSMCheckpoint(span, params, topicArn)
+      DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+    }
+
+    if (Object.keys(ddInfo).length !== 0) {
+      // BINARY types are automatically base64 encoded
+      params.MessageAttributes._datadog.BinaryValue = Buffer.from(JSON.stringify(ddInfo))
+    } else if (params.MessageAttributes._datadog) {
+      // let's avoid adding any additional information to payload if we failed to inject
+      delete params.MessageAttributes._datadog
+    }
+  }
+
+  setDSMCheckpoint (span, params, topicArn) {
+    // only set a checkpoint if publishing to a topic
+    if (topicArn) {
+      const payloadSize = getHeadersSize(params)
+      const dataStreamsContext = this.tracer
+        .setCheckpoint(['direction:out', `topic:${topicArn}`, 'type:sns'], span, payloadSize)
+      return dataStreamsContext
+    }
+  }
+}
+
+module.exports = Sns

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

@@ -0,0 +1,298 @@
+'use strict'
+
+const log = require('../../../dd-trace/src/log')
+const BaseAwsSdkPlugin = require('../base')
+const { DsmPathwayCodec, getHeadersSize } = require('../../../dd-trace/src/datastreams')
+const { extractQueueMetadata } = require('../util')
+
+class Sqs extends BaseAwsSdkPlugin {
+  static id = 'sqs'
+  static peerServicePrecursors = ['queuename']
+  static isPayloadReporter = true
+
+  constructor (...args) {
+    super(...args)
+    //
+    // TODO(bengl) Find a way to create the response span tags without this WeakMap being populated
+    // in the base class
+    this.requestTags = new WeakMap()
+
+    this.addBind('apm:aws:response:start:sqs', ctx => {
+      const { request, response } = ctx
+      const contextExtraction = this.responseExtract(request.params, request.operation, response)
+
+      let store = this._parentMap.get(request)
+      let span
+      let parsedMessageAttributes = null
+      if (contextExtraction && contextExtraction.datadogContext) {
+        ctx.needsFinish = true
+        const options = {
+          childOf: contextExtraction.datadogContext,
+          meta: {
+            ...this.requestTags.get(request),
+            'span.kind': 'server',
+          },
+          integrationName: 'aws-sdk',
+        }
+        parsedMessageAttributes = contextExtraction.parsedAttributes
+        span = this.startSpan('aws.response', options, ctx)
+        store = ctx.currentStore
+      }
+
+      // 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, { parsedAttributes: parsedMessageAttributes }
+      )
+
+      return store
+    })
+
+    this.addSub('apm:aws:response:finish:sqs', ctx => {
+      if (!ctx.needsFinish) return
+      this.finish(ctx)
+    })
+  }
+
+  operationFromRequest (request) {
+    switch (request.operation) {
+      case 'receiveMessage':
+        return this.operationName({
+          type: 'messaging',
+          kind: 'consumer',
+        })
+      case 'sendMessage':
+      case 'sendMessageBatch':
+        return this.operationName({
+          type: 'messaging',
+          kind: 'producer',
+        })
+    }
+
+    return this.operationName({
+      id: 'aws',
+      type: 'web',
+      kind: 'client',
+      awsService: 'sqs',
+    })
+  }
+
+  isEnabled (request) {
+    // TODO(bengl) Figure out a way to make separate plugins for consumer and producer so that
+    // config can be isolated to `.configure()` instead of this whole isEnabled() thing.
+    const config = this.config
+    switch (request.operation) {
+      case 'receiveMessage':
+        return config.consumer !== false
+      case 'sendMessage':
+      case 'sendMessageBatch':
+        return config.producer !== false
+      default:
+        return true
+    }
+  }
+
+  generateTags (params, operation, response) {
+    if (!params || (!params.QueueName && !params.QueueUrl)) return {}
+
+    const queueMetadata = extractQueueMetadata(params.QueueUrl)
+    const queueName = queueMetadata?.queueName || params.QueueName
+
+    const tags = {
+      'resource.name': `${operation} ${params.QueueName || params.QueueUrl}`,
+      'aws.sqs.queue_name': params.QueueName || params.QueueUrl,
+      queuename: queueName,
+    }
+
+    if (queueMetadata?.arn) {
+      tags['cloud.resource_id'] = queueMetadata.arn
+    }
+
+    switch (operation) {
+      case 'receiveMessage':
+        tags['span.type'] = 'worker'
+        tags['span.kind'] = 'consumer'
+        break
+      case 'sendMessage':
+      case 'sendMessageBatch':
+        tags['span.kind'] = 'producer'
+        break
+    }
+
+    return tags
+  }
+
+  responseExtract (params, operation, response) {
+    if (operation !== 'receiveMessage') return
+    if (params.MaxNumberOfMessages && params.MaxNumberOfMessages !== 1) return
+    if (!response || !response.Messages || !response.Messages[0]) return
+
+    let message = response.Messages[0]
+
+    if (message.Body) {
+      try {
+        const body = JSON.parse(message.Body)
+
+        // SNS to SQS
+        if (body.Type === 'Notification') {
+          message = body
+        }
+      } catch {
+        // SQS to SQS
+      }
+    }
+
+    if (!message.MessageAttributes || !message.MessageAttributes._datadog) return
+
+    const datadogAttribute = message.MessageAttributes._datadog
+
+    const parsedAttributes = this.parseDatadogAttributes(datadogAttribute)
+    if (parsedAttributes) {
+      return {
+        datadogContext: this.tracer.extract('text_map', parsedAttributes),
+        parsedAttributes,
+      }
+    }
+  }
+
+  parseDatadogAttributes (attributes) {
+    try {
+      if (attributes.StringValue) {
+        const textMap = attributes.StringValue
+        return JSON.parse(textMap)
+      } else if (attributes.Type === 'Binary' || attributes.DataType === 'Binary') {
+        const buffer = Buffer.from(attributes.Value ?? attributes.BinaryValue, 'base64')
+        return JSON.parse(buffer)
+      }
+    } catch (e) {
+      log.error('Sqs error parsing DD attributes', e)
+    }
+  }
+
+  responseExtractDSMContext (operation, params, response, span, kwargs = {}) {
+    let { parsedAttributes } = kwargs
+    if (!this.config.dsmEnabled) return
+    if (operation !== 'receiveMessage') return
+    if (!response || !response.Messages || !response.Messages[0]) return
+
+    // we only want to set the payloadSize on the span if we have one message
+    span = response.Messages.length > 1 ? null : span
+
+    for (let message of response.Messages) {
+      // we may have already parsed the message attributes when extracting trace context
+      if (!parsedAttributes) {
+        if (message.Body) {
+          try {
+            const body = JSON.parse(message.Body)
+
+            // SNS to SQS
+            if (body.Type === 'Notification') {
+              message = body
+            }
+          } catch {
+            // SQS to SQS
+          }
+        }
+        if (!parsedAttributes && message.MessageAttributes && message.MessageAttributes._datadog) {
+          parsedAttributes = this.parseDatadogAttributes(message.MessageAttributes._datadog)
+        }
+      }
+      const payloadSize = getHeadersSize({
+        Body: message.Body,
+        MessageAttributes: message.MessageAttributes,
+      })
+      const queue = params.QueueUrl.split('/').pop()
+      if (parsedAttributes) {
+        this.tracer.decodeDataStreamsContext(parsedAttributes)
+      }
+      this.tracer
+        .setCheckpoint(['direction:in', `topic:${queue}`, 'type:sqs'], span, payloadSize)
+    }
+  }
+
+  requestInject (span, request) {
+    const { operation, params } = request
+
+    if (!params) return
+
+    switch (operation) {
+      case 'sendMessage':
+        this.injectToMessage(span, params, params.QueueUrl, true)
+        break
+      case 'sendMessageBatch':
+        for (let i = 0; i < params.Entries.length; i++) {
+          this.injectToMessage(
+            span,
+            params.Entries[i],
+            params.QueueUrl,
+            i === 0 || (this.config.batchPropagationEnabled)
+          )
+        }
+        break
+      case 'receiveMessage':
+        if (!params.MessageAttributeNames) {
+          params.MessageAttributeNames = ['_datadog']
+        } else if (
+          !params.MessageAttributeNames.includes('_datadog') &&
+          !params.MessageAttributeNames.includes('.*') &&
+          !params.MessageAttributeNames.includes('All')
+        ) {
+          params.MessageAttributeNames.push('_datadog')
+        }
+        break
+    }
+  }
+
+  injectToMessage (span, params, queueUrl, injectTraceContext) {
+    if (!params) {
+      params = {}
+    }
+    if (!params.MessageAttributes) {
+      params.MessageAttributes = {}
+    } else if (Object.keys(params.MessageAttributes).length >= 10) { // SQS quota
+      // TODO: add test when the test suite is fixed
+      return
+    }
+    const ddInfo = {}
+    // for now, we only want to inject to the first message, this may change for batches in the future
+    if (injectTraceContext) {
+      this.tracer.inject(span, 'text_map', ddInfo)
+      params.MessageAttributes._datadog = {
+        DataType: 'String',
+        StringValue: JSON.stringify(ddInfo),
+      }
+    }
+
+    if (this.config.dsmEnabled) {
+      if (!params.MessageAttributes._datadog) {
+        params.MessageAttributes._datadog = {
+          DataType: 'String',
+          StringValue: JSON.stringify(ddInfo),
+        }
+      }
+
+      const dataStreamsContext = this.setDSMCheckpoint(span, params, queueUrl)
+      if (dataStreamsContext) {
+        DsmPathwayCodec.encode(dataStreamsContext, ddInfo)
+        params.MessageAttributes._datadog.StringValue = JSON.stringify(ddInfo)
+      }
+    }
+
+    if (params.MessageAttributes._datadog && Object.keys(ddInfo).length === 0) {
+      // let's avoid adding any additional information to payload if we failed to inject
+      delete params.MessageAttributes._datadog
+    }
+  }
+
+  setDSMCheckpoint (span, params, queueUrl) {
+    const payloadSize = getHeadersSize({
+      Body: params.MessageBody,
+      MessageAttributes: params.MessageAttributes,
+    })
+    const queue = queueUrl.split('/').pop()
+    const dataStreamsContext = this.tracer
+      .setCheckpoint(['direction:out', `topic:${queue}`, 'type:sqs'], span, payloadSize)
+    return dataStreamsContext
+  }
+}
+
+module.exports = Sqs

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

@@ -0,0 +1,7 @@
+'use strict'
+const Stepfunctions = require('./stepfunctions')
+class States extends Stepfunctions {
+  static id = 'states'
+}
+
+module.exports = States

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

@@ -0,0 +1,64 @@
+'use strict'
+const log = require('../../../dd-trace/src/log')
+const BaseAwsSdkPlugin = require('../base')
+
+class Stepfunctions extends BaseAwsSdkPlugin {
+  static id = 'stepfunctions'
+
+  // This is the shape of StartExecutionInput, as defined in
+  // https://github.com/aws/aws-sdk-js/blob/master/apis/states-2016-11-23.normal.json
+  // "StartExecutionInput": {
+  //   "type": "structure",
+  //   "required": [
+  //     "stateMachineArn"
+  //   ],
+  //   "members": {
+  //     "stateMachineArn": {
+  //       "shape": "Arn",
+  //     },
+  //     "name": {
+  //       "shape": "Name",
+  //     },
+  //     "input": {
+  //       "shape": "SensitiveData",
+  //     },
+  //     "traceHeader": {
+  //       "shape": "TraceHeader",
+  //     }
+  //   }
+
+  generateTags (params, operation, response) {
+    if (!params) return {}
+    const tags = { 'resource.name': params.name ? `${operation} ${params.name}` : `${operation}` }
+    if (operation === 'startExecution' || operation === 'startSyncExecution') {
+      tags.statemachinearn = `${params.stateMachineArn}`
+    }
+    return tags
+  }
+
+  requestInject (span, request) {
+    const operation = request.operation
+    if (operation === 'startExecution' || operation === 'startSyncExecution') {
+      if (!request.params || !request.params.input) {
+        return
+      }
+
+      const input = request.params.input
+
+      try {
+        const inputObj = JSON.parse(input)
+        if (inputObj !== null && typeof inputObj === 'object') {
+          // We've parsed the input JSON string
+          inputObj._datadog = {}
+          this.tracer.inject(span, 'text_map', inputObj._datadog)
+          const newInput = JSON.stringify(inputObj)
+          request.params.input = newInput
+        }
+      } catch {
+        log.info('Unable to treat input as JSON')
+      }
+    }
+  }
+}
+
+module.exports = Stepfunctions

package/packages/datadog-plugin-aws-sdk/src/util.js

@@ -0,0 +1,151 @@
+'use strict'
+
+const crypto = require('crypto')
+const log = require('../../dd-trace/src/log')
+
+/**
+ * Generates a unique hash from an array of strings by joining them with | before hashing.
+ * Used to uniquely identify AWS requests for span pointers.
+ * @param {string[]} components - Array of strings to hash
+ * @returns {string} A 32-character hash uniquely identifying the components
+ */
+function generatePointerHash (components) {
+  // If passing S3's ETag as a component, make sure any quotes have already been removed!
+  const dataToHash = components.join('|')
+  const hash = crypto.createHash('sha256').update(dataToHash).digest('hex')
+  return hash.slice(0, 32)
+}
+
+/**
+ * Encodes a DynamoDB attribute value to Buffer for span pointer hashing.
+ * @param {object} valueObject - DynamoDB value in AWS format ({ S: string } or { N: string } or { B: Buffer })
+ * @returns {Buffer|undefined} Encoded value as Buffer, or undefined if invalid input.
+ *
+ * @example
+ * encodeValue({ S: "user123" }) -> Buffer("user123")
+ * encodeValue({ N: "42" }) -> Buffer("42")
+ * encodeValue({ B: Buffer([1, 2, 3]) }) -> Buffer([1, 2, 3])
+ */
+function encodeValue (valueObject) {
+  if (!valueObject) {
+    return
+  }
+
+  try {
+    const type = Object.keys(valueObject)[0]
+    const value = valueObject[type]
+
+    switch (type) {
+      case 'S':
+        return Buffer.from(value)
+      case 'N':
+        return Buffer.from(value.toString())
+      case 'B':
+        return Buffer.isBuffer(value) ? value : Buffer.from(value)
+      default:
+        log.debug('Found unknown type while trying to create DynamoDB span pointer:', type)
+    }
+  } catch (err) {
+    log.debug('Failed to encode value while trying to create DynamoDB span pointer:', err.message)
+  }
+}
+
+/**
+ * Extracts and encodes primary key values from a DynamoDB item.
+ * Handles tables with single-key and two-key scenarios.
+ *
+ * @param {Array<string>} keyNames - Set of primary key names.
+ * @param {object} keyValuePairs - Object containing key/value pairs.
+ * @returns {Array|undefined} [key1Name, key1Value, key2Name, key2Value], or undefined if invalid input.
+ *                            key2 entries are empty strings in the single-key case.
+ * @example
+ * extractPrimaryKeys(['userId'], {userId: {S: "user123"}})
+ * // Returns ["userId", Buffer("user123"), "", ""]
+ * extractPrimaryKeys(['userId', 'timestamp'], {userId: {S: "user123"}, timestamp: {N: "1234}})
+ * // Returns ["timestamp", Buffer.from("1234"), "userId", Buffer.from("user123")]
+ */
+const extractPrimaryKeys = (keyNames, keyValuePairs) => {
+  if (keyNames.length === 0) {
+    return
+  }
+
+  if (keyNames.length === 1) {
+    const value = encodeValue(keyValuePairs[keyNames[0]])
+    if (value) {
+      return [keyNames[0], value, '', '']
+    }
+  } else {
+    const [key1, key2] = keyNames.sort()
+    const value1 = encodeValue(keyValuePairs[key1])
+    const value2 = encodeValue(keyValuePairs[key2])
+    if (value1 && value2) {
+      return [key1, value1, key2, value2]
+    }
+  }
+}
+
+/**
+ * Extracts queue metadata from an SQS queue URL for span tagging.
+ * Handles modern and legacy AWS endpoint formats, with or without schemes.
+ * Automatically detects AWS partitions (standard, China, GovCloud) from region.
+ *
+ * @param {string} queueURL - SQS queue URL in any supported format
+ * @returns {object | null} Object with queueName and arn, or null if URL format is invalid
+ *
+ * @example
+ * // Modern AWS SQS URLs
+ * extractQueueMetadata('https://sqs.us-east-1.amazonaws.com/123456789012/my-queue')
+ * // Returns { queueName: 'my-queue', arn: 'arn:aws:sqs:us-east-1:123456789012:my-queue' }
+ *
+ * extractQueueMetadata('sqs.eu-west-1.amazonaws.com/123456789012/my-queue') // no scheme
+ * // Returns { queueName: 'my-queue', arn: 'arn:aws:sqs:eu-west-1:123456789012:my-queue' }
+ *
+ * // Legacy AWS SQS URLs
+ * extractQueueMetadata('https://us-west-2.queue.amazonaws.com/123456789012/legacy-queue')
+ * // Returns { queueName: 'legacy-queue', arn: 'arn:aws:sqs:us-west-2:123456789012:legacy-queue' }
+ *
+ * extractQueueMetadata('https://queue.amazonaws.com/123456789012/global-legacy-queue')
+ * // Returns { queueName: 'global-legacy-queue', arn: 'arn:aws:sqs:us-east-1:123456789012:global-legacy-queue' }
+ */
+const extractQueueMetadata = queueURL => {
+  if (!queueURL) {
+    return null
+  }
+
+  const parts = queueURL.split('/').filter(Boolean)
+
+  // Check if URL has scheme
+  const hasScheme = Boolean(parts[0]?.startsWith('http'))
+  const minParts = hasScheme ? 4 : 3
+
+  if (parts.length < minParts) return null
+
+  const accountId = parts[parts.length - 2]
+  const queueName = parts[parts.length - 1]
+  const host = hasScheme ? parts[1] : parts[0]
+
+  let region = 'us-east-1' // Default region if not found in URL
+  if (host.includes('.amazonaws.com') && !host.startsWith('queue')) {
+    // sqs.{region}.amazonaws.com or {region}.queue.amazonaws.com
+    const startFrom = host.startsWith('sqs.') ? 4 : 0
+    const nextDot = host.indexOf('.', startFrom)
+    region = host.slice(startFrom, nextDot)
+  }
+
+  let partition = 'aws'
+  if (region.startsWith('cn-')) {
+    partition = 'aws-cn'
+  } else if (region.startsWith('us-gov-')) {
+    partition = 'aws-us-gov'
+  }
+
+  const arn = `arn:${partition}:sqs:${region}:${accountId}:${queueName}`
+  return { queueName, arn }
+}
+
+module.exports = {
+  generatePointerHash,
+  encodeValue,
+  extractPrimaryKeys,
+  extractQueueMetadata,
+}

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

@@ -0,0 +1,49 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+class AzureDurableFunctionsPlugin extends TracingPlugin {
+  static get id () { return 'azure-durable-functions' }
+  static get operation () { return 'invoke' }
+  static get prefix () { return 'tracing:datadog:azure:durable-functions:invoke' }
+  static get type () { return 'serverless' }
+  static get kind () { return 'server' }
+
+  bindStart (ctx) {
+    const span = this.startSpan(this.operationName(), {
+      kind: 'internal',
+      type: 'serverless',
+
+      meta: {
+        component: 'azure-functions',
+        'aas.function.name': ctx.functionName,
+        'aas.function.trigger': ctx.trigger,
+        'resource.name': `${ctx.trigger} ${ctx.functionName}`,
+      },
+    }, ctx)
+
+    // in the case of entity functions, operationName should be available
+    if (ctx.operationName) {
+      span.setTag('aas.function.operation', ctx.operationName)
+      span.setTag('resource.name', `${ctx.trigger} ${ctx.functionName} ${ctx.operationName}`
+      )
+    }
+
+    ctx.span = span
+    return ctx.currentStore
+  }
+
+  end (ctx) {
+    // We only want to run finish here if this is a synchronous operation
+    // Only synchronous operations would have `result` or `error` on `end`
+    // So we skip operations that dont
+    if (!ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+    super.finish(ctx)
+  }
+
+  asyncStart (ctx) {
+    super.finish(ctx)
+  }
+}
+
+module.exports = AzureDurableFunctionsPlugin