dd-trace 5.72.0 → 5.74.0

package/packages/dd-trace/src/opentelemetry/otlp/metrics_service.proto

@@ -0,0 +1,78 @@
+// Vendored from: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/collector/metrics/v1/metrics_service.proto
+// Copyright 2019, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package opentelemetry.proto.collector.metrics.v1;
+
+import "metrics.proto";
+
+option csharp_namespace = "OpenTelemetry.Proto.Collector.Metrics.V1";
+option java_multiple_files = true;
+option java_package = "io.opentelemetry.proto.collector.metrics.v1";
+option java_outer_classname = "MetricsServiceProto";
+option go_package = "go.opentelemetry.io/proto/otlp/collector/metrics/v1";
+
+// Service that can be used to push metrics between one Application
+// instrumented with OpenTelemetry and a collector, or between a collector and a
+// central collector.
+service MetricsService {
+  rpc Export(ExportMetricsServiceRequest) returns (ExportMetricsServiceResponse) {}
+}
+
+message ExportMetricsServiceRequest {
+  // An array of ResourceMetrics.
+  // For data coming from a single resource this array will typically contain one
+  // element. Intermediary nodes (such as OpenTelemetry Collector) that receive
+  // data from multiple origins typically batch the data before forwarding further and
+  // in that case this array will contain multiple elements.
+  repeated opentelemetry.proto.metrics.v1.ResourceMetrics resource_metrics = 1;
+}
+
+message ExportMetricsServiceResponse {
+  // The details of a partially successful export request.
+  //
+  // If the request is only partially accepted
+  // (i.e. when the server accepts only parts of the data and rejects the rest)
+  // the server MUST initialize the `partial_success` field and MUST
+  // set the `rejected_<signal>` with the number of items it rejected.
+  //
+  // Servers MAY also make use of the `partial_success` field to convey
+  // warnings/suggestions to senders even when the request was fully accepted.
+  // In such cases, the `rejected_<signal>` MUST have a value of `0` and
+  // the `error_message` MUST be non-empty.
+  //
+  // A `partial_success` message with an empty value (rejected_<signal> = 0 and
+  // `error_message` = "") is equivalent to it not being set/present. Senders
+  // SHOULD interpret it the same way as in the full success case.
+  ExportMetricsPartialSuccess partial_success = 1;
+}
+
+message ExportMetricsPartialSuccess {
+  // The number of rejected data points.
+  //
+  // A `rejected_<signal>` field holding a `0` value indicates that the
+  // request was fully accepted.
+  int64 rejected_data_points = 1;
+
+  // A developer-facing human-readable message in English. It should be used
+  // either to explain why the server rejected parts of the data during a partial
+  // success or to convey warnings/suggestions during a full success. The message
+  // should offer guidance on how users can address such issues.
+  //
+  // error_message is an optional field. An error_message with an empty value
+  // is equivalent to it not being set.
+  string error_message = 2;
+}

package/packages/dd-trace/src/opentelemetry/otlp/otlp_http_exporter_base.js

