dd-trace 5.80.0 → 5.82.0

package/packages/dd-trace/src/openfeature/remote_config.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const RemoteConfigCapabilities = require('../remote_config/capabilities')
+
+/**
+ * Configures remote config handlers for openfeature feature flagging
+ *
+ * @param {object} rc - RemoteConfig instance
+ * @param {object} config - Tracer config
+ * @param {Function} getOpenfeatureProxy - Function that returns the OpenFeature proxy from tracer
+ */
+function enable (rc, config, getOpenfeatureProxy) {
+  // Always enable capability for feature flag configuration
+  // This indicates the library supports this capability via remote config
+  rc.updateCapabilities(RemoteConfigCapabilities.FFE_FLAG_CONFIGURATION_RULES, true)
+
+  // Only register product handler if the experimental feature is enabled
+  if (!config.experimental.flaggingProvider.enabled) return
+
+  // Set product handler for FFE_FLAGS
+  rc.setProductHandler('FFE_FLAGS', (action, conf) => {
+    // Feed UFC config directly to OpenFeature provider
+    if (action === 'apply' || action === 'modify') {
+      getOpenfeatureProxy()._setConfiguration(conf)
+    }
+  })
+}
+
+module.exports = {
+  enable
+}

package/packages/dd-trace/src/openfeature/writers/base.js

@@ -1,21 +1,21 @@
 'use strict'
 
+const { URL, format } = require('node:url')
 const request = require('../../exporters/common/request')
 const { safeJSONStringify } = require('../../exporters/common/util')
