dd-trace 5.71.0 → 5.73.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/otlp/protobuf_loader.js

@@ -0,0 +1,66 @@
+'use strict'
+
+/**
+ * @fileoverview Protobuf Loader for OpenTelemetry Logs and Metrics
+ *
+ * This module loads protobuf definitions for OpenTelemetry logs and metrics.
+ *
+ * VERSION SUPPORT:
+ * - OTLP Protocol: v1.7.0
+ * - Protobuf Definitions: v1.7.0 (vendored from opentelemetry-proto)
+ * - Other versions are not supported
+ *
+ * Reference:
+ * - https://github.com/open-telemetry/opentelemetry-proto (v1.7.0)
+ */
+
+const protobuf = require('protobufjs')
+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,
+      protoMetricsService,
+      protoAggregationTemporality
+    }
+  }
+  // Load the proto files
+  const protoDir = __dirname
+  const protoFiles = [
+    'common.proto',
+    'resource.proto',
+    'logs.proto',
+    'logs_service.proto',
+    'metrics.proto',
+    'metrics_service.proto'
+  ].map(file => path.join(protoDir, file))
+
+  _root = protobuf.loadSync(protoFiles)
+
+  // Get the message types for logs
+  protoLogsService = _root.lookupType('opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest')
+  protoSeverityNumber = _root.lookupEnum('opentelemetry.proto.logs.v1.SeverityNumber')
+
+  // 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 = {
+  getProtobufTypes,
+}

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

@@ -0,0 +1,45 @@
+// Vendored from: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/resource/v1/resource.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.resource.v1;
+
+import "common.proto";
+
+option csharp_namespace = "OpenTelemetry.Proto.Resource.V1";
+option java_multiple_files = true;
+option java_package = "io.opentelemetry.proto.resource.v1";
+option java_outer_classname = "ResourceProto";
+option go_package = "go.opentelemetry.io/proto/otlp/resource/v1";
+
+// Resource information.
+message Resource {
+  // Set of attributes that describe the resource.
+  // Attribute keys MUST be unique (it is not allowed to have more than one
+  // attribute with the same key).
+  repeated opentelemetry.proto.common.v1.KeyValue attributes = 1;
+
+  // dropped_attributes_count is the number of dropped attributes. If the value is 0, then
+  // no attributes were dropped.
+  uint32 dropped_attributes_count = 2;
+
+  // Set of entities that participate in this Resource.
+  //
+  // Note: keys in the references MUST exist in attributes of this message.
+  //
+  // Status: [Development]
+  repeated opentelemetry.proto.common.v1.EntityRef entity_refs = 3;
+}

package/packages/dd-trace/src/plugins/ci_plugin.js

@@ -33,7 +33,7 @@ const {
   DI_DEBUG_ERROR_LINE_SUFFIX,
   getLibraryCapabilitiesTags,
   getPullRequestDiff,
-  getModifiedTestsFromDiff,
+  getModifiedFilesFromDiff,
   getPullRequestBaseBranch
 } = require('./util/test')
 const { getRepositoryRoot } = require('./util/git')
@@ -275,11 +275,11 @@ module.exports = class CiPlugin extends Plugin {
       })
     })
 
