@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-plugin-azure-event-hubs/src/index.js

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

package/packages/datadog-plugin-azure-event-hubs/src/producer.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+
+const spanContexts = new WeakMap()
+
+class AzureEventHubsProducerPlugin extends ProducerPlugin {
+  static get id () { return 'azure-event-hubs' }
+  static get operation () { return 'send' }
+  static get prefix () { return 'tracing:apm:azure-event-hubs:send' }
+
+  bindStart (ctx) {
+    // we do not want to make these spans when batch linking is disabled.
+    if (!batchLinksAreEnabled() && ctx.functionName === 'tryAdd') {
+      return ctx.currentStore
+    }
+
+    const qualifiedNamespace = ctx.config.endpoint.replace('sb://', '').replace('/', '')
+    const entityPath = ctx.config.entityPath
+    const span = this.startSpan({
+      resource: entityPath,
+      type: 'messaging',
+      meta: {
+        component: 'azure-event-hubs',
+        'messaging.system': 'eventhubs',
+        'messaging.destination.name': entityPath,
+        'network.destination.name': qualifiedNamespace,
+      },
+    }, ctx)
+
+    if (ctx.functionName === 'tryAdd') {
+      span._spanContext._name = 'azure.eventhubs.create'
+      span.setTag('messaging.operation', 'create')
+
+      if (ctx.eventData.messageID !== undefined) {
+        span.setTag('message.id', ctx.eventData.messageID)
+      }
+
+      if (batchLinksAreEnabled()) {
+        const spanContext = spanContexts.get(ctx.batch)
+        if (spanContext) {
+          spanContext.push(span.context())
+        } else {
+          spanContexts.set(ctx.batch, [span.context()])
+        }
+        injectTraceContext(this.tracer, span, ctx.eventData)
+      }
+    }
+
+    if (ctx.functionName === 'sendBatch') {
+      const eventData = ctx.eventData
+      const eventDataLength = eventData.length || eventData._context.connection._eventsCount
+      span.setTag('messaging.operation', 'send')
+      span.setTag('messaging.batch.message_count', eventDataLength)
+
+      if (eventData.constructor.name !== 'EventDataBatchImpl' && Array.isArray(eventData)) {
+        for (const event of eventData) {
+          injectTraceContext(this.tracer, span, event)
+        }
+      } else {
+        if (batchLinksAreEnabled()) {
+          const contexts = spanContexts.get(eventData)
+          if (contexts) {
+            for (const spanContext of contexts) {
+              span.addLink(spanContext)
+            }
+          }
+        }
+      }
+    }
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    super.finish(ctx)
+  }
+
+  end (ctx) {
+    super.finish(ctx)
+  }
+}
+
+function injectTraceContext (tracer, span, event) {
+  if (!event.properties) {
+    event.properties = {}
+  }
+  tracer.inject(span, 'text_map', event.properties)
+}
+
+function batchLinksAreEnabled () {
+  const eh = getValueFromEnvSources('DD_TRACE_AZURE_EVENTHUBS_BATCH_LINKS_ENABLED')
+  return eh !== 'false'
+}
+
+module.exports = AzureEventHubsProducerPlugin

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

