dd-trace 5.81.0 → 5.83.0

package/packages/dd-trace/src/{config-helper.js → config/helper.js}

@@ -34,7 +34,66 @@ for (const deprecation of Object.keys(deprecations)) {
   )
 }
 
+let localStableConfig
+let fleetStableConfig
+let stableConfigWarnings
+let stableConfigLoaded = false
+
+function loadStableConfig () {
+  stableConfigLoaded = true
+
+  // Lazy require to avoid circular dependency at module load time.
+  const { isInServerlessEnvironment } = require('../serverless')
+  if (isInServerlessEnvironment()) {
+    // Stable config is not supported in serverless environments.
+    return
+  }
+
+  const StableConfig = require('./stable')
+  const instance = new StableConfig()
+  localStableConfig = instance.localEntries
+  fleetStableConfig = instance.fleetEntries
+  stableConfigWarnings = instance.warnings
+}
+
+function getValueFromSource (name, source) {
+  const value = source[name]
+
+  if (value === undefined && aliases[name]) {
+    for (const alias of aliases[name]) {
+      if (source[alias] !== undefined) {
+        return source[alias]
+      }
+    }
+  }
+
+  return value
+}
+
+function validateAccess (name) {
+  if ((name.startsWith('DD_') || name.startsWith('OTEL_') || aliasToCanonical[name]) &&
+    !supportedConfigurations[name]) {
+    throw new Error(`Missing ${name} env/configuration in "supported-configurations.json" file.`)
+  }
+}
+
 module.exports = {
+  /**
+   * Expose raw stable config maps and warnings for consumers that need
+   * per-source access (e.g. telemetry in Config).
+   *
+   * @returns {{ localStableConfig: object, fleetStableConfig: object, stableConfigWarnings: string[] }}
+   */
+  getStableConfigSources () {
+    if (!stableConfigLoaded) {
+      loadStableConfig()
+    }
+    return {
+      localStableConfig,
+      fleetStableConfig,
+      stableConfigWarnings,
+    }
+  },
   /**
    * Returns the environment variables that are supported by the tracer
    * (including all non-Datadog/OTEL specific environment variables).
@@ -46,6 +105,7 @@ module.exports = {
   getEnvironmentVariables () {
     const configs = {}
     for (const [key, value] of Object.entries(process.env)) {
+      // TODO(BridgeAR): Handle telemetry reporting for aliases.
       if (key.startsWith('DD_') || key.startsWith('OTEL_') || aliasToCanonical[key]) {
         if (supportedConfigurations[key]) {
           configs[key] = value
@@ -72,28 +132,41 @@ module.exports = {
     return configs
   },
 
+  getEnvironmentVariable (name) {
+    validateAccess(name)
+    return getValueFromSource(name, process.env)
+  },
+
   /**
-   * Returns the environment variable, if it's supported or a non Datadog
-   * configuration. Otherwise, it throws an error.
+   * Returns the value stored at the given name, assumed to be in environment variable format,
+   * from the supported env sources (process.env, local stable config, fleet stable config).
+   * Falls back to aliases if the canonical name is not set.
    *
    * @param {string} name Environment variable name
    * @returns {string|undefined}
    * @throws {Error} if the configuration is not supported
    */
-  // This method, and callers of this method, need to be updated to check for declarative config sources as well.
-  getEnvironmentVariable (name) {
-    if ((name.startsWith('DD_') || name.startsWith('OTEL_') || aliasToCanonical[name]) &&
-        !supportedConfigurations[name]) {
-      throw new Error(`Missing ${name} env/configuration in "supported-configurations.json" file.`)
+  getValueFromEnvSources (name) {
+    validateAccess(name)
+
+    if (!stableConfigLoaded) {
+      loadStableConfig()
     }
-    const config = process.env[name]
-    if (config === undefined && aliases[name]) {
-      for (const alias of aliases[name]) {
-        if (process.env[alias] !== undefined) {
-          return process.env[alias]
-        }
+
+    if (fleetStableConfig !== undefined) {
+      const fromFleet = getValueFromSource(name, fleetStableConfig)
+      if (fromFleet !== undefined) {
+        return fromFleet
       }
     }
-    return config
-  }
+
+    const fromEnv = getValueFromSource(name, process.env)
+    if (fromEnv !== undefined) {
+      return fromEnv
+    }
+
+    if (localStableConfig !== undefined) {
+      return getValueFromSource(name, localStableConfig)
+    }
+  },
 }

package/packages/dd-trace/src/{config.js → config/index.js}

@@ -2,25 +2,30 @@
 
 const fs = require('fs')
 const os = require('os')
-const uuid = require('../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
 const { URL } = require('url')
-
-const log = require('./log')
-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 path = require('path')
+const uuid = require('../../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
+
+const set = require('../../../datadog-core/src/utils/src/set')
+const { DD_MAJOR } = require('../../../../version')
+const log = require('../log')
+const tagger = require('../tagger')
+const { isTrue, isFalse, normalizeProfilingEnabledValue } = require('../util')
+const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
+const { updateConfig } = require('../telemetry')
+const telemetryMetrics = require('../telemetry/metrics')
+const {
+  isInServerlessEnvironment,
+  getIsGCPFunction,
+  getIsAzureFunction,
+  enableGCPPubSubPushSubscription
+} = require('../serverless')
+const { ORIGIN_KEY } = require('../constants')
+const { appendRules } = require('../payload-tagging/config')
 const { getGitMetadataFromGitProperties, removeUserSensitiveInfo, getRemoteOriginURL, resolveGitHeadSHA } =
   require('./git_properties')
-const { updateConfig } = require('./telemetry')
-const telemetryMetrics = require('./telemetry/metrics')
-const { isInServerlessEnvironment, getIsGCPFunction, getIsAzureFunction } = require('./serverless')
-const { ORIGIN_KEY } = require('./constants')
-const { appendRules } = require('./payload-tagging/config')
-const { getEnvironmentVariable: getEnv, getEnvironmentVariables } = require('./config-helper')
-const defaults = require('./config_defaults')
-const path = require('path')
-const { DD_MAJOR } = require('../../../version')
+const { getEnvironmentVariable: getEnv, getEnvironmentVariables, getStableConfigSources } = require('./helper')
+const defaults = require('./defaults')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
@@ -182,7 +187,7 @@ function validateNamingVersion (versionString) {
  * @param {string | string[]} input
  */
 function splitJSONPathRules (input) {
-  if (!input) return
+  if (!input || input === '$') return
   if (Array.isArray(input)) return input
   if (input === 'all') return []
   return input.split(',')
@@ -271,13 +276,14 @@ class Config {
 
   constructor (options = {}) {
     if (!isInServerlessEnvironment()) {
-      // Bail out early if we're in a serverless environment, stable config isn't supported
-      const StableConfig = require('./config_stable')
-      this.stableConfig = new StableConfig()
+      const configEnvSources = getStableConfigSources()
+      this.stableConfig = {
+        fleetEntries: configEnvSources.fleetStableConfig,
+        localEntries: configEnvSources.localStableConfig,
+        warnings: configEnvSources.stableConfigWarnings
+      }
     }
 
-    const envs = getEnvironmentVariables()
-
     options = {
       ...options,
       appsec: options.appsec == null ? options.experimental?.appsec : options.appsec,
@@ -321,11 +327,10 @@ class Config {
     this.#defaults = defaults
     this.#applyDefaults()
     this.#applyStableConfig(this.stableConfig?.localEntries ?? {}, this.#localStableConfig)
-    this.#applyEnvironment(envs)
+    this.#applyEnvironment()
     this.#applyStableConfig(this.stableConfig?.fleetEntries ?? {}, this.#fleetStableConfig)
     this.#applyOptions(options)
     this.#applyCalculated()
-    this.#applyRemote({})
     this.#merge()
 
     tagger.add(this.tags, {
@@ -342,7 +347,7 @@ class Config {
     }
 
     if (this.gitMetadataEnabled) {
-      this.#loadGitMetadata(envs)
+      this.#loadGitMetadata()
     }
   }
 
@@ -350,15 +355,38 @@ class Config {
     return this.#parsedDdTags
   }
 
-  // Supports only a subset of options for now.
-  configure (options, remote) {
-    if (remote) {
-      this.#applyRemote(options)
-    } else {
-      this.#applyOptions(options)
+  /**
+   * Set the configuration with remote config settings.
+   * Applies remote configuration, recalculates derived values, and merges all configuration sources.
+   *
+   * @param {import('./config/remote_config').RemoteConfigOptions|null} options - Configurations received via Remote
+   *   Config or null to reset all remote configuration
+   */
+  setRemoteConfig (options) {
+    // Clear all RC-managed fields to ensure previous values don't persist.
+    // State is instead managed by the `RCClientLibConfigManager` class
+    this.#remote = {}
+    this.#remoteUnprocessed = {}
+
+    // Special case: if options is null, nothing to apply
+    // This happens when all remote configs are removed
+    if (options !== null) {
+      this.#applyRemoteConfig(options)
     }
 
-    // TODO: test
+    this.#applyCalculated()
+    this.#merge()
+  }
+
+  // TODO: Remove the `updateOptions` method. We don't want to support updating the config this way
+  /**
+   * Updates the configuration with new programmatic options.
+   *
+   * @deprecated This method should not be used and will be removed in a future version.
+   * @param {object} options - Configuration options to apply (same format as tracer init options)
+   */
+  updateOptions (options) {
+    this.#applyOptions(options)
     this.#applyCalculated()
     this.#merge()
   }
@@ -475,6 +503,7 @@ class Config {
       DD_IAST_STACK_TRACE_ENABLED,
       DD_INJECTION_ENABLED,
       DD_INJECT_FORCE,
+      DD_ENABLE_NX_SERVICE_NAME,
       DD_INSTRUMENTATION_TELEMETRY_ENABLED,
       DD_INSTRUMENTATION_CONFIG_ID,
       DD_LOGS_INJECTION,
@@ -588,7 +617,8 @@ class Config {
       OTEL_BSP_SCHEDULE_DELAY,
       OTEL_BSP_MAX_EXPORT_BATCH_SIZE,
       OTEL_BSP_MAX_QUEUE_SIZE,
-      OTEL_METRIC_EXPORT_INTERVAL
+      OTEL_METRIC_EXPORT_INTERVAL,
+      NX_TASK_TARGET_PROJECT
     } = source
 
     const tags = {}
@@ -801,6 +831,7 @@ class Config {
     this.#setBoolean(target, 'injectForce', DD_INJECT_FORCE)
     this.#setBoolean(target, 'isAzureFunction', getIsAzureFunction())
     this.#setBoolean(target, 'isGCPFunction', getIsGCPFunction())
+    this.#setBoolean(target, 'gcpPubSubPushSubscriptionEnabled', enableGCPPubSubPushSubscription())
     target['langchain.spanCharLimit'] = maybeInt(DD_LANGCHAIN_SPAN_CHAR_LIMIT)
     target['langchain.spanPromptCompletionSampleRate'] = maybeFloat(DD_LANGCHAIN_SPAN_PROMPT_COMPLETION_SAMPLE_RATE)
     this.#setBoolean(target, 'legacyBaggageEnabled', DD_TRACE_LEGACY_BAGGAGE_ENABLED)
@@ -858,7 +889,22 @@ class Config {
     this.#setSamplingRule(target, 'sampler.rules', safeJsonParse(DD_TRACE_SAMPLING_RULES))
     unprocessedTarget['sampler.rules'] = DD_TRACE_SAMPLING_RULES
     this.#setString(target, 'scope', DD_TRACE_SCOPE)
-    this.#setString(target, 'service', DD_SERVICE || tags.service || OTEL_SERVICE_NAME)
+    // Priority:
+    // DD_SERVICE > tags.service > OTEL_SERVICE_NAME > NX_TASK_TARGET_PROJECT (if DD_ENABLE_NX_SERVICE_NAME) > default
+    let serviceName = DD_SERVICE || tags.service || OTEL_SERVICE_NAME
+    if (!serviceName && NX_TASK_TARGET_PROJECT) {
+      if (isTrue(DD_ENABLE_NX_SERVICE_NAME)) {
+        serviceName = NX_TASK_TARGET_PROJECT
+      } else if (DD_MAJOR < 6) {
+        // Warn about v6 behavior change for Nx projects
+        log.warn(
+          'NX_TASK_TARGET_PROJECT is set but no service name was configured. ' +
+          'In v6, NX_TASK_TARGET_PROJECT will be used as the default service name. ' +
+          'Set DD_ENABLE_NX_SERVICE_NAME=true to opt-in to this behavior now, or set a service name explicitly.'
+        )
+      }
+    }
+    this.#setString(target, 'service', serviceName)
     if (DD_SERVICE_MAPPING) {
       target.serviceMapping = Object.fromEntries(
         DD_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
@@ -1152,9 +1198,8 @@ class Config {
     // This is reliant on environment config being set before options.
     // This is to make sure the origins of each value are tracked appropriately for telemetry.
     // We'll only set `llmobs.enabled` on the opts when it's not set on the environment, and options.llmobs is provided.
-    const llmobsEnabledEnv = this.#env['llmobs.enabled']
-    if (llmobsEnabledEnv == null && options.llmobs) {
-      this.#setBoolean(opts, 'llmobs.enabled', !!options.llmobs)
+    if (this.#env['llmobs.enabled'] == null && options.llmobs) {
+      this.#setBoolean(opts, 'llmobs.enabled', true)
     }
   }
 
@@ -1284,31 +1329,36 @@ class Config {
     }
   }
 
-  #applyRemote (options) {
+  /**
+   * Applies remote configuration options from APM_TRACING configs.
+   *
+   * @param {import('./config/remote_config').RemoteConfigOptions} options - Configurations received via Remote Config
+   */
+  #applyRemoteConfig (options) {
     const opts = this.#remote
-    const tags = {}
-    const headerTags = options.tracing_header_tags
-      ? options.tracing_header_tags.map(tag => {
-        return tag.tag_name ? `${tag.header}:${tag.tag_name}` : tag.header
-      })
-      : undefined
-
-    tagger.add(tags, options.tracing_tags)
-    if (Object.keys(tags).length) tags['runtime-id'] = runtimeId
 
+    this.#setBoolean(opts, 'dynamicInstrumentation.enabled', options.dynamic_instrumentation_enabled)
+    this.#setBoolean(opts, 'codeOriginForSpans.enabled', options.code_origin_enabled)
     this.#setUnit(opts, 'sampleRate', options.tracing_sampling_rate)
     this.#setBoolean(opts, 'logInjection', options.log_injection_enabled)
-    opts.headerTags = headerTags
-    this.#setTags(opts, 'tags', tags)
     this.#setBoolean(opts, 'tracing', options.tracing_enabled)
     this.#remoteUnprocessed['sampler.rules'] = options.tracing_sampling_rules
-    this.#setSamplingRule(opts, 'sampler.rules', this.#reformatTags(options.tracing_sampling_rules))
+    this.#setSamplingRule(opts, 'sampler.rules', this.#reformatTagsFromRC(options.tracing_sampling_rules))
+
+    opts.headerTags = options.tracing_header_tags?.map(tag => {
+      return tag.tag_name ? `${tag.header}:${tag.tag_name}` : tag.header
+    })
+
+    const tags = {}
+    tagger.add(tags, options.tracing_tags)
+    if (Object.keys(tags).length) tags['runtime-id'] = runtimeId
+    this.#setTags(opts, 'tags', tags)
   }
 
-  #reformatTags (samplingRules) {
+  #reformatTagsFromRC (samplingRules) {
     for (const rule of (samplingRules || [])) {
-      const reformattedTags = {}
       if (rule.tags) {
+        const reformattedTags = {}
         for (const tag of rule.tags) {
           reformattedTags[tag.key] = tag.value_glob
         }
@@ -1473,26 +1523,24 @@ class Config {
     }
   }
 
-  #loadGitMetadata (envs) {
+  #loadGitMetadata () {
     // try to read Git metadata from the environment variables
     this.repositoryUrl = removeUserSensitiveInfo(
-      envs.DD_GIT_REPOSITORY_URL ??
-      this.tags[GIT_REPOSITORY_URL]
+      getEnv('DD_GIT_REPOSITORY_URL') ?? this.tags[GIT_REPOSITORY_URL]
     )
-    this.commitSHA = envs.DD_GIT_COMMIT_SHA ??
-      this.tags[GIT_COMMIT_SHA]
+    this.commitSHA = getEnv('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 = envs.DD_GIT_PROPERTIES_FILE ??
-        `${process.cwd()}/git.properties`
+      const DD_GIT_PROPERTIES_FILE = getEnv('DD_GIT_PROPERTIES_FILE')
+      const gitPropertiesFile = DD_GIT_PROPERTIES_FILE ?? `${process.cwd()}/git.properties`
       let gitPropertiesString
       try {
-        gitPropertiesString = fs.readFileSync(DD_GIT_PROPERTIES_FILE, 'utf8')
+        gitPropertiesString = fs.readFileSync(gitPropertiesFile, 'utf8')
       } catch (e) {
         // Only log error if the user has set a git.properties path
-        if (envs.DD_GIT_PROPERTIES_FILE) {
-          log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', DD_GIT_PROPERTIES_FILE, e)
+        if (DD_GIT_PROPERTIES_FILE) {
+          log.error('Error reading DD_GIT_PROPERTIES_FILE: %s', gitPropertiesFile, e)
         }
       }
       if (gitPropertiesString) {
@@ -1503,11 +1551,11 @@ class Config {
     }
     // otherwise, try to read Git metadata from the .git/ folder
     if (!this.repositoryUrl || !this.commitSHA) {
-      const DD_GIT_FOLDER_PATH = envs.DD_GIT_FOLDER_PATH ??
-        path.join(process.cwd(), '.git')
+      const DD_GIT_FOLDER_PATH = getEnv('DD_GIT_FOLDER_PATH')
+      const gitFolderPath = 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')
+        const gitConfigPath = path.join(gitFolderPath, 'config')
         try {
           const gitConfigContent = fs.readFileSync(gitConfigPath, 'utf8')
           if (gitConfigContent) {
@@ -1515,14 +1563,14 @@ class Config {
           }
         } catch (e) {
           // Only log error if the user has set a .git/ path
-          if (envs.DD_GIT_FOLDER_PATH) {
+          if (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)
+        const gitHeadSha = resolveGitHeadSHA(gitFolderPath)
         if (gitHeadSha) {
           this.commitSHA = gitHeadSha
         }

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

@@ -0,0 +1,202 @@
+'use strict'
+
+const RemoteConfigCapabilities = require('../remote_config/capabilities')
+const log = require('../log')
+
+module.exports = {
+  enable
+}
+
+/**
+ * @typedef {object} RemoteConfigOptions
+ * @property {boolean} [dynamic_instrumentation_enabled] - Enable Dynamic Instrumentation
+ * @property {boolean} [code_origin_enabled] - Enable code origin tagging for spans
+ * @property {Array<{header: string, tag_name?: string}>} [tracing_header_tags] - HTTP headers to tag
+ * @property {Array<string>} [tracing_tags] - Global tags (format: "key:value")
+ * @property {number} [tracing_sampling_rate] - Global sampling rate (0.0-1.0)
+ * @property {boolean} [log_injection_enabled] - Enable trace context log injection
+ * @property {boolean} [tracing_enabled] - Enable/disable tracing globally
+ * @property {Array<object>} [tracing_sampling_rules] - Trace sampling rules configuration
+ */
+
+/**
+ * @typedef {ReturnType<import('../config')>} Config
+ */
+
+/**
+ * Manages multiple APM_TRACING configurations with priority-based merging
+ */
+class RCClientLibConfigManager {
+  /**
+   * @param {string} currentService - Current service name
+   * @param {string} currentEnv - Current environment name
+   */
+  constructor (currentService, currentEnv) {
+    this.configs = new Map() // config_id -> { conf, priority }
+    this.currentService = currentService
+    this.currentEnv = currentEnv
+  }
+
+  /**
+   * Calculate priority based on target specificity. Higher values take precedence.
+   * Priority order (highest → lowest):
+   *   Service+Env (5) > Service (4) > Env (3) > Cluster (2) > Org (1)
+   *
+   * @param {object} conf - Remote config object with service_target and k8s_target_v2 properties
+   * @returns {number} Priority value from 1 (org-level) to 5 (service+env specific)
+   */
+  calculatePriority (conf) {
+    const serviceTarget = conf.service_target
+    const k8sTarget = conf.k8s_target_v2
+
+    if (serviceTarget) {
+      const service = serviceTarget.service
+      const env = serviceTarget.env
+
+      const hasSpecificService = service && service !== '*'
+      const hasSpecificEnv = env && env !== '*'
+
+      if (hasSpecificService && hasSpecificEnv) return 5
+      if (hasSpecificService) return 4
+      if (hasSpecificEnv) return 3
+    }
+
+    if (k8sTarget) return 2
+
+    return 1 // Org level
+  }
+
+  /**
+   * Check if config matches current service/env
+   *
+   * @param {object} conf - Remote config object with service_target property
+   * @returns {boolean} True if config matches current service/env or has no filter
+   */
+  matchesCurrentServiceEnv (conf) {
+    const serviceTarget = conf.service_target
+    if (!serviceTarget) return true // No filter means match all
+
+    const service = serviceTarget.service
+    const env = serviceTarget.env
+
+    // Check service match
+    if (service && service !== '*' && service !== this.currentService) {
+      log.debug('[config/remote_config] Ignoring config for service: %s (current: %s)',
+        service, this.currentService)
+      return false
+    }
+
+    // Check env match
+    if (env && env !== '*' && env !== this.currentEnv) {
+      log.debug('[config/remote_config] Ignoring config for env: %s (current: %s)',
+        env, this.currentEnv)
+      return false
+    }
+
+    return true
+  }
+
+  /**
+   * Add or update a config
+   *
+   * @param {string} configId - Unique identifier for the config
+   * @param {object} conf - Remote config object to add
+   */
+  addConfig (configId, conf) {
+    if (!this.matchesCurrentServiceEnv(conf)) {
+      return
+    }
+
+    const priority = this.calculatePriority(conf)
+    this.configs.set(configId, { conf, priority })
+
+    log.debug('[config/remote_config] Added config %s with priority %d', configId, priority)
+  }
+
+  /**
+   * Remove a config
+   *
+   * @param {string} configId - Unique identifier for the config to remove
+   */
+  removeConfig (configId) {
+    const removed = this.configs.delete(configId)
+    if (removed) {
+      log.debug('[config/remote_config] Removed config %s', configId)
+    }
+  }
+
+  /**
+   * Get merged lib_config with higher priority configs overriding lower priority ones
+   *
+   * @returns {RemoteConfigOptions|null} Merged config object or null if no configs present
+   */
+  getMergedLibConfig () {
+    if (this.configs.size === 0) return null
+
+    let hasLibConfig = false
+
+    const merged = [...this.configs.values()]
+      .sort((a, b) => a.priority - b.priority)
+      .reduce((merged, { conf }) => {
+        if (conf.lib_config != null) hasLibConfig = true
+        return Object.assign(merged, conf.lib_config)
+      }, {})
+
+    return hasLibConfig ? merged : null
+  }
+}
+
+/**
+ * Configures remote config for core APM tracing functionality
+ *
+ * @param {import('../remote_config')} rc - RemoteConfig instance
+ * @param {Config} config - Tracer config
+ * @param {() => void} onConfigUpdated - Function to call when config is updated
+ */
+function enable (rc, config, onConfigUpdated) {
+  // This tracer supports receiving config subsets via the APM_TRACING product handler.
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_MULTICONFIG, true)
+
+  // Tracing
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLED, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RATE, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_SAMPLE_RULES, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_CUSTOM_TAGS, true)
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_HTTP_HEADER_TAGS, true)
+
+  // Log Management
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_LOGS_INJECTION, true)
+
+  // Debugger
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_DYNAMIC_INSTRUMENTATION, true)
+
+  // Code Origin
+  rc.updateCapabilities(RemoteConfigCapabilities.APM_TRACING_ENABLE_CODE_ORIGIN, true)
+
+  const rcClientLibConfigManager = new RCClientLibConfigManager(config.service, config.env)
+
+  // Subscribe to APM_TRACING product (setBatchHandler used below doesn't automatically subscribe)
+  rc.subscribeProducts('APM_TRACING')
+
+  // Use a batch handler to process all changes before updating the config. This is important in case there's
+  // conflicting configs between, for example, the org and service level.
+  rc.setBatchHandler(['APM_TRACING'], (transaction) => {
+    const { toUnapply, toApply, toModify } = transaction
+
+    for (const item of toUnapply) {
+      rcClientLibConfigManager.removeConfig(item.id)
+      transaction.ack(item.path)
+    }
+
+    for (const item of [...toApply, ...toModify]) {
+      rcClientLibConfigManager.addConfig(item.id, item.file)
+      transaction.ack(item.path)
+    }
+
+    // Get merged config and apply it
+    const mergedLibConfig = rcClientLibConfigManager.getMergedLibConfig()
+    config.setRemoteConfig(mergedLibConfig)
+
+    onConfigUpdated()
+  })
+}