dd-trace 5.108.0 → 5.110.0

package/packages/datadog-plugin-aws-sdk/src/services/kinesis.js

@@ -8,11 +8,18 @@ function recordDataAsString (data) {
   return Buffer.isBuffer(data) ? data.toString('utf8') : Buffer.from(data).toString('utf8')
 }
 
+// Caps the promise-path iterator→stream cache so abandoned shard iterators
+// (AWS expires them after 5 minutes) can't grow it without bound. Polling loops
+// delete on consume, so their working set is ~the active shard count.
+const MAX_TRACKED_SHARD_ITERATORS = 1000
+
 class Kinesis extends BaseAwsSdkPlugin {
   static id = 'kinesis'
   static peerServicePrecursors = ['streamname']
   static isPayloadReporter = true
 
+  #shardIteratorStreams = new Map()
+
   constructor (...args) {
     super(...args)
 
@@ -20,51 +27,107 @@ class Kinesis extends BaseAwsSdkPlugin {
     // in the base class
     this.requestTags = new WeakMap()
 
-    this.addBind('apm:aws:response:start:kinesis', ctx => {
-      const { request, response } = ctx
-      const plugin = this
+    this.addBind('apm:aws:response:start:kinesis', ctx => this.#startResponseSpan(ctx))
+
+    // Promise / event-emitter calls never publish response:start, so create and finish the
+    // consumer span from request:complete instead. Callback calls handle it via the bind above.
+    this.addSub('apm:aws:request:complete:kinesis', ctx => {
+      if (ctx.cbExists) return
+      // v2 nests the SDK payload under response.data; v3 spreads the output onto response.
+      const response = ctx.response?.data ?? ctx.response
+      const responseCtx = { request: ctx.request, response }
+      this.#startResponseSpan(responseCtx)
+      if (responseCtx.needsFinish) this.finish(responseCtx)
+      // The async store that carries streamName to getRecords on the callback path is
+      // absent here, so map each shard iterator to its stream for the DSM topic tag.
+      if (this.config.dsmEnabled) this.#trackShardStream(ctx.request, response)
+    })
 
-      let store = this._parentMap.get(request)
+    this.addSub('apm:aws:response:finish:kinesis', ctx => {
+      if (!ctx.needsFinish) return
+      this.finish(ctx)
+    })
+  }
 
-      // if we have either of these operations, we want to store the streamName param
-      // since it is not typically available during get/put records requests
-      if (request.operation === 'getShardIterator' || request.operation === 'listShards') {
-        return this.storeStreamName(request.params, request.operation, store)
-      }
+  /**
+   * @param {object} ctx Completion context carrying the SDK request and response.
+   */
+  #startResponseSpan (ctx) {
+    const { request, response } = ctx
 
-      if (request.operation === 'getRecords') {
-        let span
-        const responseExtraction = this.responseExtract(request.params, request.operation, response)
-        if (responseExtraction && responseExtraction.maybeChildOf) {
-          ctx.needsFinish = true
-          const options = {
-            childOf: responseExtraction.maybeChildOf,
-            meta: {
-              ...this.requestTags.get(request),
-              'span.kind': 'server',
-            },
-            integrationName: 'aws-sdk',
-          }
-          span = plugin.startSpan('aws.response', options, ctx)
-          store = ctx.currentStore
-        }
+    let store = this._parentMap.get(request)
 
-        // get the stream name that should have been stored previously
-        const { streamName } = store
+    // if we have either of these operations, we want to store the streamName param
+    // since it is not typically available during get/put records requests
+    if (request.operation === 'getShardIterator' || request.operation === 'listShards') {
+      return this.storeStreamName(request.params, request.operation, store)
+    }
 
-        // extract DSM context after as we might not have a parent-child but may have a DSM context
-        this.responseExtractDSMContext(
-          request.operation, request.params, response, span || null, { streamName }
-        )
+    if (request.operation === 'getRecords') {
+      let span
+      const responseExtraction = this.responseExtract(request.params, request.operation, response)
+      if (responseExtraction && responseExtraction.maybeChildOf) {
+        ctx.needsFinish = true
+        const options = {
+          childOf: responseExtraction.maybeChildOf,
+          meta: {
+            ...this.requestTags.get(request),
+            'span.kind': 'server',
+          },
+          integrationName: 'aws-sdk',
+        }
+        span = this.startSpan('aws.response', options, ctx)
+        store = ctx.currentStore
       }
 
-      return store
-    })
+      if (this.config.dsmEnabled) {
+        // streamName rides the async store on the callback path; the promise path has no
+        // such link, so fall back to the iterator the producer returned.
+        const streamName = store?.streamName ?? this.#shardIteratorStreams.get(request.params.ShardIterator)
+        this.responseExtractDSMContext(request.operation, request.params, response, span || null, { streamName })
+      }
+    }
 
-    this.addSub('apm:aws:response:finish:kinesis', ctx => {
-      if (!ctx.needsFinish) return
-      this.finish(ctx)
-    })
+    return store
+  }
+
+  /**
+   * @param {object} request SDK request; reads `operation` and `params`.
+   * @param {object} response SDK output; reads `ShardIterator` / `NextShardIterator`.
+   */
+  #trackShardStream (request, response) {
+    if (request.operation === 'getShardIterator') {
+      this.#rememberShardStream(response?.ShardIterator, request.params?.StreamName)
+    } else if (request.operation === 'getRecords') {
+      this.#advanceShardStream(request.params?.ShardIterator, response?.NextShardIterator)
+    }
+  }
+
+  /**
+   * @param {string} [iterator] Shard iterator the producer returned.
+   * @param {string} [streamName] Stream the iterator belongs to.
+   */
+  #rememberShardStream (iterator, streamName) {
+    if (!iterator || streamName === undefined) return
+    // FIFO-evict the oldest entry (Map keeps insertion order) when the cap is hit; only
+    // abandoned iterators get here, so no realistic test drives the cap (eviction ignored).
+    /* istanbul ignore if */
+    if (this.#shardIteratorStreams.size >= MAX_TRACKED_SHARD_ITERATORS) {
+      this.#shardIteratorStreams.delete(this.#shardIteratorStreams.keys().next().value)
+    }
+    this.#shardIteratorStreams.set(iterator, streamName)
+  }
+
+  /**
+   * @param {string} [consumedIterator] Iterator just passed to getRecords.
+   * @param {string} [nextIterator] NextShardIterator for the following poll.
+   */
+  #advanceShardStream (consumedIterator, nextIterator) {
+    const streamName = this.#shardIteratorStreams.get(consumedIterator)
+    if (streamName === undefined) return
+    this.#shardIteratorStreams.delete(consumedIterator)
+    // carry the stream onto the next iterator so the polling loop keeps its topic
+    if (nextIterator) this.#rememberShardStream(nextIterator, streamName)
   }
 
   generateTags (params, operation, response) {

package/packages/datadog-plugin-aws-sdk/src/services/sqs.js

@@ -54,41 +54,16 @@ class Sqs extends BaseAwsSdkPlugin {
     // in the base class
     this.requestTags = new WeakMap()
 
-    this.addBind('apm:aws:response:start:sqs', ctx => {
-      const { request, response } = ctx
-      const contextExtraction = this.responseExtract(request.params, request.operation, response)
-
-      let store = this._parentMap.get(request)
-      let span
-      let parsedMessageAttributes
-      let parsedFirstBody
-      let firstBodyChecked = false
-      if (contextExtraction !== undefined) {
-        parsedFirstBody = contextExtraction.parsedBody
-        firstBodyChecked = contextExtraction.bodyChecked === true
-        if (contextExtraction.datadogContext !== undefined) {
-          ctx.needsFinish = true
-          const options = {
-            childOf: contextExtraction.datadogContext,
-            meta: {
-              ...this.requestTags.get(request),
-              'span.kind': 'server',
-            },
-            integrationName: 'aws-sdk',
-          }
-          parsedMessageAttributes = contextExtraction.parsedAttributes
-          span = this.startSpan('aws.response', options, ctx)
-          store = ctx.currentStore
-        }
-      }
-
-      // Extract DSM context after, as we might not have a parent-child but may have a DSM context.
-      this.responseExtractDSMContext(
-        request.operation, request.params, response, span ?? null,
-        { parsedAttributes: parsedMessageAttributes, parsedFirstBody, firstBodyChecked }
-      )
-
-      return store
+    this.addBind('apm:aws:response:start:sqs', ctx => this.#startResponseSpan(ctx))
+
+    // No-callback receives (promises, event emitters) never publish response:start, so link and
+    // finish the consumer span here instead. Callback paths reach the same logic via the bind above.
+    this.addSub('apm:aws:request:complete:sqs', ctx => {
+      if (ctx.cbExists) return
+      // v2 nests the SDK payload under response.data; v3 spreads the output onto response.
+      const responseCtx = { request: ctx.request, response: ctx.response?.data ?? ctx.response }
+      this.#startResponseSpan(responseCtx)
+      if (responseCtx.needsFinish) this.finish(responseCtx)
     })
 
     this.addSub('apm:aws:response:finish:sqs', ctx => {
@@ -97,6 +72,57 @@ class Sqs extends BaseAwsSdkPlugin {
     })
   }
 
+  /**
+   * Start the consumer (`aws.response`) span for a receive. The first message carrying trace
+   * context becomes the parent; every additional one fans in as a span link.
+   *
+   * @param {{ request: object, response: object, needsFinish?: boolean, currentStore?: object }} ctx
+   * @returns {object | undefined} The store to activate for the consumer span, else the parent store.
+   */
+  #startResponseSpan (ctx) {
+    const { request, response } = ctx
+    const carriers = this.responseExtract(request.params, request.operation, response)
+
+    let store = this._parentMap.get(request)
+    let span
+
+    if (carriers !== undefined) {
+      // request:start records requestTags only after the isEnabled gate, so an absent entry
+      // means this consumer is disabled — gate on it instead of paying isEnabled again here.
+      const requestTags = this.requestTags.get(request)
+      if (requestTags !== undefined) {
+        // A receive can return messages from many producers; fanning the extra ones in as span
+        // links is the shape dd-trace-java and dd-trace-py use for batch SQS receives.
+        for (const carrier of carriers) {
+          if (carrier === undefined) continue
+          const datadogContext = this.tracer.extract('text_map', carrier)
+          // A DSM-only carrier (a non-first sendMessageBatch entry when batchPropagationEnabled
+          // is off) extracts to null; span.addLink dereferences the context and would throw on it.
+          if (datadogContext === null) continue
+          if (span === undefined) {
+            ctx.needsFinish = true
+            span = this.startSpan('aws.response', {
+              childOf: datadogContext,
+              meta: {
+                ...requestTags,
+                'span.kind': 'server',
+              },
+              integrationName: 'aws-sdk',
+            }, ctx)
+            store = ctx.currentStore
+          } else {
+            span.addLink({ context: datadogContext })
+          }
+        }
+      }
+    }
+
+    // Extract DSM context after, as we might not have a parent-child but may have a DSM context.
+    this.responseExtractDSMContext(request.operation, request.params, response, span ?? null, carriers)
+
+    return store
+  }
+
   operationFromRequest (request) {
     switch (request.operation) {
       case 'receiveMessage':
@@ -166,19 +192,39 @@ class Sqs extends BaseAwsSdkPlugin {
     return tags
   }
 
+  /**
+   * Parse the trace-context carrier of every received message, in message order.
+   * Entries are `undefined` for messages that carry no `_datadog` context.
+   *
+   * @param {{ MaxNumberOfMessages?: number }} params
+   * @param {string} operation
+   * @param {{ Messages?: object[] }} response
+   * @returns {Array<Record<string, string> | undefined> | undefined}
+   */
   responseExtract (params, operation, response) {
     if (operation !== 'receiveMessage') return
-    if (params.MaxNumberOfMessages && params.MaxNumberOfMessages !== 1) return
-    if (!response || !response.Messages || !response.Messages[0]) return
+    if (!response?.Messages?.length) return
 
-    let message = response.Messages[0]
-    let parsedBody
+    return response.Messages.map(message => this.parseMessageCarrier(message))
+  }
 
+  /**
+   * Resolve the trace-context carrier for a single received message. The
+   * `MessageAttributes._datadog` text map (direct SQS or SNS to SQS) wins;
+   * otherwise the EventBridge envelope, optionally wrapped in an SNS
+   * `Notification` (see getEventBridgeContext). Checking MessageAttributes first
+   * avoids parsing a large SNS `Message` just to rule out an EventBridge envelope.
+   *
+   * @param {object} message A single `response.Messages` entry.
+   * @returns {Record<string, string> | undefined}
+   */
+  parseMessageCarrier (message) {
+    let parsedBody
     if (message.Body) {
       try {
         parsedBody = JSON.parse(message.Body)
       } catch {
-        // SQS to SQS
+        // Opaque, non-JSON body (SQS to SQS).
       }
       // SNS to SQS
       if (parsedBody?.Type === 'Notification') {
@@ -186,34 +232,9 @@ class Sqs extends BaseAwsSdkPlugin {
       }
     }
 
-    // Check MessageAttributes first (common direct-SQS/SNS path): avoids parsing
-    // the body (e.g. a large SNS `Message`) just to rule out an EventBridge
-    // envelope. Precedence matches responseExtractDSMContext.
     const datadogAttribute = message.MessageAttributes?._datadog
-    if (datadogAttribute) {
-      const parsedAttributes = this.parseDatadogAttributes(datadogAttribute)
-      if (parsedAttributes) {
-        return {
-          datadogContext: this.tracer.extract('text_map', parsedAttributes),
-          parsedAttributes,
-          parsedBody,
-          bodyChecked: true,
-        }
-      }
-    }
-
-    // Then the EventBridge envelope (optionally via SNS); see getEventBridgeContext.
-    const eventBridgeContext = getEventBridgeContext(parsedBody)
-    if (eventBridgeContext) {
-      return {
-        datadogContext: this.tracer.extract('text_map', eventBridgeContext),
-        parsedAttributes: eventBridgeContext,
-        parsedBody,
-        bodyChecked: true,
-      }
-    }
-
-    return { parsedBody, bodyChecked: true }
+    const carrier = datadogAttribute ? this.parseDatadogAttributes(datadogAttribute) : undefined
+    return carrier ?? getEventBridgeContext(parsedBody)
   }
 
   parseDatadogAttributes (attributes) {
@@ -230,51 +251,39 @@ class Sqs extends BaseAwsSdkPlugin {
     }
   }
 
-  responseExtractDSMContext (operation, params, response, span, kwargs = {}) {
-    let { parsedAttributes } = kwargs
-    const { parsedFirstBody, firstBodyChecked } = kwargs
+  /**
+   * @param {string} operation
+   * @param {{ QueueUrl: string }} params
+   * @param {{ Messages?: object[] }} response
+   * @param {import('../../../dd-trace/src/opentracing/span') | null} span
+   * @param {Array<Record<string, string> | undefined>} [carriers] Per-message carriers already
+   *   parsed by `responseExtract`; reused so each message body is parsed once. When omitted, the
+   *   carriers are parsed here.
+   */
+  responseExtractDSMContext (operation, params, response, span, carriers) {
     if (!this.config.dsmEnabled) return
     if (operation !== 'receiveMessage') return
-    if (!response || !response.Messages || !response.Messages[0]) return
+    if (!response?.Messages?.length) return
 
+    const messages = response.Messages
     // Only attribute payloadSize to the span when there is a single message.
-    span = response.Messages.length > 1 ? null : span
+    span = messages.length > 1 ? null : span
 
     // QueueUrl is the same for the whole receive batch.
     const queue = params.QueueUrl.slice(params.QueueUrl.lastIndexOf('/') + 1)
 
-    for (let i = 0; i < response.Messages.length; i++) {
-      let message = response.Messages[i]
-      if (!parsedAttributes) {
-        let body
-        // responseExtract already parsed message[0]; reuse that result instead of re-parsing.
-        if (i === 0 && firstBodyChecked) {
-          body = parsedFirstBody
-        } else if (message.Body) {
-          try {
-            body = JSON.parse(message.Body)
-          } catch {
-            // SQS to SQS
-          }
-        }
-        // SNS to SQS
-        if (body?.Type === 'Notification') {
-          message = body
-        }
-        // MessageAttributes for direct SQS/SNS; else the EventBridge envelope.
-        parsedAttributes = message.MessageAttributes?._datadog
-          ? this.parseDatadogAttributes(message.MessageAttributes._datadog)
-          : getEventBridgeContext(body)
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i]
+      const carrier = carriers === undefined ? this.parseMessageCarrier(message) : carriers[i]
+      if (carrier) {
+        // Inert for EventBridge until its producer emits a pathway (separate
+        // change) — no `dd-pathway-ctx-base64` to decode yet; SQS/SNS decode now.
+        this.tracer.decodeDataStreamsContext(carrier)
       }
       const payloadSize = getHeadersSize({
         Body: message.Body,
         MessageAttributes: message.MessageAttributes,
       })
-      if (parsedAttributes) {
-        // Inert for EventBridge until its producer emits a pathway (separate
-        // change) — no `dd-pathway-ctx-base64` to decode yet; SQS/SNS decode now.
-        this.tracer.decodeDataStreamsContext(parsedAttributes)
-      }
       this.tracer
         .setCheckpoint(['direction:in', `topic:${queue}`, 'type:sqs'], span, payloadSize)
     }

package/packages/datadog-plugin-bullmq/src/filter.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const log = require('../../dd-trace/src/log')
+
+/**
+ * @typedef {object} BullmqJobShape
+ * @property {string} [name]
+ * @property {unknown} [data]
+ * @property {unknown} [opts]
+ * @property {string} [queueName]
+ */
+
+/**
+ * @typedef {(job: BullmqJobShape) => boolean} BullmqFilter
+ */
+
+/**
+ * Resolve a user-provided filter from plugin config. Returns `undefined` when
+ * no filter is configured so callers can short-circuit the filtering path on a
+ * cheap truthy check. If `producerFilter` is present but not a function, log
+ * an error and fall back to no filter.
+ *
+ * @param {{ producerFilter?: unknown }} config Plugin config that may carry a `producerFilter`.
+ * @returns {BullmqFilter | undefined}
+ */
+function getFilter (config) {
+  if (typeof config?.producerFilter === 'function') {
+    return /** @type {BullmqFilter} */ (config.producerFilter)
+  }
+  if (config?.producerFilter !== undefined) {
+    log.error('Expected `producerFilter` to be a function. Ignoring.')
+  }
+}
+
+module.exports = { getFilter }

package/packages/datadog-plugin-bullmq/src/producer.js

@@ -3,6 +3,9 @@
 const log = require('../../dd-trace/src/log')
 const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
 const { DsmPathwayCodec, getMessageSize } = require('../../dd-trace/src/datastreams')
+const { getFilter } = require('./filter')
+
+const filteredJobs = Symbol('bullmq.filteredJobs')
 
 // Customer-controlled metadata may be malformed JSON. Returning a fresh `{}`
 // on parse failure keeps the publish path alive instead of throwing into
@@ -31,6 +34,19 @@ class BaseBullmqProducerPlugin extends ProducerPlugin {
   }
 
   bindStart (ctx) {
+    let instrument = true
+    if (this.config.producerFilter) {
+      try {
+        instrument = this.shouldInstrument(ctx)
+      } catch (error) {
+        log.error('bullmq: producerFilter threw, filtering is disabled: %s', error.message)
+      }
+    }
+
+    if (!instrument) {
+      return { noop: true }
+    }
+
     const { resource, meta } = this.getSpanData(ctx)
     const span = this.startSpan({
       resource,
@@ -48,6 +64,17 @@ class BaseBullmqProducerPlugin extends ProducerPlugin {
     return ctx.currentStore
   }
 
+  configure (config) {
+    if (typeof config === 'boolean') {
+      return super.configure(config)
+    }
+    return super.configure({ ...config, producerFilter: getFilter(config) })
+  }
+
+  shouldInstrument (ctx) {
+    throw new Error('shouldInstrument must be implemented by subclass')
+  }
+
   getSpanData (ctx) {
     throw new Error('getSpanData must be implemented by subclass')
   }
@@ -87,6 +114,15 @@ class BaseBullmqProducerPlugin extends ProducerPlugin {
 class QueueAddPlugin extends BaseBullmqProducerPlugin {
   static prefix = 'tracing:orchestrion:bullmq:Queue_add'
 
+  shouldInstrument (ctx) {
+    return this.config.producerFilter({
+      name: ctx.arguments?.[0],
+      data: ctx.arguments?.[1],
+      opts: ctx.arguments?.[2],
+      queueName: ctx.self?.name,
+    })
+  }
+
   getSpanData (ctx) {
     const queueName = ctx.self?.name || 'bullmq'
     return {
@@ -128,6 +164,40 @@ class QueueAddPlugin extends BaseBullmqProducerPlugin {
 class QueueAddBulkPlugin extends BaseBullmqProducerPlugin {
   static prefix = 'tracing:orchestrion:bullmq:Queue_addBulk'
 
+  shouldInstrument (ctx) {
+    const jobs = this.#getFilteredJobs(ctx)
+    // Empty bulk calls are publish attempts and should keep producing a span.
+    return jobs === undefined || jobs.length > 0 || ctx.arguments?.[0].length === 0
+  }
+
+  #getFilteredJobs (ctx) {
+    if (Object.hasOwn(ctx, filteredJobs)) return ctx[filteredJobs]
+
+    const jobs = ctx.arguments?.[0]
+    if (!Array.isArray(jobs)) return
+
+    let allowedJobs
+    if (this.config.producerFilter) {
+      const queueName = ctx.self?.name
+      try {
+        allowedJobs = []
+        for (const job of jobs) {
+          if (job && this.config.producerFilter({ name: job.name, data: job.data, opts: job.opts, queueName })) {
+            allowedJobs.push(job)
+          }
+        }
+      } catch (error) {
+        log.error('bullmq: producerFilter threw, filtering is disabled: %s', error.message)
+        allowedJobs = jobs.filter(Boolean)
+      }
+    } else {
+      allowedJobs = jobs
+    }
+
+    ctx[filteredJobs] = allowedJobs
+    return allowedJobs
+  }
+
   operationName () {
     return 'bullmq.addBulk'
   }
@@ -139,14 +209,14 @@ class QueueAddBulkPlugin extends BaseBullmqProducerPlugin {
       resource: queueName,
       meta: {
         'messaging.destination.name': ctx.self?.name,
-        'messaging.batch.message_count': Array.isArray(jobs) ? jobs.length : undefined,
+        'messaging.batch.message_count': jobs?.length,
       },
     }
   }
 
   injectTraceContext (span, ctx) {
-    const jobs = ctx.arguments?.[0]
-    if (!Array.isArray(jobs)) return
+    const jobs = this.#getFilteredJobs(ctx)
+    if (!jobs) return
 
     const cache = []
     for (let i = 0; i < jobs.length; i++) {
@@ -159,7 +229,7 @@ class QueueAddBulkPlugin extends BaseBullmqProducerPlugin {
   }
 
   setProducerCheckpoint (span, ctx) {
-    const jobs = ctx.arguments?.[0] || []
+    const jobs = this.#getFilteredJobs(ctx) || []
     const queueName = ctx.self?.name || 'bullmq'
     const edgeTags = ['direction:out', `topic:${queueName}`, 'type:bullmq']
     const cache = ctx._ddMetadata
@@ -180,6 +250,16 @@ class QueueAddBulkPlugin extends BaseBullmqProducerPlugin {
 class FlowProducerAddPlugin extends BaseBullmqProducerPlugin {
   static prefix = 'tracing:orchestrion:bullmq:FlowProducer_add'
 
+  shouldInstrument (ctx) {
+    const flow = ctx.arguments?.[0]
+    return this.config.producerFilter({
+      name: flow?.name,
+      data: flow?.data,
+      opts: flow?.opts,
+      queueName: flow?.queueName,
+    })
+  }
+
   getSpanData (ctx) {
     const flow = ctx.arguments?.[0]
     const queueName = flow?.queueName || 'bullmq'

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -11,6 +11,7 @@ const {
   TEST_IS_RUM_ACTIVE,
   TEST_CODE_OWNERS,
   getTestEnvironmentMetadata,
+  getTestLevelsMetadataTags,
   CI_APP_ORIGIN,
   getTestParentSpan,
   getCodeOwnersFileEntries,
@@ -23,6 +24,7 @@ const {
   TEST_MODULE_ID,
   TEST_SESSION_ID,
   TEST_COMMAND,
+  TEST_LEVELS_METADATA,
   TEST_MODULE,
   TEST_SOURCE_START,
   finishAllTraceSpans,
@@ -1043,7 +1045,13 @@ class CypressPlugin {
     )
 
     if (this.tracer._tracer._exporter?.addMetadataTags) {
-      const metadataTags = { '*': { [TEST_COMMAND]: this.command, [TEST_SESSION_NAME]: testSessionName } }
+      const metadataTags = {
+        [TEST_LEVELS_METADATA]: {
+          [TEST_COMMAND]: this.command,
+          [TEST_SESSION_NAME]: testSessionName,
+          ...getTestLevelsMetadataTags(this.testEnvironmentMetadata),
+        },
+      }
       const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id, this.frameworkVersion)
       metadataTags.test = {
         ...libraryCapabilitiesTags,

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

@@ -5,6 +5,7 @@ const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 class FsPlugin extends TracingPlugin {
   static id = 'fs'
   static operation = 'operation'
+  static experimental = true
 
   configure (...args) {
     return super.configure(...args)