dd-trace 5.81.0 → 5.83.0

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

@@ -28,7 +28,15 @@ const {
   REASONING_OUTPUT_TOKENS_METRIC_KEY,
   INTEGRATION,
   DECORATOR,
-  PROPAGATED_ML_APP_KEY
+  PROPAGATED_ML_APP_KEY,
+  DEFAULT_PROMPT_NAME,
+  INTERNAL_CONTEXT_VARIABLE_KEYS,
+  INTERNAL_QUERY_VARIABLE_KEYS,
+  INPUT_PROMPT,
+  ROUTING_API_KEY,
+  ROUTING_SITE,
+  PROMPT_TRACKING_INSTRUMENTATION_METHOD,
+  INSTRUMENTATION_METHOD_ANNOTATED
 } = require('./constants/tags')
 const { storage } = require('./storage')
 
@@ -110,6 +118,18 @@ class LLMObsTagger {
     // apply annotation context name
     const annotationContextName = annotationContext?.name
     if (annotationContextName) this._setTag(span, NAME, annotationContextName)
+
+    // apply annotation context prompt
+    const annotationContextPrompt = annotationContext?.prompt
+    if (annotationContextPrompt) this.tagPrompt(span, annotationContextPrompt)
+
+    const routing = storage.getStore()?.routingContext
+    if (routing) {
+      this._setTag(span, ROUTING_API_KEY, routing.apiKey)
+      if (routing.site) {
+        this._setTag(span, ROUTING_SITE, routing.site)
+      }
+    }
   }
 
   // TODO: similarly for the following `tag` methods,
@@ -194,6 +214,160 @@ class LLMObsTagger {
     }
   }
 
