dd-trace 4.47.1 → 4.49.0

package/packages/datadog-instrumentations/src/url.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const { addHook, channel } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const names = ['url', 'node:url']
+
+const parseFinishedChannel = channel('datadog:url:parse:finish')
+const urlGetterChannel = channel('datadog:url:getter:finish')
+const instrumentedGetters = ['host', 'origin', 'hostname']
+
+addHook({ name: names }, function (url) {
+  shimmer.wrap(url, 'parse', (parse) => {
+    return function wrappedParse (input) {
+      const parsedValue = parse.apply(this, arguments)
+      if (!parseFinishedChannel.hasSubscribers) return parsedValue
+
+      parseFinishedChannel.publish({
+        input,
+        parsed: parsedValue,
+        isURL: false
+      })
+
+      return parsedValue
+    }
+  })
+
+  const URLPrototype = url.URL.prototype.constructor.prototype
+  instrumentedGetters.forEach(property => {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(URLPrototype, property)
+
+    if (originalDescriptor?.get) {
+      const newDescriptor = shimmer.wrap(originalDescriptor, 'get', function (originalGet) {
+        return function get () {
+          const result = originalGet.apply(this, arguments)
+          if (!urlGetterChannel.hasSubscribers) return result
+
+          const context = { urlObject: this, result, property }
+          urlGetterChannel.publish(context)
+
+          return context.result
+        }
+      })
+
+      Object.defineProperty(URLPrototype, property, newDescriptor)
+    }
+  })
+
+  shimmer.wrap(url, 'URL', (URL) => {
+    return class extends URL {
+      constructor (input, base) {
+        super(...arguments)
+
+        if (!parseFinishedChannel.hasSubscribers) return
+
+        parseFinishedChannel.publish({
+          input,
+          base,
+          parsed: this,
+          isURL: true
+        })
+      }
+    }
+  })
+
+  if (url.URL.parse) {
+    shimmer.wrap(url.URL, 'parse', (parse) => {
+      return function wrappedParse (input, base) {
+        const parsedValue = parse.apply(this, arguments)
+        if (!parseFinishedChannel.hasSubscribers) return parsedValue
+
+        parseFinishedChannel.publish({
+          input,
+          base,
+          parsed: parsedValue,
+          isURL: true
+        })
+
+        return parsedValue
+      }
+    })
+  }
+
+  return url
+})

package/packages/datadog-instrumentations/src/utils/src/extract-package-and-module-path.js

@@ -6,7 +6,7 @@ const NM = 'node_modules/'
  * For a given full path to a module,
  *   return the package name it belongs to and the local path to the module
  *   input: '/foo/node_modules/@co/stuff/foo/bar/baz.js'
- *   output: { pkg: '@co/stuff', path: 'foo/bar/baz.js' }
+ *   output: { pkg: '@co/stuff', path: 'foo/bar/baz.js',  pkgJson: '/foo/node_modules/@co/stuff/package.json' }
  */
 module.exports = function extractPackageAndModulePath (fullPath) {
   const nm = fullPath.lastIndexOf(NM)
@@ -17,17 +17,20 @@ module.exports = function extractPackageAndModulePath (fullPath) {
   const subPath = fullPath.substring(nm + NM.length)
   const firstSlash = subPath.indexOf('/')
 
+  const firstPath = fullPath.substring(fullPath[0], nm + NM.length)
+
   if (subPath[0] === '@') {
     const secondSlash = subPath.substring(firstSlash + 1).indexOf('/')
-
     return {
       pkg: subPath.substring(0, firstSlash + 1 + secondSlash),
-      path: subPath.substring(firstSlash + 1 + secondSlash + 1)
+      path: subPath.substring(firstSlash + 1 + secondSlash + 1),
+      pkgJson: firstPath + subPath.substring(0, firstSlash + 1 + secondSlash) + '/package.json'
     }
   }
 
   return {
     pkg: subPath.substring(0, firstSlash),
-    path: subPath.substring(firstSlash + 1)
+    path: subPath.substring(firstSlash + 1),
+    pkgJson: firstPath + subPath.substring(0, firstSlash) + '/package.json'
   }
 }

package/packages/datadog-instrumentations/src/winston.js

@@ -8,6 +8,18 @@ const shimmer = require('../../datadog-shimmer')
 
 const patched = new WeakSet()
 
+// Test Visibility log submission channels
+const configureCh = channel('ci:log-submission:winston:configure')
+const addTransport = channel('ci:log-submission:winston:add-transport')
+
+addHook({ name: 'winston', file: 'lib/winston/transports/index.js', versions: ['>=3'] }, transportsPackage => {
+  if (configureCh.hasSubscribers) {
+    configureCh.publish(transportsPackage.Http)
+  }
+
+  return transportsPackage
+})
+
 addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['>=3'] }, Logger => {
   const logCh = channel('apm:winston:log')
   shimmer.wrap(Logger.prototype, 'write', write => {
@@ -20,6 +32,16 @@ addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['>=3'] }, L
       return write.apply(this, arguments)
     }
   })