@@ -0,0 +1,171 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+const triggerMap = {
+  deleteRequest: 'Http',
+  http: 'Http',
+  get: 'Http',
+  patch: 'Http',
+  post: 'Http',
+  put: 'Http',
+  serviceBusQueue: 'ServiceBus',
+  serviceBusTopic: 'ServiceBus',
+  eventHub: 'EventHubs',
+}
+
+class AzureFunctionsPlugin extends TracingPlugin {
+  static id = 'azure-functions'
+  static operation = 'invoke'
+  static kind = 'server'
+  static type = 'serverless'
+  static prefix = 'tracing:datadog:azure:functions:invoke'
+
+  bindStart (ctx) {
+    const meta = getMetaForTrigger(ctx)
+    const triggerType = triggerMap[ctx.methodName]
+    const isHttpTrigger = triggerType === 'Http'
+    const isMessagingService = (triggerType === 'ServiceBus' || triggerType === 'EventHubs')
+
+    let span
+
+    if (isHttpTrigger) {
+      const { httpRequest } = ctx
+      const path = (new URL(httpRequest.url)).pathname
+      const req = {
+        method: httpRequest.method,
+        headers: Object.fromEntries(httpRequest.headers),
+        url: path,
+      }
+      // Patch the request to create web context
+      const webContext = web.patch(req)
+      webContext.config = this.config
+      webContext.tracer = this.tracer
+      webContext.paths = [path]
+      // Creates a standard span and an inferred proxy span if headers are present
+      span = web.startServerlessSpanWithInferredProxy(
+        this.tracer,
+        this.config,
+        this.operationName(),
+        req,
+        ctx
+      )
+
+      span._integrationName = 'azure-functions'
+      span.context()._tags.component = 'azure-functions'
+      span.addTags(meta)
+      webContext.span = span
+      webContext.azureFunctionCtx = ctx
+      ctx.webContext = webContext
+    } else {
+      // For non-HTTP triggers, use standard flow
+      span = this.startSpan(this.operationName(), {
+        service: this.serviceName(),
+        type: 'serverless',
+        meta,
+      }, ctx)
+
+      if (isMessagingService) {
+        setSpanLinks(triggerType, this.tracer, span, ctx)
+      }
+    }
+    ctx.span = span
+    return ctx.currentStore
+  }
+
+  error (ctx) {
+    this.addError(ctx.error)
+    ctx.currentStore.span.setTag('error.message', ctx.error)
+  }
+
+  asyncStart (ctx) {
+    const { methodName, result = {}, webContext } = ctx
+    const triggerType = triggerMap[methodName]
+
+    // For HTTP triggers, use web utilities to finish all spans (including inferred proxy)
+    if (triggerType === 'Http') {
+      if (webContext) {
+        webContext.res = { statusCode: result.status }
+        web.finishAll(webContext, 'serverless')
+      }
+    } else {
+      super.finish()
+    }
+  }
+
+  configure (config) {
+    return super.configure(web.normalizeConfig(config))
+  }
+}
+
+function getMetaForTrigger ({ functionName, methodName, invocationContext }) {
+  let meta = {
+    'aas.function.name': functionName,
+    'aas.function.trigger': mapTriggerTag(methodName),
+    'span.type': 'serverless',
+  }
+
+  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',
+    }
+  } else if (triggerMap[methodName] === 'EventHubs') {
+    const partitionContext = invocationContext.triggerMetadata.triggerPartitionContext
+    meta = {
+      ...meta,
+      'messaging.destination.name': partitionContext.eventHubName,
+      'messaging.operation': 'receive',
+      'messaging.system': 'eventhubs',
+      'resource.name': `EventHubs ${functionName}`,
+      'span.kind': 'consumer',
+    }
+  }
+
+  return meta
+}
+
+function mapTriggerTag (methodName) {
+  return triggerMap[methodName] || 'Unknown'
+}
+
+// message & messages & batch with cardinality of 1 == applicationProperties
+// messages with cardinality of many == applicationPropertiesArray
+function setSpanLinks (triggerType, tracer, span, ctx) {
+  const cardinality = ctx.invocationContext.options.trigger.cardinality
+  const triggerMetadata = ctx.invocationContext.triggerMetadata
+  const isServiceBus = triggerType === 'ServiceBus'
+
+  const properties = isServiceBus
+    ? triggerMetadata.applicationProperties
+    : triggerMetadata.properties
+
+  const propertiesArray = isServiceBus
+    ? triggerMetadata.applicationPropertiesArray
+    : triggerMetadata.propertiesArray
+
+  const addLinkFromProperties = (props) => {
+    if (!props || Object.keys(props).length === 0) return
+    const spanContext = tracer.extract('text_map', props)
+    if (spanContext) {
+      span.addLink(spanContext)
+    }
+  }
+
+  if (cardinality === 'many' && propertiesArray?.length > 0) {
+    for (const prop of propertiesArray) {
+      addLinkFromProperties(prop)
+    }
+  } else if (cardinality === 'one') {
+    addLinkFromProperties(properties)
+  }
+}
+
+module.exports = AzureFunctionsPlugin

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

