@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-plugin-prisma/src/datadog-tracing-helper.js

@@ -0,0 +1,118 @@
+'use strict'
+
+const { tracingChannel } = /** @type {import('node:diagnostics_channel')} */ (require('dc-polyfill'))
+const clientCH = tracingChannel('apm:prisma')
+const { storage } = require('../../datadog-core')
+
+const allowedClientSpanOperations = new Set([
+  'operation',
+  'serialize',
+  'transaction',
+])
+
+class DatadogTracingHelper {
+  #prismaClient
+  #dbConfig
+
+  /**
+   * @param {import('../../datadog-instrumentations/src/prisma').DbConfig|undefined} dbConfig
+   * @param {import('./index')} prismaClient
+   */
+  constructor (dbConfig, prismaClient) {
+    this.#dbConfig = dbConfig
+    this.#prismaClient = prismaClient
+  }
+
+  isEnabled () {
+    return true
+  }
+
+  /**
+   * Needs a sampled tracecontext to generate engine spans
+   *
+   * @param {object} [context]
+   * @returns {string}
+   */
+  getTraceParent (context) {
+    const store = storage('legacy').getStore()
+    const span = store?.span
+    if (span?._spanContext) {
+      const context = span._spanContext
+
+      const traceId = context.toTraceId(true)
+      const spanId = context.toSpanId(true)
+      const version = (context._traceparent && context._traceparent.version) || '00'
+
+      // always sampled a sampled traceparent due to the following reasons:
+      // 1. Datadog spans are sampled on span.finish
+      // 2. Prisma engine spans only generate spans when the trace is sampled
+      return `${version}-${traceId}-${spanId}-01`
+    }
+
+    // No active span - return sampled
+    return '00-00000000000000000000000000000000-0000000000000000-01'
+  }
+
+  /**
+   * @param {object[]} spans
+   */
+  dispatchEngineSpans (spans) {
+    if (!spans?.length) {
+      return
+    }
+    const childrenByParent = new Map()
+    for (const span of spans) {
+      const parentId = span.parentId
+      const children = childrenByParent.get(parentId)
+      if (children) {
+        children.push(span)
+      } else {
+        childrenByParent.set(parentId, [span])
+      }
+    }
+
+    const roots = childrenByParent.get(null)
+    if (!roots) {
+      return
+    }
+    for (const span of roots) {
+      this.#prismaClient.startEngineSpan({ engineSpan: span, childrenByParent, dbConfig: this.#dbConfig })
+    }
+  }
+
+  getActiveContext () {
+    const store = storage('legacy').getStore()
+    return store?.span?._spanContext
+  }
+
+  /**
+   * @param {object} options
+   * @param {Function} callback
+   * @returns {unknown}
+   */
+  runInChildSpan (options, callback) {
+    if (!clientCH.start?.hasSubscribers) {
+      return callback.apply(this, arguments)
+    }
+    if (typeof options === 'string') {
+      options = {
+        name: options,
+      }
+    }
+    if (allowedClientSpanOperations.has(options.name)) {
+      const ctx = {
+        resourceName: options.name,
+        attributes: options.attributes || {},
+      }
+
+      if (options.name !== 'serialize') {
+        return clientCH.tracePromise(callback, ctx, this, ...arguments)
+      }
+
+      return clientCH.traceSync(callback, ctx, this, ...arguments)
+    }
+    return callback()
+  }
+}
+
+module.exports = DatadogTracingHelper

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