+  /**
+   * Tags a prompt on an LLMObs span.
+   * @param {import('../opentracing/span')} span
+   * @param {string | Record<string, unknown>} prompt
+   * @param {boolean?} strictValidation
+   *   whether to validate the prompt against the strict schema, used for auto-instrumentation
+   */
+  tagPrompt (span, prompt, strictValidation = false) {
+    const spanKind = registry.get(span)?.[SPAN_KIND]
+    if (spanKind !== 'llm') {
+      log.warn('Dropping prompt on non-LLM span kind, annotating prompts is only supported for LLM span kinds.')
+      return
+    }
+
+    if (!prompt || typeof prompt !== 'object') {
+      this.#handleFailure('Prompt must be an object.', 'invalid_prompt')
+      return
+    }
+
+    const mlApp = registry.get(span)?.[ML_APP] // this should be defined at this point
+    const {
+      id,
+      version,
+      tags,
+      variables,
+      template,
+      contextVariables,
+      queryVariables,
+    } = prompt
+
+    if (strictValidation) {
+      if (id == null) {
+        this.#handleFailure('Prompt ID is required.', 'invalid_prompt')
+        return
+      }
+
+      if (template == null) {
+        this.#handleFailure('Prompt template is required.', 'invalid_prompt')
+        return
+      }
+    }
+
+    const finalPromptId = id ?? `${mlApp}_${DEFAULT_PROMPT_NAME}`
+    const finalCtxVariablesKeys = contextVariables ?? ['context']
+    const finalQueryVariablesKeys = queryVariables ?? ['question']
+
+    // validate prompt id
+    if (typeof finalPromptId !== 'string') {
+      this.#handleFailure('Prompt ID must be a string.', 'invalid_prompt')
+      return
+    }
+
+    // validate prompt context variables keys
+    if (Array.isArray(finalCtxVariablesKeys)) {
+      for (const key of finalCtxVariablesKeys) {
+        if (typeof key !== 'string') {
+          this.#handleFailure('Prompt context variables keys must be an array of strings.', 'invalid_prompt')
+          return
+        }
+      }
+    } else if (finalCtxVariablesKeys) {
+      this.#handleFailure('Prompt context variables keys must be an array.', 'invalid_prompt')
+      return
+    }
+
+    // validate prompt query variables keys
+    if (Array.isArray(finalQueryVariablesKeys)) {
+      for (const key of finalQueryVariablesKeys) {
+        if (typeof key !== 'string') {
+          this.#handleFailure('Prompt query variables keys must be an array of strings.', 'invalid_prompt')
+          return
+        }
+      }
+    } else if (finalQueryVariablesKeys) {
+      this.#handleFailure('Prompt query variables keys must be an array.', 'invalid_prompt')
+      return
+    }
+
+    // validate prompt version
+    if (version && typeof version !== 'string') {
+      this.#handleFailure('Prompt version must be a string.', 'invalid_prompt')
+      return
+    }
+
+    // validate prompt tags
+    if (tags && (typeof tags !== 'object' || tags instanceof Map)) {
+      this.#handleFailure('Prompt tags must be an non-Map object.', 'invalid_prompt')
+      return
+    } else if (tags) {
+      for (const [key, value] of Object.entries(tags)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+          this.#handleFailure('Prompt tags must be an object of string key-value pairs.', 'invalid_prompt')
+          return
+        }
+      }
+    }
+
+    // validate prompt template is either string or list of messages
+    if (template && !(typeof template === 'string' || Array.isArray(template))) {
+      this.#handleFailure('Prompt template must be a string or an array of messages.', 'invalid_prompt')
+      return
+    }
+
+    if (Array.isArray(template)) {
+      for (const message of template) {
+        if (typeof message !== 'object' || !message.role || !message.content) {
+          this.#handleFailure(
+            'Prompt chat template must be an array of objects with role and content properties.', 'invalid_prompt'
+          )
+          return
+        }
+      }
+    }
+
+    // validate variables are a string-string mapping
+    if (variables && (typeof variables !== 'object' || variables instanceof Map)) {
+      this.#handleFailure('Prompt variables must be an non-Map object.', 'invalid_prompt')
+      return
+    } else if (variables) {
+      for (const [key, value] of Object.entries(variables)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+          this.#handleFailure('Prompt variables must be an object of string key-value pairs.', 'invalid_prompt')
+          return
+        }
+      }
+    }
+
+    let finalTemplate, finalChatTemplate
+    if (typeof template === 'string') {
+      finalTemplate = template
+    } else if (Array.isArray(template)) {
+      finalChatTemplate = template.map(message => ({ role: message.role, content: message.content }))
+    }
+
+    const validatedPrompt = {}
+    if (finalPromptId) validatedPrompt.id = finalPromptId
+    if (version) validatedPrompt.version = version
+    if (variables) validatedPrompt.variables = variables
+    if (finalTemplate) validatedPrompt.template = finalTemplate
+    if (finalChatTemplate?.length) validatedPrompt.chat_template = finalChatTemplate
+    if (tags) validatedPrompt.tags = tags
+    if (finalCtxVariablesKeys) validatedPrompt[INTERNAL_CONTEXT_VARIABLE_KEYS] = finalCtxVariablesKeys
+    if (finalQueryVariablesKeys) validatedPrompt[INTERNAL_QUERY_VARIABLE_KEYS] = finalQueryVariablesKeys
+
+    const currentPrompt = registry.get(span)?.[INPUT_PROMPT]
+    if (currentPrompt) {
+      Object.assign(currentPrompt, validatedPrompt)
+    } else {
+      this._setTag(span, INPUT_PROMPT, validatedPrompt)
+    }
+
+    this.tagSpanTags(span, { [PROMPT_TRACKING_INSTRUMENTATION_METHOD]: INSTRUMENTATION_METHOD_ANNOTATED })
+  }
+
   changeKind (span, newKind) {
     this._setTag(span, SPAN_KIND, newKind)
   }

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

@@ -1,5 +1,8 @@
 'use strict'
 
