dd-trace 5.116.0 → 5.118.0

package/packages/datadog-plugin-openai-agents/src/processor.js

@@ -0,0 +1,108 @@
+'use strict'
+
+const log = require('../../dd-trace/src/log')
+
+const SPAN_KIND_BY_TYPE = {
+  agent: 'agent',
+  function: 'tool',
+  handoff: 'tool',
+  guardrail: 'task',
+  custom: 'task',
+  generation: 'llm',
+  response: 'llm',
+}
+
+// Lifecycle methods are awaited by agents-core. Share one resolved Promise
+// across every callback so we don't allocate per span event.
+const RESOLVED = Promise.resolve()
+
+/**
+ * dd-trace-js implementation of the agents-core `TracingProcessor` interface.
+ * Registered via `addTraceProcessor(new DDOpenAIAgentsProcessor(integration))` inside
+ * the `@openai/agents` module load hook. Mirrors Python's LLMObsTraceProcessor.
+ *
+ * Each agents-core Span / Trace lifecycle event turns into a dd-trace span
+ * (APM + LLMObs-annotated) keyed off the agents-core spanId / traceId. Parent
+ * hierarchy is resolved through the agents-core parentId chain, which gives us
+ * correct multi-agent handoff nesting that ctx-argument capture cannot provide.
+ *
+ * agents-core awaits the lifecycle methods, so each one returns a settled
+ * Promise even though the work is synchronous.
+ */
+class DDOpenAIAgentsProcessor {
+  /**
+   * @param {() => (import('./integration').OpenAIAgentsIntegration | undefined)} getIntegration - Lazy accessor for the
+   *   current OpenAIAgentsIntegration singleton. Read on each lifecycle event
+   *   so re-instantiating the plugin doesn't strand the processor against an
+   *   old integration reference inside agents-core.
+   */
+  constructor (getIntegration) {
+    this._getIntegration = getIntegration
+  }
+
+  onTraceStart (oaiTrace) {
+    const integration = this._getIntegration()
+    if (!integration?.enabled) return RESOLVED
+    try {
+      integration.startTrace(oaiTrace)
+    } catch (err) {
+      log.warn('[openai-agents] onTraceStart failed: %s', err)
+    }
+    return RESOLVED
+  }
+
+  onTraceEnd (oaiTrace) {
+    const integration = this._getIntegration()
+    if (!integration?.enabled) return RESOLVED
+    try {
+      integration.endTrace(oaiTrace)
+    } catch (err) {
+      log.warn('[openai-agents] onTraceEnd failed: %s', err)
+    }
+    return RESOLVED
+  }
+
+  onSpanStart (oaiSpan) {
+    const integration = this._getIntegration()
+    if (!integration?.enabled) return RESOLVED
+    if (!oaiSpan?.spanData) return RESOLVED // guard NoopSpan
+    const kind = SPAN_KIND_BY_TYPE[oaiSpan.spanData.type]
+    if (!kind) return RESOLVED // span types without an LLMObs kind are not traced
+    try {
+      integration.startSpan(oaiSpan, kind)
+    } catch (err) {
+      log.warn('[openai-agents] onSpanStart failed: %s', err)
+    }
+    return RESOLVED
+  }
+
+  onSpanEnd (oaiSpan) {
+    const integration = this._getIntegration()
+    if (!integration?.enabled) return RESOLVED
+    if (!oaiSpan?.spanData) return RESOLVED
+    try {
+      integration.endSpan(oaiSpan)
+    } catch (err) {
+      log.warn('[openai-agents] onSpanEnd failed: %s', err)
+    }
+    return RESOLVED
+  }
+
+  forceFlush () {
+    // dd-trace exports on its own schedule; nothing to force here.
+    return RESOLVED
+  }
+
+  shutdown () {
+    const integration = this._getIntegration()
+    if (!integration) return RESOLVED
+    try {
+      integration.clearState()
+    } catch (err) {
+      log.warn('[openai-agents] shutdown cleanup failed: %s', err)
+    }
+    return RESOLVED
+  }
+}
+
+module.exports = { DDOpenAIAgentsProcessor }