@@ -0,0 +1,144 @@
+'use strict'
+
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const DatadogTracingHelper = require('./datadog-tracing-helper')
+
+const databaseDriverMapper = {
+  postgresql: {
+    type: 'sql',
+    'db.type': 'postgres',
+  },
+  mysql: {
+    type: 'sql',
+    'db.type': 'mysql',
+  },
+  mongodb: {
+    type: 'mongodb',
+    'db.type': 'mongodb',
+  },
+  sqlite: {
+    type: 'sql',
+    'db.type': 'sqlite',
+  },
+}
+
+class PrismaPlugin extends DatabasePlugin {
+  static id = 'prisma'
+  static system = 'prisma'
+  static prefix = 'tracing:apm:prisma'
+
+  constructor (...args) {
+    super(...args)
+
+    // Subscribe to helper initialization to inject callbacks
+    this.addSub('apm:prisma:helper:init', (ctx) => {
+      const prismaHelperCtx =
+        /** @type {import('../../datadog-instrumentations/src/prisma').PrismaHelperCtx} */ (ctx)
+      prismaHelperCtx.helper = new DatadogTracingHelper(prismaHelperCtx.dbConfig, this)
+    })
+  }
+
+  startEngineSpan (ctx) {
+    const { engineSpan, childrenByParent, childOf, dbConfig } = ctx
+    const service = this.serviceName({ pluginConfig: this.config, system: this.system })
+    const spanName = engineSpan.name.slice(14) // remove 'prisma:engine:' prefix
+    const options = {
+      childOf,
+      resource: spanName,
+      service,
+      kind: engineSpan.kind,
+      meta: {
+        prisma: {
+          name: spanName,
+          type: 'engine',
+        },
+      },
+    }
+
+    if (spanName === 'db_query') {
+      const query = engineSpan.attributes['db.query.text']
+      const originalStatement = this.maybeTruncate(query)
+      const type = databaseDriverMapper[engineSpan.attributes['db.system']]?.type
+      const dbType = databaseDriverMapper[engineSpan.attributes['db.system']]?.['db.type']
+
+      options.resource = originalStatement
+      options.type = type || engineSpan.attributes['db.system']
+      options.meta['db.type'] = dbType || engineSpan.attributes['db.system']
+      options.meta['db.name'] = dbConfig?.database
+      options.meta['db.user'] = dbConfig?.user
+      options.meta['out.host'] = dbConfig?.host
+      options.meta[CLIENT_PORT_KEY] = dbConfig?.port
+    }
+
+    const activeSpan = this.startSpan(this.operationName({ operation: 'engine' }), options)
+    activeSpan._startTime = hrTimeToUnixTimeMs(engineSpan.startTime)
+    const children = childrenByParent.get(engineSpan.id)
+    if (children) {
+      for (const span of children) {
+        const startCtx = { engineSpan: span, childrenByParent, childOf: activeSpan, dbConfig }
+        this.startEngineSpan(startCtx)
+      }
+    }
+    const unixEndTime = hrTimeToUnixTimeMs(engineSpan.endTime)
+    activeSpan.finish(unixEndTime)
+  }
+
+  bindStart (ctx) {
+    const service = this.serviceName({ pluginConfig: this.config })
+    const resource = formatResourceName(ctx.resourceName, ctx.attributes)
+
+    const options = { service, resource }
+
+    if (ctx.resourceName === 'operation') {
+      options.meta = {
+        prisma: {
+          method: ctx.attributes.method,
+          model: ctx.attributes.model,
+          type: 'client',
+        },
+      }
+    }
+    const operationName = this.operationName({ operation: 'client' })
+    this.startSpan(operationName, options, ctx)
+
+    return ctx.currentStore
+  }
+
+  end (ctx) {
+    // Only synchronous operations would have `result` on `end`.
+    if (Object.hasOwn(ctx, 'result')) {
+      this.finish(ctx)
+    }
+  }
+
+  bindAsyncStart (ctx) {
+    return this.bindFinish(ctx)
+  }
+
+  asyncStart (ctx) {
+    this.finish(ctx)
+  }
+
+  error (error) {
+    this.addError(error)
+  }
+}
+
+function formatResourceName (resource, attributes) {
+  if (attributes?.name) {
+    return `${attributes.name}`.trim()
+  }
+  if (attributes?.model && attributes.method) {
+    return `${attributes.model}.${attributes.method}`.trim()
+  }
+  return resource
+}
+
+// Opentelemetry time format is defined here
+// https://github.com/open-telemetry/opentelemetry-js/blob/cbc912d/api/src/common/Time.ts#L19-L30.
+function hrTimeToUnixTimeMs ([seconds, nanoseconds]) {
+  return seconds * 1000 + nanoseconds / 1e6
+}
+
+module.exports = PrismaPlugin

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