@@ -0,0 +1,15 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ProducerPlugin = require('./producer')
+
+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,97 @@
+'use strict'
+
+const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const spanContexts = new WeakMap()
+
+class AzureServiceBusProducerPlugin extends ProducerPlugin {
+  static get id () { return 'azure-service-bus' }
+  static get operation () { return 'send' }
+  static get prefix () { return 'tracing:apm:azure-service-bus:send' }
+
+  bindStart (ctx) {
+    // we do not want to make these spans when batch linking is disabled.
+    if (!batchLinksAreEnabled() && ctx.functionName === 'tryAddMessage') {
+      return ctx.currentStore
+    }
+
+    const qualifiedSenderNamespace = ctx.config.host
+    const span = this.startSpan({
+      resource: ctx.entityPath,
+      type: 'messaging',
+      meta: {
+        component: 'azure-service-bus',
+        'messaging.destination.name': ctx.entityPath,
+        'messaging.operation': 'send',
+        'messaging.system': 'servicebus',
+        'network.destination.name': qualifiedSenderNamespace,
+      },
+    }, ctx)
+
+    if (ctx.functionName === 'tryAddMessage') {
+      span._spanContext._name = 'azure.servicebus.create'
+      span.setTag('messaging.operation', 'create')
+
+      if (ctx.msg.messageID !== undefined) {
+        span.setTag('message.id', ctx.msg)
+      }
+
+      if (batchLinksAreEnabled()) {
+        const spanContext = spanContexts.get(ctx.batch)
+        if (spanContext) {
+          spanContext.push(span.context())
+        } else {
+          spanContexts.set(ctx.batch, [span.context()])
+        }
+        injectTraceContext(this.tracer, span, ctx.msg)
+      }
+    }
+
+    if (ctx.functionName === 'send' || ctx.functionName === 'sendBatch' || ctx.functionName === 'scheduleMessages') {
+      const messages = ctx.msg
+      const isBatch = messages.constructor?.name === 'ServiceBusMessageBatchImpl'
+      if (isBatch) {
+        span.setTag('messaging.batch.message_count', messages.count)
+        if (batchLinksAreEnabled()) {
+          const contexts = spanContexts.get(messages)
+          if (contexts) {
+            for (const spanContext of contexts) {
+              span.addLink(spanContext)
+            }
+          }
+        }
+      } else if (Array.isArray(messages)) {
+        span.setTag('messaging.batch.message_count', messages.length)
+        for (const event of messages) {
+          injectTraceContext(this.tracer, span, event)
+        }
+      } else {
+        injectTraceContext(this.tracer, span, messages)
+      }
+    }
+    return ctx.currentStore
+  }
+
+  asyncEnd (ctx) {
+    super.finish(ctx)
+  }
+
+  end (ctx) {
+    super.finish(ctx)
+  }
+}
+
+function injectTraceContext (tracer, span, msg) {
+  if (!msg.applicationProperties) {
+    msg.applicationProperties = {}
+  }
+
+  tracer.inject(span, 'text_map', msg.applicationProperties)
+}
+
+function batchLinksAreEnabled () {
+  const sb = getValueFromEnvSources('DD_TRACE_AZURE_SERVICEBUS_BATCH_LINKS_ENABLED')
+  return sb !== 'false'
+}
+
+module.exports = AzureServiceBusProducerPlugin

package/packages/datadog-plugin-bullmq/src/consumer.js

