@depup/dd-trace 5.90.0-depup.0

package/packages/dd-trace/src/opentelemetry/logs/batch_log_processor.js

@@ -0,0 +1,100 @@
+'use strict'
+
+/**
+ * @typedef {import('@opentelemetry/api-logs').LogRecord} LogRecord
+ * @typedef {import('@opentelemetry/core').InstrumentationScope} InstrumentationScope
+ */
+
+/**
+ * BatchLogRecordProcessor processes log records in batches for efficient export to Datadog Agent.
+ *
+ * This implementation follows the OpenTelemetry JavaScript SDK BatchLogRecordProcessor:
+ * https://open-telemetry.github.io/opentelemetry-js/classes/_opentelemetry_sdk-logs.BatchLogRecordProcessor.html
+ *
+ * @class BatchLogRecordProcessor
+ */
+class BatchLogRecordProcessor {
+  #logRecords
+  #timer
+  #batchTimeout
+  #maxExportBatchSize
+
+  /**
+   * Creates a new BatchLogRecordProcessor instance.
+   *
+   * @param {OtlpHttpLogExporter} exporter - Log processor for exporting batches to Datadog Agent
+   * @param {number} batchTimeout - Timeout in milliseconds for batch processing
+   * @param {number} maxExportBatchSize - Maximum number of log records per batch
+   */
+  constructor (exporter, batchTimeout, maxExportBatchSize) {
+    this.exporter = exporter
+    this.#batchTimeout = batchTimeout
+    this.#maxExportBatchSize = maxExportBatchSize
+    this.#logRecords = []
+    this.#timer = null
+  }
+
+  /**
+   * Processes a single log record.
+   *
+   * @param {LogRecord} logRecord - The enriched log record with trace correlation and metadata
+   * @param {InstrumentationScope} instrumentationScope - The instrumentation library
+   */
+  onEmit (logRecord, instrumentationScope) {
+    // Store the log record (already enriched by Logger.emit)
+    this.#logRecords.push({ ...logRecord, instrumentationScope })
+
+    if (this.#logRecords.length >= this.#maxExportBatchSize) {
+      this.#export()
+    } else if (this.#logRecords.length === 1) {
+      this.#startTimer()
+    }
+  }
+
+  /**
+   * Forces an immediate flush of all pending log records.
+   * @returns {undefined} Promise that resolves when flush is complete
+   */
+  forceFlush () {
+    this.#export()
+  }
+
+  /**
+   * Starts the batch timeout timer.
+   * @private
+   */
+  #startTimer () {
+    if (this.#timer) {
+      return
+    }
+
+    this.#timer = setTimeout(() => {
+      this.#export()
+    }, this.#batchTimeout)
+  }
+
+  /**
+   * Exports the current batch of log records.
+   * @private
+   */
+  #export () {
+    const logRecords = this.#logRecords.slice(0, this.#maxExportBatchSize)
+    this.#logRecords = this.#logRecords.slice(this.#maxExportBatchSize)
+
+    this.#clearTimer()
+    this.exporter.export(logRecords, () => {})
+  }
+
+  /**
+   * Clears the batch timeout timer.
+   * @private
+   */
+  #clearTimer () {
+    if (this.#timer) {
+      clearTimeout(this.#timer)
+      this.#timer = null
+    }
+  }
+}
+
+module.exports = BatchLogRecordProcessor

package/packages/dd-trace/src/opentelemetry/logs/index.js