@@ -0,0 +1,12 @@
+'use strict'
+
+const SchemaPlugin = require('../../dd-trace/src/plugins/schema')
+const SchemaExtractor = require('./schema_iterator')
+
+class ProtobufjsPlugin extends SchemaPlugin {
+  static id = 'protobufjs'
+
+  static schemaExtractor = SchemaExtractor
+}
+
+module.exports = ProtobufjsPlugin

package/packages/datadog-plugin-protobufjs/src/schema_iterator.js

@@ -0,0 +1,181 @@
+'use strict'
+
+const PROTOBUF = 'protobuf'
+const {
+  SCHEMA_DEFINITION,
+  SCHEMA_ID,
+  SCHEMA_NAME,
+  SCHEMA_OPERATION,
+  SCHEMA_WEIGHT,
+  SCHEMA_TYPE,
+} = require('../../dd-trace/src/constants')
+const log = require('../../dd-trace/src/log')
+const {
+  SchemaBuilder,
+} = require('../../dd-trace/src/datastreams')
+
+class SchemaExtractor {
+  constructor (schema) {
+    this.schema = schema
+  }
+
+  static getTypeAndFormat (type) {
+    const typeFormatMapping = {
+      int32: ['integer', 'int32'],
+      int64: ['integer', 'int64'],
+      uint32: ['integer', 'uint32'],
+      uint64: ['integer', 'uint64'],
+      sint32: ['integer', 'sint32'],
+      sint64: ['integer', 'sint64'],
+      fixed32: ['integer', 'fixed32'],
+      fixed64: ['integer', 'fixed64'],
+      sfixed32: ['integer', 'sfixed32'],
+      sfixed64: ['integer', 'sfixed64'],
+      float: ['number', 'float'],
+      double: ['number', 'double'],
+      bool: ['boolean', null],
+      string: ['string', null],
+      bytes: ['string', 'byte'],
+      Enum: ['enum', null],
+      Type: ['type', null],
+      map: ['map', null],
+      repeated: ['array', null],
+    }
+
+    return typeFormatMapping[type] || ['string', null]
+  }
+
+  static extractProperty (field, schemaName, fieldName, builder, depth) {
+    let array = false
+    let description
+    let ref
+    let enumValues
+
+    const resolvedType = field.resolvedType ? field.resolvedType.constructor.name : field.type
+
+    const isRepeatedField = field.rule === 'repeated'
+
+    let typeFormat = this.getTypeAndFormat(isRepeatedField ? 'repeated' : resolvedType)
+    let type = typeFormat[0]
+    let format = typeFormat[1]
+
+    if (type === 'array') {
+      array = true
+      typeFormat = this.getTypeAndFormat(resolvedType)
+      type = typeFormat[0]
+      format = typeFormat[1]
+    }
+
+    if (type === 'type') {
+      format = null
+      ref = `#/components/schemas/${removeLeadingPeriod(field.resolvedType.fullName)}`
+      // keep a reference to the original builder iterator since when we recurse this reference will get reset to
+      // deeper schemas
+      const originalSchemaExtractor = builder.iterator
+      if (!this.extractSchema(field.resolvedType, builder, depth, this)) {
+        return false
+      }
+      type = 'object'
+      builder.iterator = originalSchemaExtractor
+    } else if (type === 'enum') {
+      enumValues = []
+      let i = 0
+      while (field.resolvedType.valuesById[i]) {
+        enumValues.push(field.resolvedType.valuesById[i])
+        i += 1
+      }
+    }
+    return builder.addProperty(schemaName, fieldName, array, type, description, ref, format, enumValues)
+  }
+
+  static extractSchema (schema, builder, depth, extractor) {
+    depth += 1
+    const schemaName = removeLeadingPeriod(schema.resolvedType ? schema.resolvedType.fullName : schema.fullName)
+    if (extractor) {
+      // if we already have a defined extractor, this is a nested schema. create a new extractor for the nested
+      // schema, ensure it is added to our schema builder's cache, and replace the builders iterator with our
+      // nested schema iterator / extractor. Once complete, add the new schema to our builder's schemas.
+      const nestedSchemaExtractor = new SchemaExtractor(schema)
+      builder.iterator = nestedSchemaExtractor
+      const nestedSchema = SchemaBuilder.getSchema(schemaName, nestedSchemaExtractor, builder)
+      for (const nestedSubSchemaName in nestedSchema.components.schemas) {
+        if (nestedSchema.components.schemas.hasOwnProperty(nestedSubSchemaName)) {
+          builder.schema.components.schemas[nestedSubSchemaName] = nestedSchema.components.schemas[nestedSubSchemaName]
+        }
+      }
+      return true
+    }
+    if (!builder.shouldExtractSchema(schemaName, depth)) {
+      return false
+    }
+    for (const field of schema.fieldsArray) {
+      if (!this.extractProperty(field, schemaName, field.name, builder, depth)) {
+        log.warn('DSM: Unable to extract field with name: %s from Avro schema with name:', field.name, schemaName)
+      }
+    }
+    return true
+  }
+
+  static extractSchemas (descriptor, dataStreamsProcessor) {
+    const schemaName = removeLeadingPeriod(
+      descriptor.resolvedType ? descriptor.resolvedType.fullName : descriptor.fullName
+    )
+    return dataStreamsProcessor.getSchema(schemaName, new SchemaExtractor(descriptor))
+  }
+
+  iterateOverSchema (builder) {
+    this.constructor.extractSchema(this.schema, builder, 0)
+  }
+
+  static attachSchemaOnSpan (args, span, operation, tracer) {
+    const { messageClass } = args
+    const descriptor = messageClass.$type ?? messageClass
+
+    if (!descriptor || !span) {
+      return
+    }
+
+    if (span.context()._tags[SCHEMA_TYPE] && operation === 'serialization') {
+      // we have already added a schema to this span, this call is an encode of nested schema types
+      return
+    }
+
+    span.setTag(SCHEMA_TYPE, PROTOBUF)
+    span.setTag(SCHEMA_NAME, removeLeadingPeriod(descriptor.fullName))
+    span.setTag(SCHEMA_OPERATION, operation)
+
+    if (!tracer._dataStreamsProcessor.canSampleSchema(operation)) {
+      return
+    }
+
+    // if the span is unsampled, do not sample the schema
+    if (!tracer._prioritySampler.isSampled(span)) {
+      return
+    }
+
+    const weight = tracer._dataStreamsProcessor.trySampleSchema(operation)
+    if (weight === 0) {
+      return
+    }
+
+    const schemaData = SchemaBuilder.getSchemaDefinition(
+      this.extractSchemas(descriptor, tracer._dataStreamsProcessor)
+    )
+
+    span.setTag(SCHEMA_DEFINITION, schemaData.definition)
+    span.setTag(SCHEMA_WEIGHT, weight)
+    span.setTag(SCHEMA_ID, schemaData.id)
+  }
+}
+
+function removeLeadingPeriod (str) {
+  // Check if the first character is a period
+  if (str.charAt(0) === '.') {
+    // Remove the first character
+    return str.slice(1)
+  }
+  // Return the original string if the first character is not a period
+  return str
+}
+
+module.exports = SchemaExtractor

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

