dd-trace 5.79.0 → 5.81.0

package/packages/dd-trace/src/llmobs/plugins/openai/utils.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const IMAGE_FALLBACK = '[image]'
+const FILE_FALLBACK = '[file]'
+
+const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g
+
+/**
+ * Extracts chat templates from OpenAI response instructions by replacing variable values with placeholders.
+ *
+ * Performs reverse templating: reconstructs the template by replacing actual values with {{variable_name}}.
+ * For images/files: uses {{variable_name}} when values are available, falls back to [image]/[file] when stripped.
+ *
+ * @param {Array<Object>} instructions - From Response.instructions (array of ResponseInputMessageItem)
+ * @param {Object<string, string>} variables - Normalized variables (output of normalizePromptVariables)
+ * @returns {Array<{role: string, content: string}>} Chat template with placeholders
+ */
+function extractChatTemplateFromInstructions (instructions, variables) {
+  if (!Array.isArray(instructions) || !variables) return []
+
+  const chatTemplate = []
+
+  // Build map of values to placeholders - exclude fallback markers so they remain as-is
+  const valueToPlaceholder = {}
+  for (const [varName, varValue] of Object.entries(variables)) {
+    // Exclude fallback markers - they should remain as [image]/[file] in the template
+    if (varValue && varValue !== IMAGE_FALLBACK && varValue !== FILE_FALLBACK) {
+      valueToPlaceholder[varValue] = `{{${varName}}}`
+    }
+  }
+
+  // Sort values by length (longest first) to handle overlapping values correctly
+  const sortedValues = Object.keys(valueToPlaceholder).sort((a, b) => b.length - a.length)
+
+  for (const instruction of instructions) {
+    const role = instruction.role
+    if (!role) continue
+
+    const contentItems = instruction.content
+    if (!Array.isArray(contentItems)) continue
+
+    // Extract text from all content items (uses actual values for images/files when available)
+    const textParts = contentItems
+      .map(extractTextFromContentItem)
+      .filter(Boolean)
+
+    if (textParts.length === 0) continue
+
+    // Combine text and replace variable values with placeholders (longest first)
+    let fullText = textParts.join('')
+    for (const valueStr of sortedValues) {
+      const placeholder = valueToPlaceholder[valueStr]
+      const escapedValue = valueStr.replaceAll(REGEX_SPECIAL_CHARS, String.raw`\$&`)
+      fullText = fullText.replaceAll(new RegExp(escapedValue, 'g'), placeholder)
+    }
+
+    chatTemplate.push({ role, content: fullText })
+  }
+
+  return chatTemplate
+}
+
+/**
+ * Extracts text content from a content item, using actual image_url/file_id values when available.
+ *
+ * Used for both input messages and chat template extraction. Falls back to [image]/[file] markers
+ * when the actual values are stripped (e.g., by OpenAI's default URL stripping behavior).
+ *
+ * @param {Object} contentItem - Content item from Response.instructions[].content (ResponseInputContentItem)
+ * @returns {string|null} Text content, URL/file reference, or [image]/[file] fallback marker
+ */
+function extractTextFromContentItem (contentItem) {
+  if (!contentItem) return null
+
+  if (contentItem.text) {
+    return contentItem.text
+  }
+
+  // For image/file items, extract the actual reference value
+  if (contentItem.type === 'input_image') {
+    return contentItem.image_url || contentItem.file_id || IMAGE_FALLBACK
+  }
+
+  if (contentItem.type === 'input_file') {
+    return contentItem.file_id || contentItem.file_url || contentItem.filename || FILE_FALLBACK
+  }
+
+  return null
+}
+
+/**
+ * Normalizes prompt variables by extracting meaningful values from OpenAI SDK response objects.
+ *
+ * Converts ResponseInputText, ResponseInputImage, and ResponseInputFile objects to simple string values.
+ *
+ * @param {Object<string, string|Object>} variables - From ResponsePrompt.variables
+ * @returns {Object<string, string>} Normalized variables with simple string values
+ */
+function normalizePromptVariables (variables) {
+  if (!variables) return {}
+
+  return Object.fromEntries(
+    Object.entries(variables).map(([key, value]) => [
+      key,
+      extractTextFromContentItem(value) ?? String(value ?? '')
+    ])
+  )
+}
+
+module.exports = {
+  extractChatTemplateFromInstructions,
+  normalizePromptVariables,
+  extractTextFromContentItem
+}

