dd-trace 5.71.0 → 5.72.0

package/packages/dd-trace/src/config.js

@@ -9,7 +9,8 @@ const tagger = require('./tagger')
 const set = require('../../datadog-core/src/utils/src/set')
 const { isTrue, isFalse, normalizeProfilingEnabledValue } = require('./util')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
-const { getGitMetadataFromGitProperties, removeUserSensitiveInfo } = require('./git_properties')
+const { getGitMetadataFromGitProperties, removeUserSensitiveInfo, getRemoteOriginURL, resolveGitHeadSHA } =
+  require('./git_properties')
 const { updateConfig } = require('./telemetry')
 const telemetryMetrics = require('./telemetry/metrics')
 const { isInServerlessEnvironment, getIsGCPFunction, getIsAzureFunction } = require('./serverless')
@@ -17,6 +18,7 @@ const { ORIGIN_KEY } = require('./constants')
 const { appendRules } = require('./payload-tagging/config')
 const { getEnvironmentVariable, getEnvironmentVariables } = require('./config-helper')
 const defaults = require('./config_defaults')
+const path = require('path')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
@@ -67,6 +69,8 @@ const VALID_PROPAGATION_BEHAVIOR_EXTRACT = new Set(['continue', 'restart', 'igno
 
 const VALID_LOG_LEVELS = new Set(['debug', 'info', 'warn', 'error'])
 
+const DEFAULT_OTLP_PORT = 4318
+
 function getFromOtelSamplerMap (otelTracesSampler, otelTracesSamplerArg) {
   const OTEL_TRACES_SAMPLER_MAPPING = {
     always_on: '1.0',
@@ -380,30 +384,7 @@ class Config {
     }
 
     if (this.gitMetadataEnabled) {
-      this.repositoryUrl = removeUserSensitiveInfo(
-        getEnvironmentVariable('DD_GIT_REPOSITORY_URL') ??
-        this.tags[GIT_REPOSITORY_URL]
-      )
-      this.commitSHA = getEnvironmentVariable('DD_GIT_COMMIT_SHA') ??
-        this.tags[GIT_COMMIT_SHA]
-      if (!this.repositoryUrl || !this.commitSHA) {
-        const DD_GIT_PROPERTIES_FILE = getEnvironmentVariable('DD_GIT_PROPERTIES_FILE') ??
-          `${process.cwd()}/git.properties`
-        let gitPropertiesString
-        try {
-          gitPropertiesString = fs.readFileSync(DD_GIT_PROPERTIES_FILE, 'utf8')
-        } catch (e) {
-          // Only log error if the user has set a git.properties path
-          if (getEnvironmentVariable('DD_GIT_PROPERTIES_FILE')) {
-            log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', DD_GIT_PROPERTIES_FILE, e)
-          }
-        }
-        if (gitPropertiesString) {
-          const { commitSHA, repositoryUrl } = getGitMetadataFromGitProperties(gitPropertiesString)
-          this.commitSHA = this.commitSHA || commitSHA
-          this.repositoryUrl = this.repositoryUrl || repositoryUrl
-        }
-      }
+      this._loadGitMetadata()
     }
   }
 
@@ -554,6 +535,7 @@ class Config {
       DD_INSTRUMENTATION_TELEMETRY_ENABLED,
       DD_INSTRUMENTATION_CONFIG_ID,
       DD_LOGS_INJECTION,
+      DD_LOGS_OTEL_ENABLED,
       DD_LANGCHAIN_SPAN_CHAR_LIMIT,
       DD_LANGCHAIN_SPAN_PROMPT_COMPLETION_SAMPLE_RATE,
       DD_LLMOBS_AGENTLESS_ENABLED,
@@ -635,7 +617,18 @@ class Config {
       OTEL_RESOURCE_ATTRIBUTES,
       OTEL_SERVICE_NAME,
       OTEL_TRACES_SAMPLER,
-      OTEL_TRACES_SAMPLER_ARG
+      OTEL_TRACES_SAMPLER_ARG,
+      DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED,
+      OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
+      OTEL_EXPORTER_OTLP_LOGS_HEADERS,
+      OTEL_EXPORTER_OTLP_LOGS_PROTOCOL,
+      OTEL_EXPORTER_OTLP_LOGS_TIMEOUT,
+      OTEL_EXPORTER_OTLP_PROTOCOL,
+      OTEL_EXPORTER_OTLP_ENDPOINT,
+      OTEL_EXPORTER_OTLP_HEADERS,
+      OTEL_EXPORTER_OTLP_TIMEOUT,
+      OTEL_BSP_SCHEDULE_DELAY,
+      OTEL_BSP_MAX_EXPORT_BATCH_SIZE
     } = getEnvironmentVariables()
 
     const tags = {}
@@ -649,6 +642,23 @@ class Config {
     tagger.add(tags, DD_TRACE_TAGS)
     tagger.add(tags, DD_TRACE_GLOBAL_TAGS)
 
+    this._setBoolean(env, 'otelLogsEnabled', isTrue(DD_LOGS_OTEL_ENABLED))
+    // Set OpenTelemetry logs configuration with specific _LOGS_ vars taking precedence over generic _EXPORTERS_ vars
+    if (OTEL_EXPORTER_OTLP_ENDPOINT) {
+      // Only set if there's a custom URL, otherwise let calc phase handle the default
+      this._setString(env, 'otelUrl', OTEL_EXPORTER_OTLP_ENDPOINT)
+    }
+    if (OTEL_EXPORTER_OTLP_ENDPOINT || OTEL_EXPORTER_OTLP_LOGS_ENDPOINT) {
+      this._setString(env, 'otelLogsUrl', OTEL_EXPORTER_OTLP_LOGS_ENDPOINT || env.otelUrl)
+    }
+    this._setString(env, 'otelHeaders', OTEL_EXPORTER_OTLP_HEADERS)
+    this._setString(env, 'otelLogsHeaders', OTEL_EXPORTER_OTLP_LOGS_HEADERS || env.otelHeaders)
+    this._setString(env, 'otelProtocol', OTEL_EXPORTER_OTLP_PROTOCOL)
+    this._setString(env, 'otelLogsProtocol', OTEL_EXPORTER_OTLP_LOGS_PROTOCOL || env.otelProtocol)
+    env.otelTimeout = maybeInt(OTEL_EXPORTER_OTLP_TIMEOUT)
+    env.otelLogsTimeout = maybeInt(OTEL_EXPORTER_OTLP_LOGS_TIMEOUT) || env.otelTimeout
+    env.otelLogsBatchTimeout = maybeInt(OTEL_BSP_SCHEDULE_DELAY)
+    env.otelLogsMaxExportBatchSize = maybeInt(OTEL_BSP_MAX_EXPORT_BATCH_SIZE)
     this._setBoolean(
       env,
       'apmTracingEnabled',
@@ -721,6 +731,7 @@ class Config {
     env['dynamicInstrumentation.uploadIntervalSeconds'] = maybeFloat(DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS)
     this._envUnprocessed['dynamicInstrumentation.uploadInterval'] = DD_DYNAMIC_INSTRUMENTATION_UPLOAD_INTERVAL_SECONDS
     this._setString(env, 'env', DD_ENV || tags.env)
+    this._setBoolean(env, 'experimental.flaggingProvider.enabled', DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED)
     this._setBoolean(env, 'traceEnabled', DD_TRACE_ENABLED)
     this._setBoolean(env, 'experimental.aiguard.enabled', DD_AI_GUARD_ENABLED)
     this._setString(env, 'experimental.aiguard.endpoint', DD_AI_GUARD_ENDPOINT)
@@ -970,6 +981,7 @@ class Config {
     this._optsUnprocessed['experimental.aiguard.timeout'] = options.experimental?.aiguard?.timeout
     this._setBoolean(opts, 'experimental.enableGetRumData', options.experimental?.enableGetRumData)
     this._setString(opts, 'experimental.exporter', options.experimental?.exporter)
+    this._setBoolean(opts, 'experimental.flaggingProvider.enabled', options.experimental?.flaggingProvider?.enabled)
     opts.flushInterval = maybeInt(options.flushInterval)
     this._optsUnprocessed.flushInterval = options.flushInterval
     opts.flushMinSpans = maybeInt(options.flushMinSpans)
@@ -1156,7 +1168,20 @@ class Config {
       calc.testManagementAttemptToFixRetries = maybeInt(DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES) ?? 20
       this._setBoolean(calc, 'isImpactedTestsEnabled', !isFalse(DD_CIVISIBILITY_IMPACTED_TESTS_DETECTION_ENABLED))
     }
+
+    // Disable log injection when OTEL logs are enabled
+    // OTEL logs and DD log injection are mutually exclusive
+    if (this._env.otelLogsEnabled) {
+      this._setBoolean(calc, 'logInjection', false)
+    }
+
     calc['dogstatsd.hostname'] = this._getHostname()
+
+    // Compute OTLP logs URL to send payloads to the active Datadog Agent
+    const agentHostname = this._getHostname()
+    calc.otelLogsUrl = `http://${agentHostname}:${DEFAULT_OTLP_PORT}`
+    calc.otelUrl = `http://${agentHostname}:${DEFAULT_OTLP_PORT}`
+
     this._setBoolean(calc, 'isGitUploadEnabled',
       calc.isIntelligentTestRunnerEnabled && !isFalse(this._isCiVisibilityGitUploadEnabled()))
     this._setBoolean(calc, 'spanComputePeerService', this._getSpanComputePeerService())
@@ -1366,6 +1391,63 @@ class Config {
       }
     }
   }
+
+  _loadGitMetadata () {
+    // try to read Git metadata from the environment variables
+    this.repositoryUrl = removeUserSensitiveInfo(
+      getEnvironmentVariable('DD_GIT_REPOSITORY_URL') ??
+      this.tags[GIT_REPOSITORY_URL]
+    )
+    this.commitSHA = getEnvironmentVariable('DD_GIT_COMMIT_SHA') ??
+      this.tags[GIT_COMMIT_SHA]
+
+    // otherwise, try to read Git metadata from the git.properties file
+    if (!this.repositoryUrl || !this.commitSHA) {
+      const DD_GIT_PROPERTIES_FILE = getEnvironmentVariable('DD_GIT_PROPERTIES_FILE') ??
+        `${process.cwd()}/git.properties`
+      let gitPropertiesString
+      try {
+        gitPropertiesString = fs.readFileSync(DD_GIT_PROPERTIES_FILE, 'utf8')
+      } catch (e) {
+        // Only log error if the user has set a git.properties path
+        if (getEnvironmentVariable('DD_GIT_PROPERTIES_FILE')) {
+          log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', DD_GIT_PROPERTIES_FILE, e)
+        }
+      }
+      if (gitPropertiesString) {
+        const { commitSHA, repositoryUrl } = getGitMetadataFromGitProperties(gitPropertiesString)
+        this.commitSHA = this.commitSHA || commitSHA
+        this.repositoryUrl = this.repositoryUrl || repositoryUrl
+      }
+    }
+    // otherwise, try to read Git metadata from the .git/ folder
+    if (!this.repositoryUrl || !this.commitSHA) {
+      const DD_GIT_FOLDER_PATH = getEnvironmentVariable('DD_GIT_FOLDER_PATH') ??
+        path.join(process.cwd(), '.git')
+      if (!this.repositoryUrl) {
+        // try to read git config (repository URL)
+        const gitConfigPath = path.join(DD_GIT_FOLDER_PATH, 'config')
+        try {
+          const gitConfigContent = fs.readFileSync(gitConfigPath, 'utf8')
+          if (gitConfigContent) {
+            this.repositoryUrl = getRemoteOriginURL(gitConfigContent)
+          }
+        } catch (e) {
+          // Only log error if the user has set a .git/ path
+          if (getEnvironmentVariable('DD_GIT_FOLDER_PATH')) {
+            log.error('Error reading git config: %s', gitConfigPath, e)
+          }
+        }
+      }
+      if (!this.commitSHA) {
+        // try to read git HEAD (commit SHA)
+        const gitHeadSha = resolveGitHeadSHA(DD_GIT_FOLDER_PATH)
+        if (gitHeadSha) {
+          this.commitSHA = gitHeadSha
+        }
+      }
+    }
+  }
 }
 
 function handleOtel (tagString) {

package/packages/dd-trace/src/config_defaults.js

@@ -77,6 +77,7 @@ module.exports = {
   'experimental.aiguard.timeout': 10_000, // ms
   'experimental.enableGetRumData': false,
   'experimental.exporter': undefined,
+  'experimental.flaggingProvider.enabled': false,
   flushInterval: 2000,
   flushMinSpans: 1000,
   gitMetadataEnabled: true,
@@ -126,6 +127,17 @@ module.exports = {
   isTestManagementEnabled: false,
   isImpactedTestsEnabled: false,
   logInjection: true,
+  otelLogsEnabled: false,
+  otelUrl: undefined,
+  otelLogsUrl: undefined, // Will be computed using agent host
+  otelHeaders: undefined,
+  otelLogsHeaders: '',
+  otelProtocol: 'http/protobuf',
+  otelLogsProtocol: 'http/protobuf',
+  otelLogsTimeout: 10_000,
+  otelTimeout: 10_000,
+  otelLogsBatchTimeout: 5000,
+  otelLogsMaxExportBatchSize: 512,
   lookup: undefined,
   inferredProxyServicesEnabled: false,
   memcachedCommandEnabled: false,

package/packages/dd-trace/src/git_properties.js

@@ -1,7 +1,14 @@
 'use strict'
 
-const commitSHARegex = /git\.commit\.sha=([a-f\d]{40})/
-const repositoryUrlRegex = /git\.repository_url=([\w\d:@/.-]+)/
+const fs = require('fs')
+const path = require('path')
+
+const gitPropertiesCommitSHARegex = /git\.commit\.sha=([a-f\d]{40})/
+const gitPropertiesRepositoryUrlRegex = /git\.repository_url=([\w\d:@/.-]+)/
+const repositoryUrlRegex = /^([\w\d:@/.-]+)$/
+const remoteOriginRegex = /^\[remote\s+"origin"\]/i
+const gitHeadRefRegex = /ref:\s+(refs\/[A-Za-z0-9._/-]+)/
+const commitSHARegex = /^[0-9a-f]{40}$/
 
 function removeUserSensitiveInfo (repositoryUrl) {
   try {
@@ -21,8 +28,8 @@ function getGitMetadataFromGitProperties (gitPropertiesString) {
   if (!gitPropertiesString) {
     return {}
   }
-  const commitSHAMatch = gitPropertiesString.match(commitSHARegex)
-  const repositoryUrlMatch = gitPropertiesString.match(repositoryUrlRegex)
+  const commitSHAMatch = gitPropertiesString.match(gitPropertiesCommitSHARegex)
+  const repositoryUrlMatch = gitPropertiesString.match(gitPropertiesRepositoryUrlRegex)
 
   const repositoryUrl = repositoryUrlMatch ? repositoryUrlMatch[1] : undefined
 
@@ -32,4 +39,82 @@ function getGitMetadataFromGitProperties (gitPropertiesString) {
   }
 }
 
-module.exports = { getGitMetadataFromGitProperties, removeUserSensitiveInfo }
+function getRemoteOriginURL (gitConfigContent) {
+  if (!gitConfigContent) {
+    return
+  }
+  const lines = gitConfigContent.split('\n')
+  let index = 0
+
+  // find the remote origin section
+  for (; index < lines.length; index++) {
+    const line = lines[index]
+    if (line[0] !== '[') continue // fast path
+    if (remoteOriginRegex.test(line)) break
+  }
+
+  // find the url key/value in the [remote "origin"] section
+  index++
+  for (; index < lines.length; index++) {
+    const line = lines[index]
+    if (line[0] === '[') return // abort, section didn't contain a url
+    const splitAt = line.indexOf('=')
+    if (splitAt === -1) continue
+    const key = line.slice(0, splitAt).trim().toLowerCase()
+    if (key !== 'url') continue
+    const repositoryUrlValue = line.slice(splitAt + 1).trim()
+    const repositoryUrlMatch = repositoryUrlValue.match(repositoryUrlRegex)
+    if (!repositoryUrlMatch) continue
+    return removeUserSensitiveInfo(repositoryUrlMatch[0])
+  }
+}
+
+function getGitHeadRef (gitHeadContent) {
+  if (!gitHeadContent) {
+    return
+  }
+
+  // Extract the ref after 'ref: '
+  const gitRefMatch = gitHeadContent.match(gitHeadRefRegex)
+  return gitRefMatch?.[1]
+}
+
+function resolveGitHeadSHA (DD_GIT_FOLDER_PATH) {
+  const gitHeadPath = path.join(DD_GIT_FOLDER_PATH, 'HEAD')
+
+  try {
+    const gitHeadContent = fs.readFileSync(gitHeadPath, 'utf8')
+    if (!gitHeadContent) {
+      return
+    }
+
+    const headContent = gitHeadContent.trim()
+
+    // Handle detached head case
+    if (commitSHARegex.test(headContent)) {
+      return headContent
+    }
+
+    // Handle ref case - extract the ref and read the SHA from the ref file
+    const gitHeadRef = getGitHeadRef(headContent)
+    if (!gitHeadRef) {
+      return
+    }
+    const gitHeadRefPath = path.join(DD_GIT_FOLDER_PATH, gitHeadRef)
+    const gitHeadRefContent = fs.readFileSync(gitHeadRefPath, 'utf8')
+    if (gitHeadRefContent) {
+      const headRefContent = gitHeadRefContent.trim()
+      if (commitSHARegex.test(headRefContent)) {
+        return headRefContent
+      }
+    }
+  } catch {}
+}
+
+module.exports = {
+  getGitMetadataFromGitProperties,
+  removeUserSensitiveInfo,
+  getGitHeadRef,
+  getRemoteOriginURL,
+  resolveGitHeadSHA,
+}

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

@@ -4,12 +4,14 @@ 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 noop = new NoopTracer()
 const noopAppsec = new NoopAppsecSdk()
 const noopDogStatsDClient = new NoopDogStatsDClient()
 const noopLLMObs = new NoopLLMObsSDK(noop)
+const noopOpenFeatureProvider = new NoopFlaggingProvider()
 const noopAIGuard = new NoopAIGuardSDK()
 
 /** @type {import('../../src/index')} Proxy */
@@ -19,6 +21,7 @@ class NoopProxy {
     this.appsec = noopAppsec
     this.dogstatsd = noopDogStatsDClient
     this.llmobs = noopLLMObs
+    this.openfeature = noopOpenFeatureProvider
     this.aiguard = noopAIGuard
     this.setBaggageItem = () => {}
     this.getBaggageItem = () => {}

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

@@ -0,0 +1,51 @@
+'use strict'
+
+module.exports = {
+  /**
+   * @constant
+   * @type {string} Base path for EVP proxy agent endpoint
+   */
+  EVP_PROXY_AGENT_BASE_PATH: '/evp_proxy/v2/',
+
+  /**
+   * @constant
+   * @type {string} HTTP header name for EVP subdomain routing
+   */
+  EVP_SUBDOMAIN_HEADER_NAME: 'X-Datadog-EVP-Subdomain',
+
+  /**
+   * @constant
+   * @type {string} EVP subdomain value for event platform intake
+   */
+  EVP_SUBDOMAIN_VALUE: 'event-platform-intake',
+
+  /**
+   * @constant
+   * @type {string} API endpoint for exposure events EVP track
+   */
+  EXPOSURES_ENDPOINT: '/api/v2/exposures',
+
+  /**
+   * @constant
+   * @type {number} Maximum payload size for EVP intake (5MB, actual limit is 5.1MB)
+   */
+  EVP_PAYLOAD_SIZE_LIMIT: 5 << 20,
+
+  /**
+   * @constant
+   * @type {number} Maximum individual event size (999KB, actual limit is 1MB)
+   */
+  EVP_EVENT_SIZE_LIMIT: (1 << 20) - 1024,
+
+  /**
+   * @constant
+   * @type {string} Channel name for exposure event submission
+   */
+  EXPOSURE_CHANNEL: 'ffe:exposure:submit',
+
+  /**
+   * @constant
+   * @type {string} Reason code for noop provider evaluations
+   */
+  NOOP_REASON: 'STATIC'
+}

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

@@ -0,0 +1,45 @@
+'use strict'
+
+const { DatadogNodeServerProvider } = require('@datadog/openfeature-node-server')
+const { channel } = require('dc-polyfill')
+const log = require('../log')
+const { EXPOSURE_CHANNEL } = require('./constants/constants')
+
+/**
+ * OpenFeature provider that integrates with Datadog's feature flagging system.
+ * Extends DatadogNodeServerProvider to add tracer integration and configuration management.
+ */
+class FlaggingProvider extends DatadogNodeServerProvider {
+  /**
+   * @param {import('../tracer')} tracer - Datadog tracer instance
+   * @param {import('../config')} config - Tracer configuration object
+   */
+  constructor (tracer, config) {
+    // Call parent constructor with required options
+    super({
+      exposureChannel: channel(EXPOSURE_CHANNEL)
+    })
+
+    this._tracer = tracer
+    this._config = config
+
+    log.debug(this.constructor.name + ' created')
+  }
+
+  /**
+   * Internal method to update flag configuration from Remote Config.
+   * This method is called automatically when Remote Config delivers UFC updates.
+   *
+   * @internal
+   * @param {import('@datadog/openfeature-node-server').UniversalFlagConfigurationV1} ufc
+   * - Universal Flag Configuration object
+   */
+  _setConfiguration (ufc) {
+    if (typeof this.setConfiguration === 'function') {
+      this.setConfiguration(ufc)
+    }
+    log.debug(this.constructor.name + ' provider configuration updated')
+  }
+}
+
+module.exports = FlaggingProvider

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

@@ -0,0 +1,77 @@
+'use strict'
+
+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')
+
+let exposuresWriter = null
+
+/**
+ * @private
+ * @param {Object|Array<Object>} exposureEvents - Exposure events channel subscriber
+ * @returns {void}
+ */
+function _handleExposureSubmit (exposureEvents) {
+  if (!exposuresWriter) return
+  exposuresWriter.append(exposureEvents)
+}
+
+/**
+ * Channel subscriber for manually flushing the exposures writer
+ * @private
+ * @returns {void}
+ */
+function _handleFlush () {
+  exposuresWriter?.flush()
+}
+
+/**
+ * Enables the OpenFeature module and sets up FF&E writer and channel subscribers
+ * @param {import('../config')} config - Tracer configuration object
+ * @returns {void}
+ */
+function enable (config) {
+  if (exposuresWriter) {
+    log.warn(exposuresWriter.constructor.name + ' already enabled')
+    return
+  }
+
+  exposuresWriter = new ExposuresWriter(config)
+  exposureSubmitCh.subscribe(_handleExposureSubmit)
+  flushCh.subscribe(_handleFlush)
+
+  setAgentStrategy(config, hasAgent => {
+    exposuresWriter?.setEnabled(hasAgent)
+  })
+
+  log.debug('OpenFeature module enabled')
+}
+
+/**
+ * Disables the OpenFeature module and cleans up resources
+ * @returns {void}
+ */
+function disable () {
+  if (!exposuresWriter) return
+
+  if (exposureSubmitCh.hasSubscribers) {
+    exposureSubmitCh.unsubscribe(_handleExposureSubmit)
+  }
+  if (flushCh.hasSubscribers) {
+    flushCh.unsubscribe(_handleFlush)
+  }
+
+  exposuresWriter.destroy?.()
+  exposuresWriter = null
+
+  log.debug('OpenFeature module disabled')
+}
+
+module.exports = {
+  enable,
+  disable
+}

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

@@ -0,0 +1,101 @@
+'use strict'
+
+const { NOOP_REASON } = require('./constants/constants')
+
+/**
+ * No-op implementation of OpenFeature provider that always returns default values.
+ * Used when the OpenFeature provider is not initialized or disabled.
+ * https://openfeature.dev/docs/reference/concepts/provider/
+ */
+class NoopFlaggingProvider {
+  /**
+   * @param {Object} [noopTracer] - Optional noop tracer instance
+   */
+  constructor (noopTracer) {
+    this._tracer = noopTracer
+    this._config = {}
+    this.metadata = { name: 'NoopFlaggingProvider' }
+    this.status = 'NOT_READY'
+    this.runsOn = 'server'
+  }
+
+  /**
+   * @param {string} flagKey - Flag key
+   * @param {boolean} defaultValue - Default value to return
+   * @param {Object} context - Evaluation context
+   * @param {Object} logger - Logger instance
+   * @returns {Promise<{value: boolean, reason: string}>} Resolution details
+   */
+  resolveBooleanEvaluation (flagKey, defaultValue, context, logger) {
+    return Promise.resolve({
+      value: defaultValue,
+      reason: NOOP_REASON
+    })
+  }
+
+  /**
+   * @param {string} flagKey - Flag key
+   * @param {string} defaultValue - Default value to return
+   * @param {Object} context - Evaluation context
+   * @param {Object} logger - Logger instance
+   * @returns {Promise<{value: string, reason: string}>} Resolution details
+   */
+  resolveStringEvaluation (flagKey, defaultValue, context, logger) {
+    return Promise.resolve({
+      value: defaultValue,
+      reason: NOOP_REASON
+    })
+  }
+
+  /**
+   * @param {string} flagKey - Flag key
+   * @param {number} defaultValue - Default value to return
+   * @param {Object} context - Evaluation context
+   * @param {Object} logger - Logger instance
+   * @returns {Promise<{value: number, reason: string}>} Resolution details
+   */
+  resolveNumberEvaluation (flagKey, defaultValue, context, logger) {
+    return Promise.resolve({
+      value: defaultValue,
+      reason: NOOP_REASON,
+    })
+  }
+
+  /**
+   * @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
+   */
+  resolveObjectEvaluation (flagKey, defaultValue, context, logger) {
+    return Promise.resolve({
+      value: defaultValue,
+      reason: NOOP_REASON
+    })
+  }
+
+  /**
+   * @returns {Object} Current configuration
+   */
+  getConfiguration () {
+    return this._config
+  }
+
+  /**
+   * @param {Object} config - Configuration to set
+   */
+  setConfiguration (config) {
+    this._config = config
+  }
+
+  /**
+   * @internal
+   * @param {Object} ufc - Universal Flag Configuration object
+   */
+  _setConfiguration (ufc) {
+    this.setConfiguration(ufc)
+  }
+}
+
+module.exports = NoopFlaggingProvider