dd-trace 6.18.0 → 6.20.0

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

@@ -7,6 +7,8 @@ const logger = require('../log')
 const { getValueFromEnvSources } = require('../config/helper')
 const Span = require('../opentracing/span')
 const {
+  EXPERIMENT_INPUT,
+  EXPERIMENT_OUTPUT,
   SPAN_KIND,
   OUTPUT_VALUE,
   INPUT_VALUE,
@@ -300,13 +302,18 @@ class LLMObs extends NoopLLMObs {
 
       const { inputData, outputData, metadata, metrics, tags, prompt, costTags, toolDefinitions } = options
 
-      if (inputData || outputData) {
+      const hasInputOrOutput = spanKind === 'experiment'
+        ? inputData !== undefined || outputData !== undefined
+        : inputData || outputData
+      if (hasInputOrOutput) {
         if (spanKind === 'llm') {
           this._tagger.tagLLMIO(span, inputData, outputData)
         } else if (spanKind === 'embedding') {
           this._tagger.tagEmbeddingIO(span, inputData, outputData)
         } else if (spanKind === 'retrieval') {
           this._tagger.tagRetrievalIO(span, inputData, outputData)
+        } else if (spanKind === 'experiment') {
+          this._tagger.tagExperimentIO(span, inputData, outputData)
         } else {
           this._tagger.tagTextIO(span, inputData, outputData)
         }
@@ -638,11 +645,20 @@ class LLMObs extends NoopLLMObs {
 
   #autoAnnotate (span, kind, input, output) {
     const annotations = {}
-    if (input && !['llm', 'embedding'].includes(kind) && !LLMObsTagger.tagMap.get(span)?.[INPUT_VALUE]) {
+    const spanTags = LLMObsTagger.tagMap.get(span)
+    const isExperiment = kind === 'experiment'
+    const inputKey = isExperiment ? EXPERIMENT_INPUT : INPUT_VALUE
+    const outputKey = isExperiment ? EXPERIMENT_OUTPUT : OUTPUT_VALUE
+    const hasInput = isExperiment ? input !== undefined : input
+    const hasOutput = isExperiment ? output !== undefined : output
+    const hasInputTag = spanTags !== undefined && Object.hasOwn(spanTags, inputKey)
+    const hasOutputTag = spanTags !== undefined && Object.hasOwn(spanTags, outputKey)
+
+    if (hasInput && !['llm', 'embedding'].includes(kind) && !hasInputTag) {
       annotations.inputData = input
     }
 
-    if (output && !['llm', 'retrieval'].includes(kind) && !LLMObsTagger.tagMap.get(span)?.[OUTPUT_VALUE]) {
+    if (hasOutput && !['llm', 'retrieval'].includes(kind) && !hasOutputTag) {
       annotations.outputData = output
     }
 

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

@@ -16,6 +16,8 @@ const {
   METADATA,
   COST_TAGS,
   TOOL_DEFINITIONS,
+  EXPERIMENT_INPUT,
+  EXPERIMENT_OUTPUT,
   INPUT_MESSAGES,
   INPUT_VALUE,
   INTEGRATION,
@@ -38,41 +40,13 @@ const {
   SAMPLE_RATE,
   SAMPLING_DECISION,
   TRACE_ID,
-  INPUT_TOKENS_METRIC_KEY,
-  OUTPUT_TOKENS_METRIC_KEY,
-  TOTAL_TOKENS_METRIC_KEY,
-  CACHE_READ_INPUT_TOKENS_METRIC_KEY,
-  CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
-  REASONING_OUTPUT_TOKENS_METRIC_KEY,
-  GEN_AI_OPERATION_NAME,
-  GEN_AI_REQUEST_MODEL,
-  GEN_AI_PROVIDER_NAME,
-  GEN_AI_APPLICATION_NAME,
-  GEN_AI_CONVERSATION_ID,
-  GEN_AI_USAGE_INPUT_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_OUTPUT_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_TOTAL_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
-  GEN_AI_USAGE_REASONING_OUTPUT_TOKENS_METRIC_KEY,
-  ARTIFICIAL_GEN_AI_TAGS,
+  DEFAULT_MODEL,
 } = require('./constants/tags')
 const { UNSERIALIZABLE_VALUE_TEXT } = require('./constants/text')
+const { setGenAiApmTags } = require('./gen-ai-tags')
 const telemetry = require('./telemetry')
 const LLMObsTagger = require('./tagger')
 
-const DEFAULT_MODEL = 'custom'
-const MODEL_BACKED_SPAN_KINDS = new Set(['llm', 'embedding'])
-
-const GEN_AI_TOKEN_METRIC_KEYS = [
-  [INPUT_TOKENS_METRIC_KEY, GEN_AI_USAGE_INPUT_TOKENS_METRIC_KEY],
-  [OUTPUT_TOKENS_METRIC_KEY, GEN_AI_USAGE_OUTPUT_TOKENS_METRIC_KEY],
-  [TOTAL_TOKENS_METRIC_KEY, GEN_AI_USAGE_TOTAL_TOKENS_METRIC_KEY],
-  [CACHE_READ_INPUT_TOKENS_METRIC_KEY, GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS_METRIC_KEY],
-  [CACHE_WRITE_INPUT_TOKENS_METRIC_KEY, GEN_AI_USAGE_CACHE_WRITE_INPUT_TOKENS_METRIC_KEY],
-  [REASONING_OUTPUT_TOKENS_METRIC_KEY, GEN_AI_USAGE_REASONING_OUTPUT_TOKENS_METRIC_KEY],
-]
-
 class LLMObservabilitySpan {
   /**
    * @param {string} kind span kind
@@ -210,8 +184,13 @@ class LLMObsSpanProcessor {
     }
 
     const llmObsSpan = new LLMObservabilitySpan(spanKind)
+    const isExperiment = spanKind === 'experiment'
+    const hasExperimentInput = isExperiment && Object.hasOwn(mlObsTags, EXPERIMENT_INPUT)
+    const hasExperimentOutput = isExperiment && Object.hasOwn(mlObsTags, EXPERIMENT_OUTPUT)
 
-    if (spanKind === 'llm' && mlObsTags[INPUT_MESSAGES]) {
+    if (hasExperimentInput) {
+      llmObsSpan.input = [{ role: '', content: mlObsTags[EXPERIMENT_INPUT] }]
+    } else if (spanKind === 'llm' && mlObsTags[INPUT_MESSAGES]) {
       llmObsSpan.input = mlObsTags[INPUT_MESSAGES]
       inputType = 'messages'
     } else if (spanKind === 'embedding' && mlObsTags[INPUT_DOCUMENTS]) {
@@ -222,7 +201,9 @@ class LLMObsSpanProcessor {
       inputType = 'value'
     }
 
-    if (spanKind === 'llm' && mlObsTags[OUTPUT_MESSAGES]) {
+    if (hasExperimentOutput) {
+      llmObsSpan.output = [{ role: '', content: mlObsTags[EXPERIMENT_OUTPUT] }]
+    } else if (spanKind === 'llm' && mlObsTags[OUTPUT_MESSAGES]) {
       llmObsSpan.output = mlObsTags[OUTPUT_MESSAGES]
       outputType = 'messages'
     } else if (spanKind === 'retrieval' && mlObsTags[OUTPUT_DOCUMENTS]) {
@@ -254,34 +235,41 @@ class LLMObsSpanProcessor {
     const processedSpan = this.#runProcessor(llmObsSpan)
     if (processedSpan === undefined) return null
 
-    if (processedSpan.input) {
-      if (inputType === 'messages') {
-        input.messages = processedSpan.input
-      } else if (inputType === 'value') {
-        input.value = processedSpan.input[0].content
-      } else if (inputType === 'documents') {
-        input.documents = processedSpan.input.map((processedDocument, processedDocumentIdx) => ({
-          ...mlObsTags[INPUT_DOCUMENTS][processedDocumentIdx],
-          text: processedDocument.content,
-        }))
+    if (isExperiment) {
+      const [processedInput] = processedSpan.input
+      const [processedOutput] = processedSpan.output
+      if (hasExperimentInput && processedInput !== undefined) meta.input = processedInput.content
+      if (hasExperimentOutput && processedOutput !== undefined) meta.output = processedOutput.content
+    } else {
+      if (processedSpan.input) {
+        if (inputType === 'messages') {
+          input.messages = processedSpan.input
+        } else if (inputType === 'value') {
+          input.value = processedSpan.input[0].content
+        } else if (inputType === 'documents') {
+          input.documents = processedSpan.input.map((processedDocument, processedDocumentIdx) => ({
+            ...mlObsTags[INPUT_DOCUMENTS][processedDocumentIdx],
+            text: processedDocument.content,
+          }))
+        }
       }
-    }
 
-    if (processedSpan.output) {
-      if (outputType === 'messages') {
-        output.messages = processedSpan.output
-      } else if (outputType === 'value') {
-        output.value = processedSpan.output[0].content
-      } else if (outputType === 'documents') {
-        output.documents = processedSpan.output.map((processedDocument, processedDocumentIdx) => ({
-          ...mlObsTags[OUTPUT_DOCUMENTS][processedDocumentIdx],
-          text: processedDocument.content,
-        }))
+      if (processedSpan.output) {
+        if (outputType === 'messages') {
+          output.messages = processedSpan.output
+        } else if (outputType === 'value') {
+          output.value = processedSpan.output[0].content
+        } else if (outputType === 'documents') {
+          output.documents = processedSpan.output.map((processedDocument, processedDocumentIdx) => ({
+            ...mlObsTags[OUTPUT_DOCUMENTS][processedDocumentIdx],
+            text: processedDocument.content,
+          }))
+        }
       }
-    }
 
-    if (input) meta.input = input
-    if (output) meta.output = output
+      meta.input = input
+      meta.output = output
+    }
 
     const prompt = mlObsTags[INPUT_PROMPT]
     if (prompt && spanKind === 'llm') {
@@ -320,46 +308,19 @@ class LLMObsSpanProcessor {
   }
 
   /**
-   * Writes the scalar `gen_ai.*` attributes onto the APM span, so model, provider, application,
-   * conversation and token usage are searchable in APM. Message bodies stay off the APM span.
-   *
    * @param {import('../opentracing/span')} span
    */
   #setGenAiApmTags (span) {
     const mlObsTags = LLMObsTagger.tagMap.get(span)
-    const spanContext = span.context()
-    const spanKind = mlObsTags[SPAN_KIND]
-
-    if (spanKind) spanContext.setTag(GEN_AI_OPERATION_NAME, spanKind)
-
-    const modelName = mlObsTags[MODEL_NAME]
-    const modelProvider = mlObsTags[MODEL_PROVIDER]
-    const modelBacked = MODEL_BACKED_SPAN_KINDS.has(spanKind)
-    if (modelBacked) {
-      spanContext.setTag(GEN_AI_REQUEST_MODEL, modelName || DEFAULT_MODEL)
-      spanContext.setTag(GEN_AI_PROVIDER_NAME, (modelProvider || DEFAULT_MODEL).toLowerCase())
-    } else {
-      if (modelName) spanContext.setTag(GEN_AI_REQUEST_MODEL, modelName)
-      if (modelProvider) spanContext.setTag(GEN_AI_PROVIDER_NAME, modelProvider.toLowerCase())
-    }
-
-    const mlApp = mlObsTags[ML_APP]
-    if (mlApp) spanContext.setTag(GEN_AI_APPLICATION_NAME, mlApp)
-
-    const sessionId = mlObsTags[SESSION_ID]
-    if (sessionId) spanContext.setTag(GEN_AI_CONVERSATION_ID, sessionId)
-
-    const metrics = mlObsTags[METRICS]
-    // Other kinds carry unrelated metrics that would be misleading under a `gen_ai.usage.*` key.
-    if (modelBacked && metrics) {
-      for (const [metricKey, genAiKey] of GEN_AI_TOKEN_METRIC_KEYS) {
-        const value = metrics[metricKey]
-        if (value != null) spanContext.setTag(genAiKey, value)
-      }
-    }
 
-    // matches the value dd-trace-py writes
-    spanContext.setTag(ARTIFICIAL_GEN_AI_TAGS, 'true')
+    setGenAiApmTags(span, {
+      spanKind: mlObsTags[SPAN_KIND],
+      modelName: mlObsTags[MODEL_NAME],
+      modelProvider: mlObsTags[MODEL_PROVIDER],
+      mlApp: mlObsTags[ML_APP],
+      sessionId: mlObsTags[SESSION_ID],
+      metrics: mlObsTags[METRICS],
+    })
   }
 
   // For now, this only applies to metadata, as we let users annotate this field with any object

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

@@ -10,6 +10,8 @@ const {
   SESSION_ID_TRACE_DEFAULT_KEY,
   ML_APP,
   SPAN_KIND,
+  EXPERIMENT_INPUT,
+  EXPERIMENT_OUTPUT,
   INPUT_VALUE,
   OUTPUT_DOCUMENTS,
   INPUT_DOCUMENTS,
@@ -29,14 +31,7 @@ const {
   PROPAGATED_PARENT_AGENT_ID_KEY,
   PROPAGATED_PARENT_AGENT_NAME_KEY,
   ROOT_PARENT_ID,
-  CACHE_READ_INPUT_TOKENS_METRIC_KEY,
-  CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
-  CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY,
-  CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY,
-  INPUT_TOKENS_METRIC_KEY,
-  OUTPUT_TOKENS_METRIC_KEY,
-  TOTAL_TOKENS_METRIC_KEY,
-  REASONING_OUTPUT_TOKENS_METRIC_KEY,
+  METRIC_KEY_ALIASES,
   INTEGRATION,
   DECORATOR,
   PROPAGATED_ML_APP_KEY,
@@ -280,6 +275,18 @@ class LLMObsTagger {
     this.#tagDocuments(span, outputData, OUTPUT_DOCUMENTS)
   }
 
+  /**
+   * Tags arbitrary JSON-compatible experiment input and output without converting structured values to text.
+   *
+   * @param {import('../opentracing/span')} span
+   * @param {unknown} inputData
+   * @param {unknown} outputData
+   */
+  tagExperimentIO (span, inputData, outputData) {
+    this.#tagExperimentValue(span, inputData, EXPERIMENT_INPUT, 'input')
+    this.#tagExperimentValue(span, outputData, EXPERIMENT_OUTPUT, 'output')
+  }
+
   tagTextIO (span, inputData, outputData) {
     this.#tagText(span, inputData, INPUT_VALUE)
     this.#tagText(span, outputData, OUTPUT_VALUE)
@@ -307,35 +314,8 @@ class LLMObsTagger {
   tagMetrics (span, metrics) {
     const filterdMetrics = {}
     for (const [key, value] of Object.entries(metrics)) {
-      let processedKey = key
-
       // processing these specifically for our metrics ingestion
-      switch (key) {
-        case 'inputTokens':
-          processedKey = INPUT_TOKENS_METRIC_KEY
-          break
-        case 'outputTokens':
-          processedKey = OUTPUT_TOKENS_METRIC_KEY
-          break
-        case 'totalTokens':
-          processedKey = TOTAL_TOKENS_METRIC_KEY
-          break
-        case 'cacheReadTokens':
-          processedKey = CACHE_READ_INPUT_TOKENS_METRIC_KEY
-          break
-        case 'cacheWriteTokens':
-          processedKey = CACHE_WRITE_INPUT_TOKENS_METRIC_KEY
-          break
-        case 'cacheWrite5mTokens':
-          processedKey = CACHE_WRITE_5M_INPUT_TOKENS_METRIC_KEY
-          break
-        case 'cacheWrite1hTokens':
-          processedKey = CACHE_WRITE_1H_INPUT_TOKENS_METRIC_KEY
-          break
-        case 'reasoningOutputTokens':
-          processedKey = REASONING_OUTPUT_TOKENS_METRIC_KEY
-          break
-      }
+      const processedKey = METRIC_KEY_ALIASES[key] ?? key
 
       if (typeof value === 'number') {
         filterdMetrics[processedKey] = value
@@ -596,6 +576,27 @@ class LLMObsTagger {
     }
   }
 
+  /**
+   * Validates and stores one free-form experiment I/O value.
+   *
+   * @param {import('../opentracing/span')} span
+   * @param {unknown} data
+   * @param {string} key
+   * @param {string} type
+   */
+  #tagExperimentValue (span, data, key, type) {
+    if (data === undefined) return
+
+    try {
+      if (JSON.stringify(data) !== undefined) {
+        this._setTag(span, key, data)
+        return
+      }
+    } catch {}
+
+    this.#handleFailure(`Failed to parse ${type} value, must be JSON serializable.`, 'invalid_io_text')
+  }
+
   #tagDocuments (span, data, key) {
     if (!data) {
       return

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

@@ -293,12 +293,7 @@ class BaseLLMObsWriter {
   }
 
   _encode (payload) {
-    return JSON.stringify(payload, (key, value) => {
-      if (typeof value === 'string') {
-        return encodeUnicode(value) // serialize unicode characters
-      }
-      return value
-    }).replaceAll(String.raw`\\u`, String.raw`\u`) // remove double escaping
+    return encodeUnicode(JSON.stringify(payload))
   }
 }
 

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

@@ -19,6 +19,16 @@ module.exports = {
    */
   EVP_EVENT_SIZE_LIMIT: (1 << 20) - 1024,
 
+  FLAG_EVALUATION_ENDPOINT: '/api/v2/flagevaluation',
+  FLAG_EVALUATION_FLUSH_INTERVAL: 10_000,
+  FLAG_EVALUATION_QUEUE_CAP: 4096,
+  FLAG_EVALUATION_GLOBAL_CAP: 131_072,
+  FLAG_EVALUATION_PER_FLAG_CAP: 10_000,
+  FLAG_EVALUATION_DEGRADED_CAP: 32_768,
+
+  // ECMAScript Date's maximum absolute time value, in milliseconds.
+  MAX_EVALUATION_TIMESTAMP_MS: 8_640_000_000_000_000,
+
   /**
    * @constant
    * @type {string} Channel name for exposure event submission

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

@@ -8,6 +8,7 @@ const configurationSource = require('./configuration_source')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
 const EvalMetricsHook = require('./eval-metrics-hook')
 const SpanEnrichmentHook = require('./span-enrichment-hook')
+const FlagEvalEVPHook = require('./writers/flag-eval-evp-hook')
 
 /**
  * OpenFeature provider that integrates with Datadog's feature flagging system.
@@ -17,6 +18,9 @@ class FlaggingProvider extends DatadogNodeServerProvider {
   /** @type {SpanEnrichmentHook | undefined} */
   #spanEnrichmentHook
 
+  /** @type {FlagEvalEVPHook | undefined} */
+  #flagEvalEVPHook
+
   /** @type {{ start: Function, stop: Function } | undefined} */
   #configurationSource
 
@@ -30,7 +34,9 @@ class FlaggingProvider extends DatadogNodeServerProvider {
       initializationTimeoutMs: config.featureFlags.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS,
     })
 
-    this.hooks.push(new EvalMetricsHook(config))
+    if (config.DD_METRICS_OTEL_ENABLED === true) {
+      this.hooks.push(new EvalMetricsHook(config))
+    }
 
     if (config.featureFlags.DD_EXPERIMENTAL_FLAGGING_PROVIDER_SPAN_ENRICHMENT_ENABLED) {
       this.#spanEnrichmentHook = new SpanEnrichmentHook(tracer)
@@ -44,6 +50,11 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     log.debug('%s created with timeout: %dms', this.constructor.name,
       config.featureFlags.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS)
 
+    if (config.featureFlags?.DD_FLAGGING_EVALUATION_COUNTS_ENABLED !== false) {
+      this.#flagEvalEVPHook = new FlagEvalEVPHook(config)
+      this.hooks.push(this.#flagEvalEVPHook)
+    }
+
     this.#configurationSource = configurationSource.create(config, this.setConfiguration.bind(this))
     this.#configurationSource?.start()
   }
@@ -73,6 +84,8 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     this.#configurationSource = undefined
     this.#spanEnrichmentHook?.destroy()
     this.#spanEnrichmentHook = undefined
+    this.#flagEvalEVPHook?.destroy()
+    this.#flagEvalEVPHook = undefined
   }
 }
 

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

@@ -20,6 +20,7 @@ const EVP_ORIGIN_HEADERS = {
  * @property {number} [payloadSizeLimit] - Maximum payload size in bytes
  * @property {number} [eventSizeLimit] - Maximum individual event size in bytes
  * @property {object} [headers] - Additional HTTP headers
+ * @property {(error: Error, statusCode?: number) => string} [formatError] - Optional delivery error redaction
  */
 
 /**
@@ -80,10 +81,14 @@ function shouldSwitchFutureRoute (statusCode) {
  */
 class BaseFFEWriter {
   #destroyer
+  #formatError
   /**
    * @param {BaseFFEWriterOptions} options - Writer configuration options
    */
-  constructor ({ interval, timeout, config, endpoint, agentUrl, payloadSizeLimit, eventSizeLimit, headers }) {
+  constructor ({
+    interval, timeout, config, endpoint, agentUrl, payloadSizeLimit, eventSizeLimit, headers, formatError,
+  }) {
+    this.#formatError = formatError
     this._interval = interval ?? 1000
     this._timeout = timeout ?? 5000
 
@@ -219,10 +224,11 @@ class BaseFFEWriter {
    * @protected
    * @param {string} payload - Encoded event batch
    * @param {number} eventCount - Event count
+   * @param {(delivered: boolean) => void} [onComplete] - Final outcome after any safe fallback attempt
    */
-  _sendPayload (payload, eventCount) {
+  _sendPayload (payload, eventCount, onComplete) {
     const route = this.#createActiveRoute()
-    this.#sendRequest(payload, eventCount, route, this._fallbackRoute)
+    this.#sendRequest(payload, eventCount, route, this._fallbackRoute, onComplete)
   }
 
   /**
@@ -301,9 +307,13 @@ class BaseFFEWriter {
    * @param {number} eventCount - Event count
    * @param {ActiveWriterRoute} route - Selected route
    * @param {ActiveWriterRoute} [fallbackRoute] - Direct fallback route
+   * @param {(delivered: boolean) => void} [onComplete] - True only for a successful final response
    */
-  #sendRequest (payload, eventCount, route, fallbackRoute) {
-    request(payload, route.requestOptions, (error, response, statusCode) => {
+  #sendRequest (payload, eventCount, route, fallbackRoute, onComplete) {
+    // The request helper mutates headers. Concurrent envelopes must not share them.
+    const requestOptions = { ...route.requestOptions, headers: { ...route.requestOptions.headers } }
+    request(payload, requestOptions, (error, response, statusCode) => {
+      const errorMessage = error && (this.#formatError ? this.#formatError(error, statusCode) : error.message)
       if (fallbackRoute && isSafeToReplay(error, statusCode)) {
         log.debug(
           '%s switching from %s%s to direct intake after definitive rejection',
@@ -311,10 +321,12 @@ class BaseFFEWriter {
           route.url.href,
           route.endpoint
         )
-        this.#activateRoute(fallbackRoute)
-        this._fallbackRoute = undefined
-        route.onFallback?.()
-        this.#sendRequest(payload, eventCount, fallbackRoute)
+        if (this._requestOptions === route.requestOptions) {
+          this.#activateRoute(fallbackRoute)
+          this._fallbackRoute = undefined
+          route.onFallback?.()
+        }
+        this.#sendRequest(payload, eventCount, fallbackRoute, undefined, onComplete)
         return
       }
 
@@ -325,10 +337,13 @@ class BaseFFEWriter {
           route.url.href,
           route.endpoint
         )
-        this.#activateRoute(fallbackRoute)
-        this._fallbackRoute = undefined
-        route.onFallback?.()
-        log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, error.message)
+        if (this._requestOptions === route.requestOptions) {
+          this.#activateRoute(fallbackRoute)
+          this._fallbackRoute = undefined
+          route.onFallback?.()
+        }
+        log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, errorMessage)
+        onComplete?.(false)
         return
       }
 
@@ -340,15 +355,19 @@ class BaseFFEWriter {
           route.endpoint,
           statusCode
         )
-        this.#activateRoute(fallbackRoute)
-        this._fallbackRoute = undefined
-        route.onFallback?.()
+        if (this._requestOptions === route.requestOptions) {
+          this.#activateRoute(fallbackRoute)
+          this._fallbackRoute = undefined
+          route.onFallback?.()
+        }
         log.warn('Events request returned status %d', statusCode)
+        onComplete?.(false)
         return
       }
 
       if (
         !fallbackRoute &&
+        this._requestOptions === route.requestOptions &&
         route.onUnavailable &&
         (isSafeToReplay(error, statusCode) ||
           isTransportFailure(error, statusCode) ||
@@ -356,20 +375,22 @@ class BaseFFEWriter {
       ) {
         route.onUnavailable()
         if (error) {
-          log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, error.message)
+          log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, errorMessage)
         } else {
           log.warn('Events request returned status %d', statusCode)
         }
+        onComplete?.(false)
         return
       }
 
       if (error) {
-        log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, error.message)
+        log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, errorMessage)
       } else if (statusCode >= 200 && statusCode < 300) {
         log.debug('Successfully sent %d events', eventCount)
       } else {
         log.warn('Events request returned status %d', statusCode)
       }
+      onComplete?.(!error && statusCode >= 200 && statusCode < 300)
     })
   }
 }

package/packages/dd-trace/src/openfeature/writers/flag-eval-evp-hook.js

@@ -0,0 +1,105 @@
+'use strict'
+
+const { MAX_EVALUATION_TIMESTAMP_MS } = require('../constants/constants')
+const { snapshotEvaluationContext } = require('./flag-evaluation-context')
+const {
+  recordContextTruncated, recordDropped, recordHookError, recordTargetingKeyOmitted,
+} = require('./flag-evaluation-telemetry')
+const FlagEvaluationsWriter = require('./flag-evaluations')
+const { setExposureDeliveryStrategy } = require('./util')
+
+/** Captures terminal SDK results; the writer owns deferred aggregation and delivery. */
+class FlagEvalEVPHook {
+  /** @type {FlagEvaluationsWriter} */
+  #writer
+  #closed = false
+  #stopDeliveryStrategy
+
+  /**
+   * The provider only constructs this hook when evaluation counts are enabled.
+   *
+   * @param {import('../../config/config-base')} config
+   */
+  constructor (config) {
+    const writer = new FlagEvaluationsWriter(config)
+    this.#writer = writer
+    this.#stopDeliveryStrategy = setExposureDeliveryStrategy(config, (enabled, route) => {
+      if (this.#closed) return
+      writer.setEnabled(enabled, route)
+    })
+  }
+
+  /**
+   * Provider hooks run in finally even when the SDK short-circuits before resolution.
+   * Consent belongs to the captured result, never the provider's current configuration.
+   *
+   * @param {import('@openfeature/core').HookContext} hookContext
+   * @param {import('@openfeature/core').EvaluationDetails<import('@openfeature/core').FlagValue>} evaluationDetails
+   */
+  finally (hookContext, evaluationDetails) {
+    try {
+      const unavailableReason = this.#closed ? 'closed' : this.#writer.getUnavailableReason()
+      if (unavailableReason !== undefined) {
+        recordDropped(unavailableReason)
+        return
+      }
+      if (!this.#writer.hasCapacity()) {
+        recordDropped('pre_queue_overflow')
+        return
+      }
+
+      const metadata = evaluationDetails.flagMetadata
+      const consent = metadata?.__dd_observe_full_evaluation_data === true
+      const capturedTime = metadata?.__dd_eval_timestamp_ms
+      const timestamp = typeof capturedTime === 'number' && Number.isSafeInteger(capturedTime) &&
+        Math.abs(capturedTime) <= MAX_EVALUATION_TIMESTAMP_MS
+        ? capturedTime
+        : Date.now()
+      const context = hookContext.context
+      let targetingKey
+      try {
+        targetingKey = context?.targetingKey
+      } catch {
+        // An unreadable identity must not discard an otherwise valid evaluation count.
+        recordTargetingKeyOmitted()
+      }
+      let attrs
+      if (consent) {
+        let snapshot
+        try {
+          snapshot = snapshotEvaluationContext(context)
+        } catch {
+          // Preserve the evaluation count without the failed context. Never log caller-controlled errors.
+          recordContextTruncated('snapshot_error')
+        }
+        if (snapshot !== undefined) {
+          attrs = snapshot.attrs
+          for (const reason of snapshot.reasons) recordContextTruncated(reason)
+        }
+      }
+
+      this.#writer.enqueue({
+        flagKey: hookContext.flagKey,
+        variant: evaluationDetails.variant,
+        allocationKey: typeof metadata?.__dd_allocation_key === 'string' ? metadata.__dd_allocation_key : undefined,
+        runtimeDefault: evaluationDetails.variant === undefined,
+        errorCode: evaluationDetails.errorCode,
+        targetingKey,
+        attrs,
+        observeFullEvaluationData: consent,
+        timestamp,
+      })
+    } catch {
+      recordHookError()
+    }
+  }
+
+  destroy () {
+    if (this.#closed) return
+    this.#closed = true
+    this.#stopDeliveryStrategy?.()
+    this.#writer.destroy()
+  }
+}
+
+module.exports = FlagEvalEVPHook