@@ -0,0 +1,87 @@
+'use strict'
+
+const os = require('os')
+
+/**
+ * @typedef {import('../../config')} Config
+ */
+
+/**
+ * OpenTelemetry Logs Implementation for `dd-trace-js`
+ *
+ * This package provides a custom OpenTelemetry Logs implementation that integrates
+ * with the Datadog tracing library. It includes all necessary components for
+ * emitting, processing, and exporting log records via OTLP (OpenTelemetry Protocol).
+ *
+ * Key Components:
+ * - LoggerProvider: Main entry point for creating loggers
+ * - Logger: Provides methods to emit log records
+ * - BatchLogRecordProcessor: Processes log records in batches for efficient export
+ * - OtlpHttpLogExporter: Exports log records via OTLP over HTTP
+ * - OtlpTransformer: Transforms log records to OTLP format
+ *
+ * This is a custom implementation to avoid pulling in the full OpenTelemetry SDK,
+ * based on OTLP Protocol v1.7.0. It supports both protobuf and JSON serialization
+ * formats and integrates with Datadog's configuration system.
+ *
+ * @package
+ */
+
+const LoggerProvider = require('./logger_provider')
+const BatchLogRecordProcessor = require('./batch_log_processor')
+const OtlpHttpLogExporter = require('./otlp_http_log_exporter')
+
+/**
+ * Initializes OpenTelemetry Logs support
+ * @param {Config} config - Tracer configuration instance
+ */
+function initializeOpenTelemetryLogs (config) {
+  // Build resource attributes
+  const resourceAttributes = {
+    'service.name': config.service,
+    'service.version': config.version,
+    'deployment.environment': config.env,
+  }
+
+  // Add all tracer tags (includes DD_TAGS, OTEL_RESOURCE_ATTRIBUTES, DD_TRACE_TAGS, etc.)
+  // Exclude Datadog-style keys that duplicate OpenTelemetry standard keys
+  if (config.tags) {
+    const filteredTags = { ...config.tags }
+    delete filteredTags.service
+    delete filteredTags.version
+    delete filteredTags.env
+    Object.assign(resourceAttributes, filteredTags)
+  }
+
+  // Add host.name if reportHostname is enabled
+  if (config.reportHostname) {
+    resourceAttributes['host.name'] = os.hostname()
+  }
+
+  // Create OTLP exporter using resolved config values
+  const exporter = new OtlpHttpLogExporter(
+    config.otelLogsUrl,
+    config.otelLogsHeaders,
+    config.otelLogsTimeout,
+    config.otelLogsProtocol,
+    resourceAttributes
+  )
+
+  // Create batch processor for exporting logs to Datadog Agent
+  const processor = new BatchLogRecordProcessor(
+    exporter,
+    config.otelBatchTimeout,
+    config.otelMaxExportBatchSize
+  )
+
+  // Create logger provider with processor for Datadog Agent export
+  const loggerProvider = new LoggerProvider({ processor })
+
+  // Register the logger provider globally with OpenTelemetry API
+  loggerProvider.register()
+}
+
+module.exports = {
+  LoggerProvider,
+  initializeOpenTelemetryLogs,
+}

package/packages/dd-trace/src/opentelemetry/logs/logger.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const { context } = require('@opentelemetry/api')
+const { sanitizeAttributes } = require('../../../../../vendor/dist/@opentelemetry/core')
+const { VERSION: packageVersion } = require('../../../../../version')
+
+/**
+ * @typedef {import('@opentelemetry/api-logs').LogRecord} LogRecord
+ * @typedef {import('@opentelemetry/api-logs').LoggerProvider} LoggerProvider
+ * @typedef {import('@opentelemetry/api').SpanContext} SpanContext
+ * @typedef {import('@opentelemetry/api').Attributes} Attributes
+ * @typedef {import('@opentelemetry/resources').Resource} Resource
+ * @typedef {import('@opentelemetry/core').InstrumentationScope} InstrumentationScope
+ * @typedef {import('@opentelemetry/core').InstrumentationLibrary} InstrumentationLibrary
+ */
+
+/**
+ * Logger provides methods to emit log records.
+ *
+ * This implementation follows the OpenTelemetry JavaScript API Logger:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api-logs.Logger.html
+ *
+ * @class Logger
+ */
+class Logger {
+  #instrumentationScope
+
+  /**
+   * Creates a new Logger instance.
+   *
+   * @param {LoggerProvider} loggerProvider - Parent logger provider
+   * @param {InstrumentationScope} [instrumentationScope] - Instrumentation scope information (newer API).
+   *  `name` defaults to 'dd-trace-js';
+   *  `version` defaults to tracer version;
+   *  `schemaUrl` defaults to '';
+   * @param {InstrumentationLibrary} [instrumentationLibrary]
+   *  - Instrumentation library information (legacy API) [DEPRECATED in v1.3.0].
+   *  `name` defaults to 'dd-trace-js';
+   *  `version` defaults to tracer version;
+   *  `schemaUrl` defaults to '';
+   */
+  constructor (loggerProvider, instrumentationScope, instrumentationLibrary) {
+    this.loggerProvider = loggerProvider
+
+    // Support both newer instrumentationScope and legacy instrumentationLibrary
+    const scope = instrumentationScope || instrumentationLibrary
+    this.#instrumentationScope = {
+      name: scope?.name || 'dd-trace-js',
+      version: scope?.version || packageVersion,
+      schemaUrl: scope?.schemaUrl || '',
+    }
+  }
+
+  /**
+   * Emits a log record.
+   *
+   * @param {LogRecord} logRecord - The log record to emit
+   * @returns {void}
+   */
+  emit (logRecord) {
+    if (this.loggerProvider.isShutdown || !this.loggerProvider.processor) {
+      return
+    }
+
+    if (logRecord.attributes) {
+      logRecord.attributes = sanitizeAttributes(logRecord.attributes)
+    }
+
+    // Note: timestamp is in nanoseconds (as defined by OpenTelemetry LogRecord API)
+    if (!logRecord.timestamp) {
+      logRecord.timestamp = Number(process.hrtime.bigint())
+    }
+
+    if (!logRecord.context) {
+      // Store span context in the log record context for trace correlation
+      logRecord.context = context.active()
+    }
+
+    this.loggerProvider.processor.onEmit(logRecord, this.#instrumentationScope)
+  }
+}
+
+module.exports = Logger