@@ -0,0 +1,95 @@
+'use strict'
+
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const CachePlugin = require('../../dd-trace/src/plugins/cache')
+const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
+
+class RedisPlugin extends CachePlugin {
+  static id = 'redis'
+  static system = 'redis'
+
+  constructor (...args) {
+    super(...args)
+    this._spanType = 'redis'
+  }
+
+  bindStart (ctx) {
+    const { db, command, args, connectionOptions, connectionName } = ctx
+
+    const resource = command
+    const normalizedCommand = command.toUpperCase()
+    if (!this.config.filter(normalizedCommand)) {
+      return { noop: true }
+    }
+
+    this.startSpan({
+      resource,
+      service: this.serviceName({ pluginConfig: this.config, system: this.system, connectionName }),
+      type: this._spanType,
+      meta: {
+        'db.type': this._spanType,
+        'db.name': db || '0',
+        [`${this._spanType}.raw_command`]: formatCommand(normalizedCommand, args),
+        'out.host': connectionOptions.host,
+        [CLIENT_PORT_KEY]: connectionOptions.port,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  configure (config) {
+    super.configure(normalizeConfig(config))
+  }
+}
+
+function formatCommand (command, args) {
+  if (!args || command === 'AUTH') return command
+
+  for (let i = 0, l = args.length; i < l; i++) {
+    if (typeof args[i] === 'function') continue
+
+    command = `${command} ${formatArg(args[i])}`
+
+    if (command.length > 1000) return trim(command, 1000)
+  }
+
+  return command
+}
+
+function formatArg (arg) {
+  switch (typeof arg) {
+    case 'string':
+    case 'number':
+      return trim(String(arg), 100)
+    default:
+      return '?'
+  }
+}
+
+function trim (str, maxlen) {
+  if (str.length > maxlen) {
+    str = str.slice(0, maxlen - 3) + '...'
+  }
+
+  return str
+}
+
+function normalizeConfig (config) {
+  if (config.allowlist) uppercaseAllEntries(config.allowlist)
+  if (config.whitelist) uppercaseAllEntries(config.whitelist)
+  if (config.blocklist) uppercaseAllEntries(config.blocklist)
+  if (config.blacklist) uppercaseAllEntries(config.blacklist)
+
+  const filter = urlFilter.getFilter(config)
+
+  return { ...config, filter }
+}
+
+function uppercaseAllEntries (entries) {
+  for (let i = 0; i < entries.length; i++) {
+    entries[i] = String(entries[i]).toUpperCase()
+  }
+}
+
+module.exports = RedisPlugin

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

@@ -0,0 +1,29 @@
+'use strict'
+
+const RouterPlugin = require('../../datadog-plugin-router/src')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class RestifyPlugin extends RouterPlugin {
+  static id = 'restify'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:restify:request:handle', ({ req }) => {
+      this.setFramework(req, 'restify', this.config)
+    })
+
+    this.addSub('apm:restify:request:route', ({ req, route }) => {
+      web.setRoute(req, route)
+    })
+  }
+
+  configure (config) {
+    return super.configure({
+      ...config,
+      middleware: false, // not supported
+    })
+  }
+}
+
+module.exports = RestifyPlugin

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

@@ -0,0 +1,68 @@
+'use strict'
+
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const { getAmqpMessageSize } = require('../../dd-trace/src/datastreams')
+
+class RheaConsumerPlugin extends ConsumerPlugin {
+  static id = 'rhea'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addTraceSub('dispatch', (ctx) => {
+      const span = ctx.currentStore.span
+      span.setTag('amqp.delivery.state', ctx.state)
+    })
+  }
+
+  bindStart (ctx) {
+    const { msgObj } = ctx
+    const name = getResourceNameFromMessage(msgObj)
+    const childOf = extractTextMap(msgObj, this.tracer)
+
+    const span = this.startSpan({
+      childOf,
+      resource: name,
+      type: 'worker',
+      meta: {
+        component: 'rhea',
+        'amqp.link.source.address': name,
+        'amqp.link.role': 'receiver',
+      },
+    }, ctx)
+
+    if (
+      this.config.dsmEnabled &&
+      msgObj?.message?.delivery_annotations
+    ) {
+      const payloadSize = getAmqpMessageSize(
+        { headers: msgObj.message.delivery_annotations, content: msgObj.message.body }
+      )
+      this.tracer.decodeDataStreamsContext(msgObj.message.delivery_annotations)
+      this.tracer
+        .setCheckpoint(['direction:in', `topic:${name}`, 'type:rabbitmq'], span, payloadSize)
+    }
+
+    return ctx.currentStore
+  }
+}
+
+function getResourceNameFromMessage (msgObj) {
+  let resourceName = 'amq.topic'
+  let options = {}
+  if (msgObj.receiver && msgObj.receiver.options) {
+    options = msgObj.receiver.options
+  }
+  if (options.source && options.source.address) {
+    resourceName = options.source.address
+  }
+  return resourceName
+}
+
+function extractTextMap (msgObj, tracer) {
+  if (msgObj.message) {
+    return tracer.extract('text_map', msgObj.message.delivery_annotations)
+  }
+}
+
+module.exports = RheaConsumerPlugin

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ProducerPlugin = require('./producer')
+const ConsumerPlugin = require('./consumer')
+
+class RheaPlugin extends CompositePlugin {
+  static id = 'rhea'
+  static get plugins () {
+    return {
+      producer: ProducerPlugin,
+      consumer: ConsumerPlugin,
+    }
+  }
+}
+
+module.exports = RheaPlugin