dd-trace 5.67.0 → 5.69.0

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

@@ -8,10 +8,11 @@ const telemetry = require('../telemetry')
 const {
   extractRequestParams,
   extractTextAndResponseReason,
-  parseModelId
+  parseModelId,
+  extractTextAndResponseReasonFromStream
 } = require('../../../../datadog-plugin-aws-sdk/src/services/bedrockruntime/utils')
 
-const ENABLED_OPERATIONS = new Set(['invokeModel'])
+const ENABLED_OPERATIONS = new Set(['invokeModel', 'invokeModelWithResponseStream'])
 
 const requestIdsToTokens = {}
 
@@ -19,7 +20,8 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
   constructor () {
     super(...arguments)
 
-    this.addSub('apm:aws:request:complete:bedrockruntime', ({ response }) => {
+    this.addSub('apm:aws:request:complete:bedrockruntime', (ctx) => {
+      const { response } = ctx
       const request = response.request
       const operation = request.operation
       // avoids instrumenting other non supported runtime operations
@@ -32,23 +34,34 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       if (modelName.includes('embed')) {
         return
       }
-      const span = storage('legacy').getStore()?.span
-      this.setLLMObsTags({ request, span, response, modelProvider, modelName })
+      const span = ctx.currentStore?.span
+      this.setLLMObsTags({ ctx, request, span, response, modelProvider, modelName })
     })
 
     this.addSub('apm:aws:response:deserialize:bedrockruntime', ({ headers }) => {
       const requestId = headers['x-amzn-requestid']
       const inputTokenCount = headers['x-amzn-bedrock-input-token-count']
       const outputTokenCount = headers['x-amzn-bedrock-output-token-count']
+      const cacheReadTokenCount = headers['x-amzn-bedrock-cache-read-input-token-count']
+      const cacheWriteTokenCount = headers['x-amzn-bedrock-cache-write-input-token-count']
 
       requestIdsToTokens[requestId] = {
         inputTokensFromHeaders: inputTokenCount && Number.parseInt(inputTokenCount),
-        outputTokensFromHeaders: outputTokenCount && Number.parseInt(outputTokenCount)
+        outputTokensFromHeaders: outputTokenCount && Number.parseInt(outputTokenCount),
+        cacheReadTokensFromHeaders: cacheReadTokenCount && Number.parseInt(cacheReadTokenCount),
+        cacheWriteTokensFromHeaders: cacheWriteTokenCount && Number.parseInt(cacheWriteTokenCount)
       }
     })
+
+    this.addSub('apm:aws:response:streamed-chunk:bedrockruntime', ({ ctx, chunk }) => {
+      if (!ctx.chunks) ctx.chunks = []
+
+      if (chunk) ctx.chunks.push(chunk)
+    })
   }
 
-  setLLMObsTags ({ request, span, response, modelProvider, modelName }) {
+  setLLMObsTags ({ ctx, request, span, response, modelProvider, modelName }) {
+    const isStream = request?.operation?.toLowerCase().includes('stream')
     telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: 'bedrock' })
 
     const parent = llmobsStore.getStore()?.span
@@ -62,7 +75,10 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
     })
 
     const requestParams = extractRequestParams(request.params, modelProvider)
