dd-trace 5.40.0 → 5.41.1

package/LICENSE-3rdparty.csv

@@ -37,6 +37,7 @@ dev,@eslint/eslintrc,MIT,Copyright OpenJS Foundation and other contributors, <ww
 dev,@eslint/js,MIT,Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
 dev,@msgpack/msgpack,ISC,Copyright 2019 The MessagePack Community
 dev,@stylistic/eslint-plugin-js,MIT,Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
+dev,application-config-path,MIT,Copyright (c) 2015, 2023 Linus Unnebäck
 dev,autocannon,MIT,Copyright 2016 Matteo Collina
 dev,aws-sdk,Apache 2.0,Copyright 2012-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 dev,axios,MIT,Copyright 2014-present Matt Zabriskie

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.40.0",
+  "version": "5.41.1",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -82,7 +82,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@datadog/libdatadog": "^0.4.0",
+    "@datadog/libdatadog": "^0.5.0",
     "@datadog/native-appsec": "8.4.0",
     "@datadog/native-iast-rewriter": "2.8.0",
     "@datadog/native-iast-taint-tracking": "3.3.0",
@@ -95,7 +95,7 @@
     "crypto-randomuuid": "^1.0.0",
     "dc-polyfill": "^0.1.4",
     "ignore": "^5.2.4",
-    "import-in-the-middle": "1.11.2",
+    "import-in-the-middle": "1.13.1",
     "istanbul-lib-coverage": "3.2.0",
     "jest-docblock": "^29.7.0",
     "koalas": "^1.0.2",
@@ -122,6 +122,7 @@
     "@msgpack/msgpack": "^3.0.0-beta3",
     "@stylistic/eslint-plugin-js": "^3.0.1",
     "@types/node": "^16.0.0",
+    "application-config-path": "^1.0.0",
     "autocannon": "^4.5.2",
     "aws-sdk": "^2.1446.0",
     "axios": "^1.7.4",

package/packages/datadog-instrumentations/src/fetch.js

@@ -17,7 +17,7 @@ if (globalThis.fetch) {
 
     const ch = tracingChannel('apm:fetch:request')
     const wrapFetch = createWrapFetch(globalThis.Request, ch, () => {
-      channel('dd-trace:instrumentation:load').publish({ name: 'fetch' })
+      channel('dd-trace:instrumentation:load').publish({ name: 'global:fetch' })
     })
 
     fetch = wrapFetch(globalFetch)

package/packages/datadog-plugin-graphql/src/parse.js

@@ -10,9 +10,7 @@ class GraphQLParsePlugin extends TracingPlugin {
     this.startSpan('graphql.parse', {
       service: this.config.service,
       type: 'graphql',
-      meta: {
-        'graphql.source': ''
-      }
+      meta: {}
     })
   }
 

package/packages/datadog-plugin-mongodb-core/src/index.js

@@ -25,7 +25,10 @@ class MongodbCorePlugin extends DatabasePlugin {
         'out.port': options.port
       }
     })