+const ERROR_TYPE = require('../constants')
+
+const telemetryMetrics = require('../telemetry/metrics')
 const {
   SPAN_KIND,
   MODEL_PROVIDER,
@@ -10,10 +13,6 @@ const {
   DECORATOR
 } = require('./constants/tags')
 
-const ERROR_TYPE = require('../constants')
-
-const telemetryMetrics = require('../telemetry/metrics')
-
 const LLMObsTagger = require('./tagger')
 
 const llmobsMetrics = telemetryMetrics.manager.namespace('mlobs')

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

@@ -1,9 +1,9 @@
 'use strict'
 
-const request = require('../../exporters/common/request')
-const { getEnvironmentVariable } = require('../../config-helper')
 const { URL, format } = require('node:url')
 const path = require('node:path')
+const request = require('../../exporters/common/request')
+const { getEnvironmentVariable } = require('../../config/helper')
 
 const logger = require('../../log')
 
@@ -16,85 +16,163 @@ const {
 } = require('../constants/writers')
 const { parseResponseAndLog } = require('./util')
 
+class LLMObsBuffer {
+  constructor ({ events, size, routing = {}, isDefault = false, limit = 1000 }) {
+    this.events = events
+    this.size = size
+    this.routing = routing
+    this.isDefault = isDefault
+    this.limit = limit
+  }
+
+  clear () {
+    this.events = []
+    this.size = 0
+  }
+}
+
 class BaseLLMObsWriter {
+  #destroyer
+  /** @type {Map<string, LLMObsBuffer>} */
+  #multiTenantBuffers = new Map()
+
   constructor ({ interval, timeout, eventType, config, endpoint, intake }) {
     this._interval = interval ?? getEnvironmentVariable('_DD_LLMOBS_FLUSH_INTERVAL') ?? 1000 // 1s
     this._timeout = timeout ?? getEnvironmentVariable('_DD_LLMOBS_TIMEOUT') ?? 5000 // 5s
     this._eventType = eventType
 
-    this._buffer = []
-    this._bufferLimit = 1000
-    this._bufferSize = 0
+    /** @type {LLMObsBuffer} */
+    this._buffer = new LLMObsBuffer({ events: [], size: 0, isDefault: true })
 
     this._config = config
     this._endpoint = endpoint
+    this._baseEndpoint = endpoint // should not be unset
     this._intake = intake
 
     this._periodic = setInterval(() => {
       this.flush()
     }, this._interval).unref()
 
-    this._beforeExitHandler = () => {
-      this.destroy()
-    }
-    process.once('beforeExit', this._beforeExitHandler)
+    const destroyer = this.destroy.bind(this)
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(destroyer)
 
-    this._destroyed = false
+    this.#destroyer = destroyer
+  }
+
+  // Split on protocol separator to preserve it
+  // path.join will remove some slashes unnecessarily
+  #buildUrl (baseUrl, endpoint) {
+    const [protocol, rest] = baseUrl.split('://')
+    return protocol + '://' + path.join(rest, endpoint)
   }
 
   get url () {
     if (this._agentless == null) return null
+    return this.#buildUrl(this._baseUrl.href, this._endpoint)
+  }
 
-    const baseUrl = this._baseUrl.href
-    const endpoint = this._endpoint
-
-    // Split on protocol separator to preserve it
-    // path.join will remove some slashes unnecessarily
-    const [protocol, rest] = baseUrl.split('://')
-    return protocol + '://' + path.join(rest, endpoint)
+  _getBuffer (routing) {
+    if (!routing?.apiKey) {
+      return this._buffer
+    }
+    const apiKey = routing.apiKey
+    let buffer = this.#multiTenantBuffers.get(apiKey)
+    if (!buffer) {
+      buffer = new LLMObsBuffer({ events: [], size: 0, routing })
+      this.#multiTenantBuffers.set(apiKey, buffer)
+    }
+    return buffer
   }
 
-  append (event, byteLength) {
-    if (this._buffer.length >= this._bufferLimit) {
-      logger.warn(`${this.constructor.name} event buffer full (limit is ${this._bufferLimit}), dropping event`)
+  append (event, routing, byteLength) {
+    const buffer = this._getBuffer(routing)
+
+    if (buffer.events.length >= buffer.limit) {
+      logger.warn(`${this.constructor.name} event buffer full (limit is ${buffer.limit}), dropping event`)
       telemetry.recordDroppedPayload(1, this._eventType, 'buffer_full')
       return
     }
 
-    this._bufferSize += byteLength || Buffer.byteLength(JSON.stringify(event))
-    this._buffer.push(event)
+    const eventSize = byteLength || Buffer.byteLength(JSON.stringify(event))
+
+    buffer.size += eventSize
+    buffer.events.push(event)
   }
 
   flush () {
-    const noAgentStrategy = this._agentless == null
-
-    if (this._buffer.length === 0 || noAgentStrategy) {
+    if (this._agentless == null) {
       return
     }
 
-    const events = this._buffer
-    this._buffer = []
-    this._bufferSize = 0
-    const payload = this._encode(this.makePayload(events))
+    // Flush default buffer
+    if (this._buffer.events.length > 0) {
+      const events = this._buffer.events
+      this._buffer.clear()
+
+      const payload = this._encode(this.makePayload(events))
+
+      log.debug('Encoded LLMObs payload: %s', payload)
+
+      const options = this._getOptions()
+
+      request(payload, options, (err, resp, code) => {
+        parseResponseAndLog(err, code, events.length, this.url, this._eventType)
+      })
+    }
+
+    // Flush multi-tenant buffers
+    for (const [apiKey, buffer] of this.#multiTenantBuffers) {
+      if (buffer.events.length === 0) continue
+
+      const events = buffer.events
+      buffer.clear()
+
+      const payload = this._encode(this.makePayload(events))
+      const site = buffer.routing.site || this._config.site
+      const options = {
+        headers: {
+          'Content-Type': 'application/json',
+          'DD-API-KEY': apiKey
+        },
+        method: 'POST',
+        timeout: this._timeout,
+        url: new URL(format({
+          protocol: 'https:',
+          hostname: `${this._intake}.${site}`
+        })),
+        path: this._baseEndpoint
+      }
+      const url = this.#buildUrl(options.url.href, options.path)
+      const maskedApiKey = apiKey ? `****${apiKey.slice(-4)}` : ''
 
-    log.debug('Encoded LLMObs payload: %s', payload)
+      log.debug('Encoding and flushing multi-tenant buffer for %s', maskedApiKey)
+      log.debug('Encoded LLMObs payload: %s', payload)
 
-    const options = this._getOptions()
+      request(payload, options, (err, resp, code) => {
+        parseResponseAndLog(err, code, events.length, url, this._eventType)
+      })
+    }
 
-    request(payload, options, (err, resp, code) => {
-      parseResponseAndLog(err, code, events.length, this.url, this._eventType)
-    })
+    this.#cleanupEmptyBuffers()
+  }
+
+  #cleanupEmptyBuffers () {
+    for (const [key, buffer] of this.#multiTenantBuffers) {
+      if (buffer.events.length === 0) {
+        this.#multiTenantBuffers.delete(key)
+      }
+    }
   }
 
   makePayload (events) {}
 
   destroy () {
-    if (!this._destroyed) {
+    if (this.#destroyer) {
       logger.debug(`Stopping ${this.constructor.name}`)
       clearInterval(this._periodic)
-      process.removeListener('beforeExit', this._beforeExitHandler)
+      globalThis[Symbol.for('dd-trace')].beforeExitHandlers.delete(this.#destroyer)
       this.flush()
-      this._destroyed = true
+      this.#destroyer = undefined
     }
   }
 
@@ -110,10 +188,11 @@ class BaseLLMObsWriter {
 
   _getUrlAndPath () {
     if (this._agentless) {
+      const site = this._config.site
       return {
         url: new URL(format({
           protocol: 'https:',
-          hostname: `${this._intake}.${this._config.site}`
+          hostname: `${this._intake}.${site}`
         })),
         endpoint: this._endpoint
       }

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

@@ -9,11 +9,10 @@ const {
 } = require('../constants/writers')
 const { DROPPED_VALUE_TEXT } = require('../constants/text')
 const { DROPPED_IO_COLLECTION_ERROR } = require('../constants/tags')
-const BaseWriter = require('./base')
 const telemetry = require('../telemetry')
 const logger = require('../../log')
-
 const tracerVersion = require('../../../../../package.json').version
+const BaseWriter = require('./base')
 
 class LLMObsSpanWriter extends BaseWriter {
   constructor (config) {
@@ -25,7 +24,7 @@ class LLMObsSpanWriter extends BaseWriter {
     })
   }
 
-  append (event) {
+  append (event, routing) {
     const eventSizeBytes = Buffer.byteLength(JSON.stringify(event))
     telemetry.recordLLMObsRawSpanSize(event, eventSizeBytes)
 
@@ -40,12 +39,13 @@ class LLMObsSpanWriter extends BaseWriter {
 
     telemetry.recordLLMObsSpanSize(event, processedEventSizeBytes, shouldTruncate)
 
-    if (this._bufferSize + eventSizeBytes > EVP_PAYLOAD_SIZE_LIMIT) {
+    const buffer = this._getBuffer(routing)
+    if (buffer.size + processedEventSizeBytes > EVP_PAYLOAD_SIZE_LIMIT) {
       logger.debug('Flushing queue because queuing next event will exceed EvP payload limit')
       this.flush()
     }
 
-    super.append(event, processedEventSizeBytes)
+    super.append(event, routing, processedEventSizeBytes)
   }
 
   makePayload (events) {

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

@@ -1,11 +1,11 @@
 'use strict'
 const { inspect } = require('util')
 const { isTrue } = require('../util')
+const { getValueFromEnvSources } = require('../config/helper')
 const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
 const { Log, LogConfig, NoTransmitError } = require('./log')
 const { memoize } = require('./utils')
-const { getEnvironmentVariable } = require('../config-helper')
 
 const config = {
   enabled: false,
@@ -112,8 +112,8 @@ const log = {
   isEnabled (fleetStableConfigValue, localStableConfigValue) {
     return isTrue(
       fleetStableConfigValue ??
-      getEnvironmentVariable('DD_TRACE_DEBUG') ??
-      (getEnvironmentVariable('OTEL_LOG_LEVEL') === 'debug' || undefined) ??
+      getValueFromEnvSources('DD_TRACE_DEBUG') ??
+      (getValueFromEnvSources('OTEL_LOG_LEVEL') === 'debug' || undefined) ??
       localStableConfigValue ??
       config.enabled
     )
@@ -126,8 +126,8 @@ const log = {
   ) {
     return optionsValue ??
       fleetStableConfigValue ??
-      getEnvironmentVariable('DD_TRACE_LOG_LEVEL') ??
-      getEnvironmentVariable('OTEL_LOG_LEVEL') ??
+      getValueFromEnvSources('DD_TRACE_LOG_LEVEL') ??
+      getValueFromEnvSources('OTEL_LOG_LEVEL') ??
       localStableConfigValue ??
       config.logLevel
   }

package/packages/dd-trace/src/noop/proxy.js

@@ -1,11 +1,11 @@
 'use strict'
 
-const NoopTracer = require('./tracer')
 const NoopAppsecSdk = require('../appsec/sdk/noop')
-const NoopDogStatsDClient = require('./dogstatsd')
 const NoopLLMObsSDK = require('../llmobs/noop')
 const NoopFlaggingProvider = require('../openfeature/noop')
 const NoopAIGuardSDK = require('../aiguard/noop')
+const NoopDogStatsDClient = require('./dogstatsd')
+const NoopTracer = require('./tracer')
 
 const noop = new NoopTracer()
 const noopAppsec = new NoopAppsecSdk()
@@ -23,10 +23,10 @@ class NoopProxy {
     this.llmobs = noopLLMObs
     this.openfeature = noopOpenFeatureProvider
     this.aiguard = noopAIGuard
-    this.setBaggageItem = () => {}
-    this.getBaggageItem = () => {}
+    this.setBaggageItem = (key, value) => {}
+    this.getBaggageItem = (key) => {}
     this.getAllBaggageItems = () => {}
-    this.removeBaggageItem = () => {}
+    this.removeBaggageItem = (keyToRemove) => {}
     this.removeAllBaggageItems = () => {}
   }
 

package/packages/dd-trace/src/noop/span.js

@@ -1,8 +1,8 @@
 'use strict'
 
-const NoopSpanContext = require('./span_context')
 const id = require('../id')
 const { storage } = require('../../../datadog-core') // TODO: noop storage?
+const NoopSpanContext = require('./span_context')
 
 class NoopSpan {
   constructor (tracer, parent) {

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

@@ -1,9 +1,9 @@
 'use strict'
 
+const { channel } = require('dc-polyfill')
 const log = require('../log')
 const ExposuresWriter = require('./writers/exposures')
 const { setAgentStrategy } = require('./writers/util')
-const { channel } = require('dc-polyfill')
 
 const exposureSubmitCh = channel('ffe:exposure:submit')
 const flushCh = channel('ffe:writers:flush')
@@ -12,7 +12,7 @@ let exposuresWriter = null
 
 /**
  * @private
- * @param {Object|Array<Object>} exposureEvents - Exposure events channel subscriber
+ * @param {object | Array<object>} exposureEvents - Exposure events channel subscriber
  * @returns {void}
  */
 function _handleExposureSubmit (exposureEvents) {

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

@@ -9,7 +9,7 @@ const { NOOP_REASON } = require('./constants/constants')
  */
 class NoopFlaggingProvider {
   /**
-   * @param {Object} [noopTracer] - Optional noop tracer instance
+   * @param {object} [noopTracer] - Optional noop tracer instance
    */
   constructor (noopTracer) {
     this._tracer = noopTracer
@@ -22,8 +22,8 @@ class NoopFlaggingProvider {
   /**
    * @param {string} flagKey - Flag key
    * @param {boolean} defaultValue - Default value to return
-   * @param {Object} context - Evaluation context
-   * @param {Object} logger - Logger instance
+   * @param {object} context - Evaluation context
+   * @param {object} logger - Logger instance
    * @returns {Promise<{value: boolean, reason: string}>} Resolution details
    */
   resolveBooleanEvaluation (flagKey, defaultValue, context, logger) {
@@ -36,8 +36,8 @@ class NoopFlaggingProvider {
   /**
    * @param {string} flagKey - Flag key
    * @param {string} defaultValue - Default value to return
-   * @param {Object} context - Evaluation context
-   * @param {Object} logger - Logger instance
+   * @param {object} context - Evaluation context
+   * @param {object} logger - Logger instance
    * @returns {Promise<{value: string, reason: string}>} Resolution details
    */
   resolveStringEvaluation (flagKey, defaultValue, context, logger) {
@@ -50,8 +50,8 @@ class NoopFlaggingProvider {
   /**
    * @param {string} flagKey - Flag key
    * @param {number} defaultValue - Default value to return
-   * @param {Object} context - Evaluation context
-   * @param {Object} logger - Logger instance
+   * @param {object} context - Evaluation context
+   * @param {object} logger - Logger instance
    * @returns {Promise<{value: number, reason: string}>} Resolution details
    */
   resolveNumberEvaluation (flagKey, defaultValue, context, logger) {
@@ -63,10 +63,10 @@ class NoopFlaggingProvider {
 
   /**
    * @param {string} flagKey - Flag key
-   * @param {Object} defaultValue - Default value to return
-   * @param {Object} context - Evaluation context
-   * @param {Object} logger - Logger instance
-   * @returns {Promise<{value: Object, reason: string}>} Resolution details
+   * @param {object} defaultValue - Default value to return
+   * @param {object} context - Evaluation context
+   * @param {object} logger - Logger instance
+   * @returns {Promise<{value: object, reason: string}>} Resolution details
    */
   resolveObjectEvaluation (flagKey, defaultValue, context, logger) {
     return Promise.resolve({
@@ -76,14 +76,14 @@ class NoopFlaggingProvider {
   }
 
   /**
-   * @returns {Object} Current configuration
+   * @returns {object} Current configuration
    */
   getConfiguration () {
     return this._config
   }
 
   /**
-   * @param {Object} config - Configuration to set
+   * @param {object} config - Configuration to set
    */
   setConfiguration (config) {
     this._config = config
@@ -91,7 +91,7 @@ class NoopFlaggingProvider {
 
   /**
    * @internal
-   * @param {Object} ufc - Universal Flag Configuration object
+   * @param {object} ufc - Universal Flag Configuration object
    */
   _setConfiguration (ufc) {
     this.setConfiguration(ufc)

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
+}