dd-trace 6.2.0 → 6.4.0

package/packages/dd-trace/src/ci-visibility/intelligent-test-runner/get-skippable-suites.js

@@ -28,12 +28,16 @@ function parseSkippableSuitesResponse (
   if (validateRequiredFields) {
     validateSkippableTestsResponse(parsedResponse)
   }
-  const coverage = parsedResponse.meta?.coverage || {}
+  const coverage = {}
+  for (const [filename, bitmap] of Object.entries(parsedResponse.meta?.coverage || {})) {
+    coverage[filename.replaceAll('\\', '/')] = bitmap
+  }
 
   const skippableItems = parsedResponse
     .data
     .filter(({ type }) => type === testLevel)
   const skippableSuites = []
+  let numExcludedByMissingLineCoverage = 0
   for (const {
     attributes: {
       suite,
@@ -42,13 +46,58 @@ function parseSkippableSuitesResponse (
     },
   } of skippableItems) {
     // Only reject candidates without backend line coverage when we need that coverage to backfill reports.
-    if (isCoverageReportUploadEnabled && isMissingLineCodeCoverage) continue
+    if (isCoverageReportUploadEnabled && isMissingLineCodeCoverage) {
+      numExcludedByMissingLineCoverage++
+      continue
+    }
 
     skippableSuites.push(testLevel === 'suite' ? suite : { suite, name })
   }
   const correlationId = parsedResponse.meta?.correlation_id
 
-  return { skippableSuites, correlationId, coverage }
+  return {
+    skippableSuites,
+    correlationId,
+    coverage,
+    numReceivedSkippableItems: skippableItems.length,
+    numExcludedByMissingLineCoverage,
+  }
+}
+
+/**
+ * Logs how missing line coverage affected the skippable candidates without logging their contents.
+ *
+ * @param {{
+ *   skippableSuites: Array<string|{suite: string, name: string}>,
+ *   numReceivedSkippableItems?: number,
+ *   numExcludedByMissingLineCoverage?: number
+ * }} result - Parsed skippable response.
+ * @param {'suite'|'test'} testLevel - Test optimization skipping level.
+ * @returns {void}
+ */
+function logSkippableSuitesResponse (result, testLevel) {
+  if (result.numReceivedSkippableItems === undefined) {
+    log.debug('Number of received skippable %ss: %d', testLevel, result.skippableSuites.length)
+    return
+  }
+
+  log.debug(
+    'Received %d skippable %s candidates; excluded %d because line coverage is missing; %d remain.',
+    result.numReceivedSkippableItems,
+    testLevel,
+    result.numExcludedByMissingLineCoverage,
+    result.skippableSuites.length
+  )
+  if (
+    result.numReceivedSkippableItems > 0 &&
+    result.numExcludedByMissingLineCoverage === result.numReceivedSkippableItems
+  ) {
+    log.warn(
+      'All %d skippable %s candidates were excluded: coverage upload is enabled but line coverage is missing.',
+      result.numReceivedSkippableItems,
+      testLevel
+    )
+  }
 }
 
 function getSkippableSuites ({
@@ -96,6 +145,7 @@ function getSkippableSuites ({
     }, cb)
   }, (err, data) => {
     if (err) return done(err)
+    logSkippableSuitesResponse(data, testLevel)
     done(null, data.skippableSuites, data.correlationId, data.coverage)
   })
 }