package/packages/dd-trace/src/opentelemetry/logs/logger_provider.js

@@ -0,0 +1,126 @@
+'use strict'
+const { logs } = require('@opentelemetry/api-logs')
+const { context } = require('@opentelemetry/api')
+const log = require('../../log')
+const ContextManager = require('../context_manager')
+const Logger = require('./logger')
+
+/**
+ * @typedef {import('@opentelemetry/api-logs').Logger} Logger
+ * @typedef {import('./batch_log_processor')} BatchLogRecordProcessor
+ */
+
+/**
+ * LoggerProvider is the main entry point for creating loggers with a single processor for Datadog Agent export.
+ *
+ * This implementation follows the OpenTelemetry JavaScript API LoggerProvider interface:
+ * https://github.com/open-telemetry/opentelemetry-js/blob/a7a36499f70f25201949aeabb84c5fd4ca80e860/experimental/packages/api-logs/src/types/LoggerProvider.ts
+ *
+ * @class LoggerProvider
+ * @implements {import('@opentelemetry/api-logs').LoggerProvider}
+ */
+class LoggerProvider {
+  #loggers
+  #contextManager
+
+  /**
+   * Creates a new LoggerProvider instance with a single processor for Datadog Agent export.
+   *
+   * @param {object} [options] - LoggerProvider options
+   * @param {BatchLogRecordProcessor} [options.processor] - Single LogRecordProcessor instance for
+   *   exporting logs to Datadog Agent
+   */
+  constructor (options = {}) {
+    this.processor = options.processor
+    this.#loggers = new Map()
+    this.#contextManager = new ContextManager()
+    this.isShutdown = false
+  }
+
+  /**
+   * Gets or creates a logger instance.
+   *
+   * @param {string | object} nameOrOptions - Logger name or options object
+   * @param {string} [version] - Logger version (when nameOrOptions is a string)
+   * @param {object} [options] - Additional options (when nameOrOptions is a string)
+   * @returns {Logger} Logger instance
+   */
+  getLogger (nameOrOptions, version, options = {}) {
+    if (this.isShutdown) {
+      return this.#createNoOpLogger()
+    }
+
+    let name, loggerOptions
+    if (typeof nameOrOptions === 'string') {
+      name = nameOrOptions
+      loggerOptions = { version, ...options }
+    } else {
+      name = nameOrOptions.name
+      loggerOptions = nameOrOptions
+    }
+
+    const loggerVersion = loggerOptions.version || ''
+    const loggerSchemaUrl = loggerOptions?.schemaUrl || ''
+    const key = `${name}@${loggerVersion}`
+
+    if (!this.#loggers.has(key)) {
+      this.#loggers.set(key, new Logger(this, { name, version: loggerVersion, schemaUrl: loggerSchemaUrl }))
+    }
+    return this.#loggers.get(key)
+  }
+
+  /**
+   * Registers this logger provider as the global provider.
+   */
+  register () {
+    if (this.isShutdown) {
+      log.warn('Cannot register after shutdown')
+      return
+    }
+    // Set context manager, this is required to correlate logs to spans
+    context.setGlobalContextManager(this.#contextManager)
+    logs.setGlobalLoggerProvider(this)
+  }
+
+  /**
+   * Forces a flush of all pending log records.
+   * @returns {undefined} Promise that resolves when flush is n ssue cncomplete
+   */
+  forceFlush () {
+    if (!this.isShutdown) {
+      return this.processor?.forceFlush()
+    }
+  }
+
+  /**
+   * Shuts down the logger provider and all associated processors.
+   * @returns {undefined} Promise that resolves when shutdown is complete
+   */
+  shutdown () {
+    if (!this.isShutdown) {
+      this.isShutdown = true
+    }
+  }
+
+  /**
+   * Creates a no-op logger for use when the provider is shutdown.
+   * @returns {Logger} A no-op logger instance
+   * @private
+   */
+  #createNoOpLogger () {
+    return {
+      instrumentationScope: {
+        name: 'dd-trace-js',
+        version: '',
+      },
+      emit: () => {},
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+      fatal: () => {},
+    }
+  }
+}
+
+module.exports = LoggerProvider