@@ -0,0 +1,82 @@
+'use strict'
+
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const { getMessageSize } = require('../../dd-trace/src/datastreams')
+
+class BullmqConsumerPlugin extends ConsumerPlugin {
+  static id = 'bullmq'
+  static prefix = 'tracing:orchestrion:bullmq:Worker_callProcessJob'
+
+  asyncEnd (ctx) {
+    ctx.currentStore?.span?.finish()
+  }
+
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    const { span } = ctx.currentStore
+    this.setConsumerCheckpoint(span, ctx)
+  }
+
+  bindStart (ctx) {
+    const job = ctx.arguments?.[0]
+    const queueName = job?.queueName || job?.queue?.name || 'bullmq'
+
+    let childOf
+    const ddCarrier = this._extractDatadog(job)
+    if (ddCarrier) {
+      ctx._ddCarrier = ddCarrier
+      childOf = this.tracer.extract('text_map', ddCarrier)
+    }
+
+    this.startSpan({
+      childOf,
+      resource: queueName,
+      meta: {
+        component: 'bullmq',
+        'span.kind': 'consumer',
+        'messaging.system': 'bullmq',
+        'messaging.destination.name': queueName,
+        'messaging.operation': 'process',
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  setConsumerCheckpoint (span, ctx) {
+    const job = ctx.arguments?.[0]
+    if (!job) return
+
+    const queueName = job.queueName || job.queue?.name || 'bullmq'
+    const payloadSize = job.data ? getMessageSize(job.data) : 0
+
+    const ddCarrier = ctx._ddCarrier
+    if (ddCarrier) {
+      this.tracer.decodeDataStreamsContext(ddCarrier)
+    }
+
+    const edgeTags = ['direction:in', `topic:${queueName}`, 'type:bullmq']
+    this.tracer.setCheckpoint(edgeTags, span, payloadSize)
+  }
+
+  _extractDatadog (job) {
+    const metadataStr = job?.opts?.telemetry?.metadata
+    if (!metadataStr) return
+
+    try {
+      const metadata = JSON.parse(metadataStr)
+      const ddCarrier = metadata._datadog
+      if (!ddCarrier) return
+
+      // Clean up only our _datadog key, preserve other metadata
+      delete metadata._datadog
+      job.opts.telemetry.metadata = JSON.stringify(metadata)
+
+      return ddCarrier
+    } catch {
+      // Ignore malformed metadata
+    }
+  }
+}
+
+module.exports = BullmqConsumerPlugin

package/packages/datadog-plugin-bullmq/src/index.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const BullmqProducerPlugins = require('./producer')
+const BullmqConsumerPlugin = require('./consumer')
+
+class BullmqPlugin extends CompositePlugin {
+  static id = 'bullmq'
+
+  static plugins = {
+    queueAdd: BullmqProducerPlugins[0],
+    queueAddBulk: BullmqProducerPlugins[1],
+    flowProducerAdd: BullmqProducerPlugins[2],
+    consumer: BullmqConsumerPlugin,
+  }
+}
+
+module.exports = BullmqPlugin

package/packages/datadog-plugin-bullmq/src/producer.js

@@ -0,0 +1,207 @@
+'use strict'
+
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { DsmPathwayCodec, getMessageSize } = require('../../dd-trace/src/datastreams')
+
+class BaseBullmqProducerPlugin extends ProducerPlugin {
+  static id = 'bullmq'
+
+  asyncEnd (ctx) {
+    ctx.currentStore?.span?.finish()
+  }
+
+  start (ctx) {
+    if (!this.config.dsmEnabled) return
+    const { span } = ctx.currentStore
+    this.setProducerCheckpoint(span, ctx)
+  }
+
+  bindStart (ctx) {
+    const { resource, meta } = this.getSpanData(ctx)
+    const span = this.startSpan({
+      resource,
+      meta: {
+        component: 'bullmq',
+        'span.kind': 'producer',
+        'messaging.system': 'bullmq',
+        'messaging.operation': 'publish',
+        ...meta,
+      },
+    }, ctx)
+
+    this.injectTraceContext(span, ctx)
+
+    return ctx.currentStore
+  }
+
+  getSpanData (ctx) {
+    throw new Error('getSpanData must be implemented by subclass')
+  }
+
+  injectTraceContext (span, ctx) {
+    throw new Error('injectTraceContext must be implemented by subclass')
+  }
+
+  _injectIntoOpts (span, opts) {
+    const carrier = {}
+    this.tracer.inject(span, 'text_map', carrier)
+    const existing = opts.telemetry?.metadata ? JSON.parse(opts.telemetry.metadata) : {}
+    existing._datadog = carrier
+    opts.telemetry = { metadata: JSON.stringify(existing), omitContext: true }
+  }
+
+  setProducerCheckpoint (span, ctx) {
+    const { queueName, payloadSize, optsTarget } = this.getDsmData(ctx)
+    const edgeTags = ['direction:out', `topic:${queueName}`, 'type:bullmq']
+    const dataStreamsContext = this.tracer.setCheckpoint(edgeTags, span, payloadSize)
+
+    if (optsTarget && typeof optsTarget === 'object') {
+      const existing = optsTarget.telemetry?.metadata ? JSON.parse(optsTarget.telemetry.metadata) : {}
+      DsmPathwayCodec.encode(dataStreamsContext, existing._datadog || existing)
+      if (!existing._datadog) existing._datadog = {}
+      optsTarget.telemetry = { metadata: JSON.stringify(existing), omitContext: true }
+    }
+  }
+
+  getDsmData (ctx) {
+    throw new Error('getDsmData must be implemented by subclass')
+  }
+}
+
+class QueueAddPlugin extends BaseBullmqProducerPlugin {
+  static prefix = 'tracing:orchestrion:bullmq:Queue_add'
+
+  getSpanData (ctx) {
+    const queueName = ctx.self?.name || 'bullmq'
+    return {
+      resource: queueName,
+      meta: {
+        'messaging.destination.name': ctx.self?.name,
+      },
+    }
+  }
+
+  #ensureOpts (ctx) {
+    let opts = ctx.arguments?.[2]
+    if (!opts || typeof opts !== 'object') {
+      opts = {}
+      if (ctx.arguments.length <= 2) {
+        Array.prototype.push.call(ctx.arguments, opts)
+      } else {
+        ctx.arguments[2] = opts
+      }
+    }
+    return opts
+  }
+
+  injectTraceContext (span, ctx) {
+    const opts = this.#ensureOpts(ctx)
+    this._injectIntoOpts(span, opts)
+  }
+
+  getDsmData (ctx) {
+    const data = ctx.arguments?.[1]
+    return {
+      queueName: ctx.self?.name || 'bullmq',
+      payloadSize: data ? getMessageSize(data) : 0,
+      optsTarget: this.#ensureOpts(ctx),
+    }
+  }
+}
+
+class QueueAddBulkPlugin extends BaseBullmqProducerPlugin {
+  static prefix = 'tracing:orchestrion:bullmq:Queue_addBulk'
+
+  operationName () {
+    return 'bullmq.addBulk'
+  }
+
+  getSpanData (ctx) {
+    const queueName = ctx.self?.name || 'bullmq'
+    const jobs = ctx.arguments?.[0]
+    return {
+      resource: queueName,
+      meta: {
+        'messaging.destination.name': ctx.self?.name,
+        'messaging.batch.message_count': Array.isArray(jobs) ? jobs.length : undefined,
+      },
+    }
+  }
+
+  injectTraceContext (span, ctx) {
+    const jobs = ctx.arguments?.[0]
+    if (!Array.isArray(jobs)) return
+
+    for (const job of jobs) {
+      if (!job) continue
+      job.opts = job.opts || {}
+      this._injectIntoOpts(span, job.opts)
+    }
+  }
+
+  getDsmData (ctx) {
+    const jobs = ctx.arguments?.[0] || []
+    const payloadSize = jobs.reduce((total, job) => {
+      return total + (job?.data ? getMessageSize(job.data) : 0)
+    }, 0)
+    return {
+      queueName: ctx.self?.name || 'bullmq',
+      payloadSize,
+      optsTarget: jobs[0]?.opts,
+    }
+  }
+
+  setProducerCheckpoint (span, ctx) {
+    const jobs = ctx.arguments?.[0] || []
+    const queueName = ctx.self?.name || 'bullmq'
+    const edgeTags = ['direction:out', `topic:${queueName}`, 'type:bullmq']
+
+    for (const job of jobs) {
+      if (!job?.data) continue
+      const payloadSize = getMessageSize(job.data)
+      const dataStreamsContext = this.tracer.setCheckpoint(edgeTags, span, payloadSize)
+      job.opts = job.opts || {}
+      const existing = job.opts.telemetry?.metadata ? JSON.parse(job.opts.telemetry.metadata) : {}
+      DsmPathwayCodec.encode(dataStreamsContext, existing._datadog || existing)
+      if (!existing._datadog) existing._datadog = {}
+      job.opts.telemetry = { metadata: JSON.stringify(existing), omitContext: true }
+    }
+  }
+}
+
+class FlowProducerAddPlugin extends BaseBullmqProducerPlugin {
+  static prefix = 'tracing:orchestrion:bullmq:FlowProducer_add'
+
+  getSpanData (ctx) {
+    const flow = ctx.arguments?.[0]
+    const queueName = flow?.queueName || 'bullmq'
+    return {
+      resource: queueName,
+      meta: {
+        'messaging.destination.name': flow?.queueName,
+      },
+    }
+  }
+
+  injectTraceContext (span, ctx) {
+    const flow = ctx.arguments?.[0]
+    if (!flow) return
+    flow.opts = flow.opts || {}
+    this._injectIntoOpts(span, flow.opts)
+  }
+
+  getDsmData (ctx) {
+    const flow = ctx.arguments?.[0]
+    if (!flow) {
+      return { queueName: 'bullmq', payloadSize: 0, optsTarget: undefined }
+    }
+    flow.opts = flow.opts || {}
+    return {
+      queueName: flow.queueName || 'bullmq',
+      payloadSize: flow.data ? getMessageSize(flow.data) : 0,
+      optsTarget: flow.opts,
+    }
+  }
+}
+
+module.exports = [QueueAddPlugin, QueueAddBulkPlugin, FlowProducerAddPlugin]