-const { URL, format } = require('node:url')
 
 const log = require('../../log')
 
 /**
- * @typedef {Object} BaseFFEWriterOptions
+ * @typedef {object} BaseFFEWriterOptions
  * @property {number} [interval] - Flush interval in milliseconds
  * @property {number} [timeout] - Request timeout in milliseconds
- * @property {Object} config - Tracer configuration object
+ * @property {object} config - Tracer configuration object
  * @property {string} endpoint - API endpoint path
  * @property {URL} [agentUrl] - Base URL for the agent
  * @property {number} [payloadSizeLimit] - Maximum payload size in bytes
  * @property {number} [eventSizeLimit] - Maximum individual event size in bytes
- * @property {Object} [headers] - Additional HTTP headers
+ * @property {object} [headers] - Additional HTTP headers
  */
 
 /**
@@ -67,7 +67,7 @@ class BaseFFEWriter {
 
   /**
    * Appends an event array to the buffer
-   * @param {Array|Object} events - Event object(s) to append to buffer
+   * @param {Array | object} events - Event object(s) to append to buffer
    */
   append (events) {
     const eventArray = Array.isArray(events) ? events : [events]

package/packages/dd-trace/src/openfeature/writers/exposures.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const BaseFFEWriter = require('./base')
 const {
   EXPOSURES_ENDPOINT,
   EVP_PROXY_AGENT_BASE_PATH,
@@ -9,31 +8,32 @@ const {
   EVP_PAYLOAD_SIZE_LIMIT,
   EVP_EVENT_SIZE_LIMIT
 } = require('../constants/constants')
+const BaseFFEWriter = require('./base')
 
 /**
- * @typedef {Object} ExposureEvent
+ * @typedef {object} ExposureEvent
  * @property {number} timestamp - Unix timestamp in milliseconds
- * @property {Object} allocation - Allocation information
+ * @property {object} allocation - Allocation information
  * @property {string} allocation.key - Allocation key
- * @property {Object} flag - Flag information
+ * @property {object} flag - Flag information
  * @property {string} flag.key - Flag key
- * @property {Object} variant - Variant information
+ * @property {object} variant - Variant information
  * @property {string} variant.key - Variant key
- * @property {Object} subject - Subject (user/entity) information
+ * @property {object} subject - Subject (user/entity) information
  * @property {string} subject.id - Subject identifier
  * @property {string} [subject.type] - Subject type
- * @property {Object} [subject.attributes] - Additional subject attributes
+ * @property {object} [subject.attributes] - Additional subject attributes
  */
 
 /**
- * @typedef {Object} ExposureContext
+ * @typedef {object} ExposureContext
  * @property {string} service - Service name
  * @property {string} [version] - Service version
  * @property {string} [env] - Service environment
  */
 
 /**
- * @typedef {Object} ExposureEventPayload
+ * @typedef {object} ExposureEventPayload
  * @property {ExposureContext} context - Service context metadata
  * @property {ExposureEvent[]} exposures - Formatted exposure events
  */

package/packages/dd-trace/src/opentelemetry/context_manager.js

@@ -1,11 +1,11 @@
 'use strict'
 
-const { storage } = require('../../../datadog-core')
 const { trace, ROOT_CONTEXT, propagation } = require('@opentelemetry/api')
+const { storage } = require('../../../datadog-core')
 const DataDogSpanContext = require('../opentracing/span_context')
 
-const SpanContext = require('./span_context')
 const tracer = require('../../')
+const SpanContext = require('./span_context')
 
 class ContextManager {
   constructor () {

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

@@ -70,8 +70,8 @@ function initializeOpenTelemetryLogs (config) {
   // Create batch processor for exporting logs to Datadog Agent
   const processor = new BatchLogRecordProcessor(
     exporter,
-    config.otelLogsBatchTimeout,
-    config.otelLogsMaxExportBatchSize
+    config.otelBatchTimeout,
+    config.otelMaxExportBatchSize
   )
 
   // Create logger provider with processor for Datadog Agent export

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

@@ -1,8 +1,9 @@
 'use strict'
 
-const { sanitizeAttributes } = require('@opentelemetry/core')
 const { context } = require('@opentelemetry/api')
-const packageVersion = require('../../../../../package.json').version
+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

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

@@ -1,9 +1,9 @@
 'use strict'
 const { logs } = require('@opentelemetry/api-logs')
 const { context } = require('@opentelemetry/api')
-const Logger = require('./logger')
 const log = require('../../log')
 const ContextManager = require('../context_manager')
+const Logger = require('./logger')
 
 /**
  * @typedef {import('@opentelemetry/api-logs').Logger} Logger
@@ -26,7 +26,7 @@ class LoggerProvider {
   /**
    * Creates a new LoggerProvider instance with a single processor for Datadog Agent export.
    *
-   * @param {Object} [options] - LoggerProvider options
+   * @param {object} [options] - LoggerProvider options
    * @param {BatchLogRecordProcessor} [options.processor] - Single LogRecordProcessor instance for
    *   exporting logs to Datadog Agent
    */
@@ -40,9 +40,9 @@ class LoggerProvider {
   /**
    * Gets or creates a logger instance.
    *
-   * @param {string|Object} nameOrOptions - Logger name or options object
+   * @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)
+   * @param {object} [options] - Additional options (when nameOrOptions is a string)
    * @returns {Logger} Logger instance
    */
   getLogger (nameOrOptions, version, options = {}) {

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

@@ -11,7 +11,7 @@ const OtlpTransformer = require('./otlp_transformer')
 /**
  * OtlpHttpLogExporter exports log records via OTLP over HTTP.
  *
- * This implementation follows the OTLP HTTP specification:
+ * This implementation follows the OTLP HTTP v1.7.0 specification:
  * https://opentelemetry.io/docs/specs/otlp/#otlphttp
  *
  * @class OtlpHttpLogExporter
@@ -37,6 +37,8 @@ class OtlpHttpLogExporter extends OtlpHttpExporterBase {
    *
    * @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) {
@@ -45,8 +47,8 @@ class OtlpHttpLogExporter extends OtlpHttpExporterBase {
     }
 
     const payload = this.transformer.transformLogRecords(logRecords)
-    this._sendPayload(payload, resultCallback)
-    this._recordTelemetry('otel.log_records', logRecords.length)
+    this.sendPayload(payload, resultCallback)
+    this.recordTelemetry('otel.log_records', logRecords.length)
   }
 }
 

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

@@ -1,10 +1,11 @@
 'use strict'
 
-const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
 const { SeverityNumber } = require('@opentelemetry/api-logs')
-const { getProtobufTypes } = require('../otlp/protobuf_loader')
 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
  */
@@ -40,7 +41,7 @@ const SEVERITY_MAP = {
 /**
  * OtlpTransformer transforms log records to OTLP format.
  *
- * This implementation follows the OTLP Logs Data Model specification:
+ * This implementation follows the OTLP Logs v1.7.0 Data Model specification:
  * https://opentelemetry.io/docs/specs/otlp/#log-data-model
  *
  * @class OtlpTransformer
@@ -79,12 +80,12 @@ class OtlpTransformer extends OtlpTransformerBase {
 
     const logsData = {
       resourceLogs: [{
-        resource: this._transformResource(),
+        resource: this.transformResource(),
         scopeLogs: this.#transformScope(logRecords),
       }]
     }
 
-    return this._serializeToProtobuf(protoLogsService, logsData)
+    return this.serializeToProtobuf(protoLogsService, logsData)
   }
 
   /**
@@ -95,20 +96,20 @@ class OtlpTransformer extends OtlpTransformerBase {
   #transformToJson (logRecords) {
     const logsData = {
       resourceLogs: [{
-        resource: this._transformResource(),
+        resource: this.transformResource(),
         scopeLogs: this.#transformScope(logRecords)
       }]
     }
-    return this._serializeToJson(logsData)
+    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
+   * @returns {object[]} Array of scope log objects
    */
   #transformScope (logRecords) {
-    const groupedRecords = this._groupByInstrumentationScope(logRecords)
+    const groupedRecords = this.groupByInstrumentationScope(logRecords)
     const scopeLogs = []
 
     for (const records of groupedRecords.values()) {
@@ -131,7 +132,7 @@ class OtlpTransformer extends OtlpTransformerBase {
   /**
    * Transforms a single log record to OTLP format.
    * @param {LogRecord} logRecord - Log record to transform
-   * @returns {Object} OTLP log record object
+   * @returns {object} OTLP log record object
    */
   #transformLogRecord (logRecord) {
     const spanContext = this.#extractSpanContext(logRecord.context)
@@ -155,7 +156,7 @@ class OtlpTransformer extends OtlpTransformerBase {
     }
 
     if (logRecord.attributes) {
-      result.attributes = this._transformAttributes(logRecord.attributes)
+      result.attributes = this.transformAttributes(logRecord.attributes)
     }
 
     if (spanContext?.traceFlags !== undefined) {
@@ -176,8 +177,8 @@ class OtlpTransformer extends OtlpTransformerBase {
 
   /**
    * 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
+   * @param {object} logContext - The log record's context
+   * @returns {object | null} Span context or null if not available
    */
   #extractSpanContext (logContext) {
     if (!logContext) return null
@@ -214,8 +215,8 @@ class OtlpTransformer extends OtlpTransformerBase {
 
   /**
    * Transforms log body to OTLP AnyValue format.
-   * @param {any} body - Log body to transform
-   * @returns {Object} OTLP AnyValue object
+   * @param {import('@opentelemetry/api-logs').LogBody} body - Log body to transform
+   * @returns {object} OTLP AnyValue object
    */
   #transformBody (body) {
     if (typeof body === 'string') {
@@ -232,7 +233,7 @@ class OtlpTransformer extends OtlpTransformerBase {
         kvlistValue: {
           values: Object.entries(body).map(([key, value]) => ({
             key,
-            value: this._transformAnyValue(value)
+            value: this.transformAnyValue(value)
           }))
         }
       }

package/packages/dd-trace/src/opentelemetry/metrics/constants.js

@@ -0,0 +1,34 @@
+'use strict'
+
+// Metric type constants
+const METRIC_TYPES = {
+  HISTOGRAM: 'histogram',
+  COUNTER: 'counter',
+  UPDOWNCOUNTER: 'updowncounter',
+  OBSERVABLECOUNTER: 'observable-counter',
+  OBSERVABLEUPDOWNCOUNTER: 'observable-updowncounter',
+  GAUGE: 'gauge'
+}
+
+// Temporality constants
+const TEMPORALITY = {
+  DELTA: 'DELTA',
+  CUMULATIVE: 'CUMULATIVE',
+  GAUGE: 'GAUGE',
+  LOWMEMORY: 'LOWMEMORY'
+}
+
+// Default histogram bucket boundaries (in milliseconds for latency metrics)
+const DEFAULT_HISTOGRAM_BUCKETS = [0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10_000]
+
+// Maximum number of measurements to queue before dropping
+// This limit corresponds to the maximum number of items
+// that be reliably added to a single Array.
+const DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE = 65_536
+
+module.exports = {
+  METRIC_TYPES,
+  TEMPORALITY,
+  DEFAULT_HISTOGRAM_BUCKETS,
+  DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE
+}

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

@@ -0,0 +1,81 @@
+'use strict'
+
+const os = require('os')
+
+/**
+ * @typedef {import('../../config')} Config
+ */
+
+/**
+ * @file OpenTelemetry Metrics Implementation for dd-trace-js
+ *
+ * This package provides a custom OpenTelemetry Metrics implementation that integrates
+ * with the Datadog tracing library. It includes all necessary components for
+ * creating instruments, recording measurements, and exporting metrics via OTLP.
+ *
+ * Key Components:
+ * - MeterProvider: Main entry point for creating meters
+ * - Meter: Provides methods to create metric instruments
+ * - Instruments: Gauge, Counter, UpDownCounter, ObservableGauge, ObservableCounter, ObservableUpDownCounter, Histogram
+ * - PeriodicMetricReader: Collects and exports instruments (metrics) at regular intervals
+ * - OtlpHttpMetricExporter: Exports instruments (metrics) via OTLP over HTTP
+ * - OtlpTransformer: Transforms instruments (metrics) 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 { metrics } = require('@opentelemetry/api')
+const MeterProvider = require('./meter_provider')
+const PeriodicMetricReader = require('./periodic_metric_reader')
+const OtlpHttpMetricExporter = require('./otlp_http_metric_exporter')
+
+/**
+ * Initializes OpenTelemetry Metrics support
+ * @param {Config} config - Tracer configuration instance
+ */
+function initializeOpenTelemetryMetrics (config) {
+  const resourceAttributes = {
+    'service.name': config.service,
+    'service.version': config.version,
+    'deployment.environment': config.env
+  }
+
+  if (config.tags) {
+    const filteredTags = { ...config.tags }
+    delete filteredTags.service
+    delete filteredTags.version
+    delete filteredTags.env
+    Object.assign(resourceAttributes, filteredTags)
+  }
+
+  if (config.reportHostname) {
+    resourceAttributes['host.name'] = os.hostname()
+  }
+
+  const exporter = new OtlpHttpMetricExporter(
+    config.otelMetricsUrl,
+    config.otelMetricsHeaders,
+    config.otelMetricsTimeout,
+    config.otelMetricsProtocol,
+    resourceAttributes
+  )
+
+  const reader = new PeriodicMetricReader(
+    exporter,
+    config.otelMetricsExportInterval,
+    config.otelMetricsTemporalityPreference,
+    config.otelMaxQueueSize
+  )
+
+  const meterProvider = new MeterProvider({ reader })
+  metrics.setGlobalMeterProvider(meterProvider)
+}
+
+module.exports = {
+  MeterProvider,
+  initializeOpenTelemetryMetrics
+}

package/packages/dd-trace/src/opentelemetry/metrics/instruments.js

@@ -0,0 +1,225 @@
+'use strict'
+
+const { sanitizeAttributes } = require('../../../../../vendor/dist/@opentelemetry/core')
+const { METRIC_TYPES } = require('./constants')
+
+/**
+ * @typedef {import('@opentelemetry/api').Attributes} Attributes
+ * @typedef {import('@opentelemetry/core').InstrumentationScope} InstrumentationScope
+ */
+
+/**
+ * @typedef {object} Measurement
+ * @property {string} name - Instrument name
+ * @property {string} description - Instrument description
+ * @property {string} unit - Measurement unit
+ * @property {InstrumentationScope} instrumentationScope - Instrumentation scope
+ * @property {string} type - Metric type from METRIC_TYPES
+ * @property {number} value - Measured value
+ * @property {Attributes} attributes - Sanitized metric attributes
+ * @property {number} timestamp - Timestamp in nanoseconds
+ */
+
+/**
+ * Base class for all metric instruments.
+ *
+ *
+ */
+class Instrument {
+  /**
+   * Creates a new instrument instance.
+   *
+   * @param {string} name - Instrument name (e.g., 'http.request.duration')
+   * @param {object} options - Instrument configuration options
+   * @param {string} [options.description] - Human-readable description of the instrument
+   * @param {string} [options.unit] - Unit of measurement (e.g., 'ms', 'bytes', '1')
+   * @param {InstrumentationScope} instrumentationScope - Instrumentation scope for this instrument
+   * @param {object} reader - Metric reader for recording measurements
+   */
+  constructor (name, options, instrumentationScope, reader) {
+    this.name = name
+    this.description = options.description ?? ''
+    this.unit = options.unit ?? ''
+    this.valueType = options.valueType // currently ignored, TODO: add support for ValueType
+    this.advice = options.advice // currently ignored, TODO: add support for MetricAdvice
+    this.instrumentationScope = instrumentationScope
+    this.reader = reader
+  }
+
+  /**
+   * Creates a measurement object for recording metric values.
+   * @param {string} type - Metric type from METRIC_TYPES
+   * @param {number} value - Numeric value to record
+   * @param {Attributes} attributes - Key-value pairs for metric dimensions
+   * @returns {Measurement} Measurement object with metadata and timestamp
+   */
+  createMeasurement (type, value, attributes) {
+    return {
+      name: this.name,
+      description: this.description,
+      unit: this.unit,
+      instrumentationScope: this.instrumentationScope,
+      type,
+      value,
+      attributes: sanitizeAttributes(attributes),
+      timestamp: Number(process.hrtime.bigint())
+    }
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry Counter interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.Counter.html
+ * @class Counter
+ */
+class Counter extends Instrument {
+  add (value, attributes = {}) {
+    if (value < 0) return
+    this.reader?.record(this.createMeasurement(METRIC_TYPES.COUNTER, value, attributes))
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry UpDownCounter interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.UpDownCounter.html
+ * @class UpDownCounter
+ */
+class UpDownCounter extends Instrument {
+  add (value, attributes = {}) {
+    this.reader?.record(this.createMeasurement(METRIC_TYPES.UPDOWNCOUNTER, value, attributes))
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry Histogram interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.Histogram.html
+ * @class Histogram
+ */
+class Histogram extends Instrument {
+  record (value, attributes = {}) {
+    if (value < 0) return
+    this.reader?.record(this.createMeasurement(METRIC_TYPES.HISTOGRAM, value, attributes))
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry Gauge interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.Gauge.html
+ * @class Gauge
+ */
+class Gauge extends Instrument {
+  record (value, attributes = {}) {
+    this.reader?.record(this.createMeasurement(METRIC_TYPES.GAUGE, value, attributes))
+  }
+}
+
+/**
+ * Base class for observable (asynchronous) instruments.
+ * Implementation of the OpenTelemetry Observable interface:
+ * https://open-telemetry.github.io/opentelemetry-js/interfaces/_opentelemetry_api._opentelemetry_api.Observable.html
+ *
+ */
+class ObservableInstrument extends Instrument {
+  #callbacks = []
+  #type
+
+  constructor (name, options, instrumentationScope, reader, type) {
+    super(name, options, instrumentationScope, reader)
+    this.#type = type
+  }
+
+  /**
+   * Adds a callback to invoke during metric collection.
+   *
+   * @param {Function} callback - Receives an ObservableResult to record observations
+   */
+  addCallback (callback) {
+    if (typeof callback !== 'function') return
+    this.#callbacks.push(callback)
+    this.reader?.observableInstruments.add(this)
+  }
+
+  /**
+   * Removes a callback.
+   *
+   * @param {Function} callback - The callback to remove
+   */
+  removeCallback (callback) {
+    const index = this.#callbacks.indexOf(callback)
+    if (index !== -1) {
+      this.#callbacks.splice(index, 1)
+      if (this.#callbacks.length === 0) {
+        // Remove instrument from collection when no callbacks remain
+        this.reader?.observableInstruments.delete(this)
+      }
+    }
+  }
+
+  /**
+   * Collects observations from all callbacks. Errors are silently ignored.
+   *
+   * @returns {Array<Measurement>} Array of measurements
+   */
+  collect () {
+    const observations = []
+    const observableResult = {
+      observe: (value, attributes = {}) => {
+        observations.push(this.createMeasurement(this.#type, value, attributes))
+      }
+    }
+
+    for (const callback of this.#callbacks) {
+      try {
+        callback(observableResult)
+      } catch {
+        // Ignore callback errors per OpenTelemetry spec to prevent disruption
+        // Errors are swallowed as callbacks should not break metric collection
+      }
+    }
+
+    return observations
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry ObservableGauge interface:
+ * https://open-telemetry.github.io/opentelemetry-js/types/_opentelemetry_api._opentelemetry_api.ObservableGauge.html
+ * @class ObservableGauge
+ */
+class ObservableGauge extends ObservableInstrument {
+  constructor (name, options, instrumentationScope, reader) {
+    super(name, options, instrumentationScope, reader, METRIC_TYPES.GAUGE)
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry ObservableCounter interface:
+ * https://open-telemetry.github.io/opentelemetry-js/types/_opentelemetry_api._opentelemetry_api.ObservableCounter.html
+ * @class ObservableCounter
+ */
+class ObservableCounter extends ObservableInstrument {
+  constructor (name, options, instrumentationScope, reader) {
+    super(name, options, instrumentationScope, reader, METRIC_TYPES.OBSERVABLECOUNTER)
+  }
+}
+
+/**
+ * Implementation of the OpenTelemetry ObservableUpDownCounter interface:
+ * https://open-telemetry.github.io/opentelemetry-js/types/_opentelemetry_api._opentelemetry_api.ObservableUpDownCounter.html
+ * @class ObservableUpDownCounter
+ */
+class ObservableUpDownCounter extends ObservableInstrument {
+  constructor (name, options, instrumentationScope, reader) {
+    super(name, options, instrumentationScope, reader, METRIC_TYPES.OBSERVABLEUPDOWNCOUNTER)
+  }
+}
+
+module.exports = {
+  Counter,
+  UpDownCounter,
+  Histogram,
+  Gauge,
+  ObservableGauge,
+  ObservableCounter,
+  ObservableUpDownCounter
+}