package/packages/datadog-plugin-openai-agents/src/util.js

@@ -0,0 +1,60 @@
+'use strict'
+
+// agents-core's `error` is a plain `{ message, data }` object, not a JS Error
+// — there's no constructor to name and no stack. We tag a stable type constant
+// and stringify `data` into the message so the LLMObs error shape stays
+// consistent with other integrations.
+const AGENTS_ERROR_TYPE = 'AgentsCoreError'
+
+/**
+ * Build the dd-trace span name from an agents-core oai-span. Handoffs collapse
+ * the target agent name into snake_case under a `transfer_to_` prefix; other
+ * span types use the SDK-provided name, falling back to
+ * `openai_agents.<type>` (or `openai_agents.request` when even the type is
+ * missing).
+ *
+ * @param {object} oaiSpan
+ * @returns {string}
+ */
+function deriveSpanName (oaiSpan) {
+  const spanData = oaiSpan.spanData
+  if (spanData?.type === 'handoff') {
+    const toAgent = spanData.to_agent || ''
+    if (toAgent) return `transfer_to_${toAgent.replaceAll(' ', '_').toLowerCase()}`
+  }
+  if (spanData?.name) return spanData.name
+  return spanData?.type ? `openai_agents.${spanData.type}` : 'openai_agents.request'
+}
+
+/**
+ * Apply agents-core's error shape onto a dd-trace span. No-op when the
+ * oai-span has no error attached.
+ *
+ * @param {object} ddSpan
+ * @param {object} oaiSpan
+ */
+function applyError (ddSpan, oaiSpan) {
+  const err = oaiSpan.error
+  if (!err) return
+
+  ddSpan.setTag('error', true)
+
+  let errorMessage = err.message || 'Error'
+  if (err.data) {
+    try {
+      errorMessage = JSON.stringify(err.data)
+    } catch {
+      // circular / non-serializable — fall back to the raw message
+    }
+  }
+
+  ddSpan.setTag('error.type', AGENTS_ERROR_TYPE)
+  ddSpan.setTag('error.message', errorMessage)
+  ddSpan.setTag('error.stack', err.stack || '')
+}
+
+module.exports = {
+  AGENTS_ERROR_TYPE,
+  deriveSpanName,
+  applyError,
+}

package/packages/datadog-plugin-playwright/src/index.js

@@ -388,7 +388,10 @@ class PlaywrightPlugin extends CiPlugin {
       earlyFlakeAbortReason,
       onDone,
     }) => {
-      if (!span) return
+      if (!span) {
+        onDone?.()
+        return
+      }
 
       const isRUMActive = span.context().getTag(TEST_IS_RUM_ACTIVE)
 

package/packages/datadog-plugin-vitest/src/index.js

@@ -400,7 +400,7 @@ class VitestPlugin extends CiPlugin {
       return ctx.currentStore
     })
 