-    this.addBind(`ci:${this.constructor.id}:modified-tests`, (ctx) => {
+    this.addBind(`ci:${this.constructor.id}:modified-files`, (ctx) => {
       return ctx.currentStore
     })
 
-    this.addSub(`ci:${this.constructor.id}:modified-tests`, ({ onDone }) => {
+    this.addSub(`ci:${this.constructor.id}:modified-files`, ({ onDone }) => {
       const {
         [GIT_PULL_REQUEST_BASE_BRANCH]: pullRequestBaseBranch,
         [GIT_PULL_REQUEST_BASE_BRANCH_SHA]: pullRequestBaseBranchSha,
@@ -290,9 +290,10 @@ module.exports = class CiPlugin extends Plugin {
 
       if (baseBranchSha) {
         const diff = getPullRequestDiff(baseBranchSha, commitHeadSha)
-        const modifiedTests = getModifiedTestsFromDiff(diff)
-        if (modifiedTests) {
-          return onDone({ err: null, modifiedTests })
+        const modifiedFiles = getModifiedFilesFromDiff(diff)
+
+        if (modifiedFiles) {
+          return onDone({ err: null, modifiedFiles })
         }
       }
 

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

@@ -4,6 +4,7 @@ module.exports = {
   get '@anthropic-ai/sdk' () { return require('../../../datadog-plugin-anthropic/src') },
   get '@apollo/gateway' () { return require('../../../datadog-plugin-apollo/src') },
   get '@aws-sdk/smithy-client' () { return require('../../../datadog-plugin-aws-sdk/src') },
+  get '@azure/event-hubs' () { return require('../../../datadog-plugin-azure-event-hubs/src') },
   get '@azure/functions' () { return require('../../../datadog-plugin-azure-functions/src') },
   get '@azure/service-bus' () { return require('../../../datadog-plugin-azure-service-bus/src') },
   get '@cucumber/cucumber' () { return require('../../../datadog-plugin-cucumber/src') },

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

@@ -301,7 +301,7 @@ module.exports = {
   checkShaDiscrepancies,
   getPullRequestDiff,
   getPullRequestBaseBranch,
-  getModifiedTestsFromDiff,
+  getModifiedFilesFromDiff,
   isModifiedTest,
   POSSIBLE_BASE_BRANCHES
 }
@@ -1069,7 +1069,7 @@ function getPullRequestDiff (baseCommit, targetCommit) {
   return getGitDiff(baseCommit, targetCommit)
 }
 
-function getModifiedTestsFromDiff (diff) {
+function getModifiedFilesFromDiff (diff) {
   if (!diff) return null
   const result = {}
 
@@ -1110,12 +1110,13 @@ function getModifiedTestsFromDiff (diff) {
   return result
 }
 
-function isModifiedTest (testPath, testStartLine, testEndLine, modifiedTests, testFramework) {
-  if (modifiedTests === undefined) {
+function isModifiedTest (testPath, testStartLine, testEndLine, modifiedFiles, testFramework) {
+  if (modifiedFiles === undefined) {
     return false
   }
 
-  const lines = modifiedTests[testPath]
+  const lines = modifiedFiles[testPath]
+
   if (!lines) {
     return false
   }

package/packages/dd-trace/src/profiling/config.js

@@ -25,6 +25,7 @@ class Config {
       DD_AGENT_HOST,
       DD_ENV,
       DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, // used for testing
+      DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED,
       DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_CPU_ENABLED,
       DD_PROFILING_DEBUG_SOURCE_MAPS,
@@ -42,7 +43,6 @@ class Config {
       DD_PROFILING_TIMELINE_ENABLED,
       DD_PROFILING_UPLOAD_PERIOD,
       DD_PROFILING_UPLOAD_TIMEOUT,
-      DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED,
       DD_PROFILING_V8_PROFILER_BUG_WORKAROUND,
       DD_PROFILING_WALLTIME_ENABLED,
       DD_SERVICE,
@@ -242,6 +242,26 @@ class Config {
 
     this.profilers = ensureProfilers(profilers, this)
   }
+
+  get systemInfoReport () {
+    const report = {
+      asyncContextFrameEnabled: this.asyncContextFrameEnabled,
+      codeHotspotsEnabled: this.codeHotspotsEnabled,
+      cpuProfilingEnabled: this.cpuProfilingEnabled,
+      debugSourceMaps: this.debugSourceMaps,
+      endpointCollectionEnabled: this.endpointCollectionEnabled,
+      heapSamplingInterval: this.heapSamplingInterval,
+      oomMonitoring: { ...this.oomMonitoring },
+      profilerTypes: this.profilers.map(p => p.type),
+      sourceMap: this.sourceMap,
+      timelineEnabled: this.timelineEnabled,
+      timelineSamplingEnabled: this.timelineSamplingEnabled,
+      uploadCompression: { ...this.uploadCompression },
+      v8ProfilerBugWorkaroundEnabled: this.v8ProfilerBugWorkaroundEnabled
+    }
+    delete report.oomMonitoring.exportCommand
+    return report
+  }
 }
 
 module.exports = { Config }

package/packages/dd-trace/src/profiling/exporters/event_serializer.js

@@ -21,7 +21,7 @@ class EventSerializer {
     return `${type}.pprof`
   }
 
-  getEventJSON ({ profiles, start, end, tags = {}, endpointCounts }) {
+  getEventJSON ({ profiles, infos, start, end, tags = {}, endpointCounts }) {
     return JSON.stringify({
       attachments: Object.keys(profiles).map(t => this.typeToFile(t)),
       start: start.toISOString(),
@@ -58,7 +58,8 @@ class EventSerializer {
           ssi: {
             mechanism: this._libraryInjected ? 'injected_agent' : 'none'
           },
-          version
+          version,
+          ...infos
         },
         runtime: {
           available_processors: availableParallelism(),