+
+  shimmer.wrap(Logger.prototype, 'configure', configure => function () {
+    const configureResponse = configure.apply(this, arguments)
+    // After the original `configure`, because it resets transports
+    if (addTransport.hasSubscribers) {
+      addTransport.publish(this)
+    }
+    return configureResponse
+  })
+
   return Logger
 })
 

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

@@ -9,17 +9,18 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
   static get id () { return 'amqplib' }
   static get operation () { return 'command' }
 
-  start ({ method, fields, message }) {
+  start ({ method, fields, message, queue }) {
     if (method !== 'basic.deliver' && method !== 'basic.get') return
 
     const childOf = extract(this.tracer, message)
 
+    const queueName = queue || fields.queue || fields.routingKey
     const span = this.startSpan({
       childOf,
       resource: getResourceName(method, fields),
       type: 'worker',
       meta: {
-        'amqp.queue': fields.queue,
+        'amqp.queue': queueName,
         'amqp.exchange': fields.exchange,
         'amqp.routingKey': fields.routingKey,
         'amqp.consumerTag': fields.consumerTag,
@@ -32,10 +33,9 @@ class AmqplibConsumerPlugin extends ConsumerPlugin {
       this.config.dsmEnabled && message?.properties?.headers
     ) {
       const payloadSize = getAmqpMessageSize({ headers: message.properties.headers, content: message.content })
-      const queue = fields.queue ? fields.queue : fields.routingKey
       this.tracer.decodeDataStreamsContext(message.properties.headers)
       this.tracer
-        .setCheckpoint(['direction:in', `topic:${queue}`, 'type:rabbitmq'], span, payloadSize)
+        .setCheckpoint(['direction:in', `topic:${queueName}`, 'type:rabbitmq'], span, payloadSize)
     }
   }
 }

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

@@ -0,0 +1,9 @@
+const SchemaPlugin = require('../../dd-trace/src/plugins/schema')
+const SchemaExtractor = require('./schema_iterator')
+
+class AvscPlugin extends SchemaPlugin {
+  static get id () { return 'avsc' }
+  static get schemaExtractor () { return SchemaExtractor }
+}
+
+module.exports = AvscPlugin

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

@@ -0,0 +1,169 @@
+const AVRO = 'avro'
+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/schemas/schema_builder')
+
+class SchemaExtractor {
+  constructor (schema) {
+    this.schema = schema
+  }
+
+  static getType (type) {
+    const typeMapping = {
+      string: 'string',
+      int: 'integer',
+      long: 'integer',
+      float: 'number',
+      double: 'number',
+      boolean: 'boolean',
+      bytes: 'string',
+      record: 'object',
+      enum: 'string',
+      array: 'array',
+      map: 'object',
+      fixed: 'string'
+    }
+    const typeName = type.typeName ?? type.name ?? type
+    return typeName === 'null' ? typeName : typeMapping[typeName] || 'string'
+  }
+
+  static extractProperty (field, schemaName, fieldName, builder, depth) {
+    let array = false
+    let type
+    let format
+    let enumValues
+    let description
+    let ref
+
+    const fieldType = field.type?.types ?? field.type?.typeName ?? field.type
+
+    if (Array.isArray(fieldType)) {
+      // Union Type
+      type = 'union[' + fieldType.map(t => SchemaExtractor.getType(t.type || t)).join(',') + ']'
+    } else if (fieldType === 'array') {
+      // Array Type
+      array = true
+      const nestedType = field.type.itemsType.typeName
+      type = SchemaExtractor.getType(nestedType)
+    } else if (fieldType === 'record') {
+      // Nested Record Type
+      type = 'object'
+      ref = `#/components/schemas/${field.type.name}`
+      if (!SchemaExtractor.extractSchema(field.type, builder, depth + 1, this)) {
+        return false
+      }
+    } else if (fieldType === 'enum') {
+      enumValues = []
+      let i = 0
+      type = 'string'
+      while (field.type.symbols[i]) {
+        enumValues.push(field.type.symbols[i])
+        i += 1
+      }
+    } else {
+      // Primitive type
+      type = SchemaExtractor.getType(fieldType.type || fieldType)
+      if (fieldType === 'bytes') {
+        format = 'byte'
+      } else if (fieldType === 'int') {
+        format = 'int32'
+      } else if (fieldType === 'long') {
+        format = 'int64'
+      } else if (fieldType === 'float') {
+        format = 'float'
+      } else if (fieldType === 'double') {
+        format = 'double'
+      }
+    }
+
+    return builder.addProperty(schemaName, fieldName, array, type, description, ref, format, enumValues)
+  }
+
+  static extractSchema (schema, builder, depth, extractor) {
+    depth += 1
+    const schemaName = schema.name
+    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
+    } else {
+      if (!builder.shouldExtractSchema(schemaName, depth)) {
+        return false
+      }
+      for (const field of schema.fields) {
+        if (!this.extractProperty(field, schemaName, field.name, builder, depth)) {
+          log.warn(`DSM: Unable to extract field with name: ${field.name} from Avro schema with name: ${schemaName}`)
+        }
+      }
+    }
+    return true
+  }
+
+  static extractSchemas (descriptor, dataStreamsProcessor) {
+    return dataStreamsProcessor.getSchema(descriptor.name, new SchemaExtractor(descriptor))
+  }
+
+  iterateOverSchema (builder) {
+    this.constructor.extractSchema(this.schema, builder, 0)
+  }
+
+  static attachSchemaOnSpan (args, span, operation, tracer) {
+    const { messageClass } = args
+    const descriptor = messageClass?.constructor?.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, AVRO)
+    span.setTag(SCHEMA_NAME, descriptor.name)
+    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)
+  }
+}
+
+module.exports = SchemaExtractor

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