@@ -0,0 +1,177 @@
+'use strict'
+
+const http = require('http')
+const { URL } = require('url')
+const log = require('../../log')
+const telemetryMetrics = require('../../telemetry/metrics')
+
+const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
+
+/**
+ * Base class for OTLP HTTP exporters.
+ *
+ * This implementation follows the OTLP HTTP specification:
+ * https://opentelemetry.io/docs/specs/otlp/#otlphttp
+ *
+ * @class OtlpHttpExporterBase
+ */
+class OtlpHttpExporterBase {
+  #telemetryTags
+
+  /**
+   * Creates a new OtlpHttpExporterBase instance.
+   *
+   * @param {string} url - OTLP endpoint URL
+   * @param {string} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {number} timeout - Request timeout in milliseconds
+   * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
+   * @param {string} defaultPath - Default path to use if URL has no path
+   * @param {string} signalType - Signal type for error messages (e.g., 'logs', 'metrics')
+   */
+  constructor (url, headers, timeout, protocol, defaultPath, signalType) {
+    const parsedUrl = new URL(url)
+
+    this.protocol = protocol
+    this.signalType = signalType
+
+    // If no path is provided, use default path
+    const path = parsedUrl.pathname === '/' ? defaultPath : parsedUrl.pathname
+    const isJson = protocol === 'http/json'
+
+    this.options = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port,
+      path: path + parsedUrl.search,
+      method: 'POST',
+      timeout,
+      headers: {
+        'Content-Type': isJson ? 'application/json' : 'application/x-protobuf',
+        ...this.#parseAdditionalHeaders(headers)
+      }
+    }
+    this.#telemetryTags = [
+      'protocol:http',
+      `encoding:${isJson ? 'json' : 'protobuf'}`
+    ]
+  }
+
+  /**
+   * Gets the telemetry tags for this exporter.
+   * @returns {Array<string>} Telemetry tags
+   * @protected
+   */
+  _getTelemetryTags () {
+    return this.#telemetryTags
+  }
+
+  /**
+   * Records telemetry metrics for exported data.
+   * @param {string} metricName - Name of the metric to record
+   * @param {number} count - Count to increment
+   * @param {Array<string>} [tags] - Optional custom tags (defaults to this exporter's tags)
+   * @protected
+   */
+  _recordTelemetry (metricName, count, tags) {
+    const telemetryTags = tags || this.#telemetryTags
+    tracerMetrics.count(metricName, telemetryTags).inc(count)
+  }
+
+  /**
+   * Sends the payload via HTTP request.
+   * @param {Buffer|string} payload - The payload to send
+   * @param {Function} resultCallback - Callback for the result
+   * @protected
+   */
+  _sendPayload (payload, resultCallback) {
+    const options = {
+      ...this.options,
+      headers: {
+        ...this.options.headers,
+        'Content-Length': payload.length
+      }
+    }
+
+    const req = http.request(options, (res) => {
+      let data = ''
+
+      res.on('data', (chunk) => {
+        data += chunk
+      })
+
+      res.on('end', () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          resultCallback({ code: 0 })
+        } else {
+          const error = new Error(`HTTP ${res.statusCode}: ${data}`)
+          resultCallback({ code: 1, error })
+        }
+      })
+    })
+
+    req.on('error', (error) => {
+      log.error(`Error sending OTLP ${this.signalType}:`, error)
+      resultCallback({ code: 1, error })
+    })
+
+    req.on('timeout', () => {
+      req.destroy()
+      const error = new Error('Request timeout')
+      resultCallback({ code: 1, error })
+    })
+
+    req.write(payload)
+    req.end()
+  }
+
+  /**
+   * Parses additional HTTP headers from a comma-separated string.
+   * @param {string} headersString - Comma-separated key=value pairs
+   * @returns {Record<string, string>} Parsed headers object
+   * @private
+   */
+  #parseAdditionalHeaders (headersString) {
+    const headers = {}
+    let key = ''
+    let value = ''
+    let readingKey = true
+
+    for (const char of headersString) {
+      if (readingKey) {
+        if (char === '=') {
+          readingKey = false
+          key = key.trim()
+        } else {
+          key += char
+        }
+      } else if (char === ',') {
+        value = value.trim()
+        if (key && value) {
+          headers[key] = value
+        }
+        key = ''
+        value = ''
+        readingKey = true
+      } else {
+        value += char
+      }
+    }
+
+    // Add the last pair if present
+    if (!readingKey) {
+      value = value.trim()
+      if (value) {
+        headers[key] = value
+      }
+    }
+
+    return headers
+  }
+
+  /**
+   * Shuts down the exporter.
+   * Subclasses can override to add cleanup logic.
+   */
+  shutdown () {}
+}
+
+module.exports = OtlpHttpExporterBase

package/packages/dd-trace/src/opentelemetry/otlp/otlp_transformer_base.js