package/packages/dd-trace/src/llmobs/sdk.js

@@ -369,7 +369,7 @@ class LLMObs extends NoopLLMObs {
         err = 'invalid_metric_label'
         throw new Error('label must be the specified name of the evaluation metric')
       }
-      if (!metricType || !['categorical', 'score'].includes(metricType)) {
+      if (!metricType || !['categorical', 'score', 'boolean'].includes(metricType)) {
         err = 'invalid_metric_type'
         throw new Error('metricType must be one of "categorical" or "score"')
       }
@@ -381,6 +381,10 @@ class LLMObs extends NoopLLMObs {
         err = 'invalid_metric_value'
         throw new Error('value must be a number for a score metric.')
       }
+      if (metricType === 'boolean' && typeof value !== 'boolean') {
+        err = 'invalid_metric_value'
+        throw new Error('value must be a boolean for a boolean metric')
+      }
 
       const evaluationTags = {
         'ddtrace.version': tracerVersion,
@@ -406,6 +410,11 @@ class LLMObs extends NoopLLMObs {
         }
       }
 
+      // When OTel tracing is enabled, add source:otel tag to allow backend to wait for OTel span conversion
+      if (isTrue(getEnvironmentVariable('DD_TRACE_OTEL_ENABLED'))) {
+        evaluationTags.source = 'otel'
+      }
+
       const payload = {
         span_id: spanId,
         trace_id: traceId,

package/packages/dd-trace/src/llmobs/span_processor.js

@@ -72,7 +72,7 @@ class LLMObsSpanProcessor {
   }
 
   // TODO: instead of relying on the tagger's weakmap registry, can we use some namespaced storage correlation?
-  process ({ span }) {
+  process (span) {
     if (!this.#config.llmobs.enabled) return
     // if the span is not in our private tagger map, it is not an llmobs span
     if (!LLMObsTagger.tagMap.has(span)) return
@@ -126,6 +126,11 @@ class LLMObsSpanProcessor {
       inputType = 'value'
     }
 
+    // Handle prompt metadata for reusable prompts
+    if (mlObsTags['_ml_obs.meta.input.prompt']) {
+      input.prompt = mlObsTags['_ml_obs.meta.input.prompt']
+    }
+
     if (spanKind === 'llm' && mlObsTags[OUTPUT_MESSAGES]) {
       llmObsSpan.output = mlObsTags[OUTPUT_MESSAGES]
       outputType = 'messages'
@@ -155,7 +160,7 @@ class LLMObsSpanProcessor {
     llmObsSpan._tags = tags
 
     const processedSpan = this.#runProcessor(llmObsSpan)
-    if (processedSpan === null) return null
+    if (processedSpan === undefined) return null
 
     if (processedSpan.input) {
       if (inputType === 'messages') {
@@ -207,7 +212,7 @@ class LLMObsSpanProcessor {
     const seenObjects = new WeakSet([obj])
 
     const isCircular = value => {
-      if (typeof value !== 'object') return false
+      if (value == null || typeof value !== 'object') return false
       if (seenObjects.has(value)) return true
       seenObjects.add(value)
       return false
@@ -269,7 +274,7 @@ class LLMObsSpanProcessor {
   /**
    * Runs the user span processor, emitting telemetry and adding some guardrails against invalid return types
    * @param {LLMObservabilitySpan} span
-   * @returns {LLMObservabilitySpan | null}
+   * @returns {LLMObservabilitySpan | undefined}
    */
   #runProcessor (span) {
     const processor = this.#userSpanProcessor
@@ -279,12 +284,12 @@ class LLMObsSpanProcessor {
 
     try {
       const processedLLMObsSpan = processor(span)
-      if (processedLLMObsSpan === null) return null
+      if (processedLLMObsSpan === null) return
 
       if (!(processedLLMObsSpan instanceof LLMObservabilitySpan)) {
         error = true
         logger.warn('User span processor must return an instance of an LLMObservabilitySpan or null, dropping span.')
-        return null
+        return
       }
 
       return processedLLMObsSpan

package/packages/dd-trace/src/llmobs/tagger.js

@@ -25,6 +25,7 @@ const {
   INPUT_TOKENS_METRIC_KEY,
   OUTPUT_TOKENS_METRIC_KEY,
   TOTAL_TOKENS_METRIC_KEY,
+  REASONING_OUTPUT_TOKENS_METRIC_KEY,
   INTEGRATION,
   DECORATOR,
   PROPAGATED_ML_APP_KEY
@@ -85,7 +86,7 @@ class LLMObsTagger {
     if (name) this._setTag(span, NAME, name)
 
     this._setTag(span, SPAN_KIND, kind)
-    if (modelName) this._setTag(span, MODEL_NAME, modelName)
+    if (modelName) this.tagModelName(span, modelName)
     if (modelProvider) this._setTag(span, MODEL_PROVIDER, modelProvider)
 
     sessionId = sessionId || registry.get(parent)?.[SESSION_ID]
@@ -164,6 +165,9 @@ class LLMObsTagger {
         case 'cacheWriteTokens':
           processedKey = CACHE_WRITE_INPUT_TOKENS_METRIC_KEY
           break
+        case 'reasoningOutputTokens':
+          processedKey = REASONING_OUTPUT_TOKENS_METRIC_KEY
+          break
       }
 
       if (typeof value === 'number') {
@@ -194,6 +198,10 @@ class LLMObsTagger {
     this._setTag(span, SPAN_KIND, newKind)
   }
 
+  tagModelName (span, modelName) {
+    this._setTag(span, MODEL_NAME, modelName)
+  }
+
   #tagText (span, data, key) {
     if (data) {
       if (typeof data === 'string') {
@@ -324,7 +332,7 @@ class LLMObsTagger {
 
     for (const message of data) {
       if (typeof message === 'string') {
-        messages.push({ content: message })
+        messages.push({ content: message, role: '' })
         continue
       }
       if (message == null || typeof message !== 'object') {
@@ -332,20 +340,30 @@ class LLMObsTagger {
         continue
       }
 
-      const { content = '', role } = message
-      const toolCalls = message.toolCalls
-      const toolResults = message.toolResults
-      const toolId = message.toolId
-      const messageObj = { content }
+      const {
+        role = '',
+        content,
+        toolCalls,
+        toolResults,
+        toolId
+      } = message
+      const messageObj = {}
 
       let condition = this.#tagConditionalString(role, 'Message role', messageObj, 'role')
 
-      const valid = typeof content === 'string'
-      if (!valid) {
-        this.#handleFailure('Message content must be a string.', 'invalid_io_messages')
+      if (
+        content == null &&
+        toolCalls == null &&
+        toolResults == null
+      ) {
+        messageObj.content = ''
+      }
+
+      if (content != null) {
+        condition = this.#tagConditionalString(content, 'Message content', messageObj, 'content') && condition
       }
 
-      if (toolCalls) {
+      if (toolCalls != null) {
         const filteredToolCalls = this.#filterToolCalls(toolCalls)
 
         if (filteredToolCalls.length) {
@@ -353,7 +371,7 @@ class LLMObsTagger {
         }
       }
 
-      if (toolResults) {
+      if (toolResults != null) {
         const filteredToolResults = this.#filterToolResults(toolResults)
 
         if (filteredToolResults.length) {
@@ -363,13 +381,13 @@ class LLMObsTagger {
 
       if (toolId) {
         if (role === 'tool') {
-          condition = this.#tagConditionalString(toolId, 'Tool ID', messageObj, 'tool_id')
+          condition = this.#tagConditionalString(toolId, 'Tool ID', messageObj, 'tool_id') && condition
         } else {
           log.warn(`Tool ID for tool message not associated with a "tool" role, instead got "${role}"`)
         }
       }
 
-      if (valid && condition) {
+      if (condition) {
         messages.push(messageObj)
       }
     }
@@ -380,7 +398,7 @@ class LLMObsTagger {
   }
 
   #tagConditionalString (data, type, carrier, key) {
-    if (!data) return true
+    if (data == null) return true
     if (typeof data !== 'string') {
       this.#handleFailure(`"${type}" must be a string.`)
       return false
@@ -390,7 +408,7 @@ class LLMObsTagger {
   }
 
   #tagConditionalNumber (data, type, carrier, key) {
-    if (!data) return true
+    if (data == null) return true
     if (typeof data !== 'number') {
       this.#handleFailure(`"${type}" must be a number.`)
       return false
@@ -400,7 +418,7 @@ class LLMObsTagger {
   }
 
   #tagConditionalObject (data, type, carrier, key) {
-    if (!data) return true
+    if (data == null) return true
     if (typeof data !== 'object') {
       this.#handleFailure(`"${type}" must be an object.`)
       return false

package/packages/dd-trace/src/msgpack/chunk.js

@@ -7,7 +7,7 @@ const DEFAULT_MIN_SIZE = 2 * 1024 * 1024 // 2MB
  * interfaces so that it can be used seamlessly by any encoder code that expects
  * either.
  */
-class Chunk {
+class MsgpackChunk {
   constructor (minSize = DEFAULT_MIN_SIZE) {
     this.buffer = Buffer.allocUnsafe(minSize)
     this.view = new DataView(this.buffer.buffer)
@@ -66,4 +66,4 @@ class Chunk {
   }
 }
 
-module.exports = Chunk
+module.exports = MsgpackChunk

package/packages/dd-trace/src/msgpack/encoder.js

@@ -1,11 +1,10 @@
 'use strict'
 
-const Chunk = require('./chunk')
+const MsgpackChunk = require('./chunk')
 
 class MsgpackEncoder {
   encode (value) {
-    const bytes = new Chunk()
-
+    const bytes = new MsgpackChunk()
     this.encodeValue(bytes, value)
 
     return bytes.buffer.subarray(0, bytes.length)

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const Chunk = require('./chunk')
+const MsgpackChunk = require('./chunk')
 const { MsgpackEncoder } = require('./encoder')
 
-module.exports = { Chunk, MsgpackEncoder }
+module.exports = { MsgpackChunk, MsgpackEncoder }

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

@@ -15,15 +15,17 @@ class FlaggingProvider extends DatadogNodeServerProvider {
    * @param {import('../config')} config - Tracer configuration object
    */
   constructor (tracer, config) {
-    // Call parent constructor with required options
+    // Call parent constructor with required options and timeout
     super({
-      exposureChannel: channel(EXPOSURE_CHANNEL)
+      exposureChannel: channel(EXPOSURE_CHANNEL),
+      initializationTimeoutMs: config.experimental.flaggingProvider.initializationTimeoutMs
     })
 
     this._tracer = tracer
     this._config = config
 
-    log.debug(this.constructor.name + ' created')
+    log.debug(this.constructor.name + ' created with timeout: ' +
+      config.experimental.flaggingProvider.initializationTimeoutMs + 'ms')
   }
 
   /**

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

@@ -7,7 +7,7 @@ const os = require('os')
  */
 
 /**
- * @fileoverview OpenTelemetry Logs Implementation for dd-trace-js
+ * 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
@@ -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,14 +1,17 @@
 'use strict'
 
-const { sanitizeAttributes } = require('@opentelemetry/core')
+const { sanitizeAttributes } = require('../../../../../vendor/dist/@opentelemetry/core')
 const { context } = require('@opentelemetry/api')
-const packageVersion = require('../../../../../package.json').version
+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
  */
 
 /**
@@ -26,12 +29,15 @@ class Logger {
    * Creates a new Logger instance.
    *
    * @param {LoggerProvider} loggerProvider - Parent logger provider
-   * @param {InstrumentationScope} [instrumentationScope] - Instrumentation scope information (newer API)
-   * @param {Object} [instrumentationLibrary] - Instrumentation library information (legacy API) [DEPRECATED in v1.3.0]
-   * @param {InstrumentationScope} [instrumentationScope.name] - Library name (defaults to 'dd-trace-js')
-   * @param {InstrumentationScope} [instrumentationScope.version] - Library version (defaults to tracer version)
-   * @param {string} [instrumentationLibrary.name] - Library name (legacy, defaults to 'dd-trace-js')
-   * @param {string} [instrumentationLibrary.version] - Library version (legacy, defaults to tracer version)
+   * @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

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

@@ -11,11 +11,11 @@ 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
- * @extends OtlpHttpExporterBase
+ * @augments OtlpHttpExporterBase
  */
 class OtlpHttpLogExporter extends OtlpHttpExporterBase {
   /**
@@ -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

@@ -40,11 +40,11 @@ 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
- * @extends OtlpTransformerBase
+ * @augments OtlpTransformerBase
  */
 class OtlpTransformer extends OtlpTransformerBase {
   /**
@@ -73,45 +73,42 @@ class OtlpTransformer extends OtlpTransformerBase {
    * Transforms log records to protobuf format.
    * @param {LogRecord[]} logRecords - Array of enriched log records to transform
    * @returns {Buffer} Protobuf-encoded log records
-   * @private
    */
   #transformToProtobuf (logRecords) {
     const { protoLogsService } = getProtobufTypes()
 
     const logsData = {
       resourceLogs: [{
-        resource: this._transformResource(),
+        resource: this.transformResource(),
         scopeLogs: this.#transformScope(logRecords),
       }]
     }
 
-    return this._serializeToProtobuf(protoLogsService, logsData)
+    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
-   * @private
    */
   #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
-   * @private
    */
   #transformScope (logRecords) {
-    const groupedRecords = this._groupByInstrumentationScope(logRecords)
+    const groupedRecords = this.groupByInstrumentationScope(logRecords)
     const scopeLogs = []
 
     for (const records of groupedRecords.values()) {
@@ -135,7 +132,6 @@ 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
-   * @private
    */
   #transformLogRecord (logRecord) {
     const spanContext = this.#extractSpanContext(logRecord.context)
@@ -159,7 +155,7 @@ class OtlpTransformer extends OtlpTransformerBase {
     }
 
     if (logRecord.attributes) {
-      result.attributes = this._transformAttributes(logRecord.attributes)
+      result.attributes = this.transformAttributes(logRecord.attributes)
     }
 
     if (spanContext?.traceFlags !== undefined) {
@@ -182,7 +178,6 @@ 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
-   * @private
    */
   #extractSpanContext (logContext) {
     if (!logContext) return null
@@ -199,7 +194,6 @@ class OtlpTransformer extends OtlpTransformerBase {
    * Maps OpenTelemetry severity number to protobuf severity number.
    * @param {number} severityNumber - OpenTelemetry severity number
    * @returns {number} Protobuf severity number
-   * @private
    */
   #mapSeverityNumber (severityNumber) {
     const { protoSeverityNumber } = getProtobufTypes()
@@ -211,7 +205,6 @@ class OtlpTransformer extends OtlpTransformerBase {
    * Converts a hex string to a Buffer.
    * @param {string} hexString - Hex string to convert
    * @returns {Buffer} Buffer containing the hex data
-   * @private
    */
   #hexToBytes (hexString) {
     const cleanHex = hexString ? (hexString.startsWith('0x') ? hexString.slice(2) : hexString) : ''
@@ -223,7 +216,6 @@ class OtlpTransformer extends OtlpTransformerBase {
    * Transforms log body to OTLP AnyValue format.
    * @param {any} body - Log body to transform
    * @returns {Object} OTLP AnyValue object
-   * @private
    */
   #transformBody (body) {
     if (typeof body === 'string') {
@@ -240,7 +232,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
+}