@depup/dd-trace 5.90.0-depup.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,168 @@
+'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 v1.7.0 specification:
+ * https://opentelemetry.io/docs/specs/otlp/#otlphttp
+ *
+ * @class OtlpHttpExporterBase
+ */
+class OtlpHttpExporterBase {
+  /**
+   * Creates a new OtlpHttpExporterBase instance.
+   *
+   * @param {string} url - OTLP endpoint URL
+   * @param {string|undefined} 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'}`,
+    ]
+  }
+
+  /**
+   * Records telemetry metrics for exported data.
+   * @param {string} metricName - Name of the metric to record
+   * @param {number} count - Count to increment
+   * @param {Array<string>} [additionalTags] - Optional custom tags (defaults to this exporter's tags)
+   * @protected
+   */
+  recordTelemetry (metricName, count, additionalTags) {
+    if (additionalTags?.length > 0) {
+      tracerMetrics.count(metricName, [...this.telemetryTags, ...additionalTags || []]).inc(count)
+    } else {
+      tracerMetrics.count(metricName, this.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.once('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 %s:', this.signalType, error)
+      resultCallback({ code: 1, error })
+    })
+
+    req.once('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
+   */
+  #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,181 @@
+'use strict'
+
+const log = require('../../log')
+
+/**
+ * @typedef {import('@opentelemetry/api').Attributes} Attributes
+ * @typedef {import('@opentelemetry/api').AttributeValue} AttributeValue
+ */
+
+/**
+ * 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(
+        // eslint-disable-next-line @stylistic/max-len
+        'OTLP gRPC protocol is not supported for %s. Defaulting to http/protobuf. gRPC protobuf support may be added in a future release.',
+        signalType
+      )
+      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 = stableStringify(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 {Attributes} attributes - Attributes to transform
+   * @returns {object[]} Array of OTLP KeyValue objects
+   * @protected
+   */
+  transformAttributes (attributes) {
+    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.
+   * Supports: strings, numbers (int/double), booleans, arrays.
+   * Objects are filtered out by sanitizeAttributes before reaching this method.
+   * @param {AttributeValue | null | undefined} 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)),
+        },
+      }
+    }
+    // Fallback for any unexpected types
+    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))
+  }
+}
+
+/**
+ * Stable stringification of OpenTelemetry Attributes.
+ * Ensures consistent serialization regardless of key order by sorting keys.
+ * Supports string keys with primitive values or arrays of primitives.
+ *
+ * @param {Attributes} attributes - Attributes object to stringify
+ * @returns {string} Stable string representation
+ */
+function stableStringify (attributes) {
+  if (attributes == null) {
+    return JSON.stringify(attributes)
+  }
+  // Attributes are sorted by key to ensure consistent serialization regardless of key order.
+  // Keys are always strings and values are always strings, numbers, booleans,
+  // or arrays of strings, numbers, or booleans.
+  return Object.keys(attributes)
+    .sort()
+    .map(key => `${key}:${JSON.stringify(attributes[key])}`)
+    .join(',')
+}
+
+module.exports = OtlpTransformerBase
+module.exports.stableStringify = stableStringify

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

@@ -0,0 +1,66 @@
+'use strict'
+
+/**
+ * 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 path = require('path')
+const protobuf = require('../../../../../vendor/dist/protobufjs')
+
+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/opentelemetry/sampler.js

@@ -0,0 +1,18 @@
+'use strict'
+
+// This isn't used yet. We currently delegate to dd-trace core for sampling decisions.
+// Leaving here for future use.
+class Sampler {
+  shouldSample (context, traceId, spanName, spanKind, attributes, links) {
+    // 0 = no, 1 = record, 2 = record and sample
+    // TODO: Make this actually do sampling...
+    return { decision: 2 }
+  }
+
+  /** Returns the sampler name or short description with the configuration. */
+  toString () {
+    return 'DatadogSampler'
+  }
+}
+
+module.exports = Sampler