@@ -0,0 +1,163 @@
+'use strict'
+
+const log = require('../../log')
+
+/**
+ * @typedef {import('@opentelemetry/api').Attributes} Attributes
+ */
+
+/**
+ * Base class for OTLP transformers.
+ *
+ * This implementation provides common functionality for transforming
+ * data to OTLP format (protobuf or JSON).
+ *
+ * @class OtlpTransformerBase
+ */
+class OtlpTransformerBase {
+  #resourceAttributes
+
+  /**
+   * Creates a new OtlpTransformerBase instance.
+   *
+   * @param {Attributes} resourceAttributes - Resource attributes
+   * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
+   * @param {string} signalType - Signal type for warning messages (e.g., 'logs', 'metrics')
+   */
+  constructor (resourceAttributes, protocol, signalType) {
+    this.#resourceAttributes = this._transformAttributes(resourceAttributes)
+    if (protocol === 'grpc') {
+      log.warn(`OTLP gRPC protocol is not supported for ${signalType}. ` +
+        'Defaulting to http/protobuf. gRPC protobuf support may be added in a future release.')
+      protocol = 'http/protobuf'
+    }
+    this.protocol = protocol
+  }
+
+  /**
+   * Groups items by instrumentation scope (name, version, schemaUrl, and attributes).
+   * @param {Array} items - Array of items to group
+   * @returns {Map<string, Array>} Map of instrumentation scope key to items
+   * @protected
+   */
+  _groupByInstrumentationScope (items) {
+    const grouped = new Map()
+
+    for (const item of items) {
+      const instrumentationScope = item.instrumentationScope || { name: '', version: '', schemaUrl: '', attributes: {} }
+      const attrsKey = JSON.stringify(instrumentationScope.attributes || {})
+      const key = `${instrumentationScope.name}@${instrumentationScope.version}@` +
+        `${instrumentationScope.schemaUrl}@${attrsKey}`
+
+      const group = grouped.get(key)
+      if (group === undefined) {
+        grouped.set(key, [item])
+      } else {
+        group.push(item)
+      }
+    }
+    return grouped
+  }
+
+  /**
+   * Transforms resource attributes to OTLP resource format.
+   * @returns {Object} OTLP resource object
+   * @protected
+   */
+  _transformResource () {
+    return {
+      attributes: this.#resourceAttributes,
+      droppedAttributesCount: 0
+    }
+  }
+
+  /**
+   * Transforms attributes to OTLP KeyValue format.
+   * @param {Object} attributes - Attributes to transform
+   * @returns {Object[]} Array of OTLP KeyValue objects
+   * @protected
+   */
+  _transformAttributes (attributes) {
+    if (!attributes) return []
+
+    return Object.entries(attributes).map(([key, value]) => ({
+      key,
+      value: this._transformAnyValue(value)
+    }))
+  }
+
+  /**
+   * Transforms attributes to JSON format (simplified).
+   * @param {Object} attributes - Attributes to transform
+   * @returns {Object[]} Array of OTLP KeyValue objects with string values
+   * @protected
+   */
+  _attributesToJson (attributes) {
+    if (!attributes) return []
+
+    return Object.entries(attributes).map(([key, value]) => ({
+      key,
+      value: { stringValue: String(value) }
+    }))
+  }
+
+  /**
+   * Transforms any value to OTLP AnyValue format.
+   * @param {any} value - Value to transform
+   * @returns {Object} OTLP AnyValue object
+   * @protected
+   */
+  _transformAnyValue (value) {
+    if (typeof value === 'string') {
+      return { stringValue: value }
+    } else if (typeof value === 'number') {
+      if (Number.isInteger(value)) {
+        return { intValue: value }
+      }
+      return { doubleValue: value }
+    } else if (typeof value === 'boolean') {
+      return { boolValue: value }
+    } else if (Array.isArray(value)) {
+      return {
+        arrayValue: {
+          values: value.map(v => this._transformAnyValue(v))
+        }
+      }
+    } else if (value && typeof value === 'object') {
+      return {
+        kvlistValue: {
+          values: Object.entries(value).map(([k, v]) => ({
+            key: k,
+            value: this._transformAnyValue(v)
+          }))
+        }
+      }
+    }
+    return { stringValue: String(value) }
+  }
+
+  /**
+   * Serializes data to protobuf format.
+   * @param {Object} protoType - Protobuf type from protobuf_loader
+   * @param {Object} data - Data to serialize
+   * @returns {Buffer} Protobuf-encoded data
+   * @protected
+   */
+  _serializeToProtobuf (protoType, data) {
+    const message = protoType.create(data)
+    const buffer = protoType.encode(message).finish()
+    return buffer
+  }
+
+  /**
+   * Serializes data to JSON format.
+   * @param {Object} data - Data to serialize
+   * @returns {Buffer} JSON-encoded data
+   * @protected
+   */
+  _serializeToJson (data) {
+    return Buffer.from(JSON.stringify(data))
+  }
+}
+
+module.exports = OtlpTransformerBase