-    const textAndResponseReason = extractTextAndResponseReason(response, modelProvider, modelName)
+    // for streamed responses, we'll use the coerced response object we formed in the stream handler
+    const textAndResponseReason = isStream
+      ? extractTextAndResponseReasonFromStream(ctx.chunks, modelProvider, modelName)
+      : extractTextAndResponseReason(response, modelProvider, modelName)
 
     // add metadata tags
     this._tagger.tagMetadata(span, {
@@ -78,14 +94,16 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
     )
 
     // add token metrics
-    const { inputTokens, outputTokens, totalTokens } = extractTokens({
+    const { inputTokens, outputTokens, totalTokens, cacheReadTokens, cacheWriteTokens } = extractTokens({
       requestId: response.$metadata.requestId,
       usage: textAndResponseReason.usage
     })
     this._tagger.tagMetrics(span, {
       inputTokens,
       outputTokens,
-      totalTokens
+      totalTokens,
+      cacheReadTokens,
+      cacheWriteTokens
     })
   }
 }
@@ -93,17 +111,26 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
 function extractTokens ({ requestId, usage }) {
   const {
     inputTokensFromHeaders,
-    outputTokensFromHeaders
+    outputTokensFromHeaders,
+    cacheReadTokensFromHeaders,
+    cacheWriteTokensFromHeaders
   } = requestIdsToTokens[requestId] || {}
   delete requestIdsToTokens[requestId]
 
   const inputTokens = usage.inputTokens || inputTokensFromHeaders || 0
   const outputTokens = usage.outputTokens || outputTokensFromHeaders || 0
+  const cacheReadTokens = usage.cacheReadTokens || cacheReadTokensFromHeaders || 0
+  const cacheWriteTokens = usage.cacheWriteTokens || cacheWriteTokensFromHeaders || 0
+
+  // adjust for the fact that bedrock input tokens only count non-cached tokens
+  const normalizedInputTokens = inputTokens + cacheReadTokens + cacheWriteTokens
 
   return {
-    inputTokens,
+    inputTokens: normalizedInputTokens,
     outputTokens,
-    totalTokens: inputTokens + outputTokens
+    totalTokens: normalizedInputTokens + outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens
   }
 }
 

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

@@ -81,8 +81,14 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
       const outputTokens = tokenUsage.completion_tokens
       if (outputTokens) metrics.outputTokens = outputTokens
 
-      const totalTokens = tokenUsage.total_toksn || (inputTokens + outputTokens)
+      const totalTokens = tokenUsage.total_tokens || (inputTokens + outputTokens)
       if (totalTokens) metrics.totalTokens = totalTokens
+
+      const promptTokensDetails = tokenUsage.prompt_tokens_details
+      if (promptTokensDetails) {
+        const cacheReadTokens = promptTokensDetails.cached_tokens
+        if (cacheReadTokens) metrics.cacheReadTokens = cacheReadTokens
+      }
     }
 
     return metrics

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