-    this.addSub('ci:vitest:test-suite:finish', ({ testSuiteSpan, status, deferFlush, onFinish }) => {
+    this.addSub('ci:vitest:test-suite:finish', ({ testSuiteSpan, status, deferFlush, onDone }) => {
       if (testSuiteSpan) {
         testSuiteSpan.setTag(TEST_STATUS, status)
         testSuiteSpan.finish()
@@ -408,10 +408,10 @@ class VitestPlugin extends CiPlugin {
       }
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
       if (deferFlush) {
-        onFinish()
+        onDone()
         return
       }
-      this.tracer._exporter.flush(onFinish)
+      this.tracer._exporter.flush(onDone)
       if (this.runningTestProbe) {
         this.removeDiProbe(this.runningTestProbe)
       }
@@ -442,7 +442,7 @@ class VitestPlugin extends CiPlugin {
       requestErrorTags,
       vitestPool,
       isVitestNoWorkerInitActive,
-      onFinish,
+      onDone,
     }) => {
       for (const [tag, value] of Object.entries(requestErrorTags || {})) {
         this.testSessionSpan.setTag(tag, value)
@@ -481,7 +481,7 @@ class VitestPlugin extends CiPlugin {
         provider: this.ciProviderName,
         autoInjected: !!this._tracerConfig.testOptimization.DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER,
       })
-      this.tracer._exporter.flush(onFinish)
+      this.tracer._exporter.flush(onDone)
     })
 
     this.addSub('ci:vitest:coverage-report', ({ rootDir, onDone }) => {

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -20,6 +20,7 @@ const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../../plugins/util/tags'
 const { sendGitMetadata: sendGitMetadataRequest } = require('./git/git_metadata')
 
 const hostname = getHostname()
+const EMPTY_SETTINGS = Object.freeze({})
 
 function getTestConfigurationTags (tags) {
   if (!tags) {
@@ -308,60 +309,58 @@ class CiVisibilityExporter extends BufferingExporter {
   }
 
   // Takes into account potential kill switches
-  filterConfiguration (remoteConfiguration) {
-    if (!remoteConfiguration) {
-      return {}
-    }
+  filterConfiguration (remoteConfiguration = EMPTY_SETTINGS) {
+    const { testOptimization } = this._config
     const {
-      isCodeCoverageEnabled,
-      isSuitesSkippingEnabled,
-      isItrEnabled,
-      requireGit,
-      isEarlyFlakeDetectionEnabled,
+      DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED: isEarlyFlakeDetectionAllowed,
+      DD_CIVISIBILITY_FLAKY_RETRY_COUNT: flakyTestRetriesCount = 0,
+      DD_CIVISIBILITY_FLAKY_RETRY_ENABLED: isFlakyTestRetriesAllowed,
+      DD_CIVISIBILITY_IMPACTED_TESTS_DETECTION_ENABLED: isImpactedTestsAllowed,
+      DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT: earlyFlakeDetectionRetryCount,
+      DD_TEST_FAILED_TEST_REPLAY_ENABLED: isFailedTestReplayAllowed,
+      DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES: configuredAttemptToFixRetries = 0,
+      DD_TEST_MANAGEMENT_ENABLED: isTestManagementAllowed,
+    } = testOptimization
+    const hasEarlyFlakeDetectionRetryCount = earlyFlakeDetectionRetryCount !== undefined
+    const configuredSlowTestRetries = remoteConfiguration.earlyFlakeDetectionSlowTestRetries ?? EMPTY_SETTINGS
+    const earlyFlakeDetectionSlowTestRetries = hasEarlyFlakeDetectionRetryCount
+      ? Object.freeze({
+        '5s': earlyFlakeDetectionRetryCount,
+        '10s': earlyFlakeDetectionRetryCount,
+        '30s': earlyFlakeDetectionRetryCount,
+        '5m': earlyFlakeDetectionRetryCount,
+      })
+      : Object.isFrozen(configuredSlowTestRetries)
+        ? configuredSlowTestRetries
+        : Object.freeze({ ...configuredSlowTestRetries })
+    const earlyFlakeDetectionNumRetries = hasEarlyFlakeDetectionRetryCount
+      ? earlyFlakeDetectionRetryCount
+      : remoteConfiguration.earlyFlakeDetectionNumRetries ?? 0
+    const testManagementAttemptToFixRetries =
+      remoteConfiguration.testManagementAttemptToFixRetries ?? configuredAttemptToFixRetries
+
+    return Object.freeze({
+      isCodeCoverageEnabled: remoteConfiguration.isCodeCoverageEnabled === true,
+      isSuitesSkippingEnabled: remoteConfiguration.isSuitesSkippingEnabled === true,
+      isItrEnabled: remoteConfiguration.isItrEnabled === true,
+      requireGit: remoteConfiguration.requireGit === true,
+      isEarlyFlakeDetectionEnabled:
+        remoteConfiguration.isEarlyFlakeDetectionEnabled === true && isEarlyFlakeDetectionAllowed === true,
       earlyFlakeDetectionNumRetries,
       earlyFlakeDetectionSlowTestRetries,
-      earlyFlakeDetectionFaultyThreshold,
-      isFlakyTestRetriesEnabled,
-      isDiEnabled,
-      isKnownTestsEnabled,
-      isTestManagementEnabled,
+      earlyFlakeDetectionFaultyThreshold: remoteConfiguration.earlyFlakeDetectionFaultyThreshold ?? 30,
+      isFlakyTestRetriesEnabled:
+        remoteConfiguration.isFlakyTestRetriesEnabled === true && isFlakyTestRetriesAllowed === true,
+      flakyTestRetriesCount,
+      isDiEnabled: remoteConfiguration.isDiEnabled === true && isFailedTestReplayAllowed === true,
+      isKnownTestsEnabled: remoteConfiguration.isKnownTestsEnabled === true,
+      isTestManagementEnabled:
+        remoteConfiguration.isTestManagementEnabled === true && isTestManagementAllowed === true,
       testManagementAttemptToFixRetries,
-      isImpactedTestsEnabled,
-      isCoverageReportUploadEnabled,
-    } = remoteConfiguration
-    const { testOptimization } = this._config
-    const earlyFlakeDetectionRetryCount =
-      testOptimization.DD_TEST_EARLY_FLAKE_DETECTION_RETRY_COUNT
-    const hasEarlyFlakeDetectionRetryCount = earlyFlakeDetectionRetryCount !== undefined
-    return {
-      isCodeCoverageEnabled,
-      isSuitesSkippingEnabled,
-      isItrEnabled,
-      requireGit,
-      isEarlyFlakeDetectionEnabled:
-        isEarlyFlakeDetectionEnabled && testOptimization.DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED,
-      earlyFlakeDetectionNumRetries:
-        hasEarlyFlakeDetectionRetryCount ? earlyFlakeDetectionRetryCount : earlyFlakeDetectionNumRetries,
-      earlyFlakeDetectionSlowTestRetries: hasEarlyFlakeDetectionRetryCount
-        ? {
-            '5s': earlyFlakeDetectionRetryCount,
-            '10s': earlyFlakeDetectionRetryCount,
-            '30s': earlyFlakeDetectionRetryCount,
-            '5m': earlyFlakeDetectionRetryCount,
-          }
-        : earlyFlakeDetectionSlowTestRetries,
-      earlyFlakeDetectionFaultyThreshold,
-      isFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled && testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_ENABLED,
-      flakyTestRetriesCount: testOptimization.DD_CIVISIBILITY_FLAKY_RETRY_COUNT,
-      isDiEnabled: isDiEnabled && testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED,
-      isKnownTestsEnabled,
-      isTestManagementEnabled: isTestManagementEnabled && testOptimization.DD_TEST_MANAGEMENT_ENABLED,
-      testManagementAttemptToFixRetries:
-        testManagementAttemptToFixRetries ?? testOptimization.DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES,
       isImpactedTestsEnabled:
-        isImpactedTestsEnabled && testOptimization.DD_CIVISIBILITY_IMPACTED_TESTS_DETECTION_ENABLED,
-      isCoverageReportUploadEnabled,
-    }
+        remoteConfiguration.isImpactedTestsEnabled === true && isImpactedTestsAllowed === true,
+      isCoverageReportUploadEnabled: remoteConfiguration.isCoverageReportUploadEnabled === true,
+    })
   }
 
   sendGitMetadata (repositoryUrl) {

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

@@ -12,12 +12,145 @@ const {
   TELEMETRY_GIT_REQUESTS_SETTINGS_RESPONSE,
 } = require('../telemetry')
 const { writeSettingsToCache } = require('../test-optimization-cache')
-const { validateSettingsResponse } = require('../test-optimization-http-cache-schema')
+const { MAX_RETRIES, validateSettingsResponse } = require('../test-optimization-http-cache-schema')
 const request = require('./request')
 
 const DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES = 2
-const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
+const DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES = Object.freeze({
+  '5s': 10,
+  '10s': 5,
+  '30s': 3,
+  '5m': 2,
+})
 const DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD = 30
+const EARLY_FLAKE_DETECTION_RETRY_BUCKETS = Object.keys(DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES)
+
+/**
+ * @typedef {object} EarlyFlakeDetectionSettings
+ * @property {boolean} enabled
+ * @property {number} numRetries
+ * @property {Readonly<Record<string, number>>} slowTestRetries
+ * @property {number} faultyThreshold
+ */
+
+/**
+ * @typedef {object} TestManagementSettings
+ * @property {boolean} enabled
+ * @property {number|undefined} attemptToFixRetries
+ */
+
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isRecord (value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+function isNonNegativeInteger (value) {
+  return Number.isInteger(value) && value >= 0
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+function isRetryCount (value) {
+  return isNonNegativeInteger(value) && value <= MAX_RETRIES
+}
+
+/**
+ * @param {unknown} value
+ * @returns {Readonly<Record<string, number>>|undefined}
+ */
+function parseSlowTestRetries (value) {
+  if (!isRecord(value)) return
+
+  const slowTestRetries = {}
+  for (const bucket of EARLY_FLAKE_DETECTION_RETRY_BUCKETS) {
+    if (!Object.hasOwn(value, bucket)) continue
+
+    const retries = value[bucket]
+    if (!isRetryCount(retries)) return
+    slowTestRetries[bucket] = retries
+  }
+  return Object.freeze(slowTestRetries)
+}
+
+/**
+ * @param {unknown} value
+ * @param {boolean} isKnownTestsEnabled
+ * @returns {EarlyFlakeDetectionSettings}
+ */
+function parseEarlyFlakeDetectionSettings (value, isKnownTestsEnabled) {
+  if (!isRecord(value) || value.enabled !== true) {
+    return {
+      enabled: false,
+      numRetries: DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
+      slowTestRetries: DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
+      faultyThreshold: DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
+    }
+  }
+
+  let isValid = true
+  let numRetries = DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES
+  let slowTestRetries = DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES
+  if (Object.hasOwn(value, 'slow_test_retries')) {
+    const parsedSlowTestRetries = parseSlowTestRetries(value.slow_test_retries)
+    if (parsedSlowTestRetries) {
+      slowTestRetries = parsedSlowTestRetries
+      numRetries = parsedSlowTestRetries['5s'] ?? DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES
+    } else {
+      isValid = false
+    }
+  }
+
+  let faultyThreshold = DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD
+  if (Object.hasOwn(value, 'faulty_session_threshold')) {
+    if (isNonNegativeInteger(value.faulty_session_threshold) && value.faulty_session_threshold <= 100) {
+      faultyThreshold = value.faulty_session_threshold
+    } else {
+      isValid = false
+    }
+  }
+
+  return {
+    enabled: isKnownTestsEnabled && isValid,
+    numRetries,
+    slowTestRetries,
+    faultyThreshold,
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @returns {TestManagementSettings}
+ */
+function parseTestManagementSettings (value) {
+  if (!isRecord(value) || value.enabled !== true) {
+    return {
+      enabled: false,
+      attemptToFixRetries: undefined,
+    }
+  }
+
+  const attemptToFixRetries = value.attempt_to_fix_retries
+  if (attemptToFixRetries !== undefined && !isRetryCount(attemptToFixRetries)) {
+    return {
+      enabled: false,
+      attemptToFixRetries: undefined,
+    }
+  }
+
+  return {
+    enabled: true,
+    attemptToFixRetries,
+  }
+}
 
 function parseJsonResponse (rawJson) {
   return typeof rawJson === 'string' ? JSON.parse(rawJson) : rawJson
@@ -28,40 +161,35 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
   if (options.validateRequiredFields) {
     validateSettingsResponse(parsedResponse, options)
   }
-  const {
-    code_coverage: isCodeCoverageEnabled,
-    tests_skipping: isSuitesSkippingEnabled,
-    itr_enabled: isItrEnabled,
-    require_git: requireGit,
-    early_flake_detection: earlyFlakeDetectionConfig,
-    flaky_test_retries_enabled: isFlakyTestRetriesEnabled,
-    di_enabled: isDiEnabled,
-    known_tests_enabled: isKnownTestsEnabled,
-    test_management: testManagementConfig,
-    impacted_tests_enabled: isImpactedTestsEnabled,
-    coverage_report_upload_enabled: isCoverageReportUploadEnabled,
-  } = parsedResponse?.data?.attributes ?? parsedResponse
+  const parsedAttributes = parsedResponse?.data?.attributes ?? parsedResponse
+  if (!isRecord(parsedAttributes)) {
+    throw new TypeError('Invalid settings response: attributes must be an object')
+  }
+  const attributes = parsedAttributes
+  const isKnownTestsEnabled = attributes.known_tests_enabled === true
+  const isFlakyTestRetriesEnabled = attributes.flaky_test_retries_enabled === true
+  const earlyFlakeDetection = parseEarlyFlakeDetectionSettings(
+    attributes.early_flake_detection,
+    isKnownTestsEnabled
+  )
+  const testManagement = parseTestManagementSettings(attributes.test_management)
 
   const settings = {
-    isCodeCoverageEnabled,
-    isSuitesSkippingEnabled,
-    isItrEnabled,
-    requireGit,
-    isEarlyFlakeDetectionEnabled: isKnownTestsEnabled && (earlyFlakeDetectionConfig?.enabled ?? false),
-    earlyFlakeDetectionNumRetries:
-      earlyFlakeDetectionConfig?.slow_test_retries?.['5s'] ?? DEFAULT_EARLY_FLAKE_DETECTION_NUM_RETRIES,
-    earlyFlakeDetectionSlowTestRetries:
-      earlyFlakeDetectionConfig?.slow_test_retries ?? DEFAULT_EARLY_FLAKE_DETECTION_SLOW_TEST_RETRIES,
-    earlyFlakeDetectionFaultyThreshold:
-      earlyFlakeDetectionConfig?.faulty_session_threshold ?? DEFAULT_EARLY_FLAKE_DETECTION_ERROR_THRESHOLD,
+    isCodeCoverageEnabled: attributes.code_coverage === true,
+    isSuitesSkippingEnabled: attributes.tests_skipping === true,
+    isItrEnabled: attributes.itr_enabled === true,
+    requireGit: attributes.require_git === true,
+    isEarlyFlakeDetectionEnabled: earlyFlakeDetection.enabled,
+    earlyFlakeDetectionNumRetries: earlyFlakeDetection.numRetries,
+    earlyFlakeDetectionSlowTestRetries: earlyFlakeDetection.slowTestRetries,
+    earlyFlakeDetectionFaultyThreshold: earlyFlakeDetection.faultyThreshold,
     isFlakyTestRetriesEnabled,
-    isDiEnabled: isDiEnabled && isFlakyTestRetriesEnabled,
+    isDiEnabled: attributes.di_enabled === true && isFlakyTestRetriesEnabled,
     isKnownTestsEnabled,
-    isTestManagementEnabled: (testManagementConfig?.enabled ?? false),
-    testManagementAttemptToFixRetries:
-      testManagementConfig?.attempt_to_fix_retries,
-    isImpactedTestsEnabled,
-    isCoverageReportUploadEnabled: isCoverageReportUploadEnabled ?? false,
+    isTestManagementEnabled: testManagement.enabled,
+    testManagementAttemptToFixRetries: testManagement.attemptToFixRetries,
+    isImpactedTestsEnabled: attributes.impacted_tests_enabled === true,
+    isCoverageReportUploadEnabled: attributes.coverage_report_upload_enabled === true,
   }
 
   log.debug('Remote settings: %j', settings)
@@ -82,7 +210,7 @@ function parseLibraryConfigurationResponse (rawJson, config = getConfig(), optio
     log.debug('Code coverage report upload was disabled by the environment variable')
   }
 
-  return settings
+  return Object.freeze(settings)
 }
 
 function getLibraryConfiguration ({

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

@@ -30,7 +30,7 @@ const RETRY_THRESHOLD_PATTERN = /^\d+(?:ms|s|m|h)$/
 const MAX_VALIDATION_MODULES = 1000
 const MAX_VALIDATION_SUITES = 10_000
 const MAX_VALIDATION_TESTS = 100_000
-const MAX_VALIDATION_RETRIES = 100
+const MAX_RETRIES = 100
 const MAX_VALIDATION_STRING_BYTES = 4096
 
 function isObject (value) {
@@ -75,7 +75,8 @@ function validateSettingsResponse (response, options = {}) {
   assertBooleanFields(attributes.test_management, ['enabled'], 'settings test_management')
   assertOptionalBoundedNumber(
     attributes.early_flake_detection.faulty_session_threshold,
-    'settings early_flake_detection faulty_session_threshold'
+    'settings early_flake_detection faulty_session_threshold',
+    { integer: true }
   )
   assertRetryMap(attributes.early_flake_detection.slow_test_retries)
   assertOptionalBoundedNumber(
@@ -216,8 +217,8 @@ function assertBooleanFields (object, keys, endpoint) {
 function assertOptionalBoundedNumber (value, endpoint, { integer = false } = {}) {
   if (value === undefined) return
   if (!Number.isFinite(value) || (integer && !Number.isInteger(value)) ||
-    value < 0 || value > MAX_VALIDATION_RETRIES) {
-    throw new TypeError(`Invalid ${endpoint}: value must be between 0 and ${MAX_VALIDATION_RETRIES}`)
+    value < 0 || value > MAX_RETRIES) {
+    throw new TypeError(`Invalid ${endpoint}: value must be between 0 and ${MAX_RETRIES}`)
   }
 }
 
@@ -249,6 +250,7 @@ function assertValidationString (value, field) {
 }
 
 module.exports = {
+  MAX_RETRIES,
   validateKnownTestsResponse,
   validateSettingsResponse,
   validateSkippableTestsResponse,

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

@@ -333,6 +333,7 @@ export interface GeneratedConfig {
   DD_TRACE_NODE_SERIALIZE_ENABLED: boolean;
   DD_TRACE_NYC_ENABLED: boolean;
   DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP: string;
+  DD_TRACE_OPENAI_AGENTS_ENABLED: boolean;
   DD_TRACE_OPENAI_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_PROJECT_OPENSEARCH_ENABLED: boolean;
@@ -1028,6 +1029,7 @@ export interface GeneratedEnvVarConfig {
   DD_TRACE_NODE_SERIALIZE_ENABLED: boolean;
   DD_TRACE_NYC_ENABLED: boolean;
   DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP: string;
+  DD_TRACE_OPENAI_AGENTS_ENABLED: boolean;
   DD_TRACE_OPENAI_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_ENABLED: boolean;
   DD_TRACE_OPENSEARCH_PROJECT_OPENSEARCH_ENABLED: boolean;

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

@@ -3452,6 +3452,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_OPENAI_AGENTS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "true"
+      }
+    ],
     "DD_TRACE_OPENSEARCH_ENABLED": [
       {
         "implementation": "A",

package/packages/dd-trace/src/encode/span-stats.js

@@ -31,7 +31,7 @@ class SpanStatsEncoder extends AgentEncoder {
   }
 
   _encodeStat (bytes, stat) {
-    bytes.writeMapPrefix(15)
+    bytes.writeMapPrefix(17)
 
     this._encodeString(bytes, 'Service')
     const service = stat.Service || DEFAULT_SERVICE_NAME
@@ -79,6 +79,12 @@ class SpanStatsEncoder extends AgentEncoder {
 
     this._encodeString(bytes, 'srv_src')
     this._encodeString(bytes, stat.srv_src || '')
+
+    this._encodeString(bytes, 'SpanKind')
+    this._encodeString(bytes, stat.SpanKind || '')
+
+    this._encodeString(bytes, 'GRPCStatusCode')
+    this._encodeString(bytes, stat.GRPCStatusCode || '')
   }
 
   _encodeBucket (bytes, bucket) {