package/packages/dd-trace/src/opentelemetry/logs/otlp_http_log_exporter.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const OtlpHttpExporterBase = require('../otlp/otlp_http_exporter_base')
+const OtlpTransformer = require('./otlp_transformer')
+
+/**
+ * @typedef {import('@opentelemetry/resources').Resource} Resource
+ * @typedef {import('@opentelemetry/api-logs').LogRecord} LogRecord
+ */
+
+/**
+ * OtlpHttpLogExporter exports log records via OTLP over HTTP.
+ *
+ * This implementation follows the OTLP HTTP v1.7.0 specification:
+ * https://opentelemetry.io/docs/specs/otlp/#otlphttp
+ *
+ * @class OtlpHttpLogExporter
+ * @augments OtlpHttpExporterBase
+ */
+class OtlpHttpLogExporter extends OtlpHttpExporterBase {
+  /**
+   * Creates a new OtlpHttpLogExporter 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 {Resource} resource - Resource attributes
+   */
+  constructor (url, headers, timeout, protocol, resource) {
+    super(url, headers, timeout, protocol, '/v1/logs', 'logs')
+    this.transformer = new OtlpTransformer(resource, protocol)
+  }
+
+  /**
+   * Exports log records via OTLP over HTTP.
+   *
+   * @param {LogRecord[]} logRecords - Array of enriched log records to export
+   * @param {Function} resultCallback - Callback function for export result
+   *
+   * @returns {void}
+   */
+  export (logRecords, resultCallback) {
+    if (logRecords.length === 0) {
+      resultCallback({ code: 0 })
+      return
+    }
+
+    const payload = this.transformer.transformLogRecords(logRecords)
+    this.sendPayload(payload, resultCallback)
+    this.recordTelemetry('otel.log_records', logRecords.length)
+  }
+}
+
+module.exports = OtlpHttpLogExporter

package/packages/dd-trace/src/opentelemetry/logs/otlp_transformer.js