@@ -20,6 +20,8 @@ const {
   NAME,
   PROPAGATED_PARENT_ID_KEY,
   ROOT_PARENT_ID,
+  CACHE_READ_INPUT_TOKENS_METRIC_KEY,
+  CACHE_WRITE_INPUT_TOKENS_METRIC_KEY,
   INPUT_TOKENS_METRIC_KEY,
   OUTPUT_TOKENS_METRIC_KEY,
   TOTAL_TOKENS_METRIC_KEY,
@@ -144,6 +146,12 @@ class LLMObsTagger {
         case 'totalTokens':
           processedKey = TOTAL_TOKENS_METRIC_KEY
           break
+        case 'cacheReadTokens':
+          processedKey = CACHE_READ_INPUT_TOKENS_METRIC_KEY
+          break
+        case 'cacheWriteTokens':
+          processedKey = CACHE_WRITE_INPUT_TOKENS_METRIC_KEY
+          break
       }
 
       if (typeof value === 'number') {

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

@@ -85,7 +85,8 @@ function recordLLMObsEnabled (startTime, config, value = 1) {
     error: 0,
     agentless: Number(config.llmobs.agentlessEnabled),
     site: config.site,
-    auto: Number(autoEnabled)
+    auto: Number(autoEnabled),
+    ml_app: config.llmobs.mlApp
   }
   llmobsMetrics.count('product_enabled', tags).inc(value)
   llmobsMetrics.distribution('init_time', tags).track(initTimeMs)

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

@@ -1,11 +1,9 @@
 'use strict'
-
-const coalesce = require('koalas')
 const { inspect } = require('util')
 const { isTrue } = require('../util')
 const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
-const { Log } = require('./log')
+const { Log, LogConfig, NoTransmitError } = require('./log')
 const { memoize } = require('./utils')
 const { getEnvironmentVariable } = require('../config-helper')
 
@@ -15,7 +13,14 @@ const config = {
   logLevel: 'debug'
 }
 
+// in most places where we know we want to mute a log we use log.error() directly
+const NO_TRANSMIT = new LogConfig(false)
+
 const log = {
+  LogConfig,
+  NO_TRANSMIT,
+  NoTransmitError,
+
   /**
    * @returns Read-only version of logging config. To modify config, call `log.use` and `log.toggle`
    */
@@ -92,18 +97,26 @@ const log = {
     return this
   },
 
+  errorWithoutTelemetry (...args) {
+    args.push(NO_TRANSMIT)
+    if (errorChannel.hasSubscribers) {
+      errorChannel.publish(Log.parse(...args))
+    }
+    return this
+  },
+
   deprecate (code, message) {
     return this._deprecate(code, message)
   },
 
   isEnabled (fleetStableConfigValue, localStableConfigValue) {
-    return isTrue(coalesce(
-      fleetStableConfigValue,
-      getEnvironmentVariable('DD_TRACE_DEBUG'),
-      getEnvironmentVariable('OTEL_LOG_LEVEL') === 'debug' || undefined,
-      localStableConfigValue,
+    return isTrue(
+      fleetStableConfigValue ??
+      getEnvironmentVariable('DD_TRACE_DEBUG') ??
+      (getEnvironmentVariable('OTEL_LOG_LEVEL') === 'debug' || undefined) ??
+      localStableConfigValue ??
       config.enabled
-    ))
+    )
   },
 
   getLogLevel (
@@ -111,14 +124,12 @@ const log = {
     fleetStableConfigValue,
     localStableConfigValue
   ) {
-    return coalesce(
-      optionsValue,
-      fleetStableConfigValue,
-      getEnvironmentVariable('DD_TRACE_LOG_LEVEL'),
-      getEnvironmentVariable('OTEL_LOG_LEVEL'),
-      localStableConfigValue,
+    return optionsValue ??
+      fleetStableConfigValue ??
+      getEnvironmentVariable('DD_TRACE_LOG_LEVEL') ??
+      getEnvironmentVariable('OTEL_LOG_LEVEL') ??
+      localStableConfigValue ??
       config.logLevel
-    )
   }
 }
 

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

@@ -2,12 +2,16 @@
 
 const { format } = require('util')
 
+// other times we produce an Error in a central location and log it several other places
+class NoTransmitError extends Error {}
+
 class Log {
-  constructor (message, args, cause, delegate) {
+  constructor (message, args, cause, delegate, sendViaTelemetry = true) {
     this.message = message
     this.args = args
     this.cause = cause
     this.delegate = delegate
+    this.sendViaTelemetry = sendViaTelemetry
   }
 
   get formatted () {
@@ -22,10 +26,18 @@ class Log {
 
   static parse (...args) {
     let message, cause, delegate
+    let sendViaTelemetry = true
+
+    const maybeLogConfig = args.at(-1)
+    if (maybeLogConfig instanceof LogConfig) {
+      args.pop()
+      sendViaTelemetry = maybeLogConfig.transmit
+    }
 
-    const lastArg = args.at(-1)
-    if (lastArg && typeof lastArg === 'object' && lastArg.stack) { // lastArg instanceof Error?
+    const maybeError = args.at(-1)
+    if (maybeError && typeof maybeError === 'object' && maybeError.stack) { // maybeError instanceof Error?
       cause = args.pop()
+      if (cause instanceof NoTransmitError) sendViaTelemetry = false
     }
 
     const firstArg = args.shift()
@@ -43,10 +55,22 @@ class Log {
       message = String(firstArg)
     }
 
-    return new Log(message, args, cause, delegate)
+    return new Log(message, args, cause, delegate, sendViaTelemetry)
+  }
+}
+
+/**
+ * Pass instances of this class to logger methods when fine-grain control is needed
+ * @property {boolean} transmit - Whether to send the log via telemetry.
+ */
+class LogConfig {
+  constructor (transmit = true) {
+    this.transmit = transmit
   }
 }
 
 module.exports = {
-  Log
+  Log,
+  LogConfig,
+  NoTransmitError,
 }

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

@@ -75,12 +75,12 @@ function onError (err) {
   // TODO: replace it with Error(message, { cause }) when cause has broad support
   if (formatted) {
     withNoop(() => {
-      const l = Error.stackTraceLimit
+      const stackTraceLimitBackup = Error.stackTraceLimit
       Error.stackTraceLimit = 0
-      const e = new Error(formatted)
-      Error.stackTraceLimit = l
-      Error.captureStackTrace(e, stackTraceLimitFunction)
-      logger.error(e)
+      const newError = new Error(formatted)
+      Error.stackTraceLimit = stackTraceLimitBackup
+      Error.captureStackTrace(newError, stackTraceLimitFunction)
+      logger.error(newError)
     })
   }
   if (cause) withNoop(() => logger.error(cause))

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

@@ -4,18 +4,22 @@ const NoopTracer = require('./tracer')
 const NoopAppsecSdk = require('../appsec/sdk/noop')
 const NoopDogStatsDClient = require('./dogstatsd')
 const NoopLLMObsSDK = require('../llmobs/noop')
+const NoopAIGuardSDK = require('../aiguard/noop')
 
 const noop = new NoopTracer()
 const noopAppsec = new NoopAppsecSdk()
 const noopDogStatsDClient = new NoopDogStatsDClient()
 const noopLLMObs = new NoopLLMObsSDK(noop)
+const noopAIGuard = new NoopAIGuardSDK()
 
+/** @type {import('../../src/index')} Proxy */
 class NoopProxy {
   constructor () {
     this._tracer = noop
     this.appsec = noopAppsec
     this.dogstatsd = noopDogStatsDClient
     this.llmobs = noopLLMObs
+    this.aiguard = noopAIGuard
     this.setBaggageItem = () => {}
     this.getBaggageItem = () => {}
     this.getAllBaggageItems = () => {}

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

@@ -22,6 +22,7 @@ class NoopSpan {
   setTag (key, value) { return this }
   addTags (keyValueMap) { return this }
   addLink (link) { return this }
+  addLinks (links) { return this }
   addSpanPointer (ptrKind, ptrDir, ptrHash) { return this }
   log () { return this }
   logEvent () {}

package/packages/dd-trace/src/opentelemetry/span.js

@@ -211,10 +211,21 @@ class Span {
     return this
   }
 
-  addLink (context, attributes) {
-    // extract dd context
+  addLink (link, attrs) {
+    // TODO: Remove this once we remove addLink(context, attrs) in v6.0.0
+    if (link instanceof SpanContext) {
+      link = { context: link, attributes: attrs ?? {} }
+    }
+
+    const { context, attributes } = link
+    // Extract dd context
     const ddSpanContext = context._ddContext
-    this._ddSpan.addLink(ddSpanContext, attributes)
+    this._ddSpan.addLink({ context: ddSpanContext, attributes })
+    return this
+  }
+
+  addLinks (links) {
+    links.forEach(link => this.addLink(link))
     return this
   }
 

package/packages/dd-trace/src/opentracing/span.js

@@ -86,8 +86,10 @@ class DatadogSpan {
 
     this._startTime = fields.startTime || this._getTime()
 
-    this._links = []
-    fields.links && fields.links.forEach(link => this.addLink(link.context, link.attributes))
+    this._links = fields.links?.map(link => ({
+      context: link.context._ddContext ?? link.context,
+      attributes: this._sanitizeAttributes(link.attributes)
+    })) ?? []
 
     if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
       runtimeMetrics.increment('runtime.node.spans.unfinished')
@@ -144,7 +146,7 @@ class DatadogSpan {
   }
 
   /**
-   * @returns {DatadogSpanContext}
+   * @returns {import('../priority_sampler').DatadogSpanContext}
    */
   context () {
     return this._spanContext
@@ -196,13 +198,25 @@ class DatadogSpan {
 
   logEvent () {}
 
-  addLink (context, attributes) {
+  addLink (link, attrs) {
+    // TODO: Remove this once we remove addLink(context, attrs) in v6.0.0
+    if (link instanceof SpanContext) {
+      link = { context: link, attributes: attrs ?? {} }
+    }
+
+    const { context, attributes } = link
+
     this._links.push({
       context: context._ddContext ?? context,
       attributes: this._sanitizeAttributes(attributes)
     })
   }
 
+  addLinks (links) {
+    links.forEach(link => this.addLink(link))
+    return this
+  }
+
   addSpanPointer (ptrKind, ptrDir, ptrHash) {
     const zeroContext = new SpanContext({
       traceId: id('0'),
@@ -214,7 +228,7 @@ class DatadogSpan {
       'ptr.hash': ptrHash,
       'link.kind': 'span-pointer'
     }
-    this.addLink(zeroContext, attributes)
+    this.addLink({ context: zeroContext, attributes })
   }
 
   addEvent (name, attributesOrStartTime, startTime) {

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

@@ -3,6 +3,14 @@
 const aws = require('./aws.json')
 const sdks = { aws }
 
+/**
+ * Builds rules per service for a given SDK, appending user-provided rules.
+ *
+ * @param {Record<string, { request: string[], response: string[], expand: string[] }>} sdk
+ * @param {string[]} requestInput
+ * @param {string[]} responseInput
+ * @returns {Record<string, { request: string[], response: string[], expand: string[] }>}
+ */
 function getSDKRules (sdk, requestInput, responseInput) {
   const sdkServiceRules = {}
   for (const [service, serviceRules] of Object.entries(sdk)) {
@@ -17,6 +25,14 @@ function getSDKRules (sdk, requestInput, responseInput) {
   return sdkServiceRules
 }
 
+/**
+ * Appends input rules to all supported SDKs and returns a structure mapping SDK
+ * names to per-service rules.
+ *
+ * @param {string[]} [requestInput=[]]
+ * @param {string[]} [responseInput=[]]
+ * @returns {Record<string, Record<string, { request: string[], response: string[], expand: string[] }>>}
+ */
 function appendRules (requestInput = [], responseInput = []) {
   const sdkRules = {}
   for (const [name, sdk] of Object.entries(sdks)) {

package/packages/dd-trace/src/payload-tagging/index.js

@@ -14,8 +14,8 @@ const { tagsFromObject } = require('./tagging')
 /**
  * Given an identified value, attempt to parse it as JSON if relevant
  *
- * @param {any} value
- * @returns {any} the parsed object if parsing was successful, the input if not
+ * @param {unknown} value
+ * @returns {unknown} the parsed object if parsing was successful, the input if not
  */
 function maybeJSONParseValue (value) {
   if (typeof value !== 'string' || value[0] !== '{') {
@@ -32,8 +32,8 @@ function maybeJSONParseValue (value) {
 /**
  * Apply expansion to all expansion JSONPath queries
  *
- * @param {Object} object
- * @param {[String]} expansionRules list of JSONPath queries
+ * @param {Record<string, unknown>} object
+ * @param {string[]} expansionRules list of JSONPath queries
  */
 function expand (object, expansionRules) {
   for (const rule of expansionRules) {
@@ -46,8 +46,8 @@ function expand (object, expansionRules) {
 /**
  * Apply redaction to all redaction JSONPath queries
  *
- * @param {Object} object
- * @param {[String]} redactionRules
+ * @param {Record<string, unknown>} object
+ * @param {string[]} redactionRules
  */
 function redact (object, redactionRules) {
   for (const rule of redactionRules) {
@@ -65,15 +65,10 @@ function redact (object, redactionRules) {
  *    as there are leaf values in the object
  * This function performs side-effects on a _copy_ of the input object.
  *
- * @param {Object} config sdk configuration for the service
- * @param {[String]} config.expand expansion rules for the service
- * @param {[String]} config.request redaction rules for the request
- * @param {[String]} config.response redaction rules for the response
- * @param {Object} object the input object to generate tags from
- * @param {Object} opts tag generation options
- * @param {String} opts.prefix prefix for all generated tags
- * @param {number} opts.maxDepth maximum depth to traverse the object
- * @returns
+ * @param {{ expand: string[], request: string[], response: string[] }} config sdk configuration for the service
+ * @param {Record<string, unknown>} object the input object to generate tags from
+ * @param {{ prefix: string, maxDepth: number }} opts tag generation options
+ * @returns {Record<string, string|boolean>} Tags map
  */
 function computeTags (config, object, opts) {
   const payload = rfdc(object)
@@ -84,10 +79,26 @@ function computeTags (config, object, opts) {
   return tagsFromObject(payload, opts)
 }
 
+/**
+ * Compute request tags with the request prefix.
+ *
+ * @param {{ expand: string[], request: string[], response: string[] }} config
+ * @param {Record<string, unknown>} object
+ * @param {{ maxDepth: number }} opts
+ * @returns {Record<string, string|boolean>}
+ */
 function tagsFromRequest (config, object, opts) {
   return computeTags(config, object, { ...opts, prefix: PAYLOAD_TAG_REQUEST_PREFIX })
 }
 
+/**
+ * Compute response tags with the response prefix.
+ *
+ * @param {{ expand: string[], request: string[], response: string[] }} config
+ * @param {Record<string, unknown>} object
+ * @param {{ maxDepth: number }} opts
+ * @returns {Record<string, string|boolean>}
+ */
 function tagsFromResponse (config, object, opts) {
   return computeTags(config, object, { ...opts, prefix: PAYLOAD_TAG_RESPONSE_PREFIX })
 }

package/packages/dd-trace/src/payload-tagging/tagging.js

@@ -8,24 +8,33 @@ const redactedKeys = new Set([
 const truncated = 'truncated'
 const redacted = 'redacted'
 
+/**
+ * Escapes dots in keys to preserve hierarchy in flattened tag names.
+ *
+ * @param {string} key
+ * @returns {string}
+ */
 function escapeKey (key) {
   return key.replaceAll('.', String.raw`\.`)
 }
 
 /**
-   * Compute normalized payload tags from any given object.
-   *
-   * @param {object} object
-   * @param {import('./mask').Mask} mask
-   * @param {number} maxDepth
-   * @param {string} prefix
-   * @returns
-   */
+ * Compute normalized payload tags from any given object.
+ *
+ * - Limits total tag count to `PAYLOAD_TAGGING_MAX_TAGS - 1` plus the `_dd.payload_tags_incomplete` flag
+ * - Truncates values at max depth and for large scalars
+ * - Redacts known sensitive keys
+ *
+ * @param {unknown} object - Input to flatten into tags
+ * @param {{ maxDepth: number, prefix: string }} opts - Traversal options
+ * @returns {Record<string, string|boolean>} Map of tag names to values
+ */
 function tagsFromObject (object, opts) {
   const { maxDepth, prefix } = opts
 
   let tagCount = 0
   let abort = false
+  /** @type {Record<string, string|boolean>} */
   const result = {}
 
   function tagRec (prefix, object, depth = 0) {

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

@@ -20,8 +20,10 @@ function findPkg () {
 
   const filePath = findUp('package.json', root, directory)
 
+  if (filePath === undefined) return {}
+
   try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+    return require(filePath)
   } catch {
     return {}
   }

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

@@ -6,6 +6,15 @@ const plugins = require('./plugins')
 const log = require('./log')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
+// Test optimization plugins that should only be enabled when isCiVisibility is true
+const TEST_OPTIMIZATION_PLUGINS = new Set([
+  'jest',
+  'vitest',
+  'cucumber',
+  'mocha',
+  'playwright'
+])
+
 const loadChannel = channel('dd-trace:instrumentation:load')
 
 // instrument everything that needs Plugin System V2 instrumentation
@@ -74,6 +83,13 @@ module.exports = class PluginManager {
 
     if (!Plugin) return
     if (!this._tracerConfig) return // TODO: don't wait for tracer to be initialized
+
+    // Check if this is a Test Optimization plugin and Test Optimization is not enabled
+    if (TEST_OPTIMIZATION_PLUGINS.has(name) && !this._tracerConfig.isCiVisibility) {
+      log.debug('Plugin "%s" is not initialized because Test Optimization mode is not enabled.', name)
+      return
+    }
+
     if (!this._pluginsByName[name]) {
       this._pluginsByName[name] = new Plugin(this._tracer, this._tracerConfig)
     }
@@ -148,7 +164,8 @@ module.exports = class PluginManager {
       middlewareTracingEnabled,
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
-      traceWebsocketMessagesSeparateTraces
+      traceWebsocketMessagesSeparateTraces,
+      experimental
     } = this._tracerConfig
 
     const sharedConfig = {
@@ -166,7 +183,8 @@ module.exports = class PluginManager {
       isServiceUserProvided,
       traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
-      traceWebsocketMessagesSeparateTraces
+      traceWebsocketMessagesSeparateTraces,
+      experimental
     }
 
     if (logInjection !== undefined) {