@@ -4,6 +4,7 @@ const BaseAwsSdkPlugin = require('../base')
 
 class EventBridge extends BaseAwsSdkPlugin {
   static get id () { return 'eventbridge' }
+  static get isPayloadReporter () { return true }
 
   generateTags (params, operation, response) {
     if (!params || !params.source) return {}

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

@@ -10,6 +10,7 @@ const { storage } = require('../../../datadog-core')
 class Kinesis extends BaseAwsSdkPlugin {
   static get id () { return 'kinesis' }
   static get peerServicePrecursors () { return ['streamname'] }
+  static get isPayloadReporter () { return true }
 
   constructor (...args) {
     super(...args)

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

@@ -5,6 +5,7 @@ const BaseAwsSdkPlugin = require('../base')
 class S3 extends BaseAwsSdkPlugin {
   static get id () { return 's3' }
   static get peerServicePrecursors () { return ['bucketname'] }
+  static get isPayloadReporter () { return true }
 
   generateTags (params, operation, response) {
     const tags = {}

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

@@ -9,6 +9,7 @@ const { DsmPathwayCodec } = require('../../../dd-trace/src/datastreams/pathway')
 class Sqs extends BaseAwsSdkPlugin {
   static get id () { return 'sqs' }
   static get peerServicePrecursors () { return ['queuename'] }
+  static get isPayloadReporter () { return true }
 
   constructor (...args) {
     super(...args)

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

@@ -0,0 +1,77 @@
+'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')
+
+const triggerMap = {
+  deleteRequest: 'Http',
+  http: 'Http',
+  get: 'Http',
+  patch: 'Http',
+  post: 'Http',
+  put: 'Http'
+}
+
+class AzureFunctionsPlugin extends TracingPlugin {
+  static get id () { return 'azure-functions' }
+  static get operation () { return 'invoke' }
+  static get kind () { return 'server' }
+  static get type () { return 'serverless' }
+
+  static get prefix () { return 'tracing:datadog:azure-functions:invoke' }
+
+  bindStart (ctx) {
+    const { functionName, methodName } = ctx
+    const store = storage.getStore()
+
+    const span = this.startSpan(this.operationName(), {
+      service: this.serviceName(),
+      type: 'serverless',
+      meta: {
+        'aas.function.name': functionName,
+        'aas.function.trigger': mapTriggerTag(methodName)
+      }
+    }, false)
+
+    ctx.span = span
+    ctx.parentStore = store
+    ctx.currentStore = { ...store, span }
+
+    return ctx.currentStore
+  }
+
+  error (ctx) {
+    this.addError(ctx.error)
+    ctx.currentStore.span.setTag('error.message', ctx.error)
+  }
+
+  asyncEnd (ctx) {
+    const { httpRequest, result = {} } = ctx
+    const path = (new URL(httpRequest.url)).pathname
+    const req = {
+      method: httpRequest.method,
+      headers: Object.fromEntries(httpRequest.headers.entries()),
+      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)
+  }
+
+  configure (config) {
+    return super.configure(web.normalizeConfig(config))
+  }
+}
+
+function mapTriggerTag (methodName) {
+  return triggerMap[methodName] || 'Unknown'
+}
+
+module.exports = AzureFunctionsPlugin

package/packages/datadog-plugin-fastify/src/code_origin.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const { entryTags } = require('../../datadog-code-origin')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+const kCodeOriginForSpansTagsSym = Symbol('datadog.codeOriginForSpansTags')
+
+class FastifyCodeOriginForSpansPlugin extends Plugin {
+  static get id () {
+    return 'fastify'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:fastify:request:handle', ({ req, routeConfig }) => {
+      const tags = routeConfig?.[kCodeOriginForSpansTagsSym]
+      if (!tags) return
+      const context = web.getContext(req)
+      context.span?.addTags(tags)
+    })
+
+    this.addSub('apm:fastify:route:added', ({ routeOptions, onRoute }) => {
+      if (!routeOptions.config) routeOptions.config = {}
+      routeOptions.config[kCodeOriginForSpansTagsSym] = entryTags(onRoute)
+    })
+  }
+}
+
+module.exports = FastifyCodeOriginForSpansPlugin

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

@@ -1,18 +1,16 @@
 'use strict'
 
-const RouterPlugin = require('../../datadog-plugin-router/src')
+const FastifyTracingPlugin = require('./tracing')
+const FastifyCodeOriginForSpansPlugin = require('./code_origin')
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 
-class FastifyPlugin extends RouterPlugin {
-  static get id () {
-    return 'fastify'
-  }
-
-  constructor (...args) {
-    super(...args)
-
-    this.addSub('apm:fastify:request:handle', ({ req }) => {
-      this.setFramework(req, 'fastify', this.config)
-    })
+class FastifyPlugin extends CompositePlugin {
+  static get id () { return 'fastify' }
+  static get plugins () {
+    return {
+      tracing: FastifyTracingPlugin,
+      codeOriginForSpans: FastifyCodeOriginForSpansPlugin
+    }
   }
 }
 

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

@@ -0,0 +1,19 @@
+'use strict'
+
+const RouterPlugin = require('../../datadog-plugin-router/src')
+
+class FastifyTracingPlugin extends RouterPlugin {
+  static get id () {
+    return 'fastify'
+  }
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('apm:fastify:request:handle', ({ req }) => {
+      this.setFramework(req, 'fastify', this.config)
+    })
+  }
+}
+
+module.exports = FastifyTracingPlugin

package/packages/datadog-plugin-google-cloud-pubsub/src/consumer.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { getMessageSize } = require('../../dd-trace/src/datastreams/processor')
 const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
 
 class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
@@ -11,7 +12,7 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
     const topic = subscription.metadata && subscription.metadata.topic
     const childOf = this.tracer.extract('text_map', message.attributes) || null
 
-    this.startSpan({
+    const span = this.startSpan({
       childOf,
       resource: topic,
       type: 'worker',
@@ -23,6 +24,12 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
         'pubsub.ack': 0
       }
     })
+    if (this.config.dsmEnabled && message?.attributes) {
+      const payloadSize = getMessageSize(message)
+      this.tracer.decodeDataStreamsContext(message.attributes)
+      this.tracer
+        .setCheckpoint(['direction:in', `topic:${topic}`, 'type:google-pubsub'], span, payloadSize)
+    }
   }
 
   finish (message) {

package/packages/datadog-plugin-google-cloud-pubsub/src/producer.js

@@ -1,6 +1,8 @@
 'use strict'
 
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { DsmPathwayCodec } = require('../../dd-trace/src/datastreams/pathway')
+const { getHeadersSize } = require('../../dd-trace/src/datastreams/processor')
 
 class GoogleCloudPubsubProducerPlugin extends ProducerPlugin {
   static get id () { return 'google-cloud-pubsub' }
@@ -25,6 +27,12 @@ class GoogleCloudPubsubProducerPlugin extends ProducerPlugin {
         msg.attributes = {}
       }
       this.tracer.inject(span, 'text_map', msg.attributes)
+      if (this.config.dsmEnabled) {
+        const payloadSize = getHeadersSize(msg)
+        const dataStreamsContext = this.tracer
+          .setCheckpoint(['direction:out', `topic:${topic}`, 'type:google-pubsub'], span, payloadSize)
+        DsmPathwayCodec.encode(dataStreamsContext, msg.attributes)
+      }
     }
   }
 }

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

@@ -64,6 +64,9 @@ class GrpcClientPlugin extends ClientPlugin {
 
   error ({ span, error }) {
     this.addCode(span, error.code)
+    if (error.code && !this._tracerConfig.grpc.client.error.statuses.includes(error.code)) {
+      return
+    }
     this.addError(error, span)
   }
 

package/packages/datadog-plugin-grpc/src/server.js

@@ -70,6 +70,9 @@ class GrpcServerPlugin extends ServerPlugin {
     if (!span) return
 
     this.addCode(span, error.code)
+    if (error.code && !this._tracerConfig.grpc.server.error.statuses.includes(error.code)) {
+      return
+    }
     this.addError(error)
   }
 

package/packages/datadog-plugin-kafkajs/src/batch-consumer.js

@@ -5,14 +5,17 @@ class KafkajsBatchConsumerPlugin extends ConsumerPlugin {
   static get id () { return 'kafkajs' }
   static get operation () { return 'consume-batch' }
 
-  start ({ topic, partition, messages, groupId }) {
+  start ({ topic, partition, messages, groupId, clusterId }) {
     if (!this.config.dsmEnabled) return
     for (const message of messages) {
       if (!message || !message.headers) continue
       const payloadSize = getMessageSize(message)
       this.tracer.decodeDataStreamsContext(message.headers)
-      this.tracer
-        .setCheckpoint(['direction:in', `group:${groupId}`, `topic:${topic}`, 'type:kafka'], null, payloadSize)
+      const edgeTags = ['direction:in', `group:${groupId}`, `topic:${topic}`, 'type:kafka']
+      if (clusterId) {
+        edgeTags.push(`kafka_cluster_id:${clusterId}`)
+      }
+      this.tracer.setCheckpoint(edgeTags, null, payloadSize)
     }
   }
 }