@@ -203,6 +253,7 @@ function fetchFromApi ({
         const result = parseSkippableSuitesResponse(parsedResponse, {
           testLevel,
           isCoverageReportUploadEnabled,
+          validateRequiredFields: true,
         })
         const skippableItems = parsedResponse.data.filter(({ type }) => type === testLevel)
         incrementCountMetric(
@@ -213,7 +264,6 @@ function fetchFromApi ({
           skippableItems.length
         )
         distributionMetric(TELEMETRY_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES, {}, res.length)
-        log.debug('Number of received skippable %ss:', testLevel, result.skippableSuites.length)
 
         writeToCache(cacheKey, result)
 
@@ -225,4 +275,4 @@ function fetchFromApi ({
   })
 }
 
-module.exports = { getSkippableSuites, parseSkippableSuitesResponse }
+module.exports = { getSkippableSuites, logSkippableSuitesResponse, parseSkippableSuitesResponse }

package/packages/dd-trace/src/ci-visibility/requests/get-library-configuration.js

@@ -49,7 +49,7 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
     requireGit,
     isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
     earlyFlakeDetectionNumRetries:
-      earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] || DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
+      earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] ?? DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
     earlyFlakeDetectionSlowTestRetries:
       earlyFlakeDetectionConfig?.slow_test_retries ?? DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
     earlyFlakeDetectionFaultyThreshold:
@@ -74,6 +74,13 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
     settings.isSuitesSkippingEnabled = true
     log.debug('Dangerously set test skipping to true')
   }
+  if (
+    settings.isCoverageReportUploadEnabled &&
+    !config.testOptimization.DD_CIVISIBILITY_CODE_COVERAGE_REPORT_UPLOAD_ENABLED
+  ) {
+    settings.isCoverageReportUploadEnabled = false
+    log.debug('Code coverage report upload was disabled by the environment variable')
+  }
 
   return settings
 }

package/packages/dd-trace/src/ci-visibility/test-optimization-http-cache.js

@@ -6,7 +6,10 @@ const path = require('node:path')
 const log = require('../log')
 const { getNumFromKnownTests } = require('../plugins/util/test')
 const { parseKnownTestsResponse } = require('./early-flake-detection/get-known-tests')