@@ -0,0 +1,245 @@
+'use strict'
+
+const { SeverityNumber } = require('@opentelemetry/api-logs')
+const { trace } = require('@opentelemetry/api')
+
+const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
+const { getProtobufTypes } = require('../otlp/protobuf_loader')
+
+/**
+ * @typedef {import('@opentelemetry/api-logs').LogRecord} LogRecord
+ */
+
+// Global severity mapping constant - no need to regenerate
+const SEVERITY_MAP = {
+  [SeverityNumber.TRACE]: 'SEVERITY_NUMBER_TRACE',
+  [SeverityNumber.TRACE2]: 'SEVERITY_NUMBER_TRACE2',
+  [SeverityNumber.TRACE3]: 'SEVERITY_NUMBER_TRACE3',
+  [SeverityNumber.TRACE4]: 'SEVERITY_NUMBER_TRACE4',
+  [SeverityNumber.DEBUG]: 'SEVERITY_NUMBER_DEBUG',
+  [SeverityNumber.DEBUG2]: 'SEVERITY_NUMBER_DEBUG2',
+  [SeverityNumber.DEBUG3]: 'SEVERITY_NUMBER_DEBUG3',
+  [SeverityNumber.DEBUG4]: 'SEVERITY_NUMBER_DEBUG4',
+  [SeverityNumber.INFO]: 'SEVERITY_NUMBER_INFO',
+  [SeverityNumber.INFO2]: 'SEVERITY_NUMBER_INFO2',
+  [SeverityNumber.INFO3]: 'SEVERITY_NUMBER_INFO3',
+  [SeverityNumber.INFO4]: 'SEVERITY_NUMBER_INFO4',
+  [SeverityNumber.WARN]: 'SEVERITY_NUMBER_WARN',
+  [SeverityNumber.WARN2]: 'SEVERITY_NUMBER_WARN2',
+  [SeverityNumber.WARN3]: 'SEVERITY_NUMBER_WARN3',
+  [SeverityNumber.WARN4]: 'SEVERITY_NUMBER_WARN4',
+  [SeverityNumber.ERROR]: 'SEVERITY_NUMBER_ERROR',
+  [SeverityNumber.ERROR2]: 'SEVERITY_NUMBER_ERROR2',
+  [SeverityNumber.ERROR3]: 'SEVERITY_NUMBER_ERROR3',
+  [SeverityNumber.ERROR4]: 'SEVERITY_NUMBER_ERROR4',
+  [SeverityNumber.FATAL]: 'SEVERITY_NUMBER_FATAL',
+  [SeverityNumber.FATAL2]: 'SEVERITY_NUMBER_FATAL2',
+  [SeverityNumber.FATAL3]: 'SEVERITY_NUMBER_FATAL3',
+  [SeverityNumber.FATAL4]: 'SEVERITY_NUMBER_FATAL4',
+}
+
+/**
+ * OtlpTransformer transforms log records to OTLP format.
+ *
+ * This implementation follows the OTLP Logs v1.7.0 Data Model specification:
+ * https://opentelemetry.io/docs/specs/otlp/#log-data-model
+ *
+ * @class OtlpTransformer
+ * @augments OtlpTransformerBase
+ */
+class OtlpTransformer extends OtlpTransformerBase {
+  /**
+   * Creates a new OtlpTransformer instance.
+   *
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
+   * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
+   */
+  constructor (resourceAttributes, protocol) {
+    super(resourceAttributes, protocol, 'logs')
+  }
+
+  /**
+   * Transforms log records to OTLP format based on the configured protocol.
+   * @param {LogRecord[]} logRecords - Array of enriched log records to transform
+   * @returns {Buffer} Transformed log records in the appropriate format
+   */
+  transformLogRecords (logRecords) {
+    if (this.protocol === 'http/json') {
+      return this.#transformToJson(logRecords)
+    }
+    return this.#transformToProtobuf(logRecords)
+  }
+
+  /**
+   * Transforms log records to protobuf format.
+   * @param {LogRecord[]} logRecords - Array of enriched log records to transform
+   * @returns {Buffer} Protobuf-encoded log records
+   */
+  #transformToProtobuf (logRecords) {
+    const { protoLogsService } = getProtobufTypes()
+
+    const logsData = {
+      resourceLogs: [{
+        resource: this.transformResource(),
+        scopeLogs: this.#transformScope(logRecords),
+      }],
+    }
+
+    return this.serializeToProtobuf(protoLogsService, logsData)
+  }
+
+  /**
+   * Transforms log records to JSON format.
+   * @param {LogRecord[]} logRecords - Array of enriched log records to transform
+   * @returns {Buffer} JSON-encoded log records
+   */
+  #transformToJson (logRecords) {
+    const logsData = {
+      resourceLogs: [{
+        resource: this.transformResource(),
+        scopeLogs: this.#transformScope(logRecords),
+      }],
+    }
+    return this.serializeToJson(logsData)
+  }
+
+  /**
+   * Creates scope logs grouped by instrumentation library.
+   * @param {LogRecord[]} logRecords - Array of log records to transform
+   * @returns {object[]} Array of scope log objects
+   */
+  #transformScope (logRecords) {
+    const groupedRecords = this.groupByInstrumentationScope(logRecords)
+    const scopeLogs = []
+
+    for (const records of groupedRecords.values()) {
+      const schemaUrl = records[0]?.instrumentationScope?.schemaUrl || ''
+      scopeLogs.push({
+        scope: {
+          name: records[0]?.instrumentationScope?.name || 'dd-trace-js',
+          version: records[0]?.instrumentationScope?.version || '',
+          attributes: [],
+          droppedAttributesCount: 0,
+        },
+        schemaUrl,
+        logRecords: records.map(record => this.#transformLogRecord(record)),
+      })
+    }
+
+    return scopeLogs
+  }
+
+  /**
+   * Transforms a single log record to OTLP format.
+   * @param {LogRecord} logRecord - Log record to transform
+   * @returns {object} OTLP log record object
+   */
+  #transformLogRecord (logRecord) {
+    const spanContext = this.#extractSpanContext(logRecord.context)
+
+    const result = {
+      timeUnixNano: logRecord.timestamp,
+      body: this.#transformBody(logRecord.body),
+    }
+
+    // Add optional fields only if they are set
+    if (logRecord.observedTimestamp) {
+      result.observedTimeUnixNano = logRecord.observedTimestamp
+    }
+
+    if (logRecord.severityNumber !== undefined) {
+      result.severityNumber = this.#mapSeverityNumber(logRecord.severityNumber)
+    }
+
+    if (logRecord.severityText) {
+      result.severityText = logRecord.severityText
+    }
+
+    if (logRecord.attributes) {
+      result.attributes = this.transformAttributes(logRecord.attributes)
+    }
+
+    if (spanContext?.traceFlags !== undefined) {
+      result.flags = spanContext.traceFlags
+    }
+
+    // Only include traceId and spanId if they are valid
+    if (spanContext?.traceId && spanContext.traceId !== '00000000000000000000000000000000') {
+      result.traceId = this.#hexToBytes(spanContext.traceId)
+    }
+
+    if (spanContext?.spanId && spanContext.spanId !== '0000000000000000') {
+      result.spanId = this.#hexToBytes(spanContext.spanId)
+    }
+
+    return result
+  }
+
+  /**
+   * Extracts span context from the log record's context.
+   * @param {object} logContext - The log record's context
+   * @returns {object | null} Span context or null if not available
+   */
+  #extractSpanContext (logContext) {
+    if (!logContext) return null
+
+    const activeSpan = trace.getSpan(logContext)
+    if (activeSpan) {
+      return activeSpan.spanContext()
+    }
+
+    return null
+  }
+
+  /**
+   * Maps OpenTelemetry severity number to protobuf severity number.
+   * @param {number} severityNumber - OpenTelemetry severity number
+   * @returns {number} Protobuf severity number
+   */
+  #mapSeverityNumber (severityNumber) {
+    const { protoSeverityNumber } = getProtobufTypes()
+    const severityName = SEVERITY_MAP[severityNumber] || 'SEVERITY_NUMBER_INFO'
+    return protoSeverityNumber.values[severityName]
+  }
+
+  /**
+   * Converts a hex string to a Buffer.
+   * @param {string} hexString - Hex string to convert
+   * @returns {Buffer} Buffer containing the hex data
+   */
+  #hexToBytes (hexString) {
+    const cleanHex = hexString ? (hexString.startsWith('0x') ? hexString.slice(2) : hexString) : ''
+    const paddedHex = cleanHex.length % 2 === 0 ? cleanHex : '0' + cleanHex
+    return Buffer.from(paddedHex, 'hex')
+  }
+
+  /**
+   * Transforms log body to OTLP AnyValue format.
+   * @param {import('@opentelemetry/api-logs').LogBody} body - Log body to transform
+   * @returns {object} OTLP AnyValue object
+   */
+  #transformBody (body) {
+    if (typeof body === 'string') {
+      return { stringValue: body }
+    } else if (typeof body === 'number') {
+      if (Number.isInteger(body)) {
+        return { intValue: body }
+      }
+      return { doubleValue: body }
+    } else if (typeof body === 'boolean') {
+      return { boolValue: body }
+    } else if (body && typeof body === 'object') {
+      return {
+        kvlistValue: {
+          values: Object.entries(body).map(([key, value]) => ({
+            key,
+            value: this.transformAnyValue(value),
+          })),
+        },
+      }
+    }
+    return { stringValue: String(body) }
+  }
+}
+
+module.exports = OtlpTransformer