package/packages/dd-trace/src/opentelemetry/{protos → otlp}/protobuf_loader.js

@@ -1,9 +1,9 @@
 'use strict'
 
 /**
- * @fileoverview Protobuf Loader for OpenTelemetry Logs
+ * @fileoverview Protobuf Loader for OpenTelemetry Logs and Metrics
  *
- * This module loads protobuf definitions for OpenTelemetry logs.
+ * This module loads protobuf definitions for OpenTelemetry logs and metrics.
  *
  * VERSION SUPPORT:
  * - OTLP Protocol: v1.7.0
@@ -20,10 +20,17 @@ const path = require('path')
 let _root = null
 let protoLogsService = null
 let protoSeverityNumber = null
+let protoMetricsService = null
+let protoAggregationTemporality = null
 
 function getProtobufTypes () {
   if (_root) {
-    return { protoLogsService, protoSeverityNumber }
+    return {
+      protoLogsService,
+      protoSeverityNumber,
+      protoMetricsService,
+      protoAggregationTemporality
+    }
   }
   // Load the proto files
   const protoDir = __dirname
@@ -31,16 +38,27 @@ function getProtobufTypes () {
     'common.proto',
     'resource.proto',
     'logs.proto',
-    'logs_service.proto'
+    'logs_service.proto',
+    'metrics.proto',
+    'metrics_service.proto'
   ].map(file => path.join(protoDir, file))
 
   _root = protobuf.loadSync(protoFiles)
 
-  // Get the message types
+  // Get the message types for logs
   protoLogsService = _root.lookupType('opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest')
   protoSeverityNumber = _root.lookupEnum('opentelemetry.proto.logs.v1.SeverityNumber')
 
-  return { protoLogsService, protoSeverityNumber }
+  // Get the message types for metrics
+  protoMetricsService = _root.lookupType('opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest')
+  protoAggregationTemporality = _root.lookupEnum('opentelemetry.proto.metrics.v1.AggregationTemporality')
+
+  return {
+    protoLogsService,
+    protoSeverityNumber,
+    protoMetricsService,
+    protoAggregationTemporality
+  }
 }
 
 module.exports = {

package/packages/dd-trace/src/plugins/util/ci.js

@@ -95,10 +95,11 @@ function normalizeNumber (number) {
 }
 
 function getGitHubEventPayload () {
-  if (!getEnvironmentVariable('GITHUB_EVENT_PATH')) {
+  const path = getEnvironmentVariable('GITHUB_EVENT_PATH')
+  if (!path) {
     return
   }
-  return JSON.parse(readFileSync(getEnvironmentVariable('GITHUB_EVENT_PATH'), 'utf8'))
+  return JSON.parse(readFileSync(path, 'utf8'))
 }
 
 module.exports = {

package/packages/dd-trace/src/plugins/util/stacktrace.js

@@ -1,12 +1,22 @@
 'use strict'
 
-const { relative, sep } = require('path')
+const { relative, sep, join } = require('path')
 
 const cwd = process.cwd()
 
 const NODE_MODULES_PATTERN_MIDDLE = `${sep}node_modules${sep}`
 const NODE_MODULES_PATTERN_START = `node_modules${sep}`
 
+/**
+ * We detect if we're running inside the dd-trace-js repo by checking if the
+ * current file path ends with the expected path structure from the repo root.
+ * This is needed for local and CI where dd-trace-js is not in node_modules.
+ * In production, these frames are already filtered by isNodeModulesFrame.
+ */
+const SHOULD_FILTER_DD_TRACE_INSTRUMENTAION = __filename.endsWith(
+  join(sep, 'dd-trace-js', 'packages', 'dd-trace', 'src', 'plugins', 'util', 'stacktrace.js')
+)
+
 module.exports = {
   getCallSites,
   parseUserLandFrames
@@ -90,6 +100,7 @@ function parseLine (stack, start, end) {
   [fileName, lineNumber, columnNumber, index] = result
 
   if (isNodeModulesFrame(fileName)) return
+  if (SHOULD_FILTER_DD_TRACE_INSTRUMENTAION && isDDInstrumentationFile(fileName)) return
 
   // parse method name
   let methodName, functionName
@@ -153,6 +164,10 @@ function isNodeModulesFrame (fileName) {
   return relativePath.startsWith(NODE_MODULES_PATTERN_START) || relativePath.includes(NODE_MODULES_PATTERN_MIDDLE)
 }
 
+function isDDInstrumentationFile (fileName) {
+  return fileName.includes(`packages${sep}datadog-instrumentations${sep}src`)
+}
+
 /**
  * A stack trace location can be in one of the following formats:
  *

package/packages/dd-trace/src/supported-configurations.json

@@ -233,6 +233,7 @@
     "DD_TRACE_AZURE_EVENTHUBS_BATCH_LINKS_ENABLED": ["A"],
     "DD_TRACE_AZURE_FUNCTIONS_ENABLED": ["A"],
     "DD_TRACE_AZURE_SERVICE_BUS_ENABLED": ["A"],
+    "DD_TRACE_AZURE_SERVICEBUS_BATCH_LINKS_ENABLED": ["A"],
     "DD_TRACE_BAGGAGE_MAX_BYTES": ["A"],
     "DD_TRACE_BAGGAGE_MAX_ITEMS": ["A"],
     "DD_TRACE_BAGGAGE_TAG_KEYS": ["A"],
@@ -281,6 +282,7 @@
     "DD_TRACE_FASTIFY_ENABLED": ["A"],
     "DD_TRACE_FETCH_ENABLED": ["A"],
     "DD_TRACE_FIND_MY_WAY_ENABLED": ["A"],
+    "DD_TRACE_FLUSH_INTERVAL": ["A"],
     "DD_TRACE_FS_ENABLED": ["A"],
     "DD_TRACE_GENERIC_POOL_ENABLED": ["A"],
     "DD_TRACE_GIT_METADATA_ENABLED": ["A"],

package/packages/dd-trace/src/telemetry/endpoints.js

@@ -4,6 +4,8 @@ const dc = require('dc-polyfill')
 const { sendData } = require('./send-data')
 
 const fastifyRouteCh = dc.channel('apm:fastify:route:added')
+const expressRouteCh = dc.channel('apm:express:route:added')
+const routerRouteCh = dc.channel('apm:router:route:added')
 
 let config
 let application
@@ -16,6 +18,7 @@ let updateRetryData
  * Map key is `${METHOD} ${PATH}`, value is { method, path }
  */
 const pendingEndpoints = new Map()
+const wildcardEndpoints = new Set()
 let flushScheduled = false
 let isFirstPayload = true
 
@@ -42,12 +45,31 @@ function onFastifyRoute (routeData) {
   if (!routeOptions?.path) return
 
   const methods = Array.isArray(routeOptions.method) ? routeOptions.method : [routeOptions.method]
-
   for (const method of methods) {
     recordEndpoint(method, routeOptions.path)
   }
 }
 
+function onExpressRoute ({ method, path }) {
+  if (!method || !path) return
+
+  // If wildcard already recorded for this path, skip specific methods
+  if (wildcardEndpoints.has(path)) return
+
+  recordEndpoint(method, path)
+
+  // If this is a wildcard event, record it and mark path as wildcarded
+  if (method === '*') {
+    wildcardEndpoints.add(path)
+    return
+  }
+
+  // Express automatically adds HEAD support for GET routes
+  if (method.toUpperCase() === 'GET') {
+    recordEndpoint('HEAD', path)
+  }
+}
+
 function buildEndpointObjects (endpoints) {
   return endpoints.map(({ method, path }) => {
     return {
@@ -108,10 +130,14 @@ function start (_config = {}, _application, _host, getRetryDataFunction, updateR
   updateRetryData = updateRetryDataFunction
 
   fastifyRouteCh.subscribe(onFastifyRoute)
+  expressRouteCh.subscribe(onExpressRoute)
+  routerRouteCh.subscribe(onExpressRoute)
 }
 
 function stop () {
   fastifyRouteCh.unsubscribe(onFastifyRoute)
+  expressRouteCh.unsubscribe(onExpressRoute)
+  routerRouteCh.unsubscribe(onExpressRoute)
 
   pendingEndpoints.clear()
   flushScheduled = false

package/packages/dd-trace/src/telemetry/index.js

@@ -1,23 +1,26 @@
 'use strict'
 
-const activate = () => {
-  const active = require('./telemetry')
+let telemetry
 
-  return Object.setPrototypeOf(module.exports, active)
-}
-
-const inactive = {
+// Lazy load the telemetry module to avoid the performance impact of loading it unconditionally
+module.exports = {
   start (config, ...args) {
-    return config?.telemetry?.enabled && activate().start(config, ...args)
+    telemetry ??= require('./telemetry')
+    telemetry.start(config, ...args)
+  },
+  stop () {
+    telemetry?.stop()
   },
-  stop () {},
   // This might be called before `start` so we have to trigger loading the
   // underlying module here as well.
   updateConfig (changes, config, ...args) {
-    return config?.telemetry?.enabled && activate().updateConfig(changes, config, ...args)
+    telemetry ??= require('./telemetry')
+    telemetry.updateConfig(changes, config, ...args)
   },
-  updateIntegrations () {},
-  appClosing () {}
+  updateIntegrations () {
+    telemetry?.updateIntegrations()
+  },
+  appClosing () {
+    telemetry?.appClosing()
+  }
 }
-
-module.exports = Object.setPrototypeOf({}, inactive)

package/scripts/preinstall.js

@@ -17,7 +17,9 @@ const nodeMajor = Number(process.versions.node.split('.')[0])
 
 const min = Number(requirePackageJson(path.join(__dirname, '..')).engines.node.match(/\d+/)[0])
 
-const hasIgnoreEngines = npmArgv &&
+// Most package managers don't support `npm_config_argv`, so we need a custom
+// flag to allow installing dd-trace on unsupported engines.
+const hasIgnoreEngines = process.env._DD_IGNORE_ENGINES === 'true' || npmArgv &&
   npmArgv.original &&
   npmArgv.original.includes('--ignore-engines')
 

package/version.js

@@ -13,5 +13,6 @@ module.exports = {
   DD_PATCH: parseInt(ddMatches[3]),
   NODE_MAJOR: parseInt(nodeMatches[1]),
   NODE_MINOR: parseInt(nodeMatches[2]),
-  NODE_PATCH: parseInt(nodeMatches[3])
+  NODE_PATCH: parseInt(nodeMatches[3]),
+  NODE_VERSION: nodeMatches[0]
 }