-const { parseSkippableSuitesResponse } = require('./intelligent-test-runner/get-skippable-suites')
+const {
+  logSkippableSuitesResponse,
+  parseSkippableSuitesResponse,
+} = require('./intelligent-test-runner/get-skippable-suites')
 const { parseLibraryConfigurationResponse } = require('./requests/get-library-configuration')
 const {
   getNumFromTestManagementTests,
@@ -112,6 +115,7 @@ class TestOptimizationHttpCache {
       const parsedResponse = JSON.parse(payload)
       const result = parseSkippableSuitesResponse(parsedResponse, { ...options, validateRequiredFields: true })
       const testLevel = options.testLevel || 'suite'
+      logSkippableSuitesResponse(result, testLevel)
       const skippableItems = parsedResponse.data.filter(({ type }) => type === testLevel)
       incrementCountMetric(
         testLevel === 'test'

package/packages/dd-trace/src/config/config-types.d.ts

@@ -70,3 +70,11 @@ export type ConfigKey = KnownStringKeys<ConfigProperties>
 export type ConfigPath = ConfigPathFor<ConfigProperties>
 export type ConfigPathValue<TPath extends ConfigPath> = ConfigPathValueFor<ConfigProperties, TPath>
 export type ConfigDefaults = Partial<{ [TPath in ConfigPath]: ConfigPathValue<TPath> }>
+export type ConfigurationOption = {
+  property?: string
+  parser?: (value: unknown, optionName: string, source: string) => unknown
+  type: string
+  canonicalName?: string
+  transformer?: (value: unknown, optionName: string, source: string) => unknown
+  telemetryTransformer?: (value: unknown) => unknown
+}

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

@@ -1,9 +1,16 @@
 'use strict'
 
+const assert = require('node:assert')
 const util = require('util')
 
 const { DD_MAJOR } = require('../../../../version')
-const { parsers, transformers, telemetryTransformers, setWarnInvalidValue } = require('./parsers')
+const {
+  parsers,
+  programmaticTypeCoercions,
+  transformers,
+  telemetryTransformers,
+  setWarnInvalidValue,
+} = require('./parsers')
 const applyMajorOverrides = require('./major-overrides')
 const {
   supportedConfigurations,
@@ -70,6 +77,7 @@ for (const [name, value] of Object.entries(defaults)) {
 function generateTelemetry (value = null, origin, optionName) {
   const tableEntry = configurationsTable[optionName]
   const { type, canonicalName = optionName } = tableEntry ?? { type: typeof value }
+  const error = parseErrors.get(`${canonicalName}${origin}`)
   // Sensitive configurations are excluded from configuration telemetry: their
   // entry is never added to `configWithOrigin`, the single source for every
   // telemetry path (app-started and app-client-configuration-change).
@@ -81,7 +89,9 @@ function generateTelemetry (value = null, origin, optionName) {
   // TODO: Validate that space separated tags are parsed by the backend. Optimizations would be possible with that.
   // TODO: How to handle telemetry reporting for aliases?
   if (value !== null) {
-    if (telemetryTransformers[type]) {
+    if (error && typeof value === 'object') {
+      value = util.inspect(value, { customInspect: false, getters: false })
+    } else if (telemetryTransformers[type]) {
       value = telemetryTransformers[type](value)
     } else if (typeof value === 'object' && value !== null) {
       // Custom optionsTable entries (no `configurationsTable` row, e.g. `logger`)
@@ -100,7 +110,6 @@ function generateTelemetry (value = null, origin, optionName) {
     origin,
     seq_id: seqId++,
   }
-  const error = parseErrors.get(`${canonicalName}${origin}`)
   if (error) {
     parseErrors.delete(`${canonicalName}${origin}`)
     telemetryEntry.error = error
@@ -135,12 +144,8 @@ function generateTelemetry (value = null, origin, optionName) {
 const optionsTable = {
   // Additional properties that are not supported by the supported-configurations.json file.
   lookup: {
-    transformer (value) {
-      if (typeof value === 'function') {
-        return value
-      }
-    },
     property: 'lookup',
+    type: 'FUNCTION',
   },
   logger: {
     transformer (object) {
@@ -165,12 +170,15 @@ const optionsTable = {
       }
     },
     property: 'logger',
+    type: 'MAP',
   },
   isCiVisibility: {
     property: 'isCiVisibility',
+    type: 'BOOLEAN',
   },
   plugins: {
     property: 'plugins',
+    type: 'BOOLEAN',
   },
 }
 
@@ -185,13 +193,7 @@ const parser = (value, optionName, source) => {
 
 /**
  * @template {import('./config-types').ConfigPath} TPath
- * @type {Partial<Record<TPath, {
- *   property?: string,
- *   parser: (value: unknown, optionName: string, source: string) => unknown,
- *   canonicalName?: string,
- *   transformer?: (value: unknown, optionName: string, source: string) => unknown,
- *   telemetryTransformer?: (value: unknown) => unknown
- * }>>} ConfigurationsTable
+ * @type {Partial<Record<TPath, import('./config-types').ConfigurationOption>>} ConfigurationsTable
  */
 const configurationsTable = {}
 
@@ -231,6 +233,7 @@ for (const [canonicalName, entries] of Object.entries(supportedConfigurations))
       ? `${entry.namespace}.${canonicalName}`
       : (entry.internalPropertyName ?? entry.configurationNames?.[0] ?? canonicalName)
     const type = entry.type.toUpperCase()
+    assert.ok(programmaticTypeCoercions[type])
 
     let transformer = transformers[entry.transform]
     if (entry.allowed) {
@@ -353,6 +356,8 @@ module.exports = {
   parseErrors,
 
   generateTelemetry,
+
+  warnInvalidValue,
 }
 
 // `dns` is instrumented, so requiring it pulls in the dns plugin, which loads

package/packages/dd-trace/src/config/generated-config-types.d.ts

@@ -546,6 +546,7 @@ export interface GeneratedConfig {
     DD_CIVISIBILITY_AGENTLESS_ENABLED: boolean;
     DD_CIVISIBILITY_AGENTLESS_URL: URL | undefined;
     DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER: string | undefined;
+    DD_CIVISIBILITY_CODE_COVERAGE_REPORT_UPLOAD_ENABLED: boolean;
     DD_CIVISIBILITY_DANGEROUSLY_FORCE_COVERAGE: boolean;
     DD_CIVISIBILITY_DANGEROUSLY_FORCE_TEST_SKIPPING: boolean;
     DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED: boolean;
@@ -561,6 +562,7 @@ export interface GeneratedConfig {
     DD_CIVISIBILITY_TEST_COMMAND: string | undefined;
     DD_CIVISIBILITY_TEST_MODULE_ID: string | undefined;
     DD_CIVISIBILITY_TEST_SESSION_ID: string | undefined;
+    DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT: number | undefined;
     DD_TEST_FAILED_TEST_REPLAY_ENABLED: boolean;
     DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean | undefined;
     DD_TEST_FLEET_CONFIG_PATH: string | undefined;
@@ -636,6 +638,7 @@ export interface GeneratedEnvVarConfig {
   DD_CIVISIBILITY_AGENTLESS_ENABLED: boolean;
   DD_CIVISIBILITY_AGENTLESS_URL: URL | undefined;
   DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER: string | undefined;
+  DD_CIVISIBILITY_CODE_COVERAGE_REPORT_UPLOAD_ENABLED: boolean;
   DD_CIVISIBILITY_DANGEROUSLY_FORCE_COVERAGE: boolean;
   DD_CIVISIBILITY_DANGEROUSLY_FORCE_TEST_SKIPPING: boolean;
   DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED: boolean;
@@ -794,6 +797,7 @@ export interface GeneratedEnvVarConfig {
   DD_TELEMETRY_HEARTBEAT_INTERVAL: number;
   DD_TELEMETRY_LOG_COLLECTION_ENABLED: boolean;
   DD_TELEMETRY_METRICS_ENABLED: boolean;
+  DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT: number | undefined;
   DD_TEST_FAILED_TEST_REPLAY_ENABLED: boolean;
   DD_TEST_FAILURE_SCREENSHOTS_ENABLED: boolean | undefined;
   DD_TEST_FLEET_CONFIG_PATH: string | undefined;

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

@@ -35,9 +35,10 @@ const {
   configWithOrigin,
   parseErrors,
   generateTelemetry,
+  warnInvalidValue,
 } = require('./defaults')
 const { normalizeService } = require('./normalize-service')
-const { transformers } = require('./parsers')
+const { programmaticTypeCoercions, transformers } = require('./parsers')
 
 const RUNTIME_ID = uuid()
 
@@ -55,6 +56,7 @@ const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
  * @typedef {import('../../../../index').TracerOptions} TracerOptions
  * @typedef {import('./config-types').ConfigKey} ConfigKey
  * @typedef {import('./config-types').ConfigPath} ConfigPath
+ * @typedef {import('./config-types').ConfigurationOption} ConfigurationOption
  * @typedef {{
  *   value: import('./config-types').ConfigPathValue<ConfigPath>,
  *   source: TelemetrySource
@@ -121,6 +123,9 @@ function setAndTrack (config, name, value, rawValue = value, source = 'calculate
   if (value == null) {
     // TODO: This works as before while ignoring undefined programmatic options is not ideal.
     if (source !== 'default') {
+      if (rawValue !== value) {
+        generateTelemetry(rawValue, source, name)
+      }
       return
     }
   } else if (source === 'calculated' || source === 'remote_config') {
@@ -285,8 +290,13 @@ class Config extends ConfigBase {
           continue
         }
       }
-      // TODO: Coerce mismatched types to the expected type, if possible. E.g., strings <> numbers
-      const transformed = value !== undefined && entry.transformer ? entry.transformer(value, fullName, source) : value
+      const coerced = programmaticTypeCoercions[entry.type](value)
+      if (coerced === undefined && value !== undefined) {
+        warnInvalidValue(value, fullName, source, `Invalid ${entry.type} input`)
+      }
+      const transformed = coerced !== undefined && entry.transformer
+        ? entry.transformer(coerced, fullName, source)
+        : coerced
       setAndTrack(this, entry.property ?? name, transformed, value, source)
     }
   }

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

@@ -297,8 +297,87 @@ const parsers = {
   },
 }
 
+const programmaticTypeCoercions = {
+  /**
+   * @param {unknown} value
+   */
+  BOOLEAN (value) {
+    if (typeof value === 'boolean') {
+      return value
+    }
+    if (typeof value === 'string') {
+      return parsers.BOOLEAN(value)
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  INT (value) {
+    if (typeof value === 'number' || typeof value === 'string' && value.trim() !== '') {
+      return parsers.INT(value)
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  DECIMAL (value) {
+    if (typeof value === 'number' || typeof value === 'string' && value.trim() !== '') {
+      return parsers.DECIMAL(value)
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  STRING (value) {
+    if (typeof value === 'string') {
+      return value
+    }
+    if (typeof value === 'boolean' || typeof value === 'number' && Number.isFinite(value)) {
+      return String(value)
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  FUNCTION (value) {
+    if (typeof value === 'function') {
+      return value
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  ARRAY (value) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item !== 'string' && typeof item !== 'number' && typeof item !== 'boolean') {
+          return
+        }
+      }
+      return value
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  MAP (value) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      return value
+    }
+  },
+  /**
+   * @param {unknown} value
+   */
+  JSON (value) {
+    if (typeof value === 'object' && value !== null) {
+      return value
+    }
+  },
+}
+
 module.exports = {
   parsers,
+  programmaticTypeCoercions,
   transformers,
   telemetryTransformers,
   setWarnInvalidValue,

package/packages/dd-trace/src/config/supported-configurations.json

@@ -470,6 +470,14 @@
         "namespace": "testOptimization"
       }
     ],
+    "DD_CIVISIBILITY_CODE_COVERAGE_REPORT_UPLOAD_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true",
+        "namespace": "testOptimization"
+      }
+    ],
     "DD_CIVISIBILITY_DANGEROUSLY_FORCE_COVERAGE": [
       {
         "implementation": "A",
@@ -494,6 +502,15 @@
         "namespace": "testOptimization"
       }
     ],
+    "DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT": [
+      {
+        "implementation": "A",
+        "type": "int",
+        "allowed": "0|[1-9][0-9]*",
+        "default": null,
+        "namespace": "testOptimization"
+      }
+    ],
     "DD_CIVISIBILITY_ENABLED": [
       {
         "implementation": "A",

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

@@ -31,6 +31,13 @@ module.exports = {
   ERROR_MESSAGE: 'error.message',
   ERROR_STACK: 'error.stack',
   IGNORE_OTEL_ERROR: Symbol('ignore.otel.error'),
+  // Marks an `Http2Server` that another instrumentation (currently @grpc/grpc-js)
+  // owns and traces through its own span lifecycle over the raw HTTP/2 stream
+  // API. The http2 server instrumentation reads this to leave such servers
+  // untraced, so a gRPC call keeps a single span with gRPC as the top frame
+  // instead of gaining an extra web.request span. A module-local Symbol keeps
+  // the mark private to dd-trace and unforgeable from user code.
+  FOREIGN_HTTP2_SERVER: Symbol('foreign.http2.server'),
   COMPONENT: 'component',
   CLIENT_PORT_KEY: 'network.destination.port',
   PEER_SERVICE_KEY: 'peer.service',

package/packages/dd-trace/src/datastreams/pathway.js

@@ -136,16 +136,18 @@ const DsmPathwayCodec = {
    * @param {Buffer} dataStreamsContext.hash
    * @param {number} dataStreamsContext.pathwayStartNs
    * @param {number} dataStreamsContext.edgeStartNs
-   * @param {object} carrier
+   * @param {object} [carrier]
+   * @returns {object | undefined}
    */
   encode (dataStreamsContext, carrier) {
-    if (!dataStreamsContext || !dataStreamsContext.hash) {
-      return
-    }
+    if (!dataStreamsContext || !dataStreamsContext.hash) return
+    carrier ??= {}
     carrier[CONTEXT_PROPAGATION_KEY_BASE64] = encodePathwayContextBase64(dataStreamsContext)
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Injected into DSM carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
+
+    return carrier
   },
 
   /**

package/packages/dd-trace/src/feature-registry.js

@@ -0,0 +1,22 @@
+'use strict'
+
+/**
+ * @typedef {object} Feature
+ * @property {string} name
+ * @property {object} noop
+ * @property {() => object} factory
+ * @property {Function} [remoteConfig]
+ * @property {Function} [enable]
+ */
+
+/** @type {{ [name: string]: Feature }} */
+const features = {}
+
+/**
+ * @param {Feature} feature
+ */
+function registerFeature (feature) {
+  features[feature.name] = feature
+}
+
+module.exports = { features, registerFeature }

package/packages/dd-trace/src/llmobs/constants/tags.js

@@ -4,6 +4,7 @@ module.exports = {
   SPAN_KINDS: ['llm', 'agent', 'workflow', 'task', 'tool', 'embedding', 'retrieval'],
   SPAN_KIND: '_ml_obs.meta.span.kind',
   SESSION_ID: '_ml_obs.session_id',
+  SESSION_ID_TRACE_DEFAULT_KEY: '_ml_obs.trace_session_id',
   DECORATOR: '_ml_obs.decorator',
   INTEGRATION: '_ml_obs.integration',
   METADATA: '_ml_obs.meta.metadata',
@@ -13,6 +14,7 @@ module.exports = {
   ML_APP: '_ml_obs.meta.ml_app',
   PROPAGATED_PARENT_ID_KEY: '_dd.p.llmobs_parent_id',
   PROPAGATED_ML_APP_KEY: '_dd.p.llmobs_ml_app',
+  PROPAGATED_SESSION_ID_KEY: '_dd.p.llmobs_sid',
   PARENT_ID_KEY: '_ml_obs.llmobs_parent_id',
   PROPAGATED_SAMPLE_RATE_KEY: '_dd.p.llmobs_sr',
   PROPAGATED_SAMPLING_DECISION_KEY: '_dd.p.llmobs_sd',

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

@@ -7,8 +7,11 @@ const { DD_MAJOR } = require('../../../../version')
 const startupLogs = require('../startup-log')
 const {
   ML_APP,
+  SESSION_ID,
+  SESSION_ID_TRACE_DEFAULT_KEY,
   PROPAGATED_ML_APP_KEY,
   PROPAGATED_PARENT_ID_KEY,
+  PROPAGATED_SESSION_ID_KEY,
   SAMPLE_RATE,
   SAMPLING_DECISION,
   PROPAGATED_SAMPLE_RATE_KEY,
@@ -110,7 +113,7 @@ function disable () {
 }
 
 // since LLMObs traces can extend between services and be the same trace,
-// we need to propagate the parent id, mlApp, and sampling rate/decision.
+// we need to propagate the parent id, mlApp, session id, and sampling rate/decision.
 function handleLLMObsInjection ({ carrier }) {
   // Respect the standard propagator's gate: when trace tag propagation is
   // disabled, don't write `x-datadog-tags` for LLMObs either.
@@ -130,8 +133,12 @@ function handleLLMObsInjection ({ carrier }) {
     mlObsSpanTags?.[SAMPLE_RATE] ?? parentContext?._trace?.tags?.[PROPAGATED_SAMPLE_RATE_KEY]
   const samplingDecision =
     mlObsSpanTags?.[SAMPLING_DECISION] ?? parentContext?._trace?.tags?.[PROPAGATED_SAMPLING_DECISION_KEY]
+  const sessionId =
+    mlObsSpanTags?.[SESSION_ID] ??
+    parentContext?._trace?.tags?.[SESSION_ID_TRACE_DEFAULT_KEY] ??
+    parentContext?._trace?.tags?.[PROPAGATED_SESSION_ID_KEY]
 
-  if (!parentId && !mlApp && samplingDecision == null) return
+  if (!parentId && !mlApp && samplingDecision == null && !sessionId) return
 
   // `_injectTags` only writes `x-datadog-tags` when the trace has `_dd.p.*`
   // tags, so it may be undefined here — coalesce before appending.
@@ -139,6 +146,7 @@ function handleLLMObsInjection ({ carrier }) {
   let tags = existing || ''
   if (parentId) tags += `${tags ? ',' : ''}${PROPAGATED_PARENT_ID_KEY}=${parentId}`
   if (mlApp) tags += `${tags ? ',' : ''}${PROPAGATED_ML_APP_KEY}=${mlApp}`
+  if (sessionId) tags += `${tags ? ',' : ''}${PROPAGATED_SESSION_ID_KEY}=${sessionId}`
   if (sampleRate != null) tags += `${tags ? ',' : ''}${PROPAGATED_SAMPLE_RATE_KEY}=${sampleRate}`
   if (samplingDecision != null) tags += `${tags ? ',' : ''}${PROPAGATED_SAMPLING_DECISION_KEY}=${samplingDecision}`
   if (tags !== existing) carrier['x-datadog-tags'] = tags

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

@@ -7,6 +7,7 @@ const {
   MODEL_NAME,
   MODEL_PROVIDER,
   SESSION_ID,
+  SESSION_ID_TRACE_DEFAULT_KEY,
   ML_APP,
   SPAN_KIND,
   INPUT_VALUE,
@@ -35,6 +36,7 @@ const {
   INTEGRATION,
   DECORATOR,
   PROPAGATED_ML_APP_KEY,
+  PROPAGATED_SESSION_ID_KEY,
   DEFAULT_PROMPT_NAME,
   INTERNAL_CONTEXT_VARIABLE_KEYS,
   INTERNAL_QUERY_VARIABLE_KEYS,
@@ -139,7 +141,11 @@ class LLMObsTagger {
     if (modelName) this.tagModelName(span, modelName)
     if (modelProvider) this._setTag(span, MODEL_PROVIDER, modelProvider)
 
-    sessionId = sessionId || registry.get(parent)?.[SESSION_ID]
+    const traceTags = span.context()._trace.tags
+    sessionId = sessionId ||
+      registry.get(parent)?.[SESSION_ID] ||
+      traceTags[SESSION_ID_TRACE_DEFAULT_KEY] ||
+      traceTags[PROPAGATED_SESSION_ID_KEY]
     if (sessionId) this._setTag(span, SESSION_ID, sessionId)
     if (integration) this._setTag(span, INTEGRATION, integration)
     if (_decorator) this._setTag(span, DECORATOR, _decorator)
@@ -752,6 +758,18 @@ class LLMObsTagger {
 
     const tagsCarrier = registry.get(span)
     tagsCarrier[key] = value
+
+    // The first session set in a trace becomes the trace-level default, stored on the trace-shared
+    // tags so later spans (incl. those under a session-less parent) inherit it in-process.
+    // Established here, the single choke point for session writes, so sessions post-populated by
+    // integrations after span start also seed it. First-writer wins, so an explicit session still
+    // overrides locally. Cross-service injection is handled centrally in `handleLLMObsInjection`.
+    if (key === SESSION_ID && value) {
+      const traceTags = span.context()._trace.tags
+      if (traceTags[SESSION_ID_TRACE_DEFAULT_KEY] === undefined) {
+        traceTags[SESSION_ID_TRACE_DEFAULT_KEY] = value
+      }
+    }
   }
 }
 

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

@@ -1,8 +1,8 @@
 'use strict'
 
+const { features } = require('../feature-registry')
 const NoopAppsecSdk = require('../appsec/sdk/noop')
 const NoopLLMObsSDK = require('../llmobs/noop')
-const NoopFlaggingProvider = require('../openfeature/noop')
 const NoopAIGuardSDK = require('../aiguard/noop')
 const NoopDogStatsDClient = require('./dogstatsd')
 const NoopTracer = require('./tracer')
@@ -11,7 +11,6 @@ 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()
 const noopProfiling = {
   setCustomLabelKeys () {},
@@ -25,8 +24,10 @@ class NoopProxy {
     this.appsec = noopAppsec
     this.dogstatsd = noopDogStatsDClient
     this.llmobs = noopLLMObs
-    this.openfeature = noopOpenFeatureProvider
     this.aiguard = noopAIGuard
+    for (const { name, noop } of Object.values(features)) {
+      this[name] = noop
+    }
     this.setBaggageItem = (key, value) => {}
     this.getBaggageItem = (key) => {}
     this.getAllBaggageItems = () => {}
@@ -82,7 +83,7 @@ class NoopProxy {
   }
 
   inject () {
-    return this._tracer.inject.apply(this._tracer, arguments)
+    this._tracer.inject.apply(this._tracer, arguments)
   }
 
   extract () {