-    ops.comment = this.injectDbmComment(span, ops.comment, service)
+    const comment = this.injectDbmComment(span, ops.comment, service)
+    if (comment) {
+      ops.comment = comment
+    }
   }
 
   getPeerService (tags) {

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

@@ -11,7 +11,7 @@ const tagger = require('./tagger')
 const get = require('../../datadog-core/src/utils/src/get')
 const has = require('../../datadog-core/src/utils/src/has')
 const set = require('../../datadog-core/src/utils/src/set')
-const { isTrue, isFalse } = require('./util')
+const { isTrue, isFalse, normalizeProfilingEnabledValue } = require('./util')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
 const { getGitMetadataFromGitProperties, removeUserSensitiveInfo } = require('./git_properties')
 const { updateConfig } = require('./telemetry')
@@ -236,6 +236,12 @@ function reformatSpanSamplingRules (rules) {
 
 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()
+    }
+
     options = {
       ...options,
       appsec: options.appsec != null ? options.appsec : options.experimental?.appsec,
@@ -244,13 +250,24 @@ class Config {
 
     // Configure the logger first so it can be used to warn about other configs
     const logConfig = log.getConfig()
-    this.debug = logConfig.enabled
+    this.debug = log.isEnabled(
+      this.stableConfig?.fleetEntries?.DD_TRACE_DEBUG,
+      this.stableConfig?.localEntries?.DD_TRACE_DEBUG
+    )
     this.logger = coalesce(options.logger, logConfig.logger)
-    this.logLevel = coalesce(options.logLevel, logConfig.logLevel)
-
+    this.logLevel = log.getLogLevel(
+      options.logLevel,
+      this.stableConfig?.fleetEntries?.DD_TRACE_LOG_LEVEL,
+      this.stableConfig?.localEntries?.DD_TRACE_LOG_LEVEL
+    )
     log.use(this.logger)
     log.toggle(this.debug, this.logLevel)
 
+    // Process stable config warnings, if any
+    for (const warning of this.stableConfig?.warnings ?? []) {
+      log.warn(warning)
+    }
+
     checkIfBothOtelAndDdEnvVarSet()
 
     const DD_API_KEY = coalesce(
@@ -337,7 +354,9 @@ class Config {
     }
 
     this._applyDefaults()
+    this._applyLocalStableConfig()
     this._applyEnvironment()
+    this._applyFleetStableConfig()
     this._applyOptions(options)
     this._applyCalculated()
     this._applyRemote({})
@@ -576,6 +595,45 @@ class Config {
     this._setValue(defaults, 'trace.dynamoDb.tablePrimaryKeys', undefined)
   }
 
+  _applyLocalStableConfig () {
+    const obj = setHiddenProperty(this, '_localStableConfig', {})
+    this._applyStableConfig(this.stableConfig?.localEntries ?? {}, obj)
+  }
+
+  _applyFleetStableConfig () {
+    const obj = setHiddenProperty(this, '_fleetStableConfig', {})
+    this._applyStableConfig(this.stableConfig?.fleetEntries ?? {}, obj)
+  }
+
+  _applyStableConfig (config, obj) {
+    const {
+      DD_APPSEC_ENABLED,
+      DD_APPSEC_SCA_ENABLED,
+      DD_DATA_STREAMS_ENABLED,
+      DD_DYNAMIC_INSTRUMENTATION_ENABLED,
+      DD_ENV,
+      DD_IAST_ENABLED,
+      DD_LOGS_INJECTION,
+      DD_PROFILING_ENABLED,
+      DD_RUNTIME_METRICS_ENABLED,
+      DD_SERVICE,
+      DD_VERSION
+    } = config
+
+    this._setBoolean(obj, 'appsec.enabled', DD_APPSEC_ENABLED)
+    this._setBoolean(obj, 'appsec.sca.enabled', DD_APPSEC_SCA_ENABLED)
+    this._setBoolean(obj, 'dsmEnabled', DD_DATA_STREAMS_ENABLED)
+    this._setBoolean(obj, 'dynamicInstrumentation.enabled', DD_DYNAMIC_INSTRUMENTATION_ENABLED)
+    this._setString(obj, 'env', DD_ENV)
+    this._setBoolean(obj, 'iast.enabled', DD_IAST_ENABLED)
+    this._setBoolean(obj, 'logInjection', DD_LOGS_INJECTION)
+    const profilingEnabled = normalizeProfilingEnabledValue(DD_PROFILING_ENABLED)
+    this._setString(obj, 'profiling.enabled', profilingEnabled)
+    this._setBoolean(obj, 'runtimeMetrics', DD_RUNTIME_METRICS_ENABLED)
+    this._setString(obj, 'service', DD_SERVICE)
+    this._setString(obj, 'version', DD_VERSION)
+  }
+
   _applyEnvironment () {
     const {
       AWS_LAMBDA_FUNCTION_NAME,
@@ -715,8 +773,8 @@ class Config {
     const env = setHiddenProperty(this, '_env', {})
     setHiddenProperty(this, '_envUnprocessed', {})
 
-    tagger.add(tags, OTEL_RESOURCE_ATTRIBUTES, true)
-    tagger.add(tags, DD_TAGS)
+    tagger.add(tags, parseSpaceSeparatedTags(handleOtel(OTEL_RESOURCE_ATTRIBUTES)))
+    tagger.add(tags, parseSpaceSeparatedTags(DD_TAGS))
     tagger.add(tags, DD_TRACE_TAGS)
     tagger.add(tags, DD_TRACE_GLOBAL_TAGS)
 
@@ -831,16 +889,13 @@ class Config {
       this._envUnprocessed.peerServiceMapping = DD_TRACE_PEER_SERVICE_MAPPING
     }
     this._setString(env, 'port', DD_TRACE_AGENT_PORT)
-    const profilingEnabledEnv = coalesce(
-      DD_EXPERIMENTAL_PROFILING_ENABLED,
-      DD_PROFILING_ENABLED,
-      this._isInServerlessEnvironment() ? 'false' : undefined
+    const profilingEnabled = normalizeProfilingEnabledValue(
+      coalesce(
+        DD_EXPERIMENTAL_PROFILING_ENABLED,
+        DD_PROFILING_ENABLED,
+        this._isInServerlessEnvironment() ? 'false' : undefined
+      )
     )
-    const profilingEnabled = isTrue(profilingEnabledEnv)
-      ? 'true'
-      : isFalse(profilingEnabledEnv)
-        ? 'false'
-        : profilingEnabledEnv === 'auto' ? 'auto' : undefined
     this._setString(env, 'profiling.enabled', profilingEnabled)
     this._setString(env, 'profiling.exporters', DD_PROFILING_EXPORTERS)
     this._setBoolean(env, 'profiling.sourceMap', DD_PROFILING_SOURCE_MAP && !isFalse(DD_PROFILING_SOURCE_MAP))
@@ -1347,9 +1402,33 @@ class Config {
   // eslint-disable-next-line @stylistic/js/max-len
   // https://github.com/DataDog/dd-go/blob/prod/trace/apps/tracer-telemetry-intake/telemetry-payload/static/config_norm_rules.json
   _merge () {
-    const containers = [this._remote, this._options, this._env, this._calculated, this._defaults]
-    const origins = ['remote_config', 'code', 'env_var', 'calculated', 'default']
-    const unprocessedValues = [this._remoteUnprocessed, this._optsUnprocessed, this._envUnprocessed, {}, {}]
+    const containers = [
+      this._remote,
+      this._options,
+      this._fleetStableConfig,
+      this._env,
+      this._localStableConfig,
+      this._calculated,
+      this._defaults
+    ]
+    const origins = [
+      'remote_config',
+      'code',
+      'fleet_stable_config',
+      'env_var',
+      'local_stable_config',
+      'calculated',
+      'default'
+    ]
+    const unprocessedValues = [
+      this._remoteUnprocessed,
+      this._optsUnprocessed,
+      {},
+      this._envUnprocessed,
+      {},
+      {},
+      {}
+    ]
     const changes = []
 
     for (const name in this._defaults) {
@@ -1394,6 +1473,21 @@ class Config {
   }
 }
 
+function handleOtel (tagString) {
+  return tagString
+    ?.replace(/(^|,)deployment\.environment=/, '$1env:')
+    .replace(/(^|,)service\.name=/, '$1service:')
+    .replace(/(^|,)service\.version=/, '$1version:')
+    .replace(/=/g, ':')
+}
+
+function parseSpaceSeparatedTags (tagString) {
+  if (tagString && !tagString.includes(',')) {
+    tagString = tagString.replace(/\s+/g, ',')
+  }
+  return tagString
+}
+
 function maybeInt (number) {
   const parsed = parseInt(number)
   return isNaN(parsed) ? undefined : parsed

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

@@ -0,0 +1,100 @@
+const os = require('os')
+const fs = require('fs')
+
+class StableConfig {
+  constructor () {
+    this.warnings = [] // Logger hasn't been initialized yet, so we can't use log.warn
+    this.localEntries = {}
+    this.fleetEntries = {}
+    this.wasm_loaded = false
+
+    const { localConfigPath, fleetConfigPath } = this._getStableConfigPaths()
+    if (!fs.existsSync(localConfigPath) && !fs.existsSync(fleetConfigPath)) {
+      // Bail out early if files don't exist to avoid unnecessary library loading
+      return
+    }
+
+    const localConfig = this._readConfigFromPath(localConfigPath)
+    const fleetConfig = this._readConfigFromPath(fleetConfigPath)
+    if (!localConfig && !fleetConfig) {
+      // Bail out early if files are empty or we can't read them to avoid unnecessary library loading
+      return
+    }
+
+    // Note: we don't enforce loading because there may be cases where the library is not available and we
+    // want to avoid breaking the application. In those cases, we will not have the file-based configuration.
+    let libdatadog
+    try {
+      libdatadog = require('@datadog/libdatadog')
+      this.wasm_loaded = true
+    } catch (e) {
+      this.warnings.push('Can\'t load libdatadog library')
+      return
+    }
+
+    const libconfig = libdatadog.maybeLoad('library_config')
+    if (libconfig === undefined) {
+      this.warnings.push('Can\'t load library_config library')
+      return
+    }
+
+    try {
+      const configurator = new libconfig.JsConfigurator()
+      configurator.set_envp(Object.entries(process.env).map(([key, value]) => `${key}=${value}`))
+      configurator.set_args(process.argv)
+      configurator.get_configuration(localConfig.toString(), fleetConfig.toString()).forEach((entry) => {
+        if (entry.source === 'local_stable_config') {
+          this.localEntries[entry.name] = entry.value
+        } else if (entry.source === 'fleet_stable_config') {
+          this.fleetEntries[entry.name] = entry.value
+        }
+      })
+    } catch (e) {
+      this.warnings.push(`Error parsing configuration from file: ${e.message}`)
+    }
+  }
+
+  _readConfigFromPath (path) {
+    try {
+      return fs.readFileSync(path, 'utf8')
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        this.warnings.push(`Error reading config file at ${path}. ${err.code}: ${err.message}`)
+      }
+      return '' // Always return a string to avoid undefined.toString() errors
+    }
+  }
+
+  _getStableConfigPaths () {
+    let localConfigPath = ''
+    let fleetConfigPath = ''
+    switch (os.type().toLowerCase()) {
+      case 'linux':
+        localConfigPath = '/etc/datadog-agent/application_monitoring.yaml'
+        fleetConfigPath = '/etc/datadog-agent/managed/datadog-agent/stable/application_monitoring.yaml'
+        break
+      case 'darwin':
+        localConfigPath = '/opt/datadog-agent/etc/application_monitoring.yaml'
+        fleetConfigPath = '/opt/datadog-agent/etc/managed/datadog-agent/stable/application_monitoring.yaml'
+        break
+      case 'win32':
+        localConfigPath = 'C:\\ProgramData\\Datadog\\application_monitoring.yaml'
+        fleetConfigPath = 'C:\\ProgramData\\Datadog\\managed\\datadog-agent\\stable\\application_monitoring.yaml'
+        break
+      default:
+        break
+    }
+
+    // Allow overriding the paths for testing
+    if (process.env.DD_TEST_LOCAL_CONFIG_PATH !== undefined) {
+      localConfigPath = process.env.DD_TEST_LOCAL_CONFIG_PATH
+    }
+    if (process.env.DD_TEST_FLEET_CONFIG_PATH !== undefined) {
+      fleetConfigPath = process.env.DD_TEST_FLEET_CONFIG_PATH
+    }
+
+    return { localConfigPath, fleetConfigPath }
+  }
+}
+
+module.exports = StableConfig

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

@@ -6,6 +6,7 @@ const dgram = require('dgram')
 const isIP = require('net').isIP
 const log = require('./log')
 const { URL, format } = require('url')
+const Histogram = require('./histogram')
 
 const MAX_BUFFER_SIZE = 1024 // limit from the agent
 
@@ -193,6 +194,117 @@ class DogStatsDClient {
   }
 }
 
+// TODO: Handle arrays of tags and tags translation.
+class MetricsAggregationClient {
+  constructor (client) {
+    this._client = client
+
+    this.reset()
+  }
+
+  flush () {
+    this._captureCounters()
+    this._captureGauges()
+    this._captureHistograms()
+
+    this._client.flush()
+  }
+
+  reset () {
+    this._counters = {}
+    this._gauges = {}
+    this._histograms = {}
+  }
+
+  distribution (name, value, tag) {
+    this._client.distribution(name, value, tag && [tag])
+  }
+
+  boolean (name, value, tag) {
+    this.gauge(name, value ? 1 : 0, tag)
+  }
+
+  histogram (name, value, tag) {
+    this._histograms[name] = this._histograms[name] || new Map()
+
+    if (!this._histograms[name].has(tag)) {
+      this._histograms[name].set(tag, new Histogram())
+    }
+
+    this._histograms[name].get(tag).record(value)
+  }
+
+  count (name, count, tag, monotonic = false) {
+    if (typeof tag === 'boolean') {
+      monotonic = tag
+      tag = undefined
+    }
+
+    const map = monotonic ? this._counters : this._gauges
+
+    map[name] = map[name] || new Map()
+
+    const value = map[name].get(tag) || 0
+
+    map[name].set(tag, value + count)
+  }
+
+  gauge (name, value, tag) {
+    this._gauges[name] = this._gauges[name] || new Map()
+    this._gauges[name].set(tag, value)
+  }
+
+  increment (name, count = 1, tag, monotonic) {
+    this.count(name, count, tag, monotonic)
+  }
+
+  decrement (name, count = 1, tag) {
+    this.count(name, -count, tag)
+  }
+
+  _captureGauges () {
+    Object.keys(this._gauges).forEach(name => {
+      this._gauges[name].forEach((value, tag) => {
+        this._client.gauge(name, value, tag && [tag])
+      })
+    })
+  }
+
+  _captureCounters () {
+    Object.keys(this._counters).forEach(name => {
+      this._counters[name].forEach((value, tag) => {
+        this._client.increment(name, value, tag && [tag])
+      })
+    })
+
+    this._counters = {}
+  }
+
+  _captureHistograms () {
+    Object.keys(this._histograms).forEach(name => {
+      this._histograms[name].forEach((stats, tag) => {
+        const tags = tag && [tag]
+
+        // Stats can contain garbage data when a value was never recorded.
+        if (stats.count === 0) {
+          stats = { max: 0, min: 0, sum: 0, avg: 0, median: 0, p95: 0, count: 0, reset: stats.reset }
+        }
+
+        this._client.gauge(`${name}.min`, stats.min, tags)
+        this._client.gauge(`${name}.max`, stats.max, tags)
+        this._client.increment(`${name}.sum`, stats.sum, tags)
+        this._client.increment(`${name}.total`, stats.sum, tags)
+        this._client.gauge(`${name}.avg`, stats.avg, tags)
+        this._client.increment(`${name}.count`, stats.count, tags)
+        this._client.gauge(`${name}.median`, stats.median, tags)
+        this._client.gauge(`${name}.95percentile`, stats.p95, tags)
+
+        stats.reset()
+      })
+    })
+  }
+}
+
 /**
  * This is a simplified user-facing proxy to the underlying DogStatsDClient instance
  *
@@ -201,7 +313,7 @@ class DogStatsDClient {
 class CustomMetrics {
   constructor (config) {
     const clientConfig = DogStatsDClient.generateClientConfig(config)
-    this.dogstatsd = new DogStatsDClient(clientConfig)
+    this._client = new MetricsAggregationClient(new DogStatsDClient(clientConfig))
 
     const flush = this.flush.bind(this)
 
@@ -212,47 +324,43 @@ class CustomMetrics {
   }
 
   increment (stat, value = 1, tags) {
-    return this.dogstatsd.increment(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.increment(stat, value, tag)
+    }
   }
 
   decrement (stat, value = 1, tags) {
-    return this.dogstatsd.decrement(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.decrement(stat, value, tag)
+    }
   }
 
   gauge (stat, value, tags) {
-    return this.dogstatsd.gauge(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.gauge(stat, value, tag)
+    }
   }
 
   distribution (stat, value, tags) {
-    return this.dogstatsd.distribution(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.distribution(stat, value, tag)
+    }
   }
 
   histogram (stat, value, tags) {
-    return this.dogstatsd.histogram(
-      stat,
-      value,
-      CustomMetrics.tagTranslator(tags)
-    )
+    for (const tag of this._normalizeTags(tags)) {
+      this._client.histogram(stat, value, tag)
+    }
   }
 
   flush () {
-    return this.dogstatsd.flush()
+    return this._client.flush()
+  }
+
+  _normalizeTags (tags) {
+    tags = CustomMetrics.tagTranslator(tags)
+
+    return tags.length === 0 ? [undefined] : tags
   }
 
   /**
@@ -274,5 +382,6 @@ class CustomMetrics {
 
 module.exports = {
   DogStatsDClient,
-  CustomMetrics
+  CustomMetrics,
+  MetricsAggregationClient
 }

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

@@ -212,7 +212,6 @@ function extractError (trace, error) {
 function addTag (meta, metrics, key, value, nested) {
   switch (typeof value) {
     case 'string':
-      if (!value) break
       meta[key] = value
       break
     case 'number':

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

@@ -2,6 +2,7 @@
 
 const log = require('../../log')
 const { storage: llmobsStorage } = require('../storage')
+const telemetry = require('../telemetry')
 
 const TracingPlugin = require('../../plugins/tracing')
 const LLMObsTagger = require('../tagger')
@@ -36,6 +37,8 @@ class LLMObsPlugin extends TracingPlugin {
     // register options may not be set for operations we do not trace with llmobs
     // ie OpenAI fine tuning jobs, file jobs, etc.
     if (registerOptions) {
+      telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: this.constructor.id })
+
       ctx.llmobs = {} // initialize context-based namespace
       llmobsStorage.enterWith({ span })
       ctx.llmobs.parent = parent

package/packages/dd-trace/src/llmobs/plugins/bedrockruntime.js

@@ -1,6 +1,7 @@
 const BaseLLMObsPlugin = require('./base')
 const { storage } = require('../../../../datadog-core')
 const llmobsStore = storage('llmobs')
+const telemetry = require('../telemetry')
 
 const {
   extractRequestParams,
@@ -46,6 +47,8 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
   }
 
   setLLMObsTags ({ request, span, response, modelProvider, modelName }) {
+    telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: 'bedrock' })
+
     const parent = llmobsStore.getStore()?.span
     this._tagger.registerLLMObsSpan(span, {
       parent,

package/packages/dd-trace/src/llmobs/plugins/langchain/index.js

@@ -21,6 +21,7 @@ const LlmHandler = require('./handlers/llm')
 const EmbeddingHandler = require('./handlers/embedding')
 
 class LangChainLLMObsPlugin extends LLMObsPlugin {
+  static get id () { return 'langchain' }
   static get prefix () {
     return 'tracing:apm:langchain:invoke'
   }

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

@@ -3,6 +3,7 @@
 const LLMObsPlugin = require('./base')
 
 class OpenAiLLMObsPlugin extends LLMObsPlugin {
+  static get id () { return 'openai' }
   static get prefix () {
     return 'tracing:apm:openai:request'
   }

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

@@ -14,6 +14,7 @@ const Span = require('../opentracing/span')
 
 const tracerVersion = require('../../../../package.json').version
 const logger = require('../log')
+const telemetry = require('./telemetry')
 
 const LLMObsTagger = require('./tagger')
 
@@ -88,6 +89,8 @@ class LLMObs extends NoopLLMObs {
 
     const kind = validateKind(options.kind) // will throw if kind is undefined or not an expected kind
 
+    telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: false, kind })
+
     // name is required for spans generated with `trace`
     // while `kind` is required, this should never throw (as otherwise it would have thrown above)
     const name = options.name || kind
@@ -133,6 +136,8 @@ class LLMObs extends NoopLLMObs {
     const llmobs = this
 
     function wrapped () {
+      telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: false, kind })
+
       const span = llmobs._tracer.scope().active()
       const fnArgs = arguments
 

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

@@ -0,0 +1,12 @@
+'use strict'
+
+const telemetryMetrics = require('../telemetry/metrics')
+const llmobsMetrics = telemetryMetrics.manager.namespace('mlobs')
+
+function incrementLLMObsSpanStartCount (tags, value = 1) {
+  llmobsMetrics.count('span.start', tags).inc(value)
+}
+
+module.exports = {
+  incrementLLMObsSpanStartCount
+}

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

@@ -105,23 +105,36 @@ const log = {
 
   deprecate (code, message) {
     return this._deprecate(code, message)
+  },
+
+  isEnabled (fleetStableConfigValue = undefined, localStableConfigValue = undefined) {
+    return isTrue(coalesce(
+      fleetStableConfigValue,
+      process.env?.DD_TRACE_DEBUG,
+      process.env?.OTEL_LOG_LEVEL === 'debug' || undefined,
+      localStableConfigValue,
+      config.enabled
+    ))
+  },
+
+  getLogLevel (
+    optionsValue = undefined,
+    fleetStableConfigValue = undefined,
+    localStableConfigValue = undefined
+  ) {
+    return coalesce(
+      optionsValue,
+      fleetStableConfigValue,
+      process.env?.DD_TRACE_LOG_LEVEL,
+      process.env?.OTEL_LOG_LEVEL,
+      localStableConfigValue,
+      config.logLevel
+    )
   }
 }
 
 log.reset()
 
-const enabled = isTrue(coalesce(
-  process.env.DD_TRACE_DEBUG,
-  process.env.OTEL_LOG_LEVEL === 'debug',
-  config.enabled
-))
-
-const logLevel = coalesce(
-  process.env.DD_TRACE_LOG_LEVEL,
-  process.env.OTEL_LOG_LEVEL,
-  config.logLevel
-)
-
-log.toggle(enabled, logLevel)
+log.toggle(log.isEnabled(), log.getLogLevel())
 
 module.exports = log

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

@@ -103,10 +103,6 @@ module.exports = class PluginManager {
     this._tracerConfig = config
     this._tracer._nomenclature.configure(config)
 
-    if (!config._isInServerlessEnvironment?.()) {
-      maybeEnable(require('../../datadog-plugin-fetch/src'))
-    }
-
     for (const name in pluginClasses) {
       this.loadPlugin(name)
     }

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

@@ -39,6 +39,7 @@ module.exports = {
   get express () { return require('../../../datadog-plugin-express/src') },
   get fastify () { return require('../../../datadog-plugin-fastify/src') },
   get 'find-my-way' () { return require('../../../datadog-plugin-find-my-way/src') },
+  get 'global:fetch' () { return require('../../../datadog-plugin-fetch/src') },
   get graphql () { return require('../../../datadog-plugin-graphql/src') },
   get grpc () { return require('../../../datadog-plugin-grpc/src') },
   get hapi () { return require('../../../datadog-plugin-hapi/src') },

package/packages/dd-trace/src/plugins/util/git.js

@@ -328,22 +328,34 @@ function getGitMetadata (ciMetadata) {
     committerDate
   ] = sanitizedExec('git', ['show', '-s', '--format=%an,%ae,%aI,%cn,%ce,%cI']).split(',')
 
-  return {
-    [GIT_REPOSITORY_URL]:
-      filterSensitiveInfoFromRepository(repositoryUrl || sanitizedExec('git', ['ls-remote', '--get-url'])),
+  const tags = {
     [GIT_COMMIT_MESSAGE]:
       commitMessage || sanitizedExec('git', ['show', '-s', '--format=%s']),
-    [GIT_COMMIT_AUTHOR_DATE]: authorDate,
-    [GIT_COMMIT_AUTHOR_NAME]: ciAuthorName || authorName,
-    [GIT_COMMIT_AUTHOR_EMAIL]: ciAuthorEmail || authorEmail,
-    [GIT_COMMIT_COMMITTER_DATE]: committerDate,
-    [GIT_COMMIT_COMMITTER_NAME]: committerName,
-    [GIT_COMMIT_COMMITTER_EMAIL]: committerEmail,
     [GIT_BRANCH]: branch || sanitizedExec('git', ['rev-parse', '--abbrev-ref', 'HEAD']),
     [GIT_COMMIT_SHA]: commitSHA || sanitizedExec('git', ['rev-parse', 'HEAD']),
-    [GIT_TAG]: tag,
     [CI_WORKSPACE_PATH]: ciWorkspacePath || sanitizedExec('git', ['rev-parse', '--show-toplevel'])
   }
+
+  const entries = [
+    GIT_REPOSITORY_URL,
+    filterSensitiveInfoFromRepository(repositoryUrl || sanitizedExec('git', ['ls-remote', '--get-url'])),
+    GIT_COMMIT_AUTHOR_DATE, authorDate,
+    GIT_COMMIT_AUTHOR_NAME, ciAuthorName || authorName,
+    GIT_COMMIT_AUTHOR_EMAIL, ciAuthorEmail || authorEmail,
+    GIT_COMMIT_COMMITTER_DATE, committerDate,
+    GIT_COMMIT_COMMITTER_NAME, committerName,
+    GIT_COMMIT_COMMITTER_EMAIL, committerEmail,
+    GIT_TAG, tag
+  ]
+
+  for (let i = 0; i < entries.length; i += 2) {
+    const value = entries[i + 1]
+    if (value) {
+      tags[entries[i]] = value
+    }
+  }
+
+  return tags
 }
 
 module.exports = {

package/packages/dd-trace/src/plugins/util/web.js

@@ -475,8 +475,9 @@ function addRequestTags (context, spanType) {
 function addResponseTags (context) {
   const { req, res, paths, span, inferredProxySpan } = context
 
-  if (paths.length > 0) {
-    span.setTag(HTTP_ROUTE, paths.join(''))
+  const route = paths.join('')
+  if (route) {
+    span.setTag(HTTP_ROUTE, route)
   }
 
   span.addTags({

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

@@ -4,7 +4,7 @@
 
 const v8 = require('v8')
 const os = require('os')
-const { DogStatsDClient } = require('../dogstatsd')
+const { DogStatsDClient, MetricsAggregationClient } = require('../dogstatsd')
 const log = require('../log')
 const Histogram = require('../histogram')
 const { performance, PerformanceObserver } = require('perf_hooks')
@@ -25,9 +25,6 @@ let interval
 let client
 let time
 let cpuUsage
-let gauges
-let counters
-let histograms
 let elu
 
 reset()
@@ -49,7 +46,7 @@ const runtimeMetrics = module.exports = {
       nativeMetrics = null
     }
 
-    client = new DogStatsDClient(clientConfig)
+    client = new MetricsAggregationClient(new DogStatsDClient(clientConfig))
 
     time = process.hrtime()
 
@@ -98,50 +95,27 @@ const runtimeMetrics = module.exports = {
   },
 
   boolean (name, value, tag) {
-    this.gauge(name, value ? 1 : 0, tag)
+    client && client.boolean(name, value, tag)
   },
 
   histogram (name, value, tag) {
-    if (!client) return
-
-    histograms[name] = histograms[name] || new Map()
-
-    if (!histograms[name].has(tag)) {
-      histograms[name].set(tag, new Histogram())
-    }
-
-    histograms[name].get(tag).record(value)
+    client && client.histogram(name, value, tag)
   },
 
   count (name, count, tag, monotonic = false) {
-    if (!client) return
-    if (typeof tag === 'boolean') {
-      monotonic = tag
-      tag = undefined
-    }
-
-    const map = monotonic ? counters : gauges
-
-    map[name] = map[name] || new Map()
-
-    const value = map[name].get(tag) || 0
-
-    map[name].set(tag, value + count)
+    client && client.count(name, count, tag, monotonic)
   },
 
   gauge (name, value, tag) {
-    if (!client) return
-
-    gauges[name] = gauges[name] || new Map()
-    gauges[name].set(tag, value)
+    client && client.gauge(name, value, tag)
   },
 
   increment (name, tag, monotonic) {
-    this.count(name, 1, tag, monotonic)
+    client && client.increment(name, 1, tag, monotonic)
   },
 
   decrement (name, tag) {
-    this.count(name, -1, tag)
+    client && client.decrement(name, 1, tag)
   }
 }
 
@@ -150,9 +124,6 @@ function reset () {
   client = null
   time = null
   cpuUsage = null
-  gauges = {}
-  counters = {}
-  histograms = {}
   nativeMetrics = null
   gcObserver && gcObserver.disconnect()
   gcObserver = null
@@ -246,33 +217,6 @@ function captureGCMetrics () {
   gcProfiler.start()
 }
 
-function captureGauges () {
-  Object.keys(gauges).forEach(name => {
-    gauges[name].forEach((value, tag) => {
-      client.gauge(name, value, tag && [tag])
-    })
-  })
-}
-
-function captureCounters () {
-  Object.keys(counters).forEach(name => {
-    counters[name].forEach((value, tag) => {
-      client.increment(name, value, tag && [tag])
-    })
-  })
-
-  counters = {}
-}
-
-function captureHistograms () {
-  Object.keys(histograms).forEach(name => {
-    histograms[name].forEach((stats, tag) => {
-      histogram(name, stats, tag && [tag])
-      stats.reset()
-    })
-  })
-}
-
 /**
  * Gathers and reports Event Loop Utilization (ELU) since last run
  *
@@ -295,9 +239,6 @@ function captureCommonMetrics () {
   captureMemoryUsage()
   captureProcess()
   captureHeapStats()
-  captureGauges()
-  captureCounters()
-  captureHistograms()
   captureELU()
   captureGCMetrics()
 }
@@ -339,21 +280,15 @@ function captureNativeMetrics () {
 }
 
 function histogram (name, stats, tags) {
-  tags = [].concat(tags)
+  tags = tags ? [].concat(tags) : []
 
-  // Stats can contain garbage data when a value was never recorded.
-  if (stats.count === 0) {
-    stats = { max: 0, min: 0, sum: 0, avg: 0, median: 0, p95: 0, count: 0 }
+  if (tags.length > 0) {
+    for (const tag of tags) {
+      client.histogram(name, stats, tag)
+    }
+  } else {
+    client.histogram(name, stats)
   }
-
-  client.gauge(`${name}.min`, stats.min, tags)
-  client.gauge(`${name}.max`, stats.max, tags)
-  client.increment(`${name}.sum`, stats.sum, tags)
-  client.increment(`${name}.total`, stats.sum, tags)
-  client.gauge(`${name}.avg`, stats.avg, tags)
-  client.increment(`${name}.count`, stats.count, tags)
-  client.gauge(`${name}.median`, stats.median, tags)
-  client.gauge(`${name}.95percentile`, stats.p95, tags)
 }
 
 function startGCObserver () {

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

@@ -6,13 +6,7 @@ const ERROR_MESSAGE = constants.ERROR_MESSAGE
 const ERROR_STACK = constants.ERROR_STACK
 const ERROR_TYPE = constants.ERROR_TYPE
 
-const otelTagMap = {
-  'deployment.environment': 'env',
-  'service.name': 'service',
-  'service.version': 'version'
-}
-
-function add (carrier, keyValuePairs, parseOtelTags = false) {
+function add (carrier, keyValuePairs) {
   if (!carrier || !keyValuePairs) return
 
   if (Array.isArray(keyValuePairs)) {
@@ -22,14 +16,13 @@ function add (carrier, keyValuePairs, parseOtelTags = false) {
     if (typeof keyValuePairs === 'string') {
       const segments = keyValuePairs.split(',')
       for (const segment of segments) {
-        const separatorIndex = parseOtelTags ? segment.indexOf('=') : segment.indexOf(':')
-        if (separatorIndex === -1) continue
-
-        let key = segment.slice(0, separatorIndex)
-        const value = segment.slice(separatorIndex + 1)
+        const separatorIndex = segment.indexOf(':')
 
-        if (parseOtelTags && key in otelTagMap) {
-          key = otelTagMap[key]
+        let value = ''
+        let key = segment
+        if (separatorIndex !== -1) {
+          key = segment.slice(0, separatorIndex)
+          value = segment.slice(separatorIndex + 1)
         }
 
         carrier[key.trim()] = value.trim()

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

@@ -79,11 +79,20 @@ function hasOwn (object, prop) {
   return Object.prototype.hasOwnProperty.call(object, prop)
 }
 
+function normalizeProfilingEnabledValue (configValue) {
+  return isTrue(configValue)
+    ? 'true'
+    : isFalse(configValue)
+      ? 'false'
+      : configValue === 'auto' ? 'auto' : undefined
+}
+
 module.exports = {
   isTrue,
   isFalse,
   isError,
   globMatch,
   calculateDDBasePath,
-  hasOwn
+  hasOwn,
+  normalizeProfilingEnabledValue
 }