dd-trace 5.103.0 → 5.105.0

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

@@ -24,6 +24,40 @@ const suppressedTestFailures = new Map()
 // to a cross-origin URL, safeGetRum() handles the access error.
 let originalWindow
 
+let currentTestCommands = []
+const commandStartTimes = new Map()
+const INTERNAL_CYPRESS_COMMANDS = new Set(['wrap', 'then', 'noop'])
+
+Cypress.on('command:start', (command) => {
+  commandStartTimes.set(command.get('id'), { startTime: Date.now(), name: command.get('name') })
+})
+
+Cypress.on('command:end', (command) => {
+  const id = command.get('id')
+  const entry = commandStartTimes.get(id)
+  commandStartTimes.delete(id)
+
+  const name = command.get('name')
+  const args = command.get('args')
+  if (name === 'task' && args && typeof args[0] === 'string' && args[0].startsWith('dd:')) {
+    return
+  }
+  if (INTERNAL_CYPRESS_COMMANDS.has(name)) {
+    return
+  }
+  if (entry == null) {
+    return
+  }
+  const err = command.get('err')
+  currentTestCommands.push({
+    name,
+    startTime: entry.startTime,
+    endTime: Date.now(),
+    // Serialize the error to a plain object so it survives cy.task JSON transport.
+    error: err ? { message: err.message, stack: err.stack, name: err.name } : null,
+  })
+})
+
 // If the test is using multi domain with cy.origin, trying to access
 // window properties will result in a cross origin error.
 function safeGetRum (window) {
@@ -56,6 +90,29 @@ function getTestProperties (testName) {
 // By not re-throwing the error, Cypress marks the test as passed
 // This allows quarantined tests to run but not affect the exit code
 Cypress.on('fail', (err, runnable) => {
+  // For commands that time out, command:end may never fire.
+  // Finalize any in-flight commands so their step spans carry the error.
+  const hadInFlightCommands = commandStartTimes.size > 0
+  for (const [, { startTime, name }] of commandStartTimes) {
+    if (INTERNAL_CYPRESS_COMMANDS.has(name)) continue
+    currentTestCommands.push({
+      name,
+      startTime,
+      endTime: Date.now(),
+      error: { message: err.message, stack: err.stack, name: err.name },
+    })
+  }
+  commandStartTimes.clear()
+
+  // If command:end fired for all commands (none in-flight) but the last command
+  // has no error, it means command:end fired before the error was attached to it.
+  if (!hadInFlightCommands && currentTestCommands.length > 0) {
+    const lastCommand = currentTestCommands[currentTestCommands.length - 1]
+    if (!lastCommand.error) {
+      lastCommand.error = { message: err.message, stack: err.stack, name: err.name }
+    }
+  }
+
   if (!isTestManagementEnabled) {
     throw err
   }
@@ -169,6 +226,9 @@ beforeEach(function () {
     retryReasonsByTestName.delete(testName)
   }
 
+  currentTestCommands = []
+  commandStartTimes.clear()
+
   cy.on('window:load', (win) => {
     originalWindow = win
   })
@@ -212,6 +272,11 @@ beforeEach(function () {
     if (shouldSkip) {
       this.skip()
     }
+  }).then(() => {
+    // Clear any commands accumulated during DD-owned setup (e.g. setCookie, RUM restart)
+    // so they are not reported as user test steps.
+    currentTestCommands = []
+    commandStartTimes.clear()
   })
 })
 
@@ -289,6 +354,9 @@ afterEach(function () {
     testInfo.testSourceStack = invocationDetails.stack
   } catch {}
 
+  // Snapshot before any DD-owned Cypress commands so they are not reported as test steps.
+  const commandsToReport = [...currentTestCommands]
+
   const rum = safeGetRum(originalWindow)
   if (rum) {
     testInfo.isRUMActive = true
@@ -310,5 +378,5 @@ afterEach(function () {
     suppressedTestFailures.delete(testName)
   }
 
-  cy.task('dd:afterEach', { test: testInfo, coverage })
+  cy.task('dd:afterEach', { test: testInfo, coverage, commands: commandsToReport })
 })

package/packages/datadog-plugin-dns/src/lookup.js

@@ -23,22 +23,24 @@ class DNSLookupPlugin extends ClientPlugin {
     return ctx.currentStore
   }
 
-  bindFinish (ctx) {
+  finish (ctx) {
     const span = ctx.currentStore.span
     const result = ctx.result
 
     if (Array.isArray(result)) {
-      const addresses = Array.isArray(result)
-        ? result.map(address => address.address).sort()
-        : [result]
-
+      // `lookup(..., { all: true })` or `dns.promises.lookup(..., { all: true })`.
+      const addresses = result.map(entry => entry.address).sort()
       span.setTag('dns.address', addresses[0])
       span.setTag('dns.addresses', addresses.join(','))
+    } else if (result && typeof result === 'object') {
+      // `dns.promises.lookup(...)` resolves to `{ address, family }`; the callback variant
+      // passes the address as a string.
+      span.setTag('dns.address', result.address)
     } else {
       span.setTag('dns.address', result)
     }
 
-    return ctx.parentStore
+    super.finish(ctx)
   }
 }
 

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

@@ -5,23 +5,43 @@ const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 class ElasticsearchPlugin extends DatabasePlugin {
   static id = 'elasticsearch'
 
+  #urlTag
+  #methodTag
+  #bodyTag
+  #paramsTag
+
+  constructor (...args) {
+    super(...args)
+
+    // Per-instance because `system` differs on the OpenSearchPlugin subclass.
+    const { system } = this
+    this.#urlTag = `${system}.url`
+    this.#methodTag = `${system}.method`
+    this.#bodyTag = `${system}.body`
+    this.#paramsTag = `${system}.params`
+  }
+
   bindStart (ctx) {
     const { params } = ctx
 
-    const body = getBody(params.body || params.bulkBody)
+    const meta = {
+      'db.type': this.system,
+      [this.#urlTag]: params.path,
+      [this.#methodTag]: params.method,
+      [this.#bodyTag]: getBody(params.body || params.bulkBody),
+    }
+
+    const queryString = params.querystring || params.query
+    if (queryString) {
+      meta[this.#paramsTag] = JSON.stringify(queryString)
+    }
 
     this.startSpan(this.operationName(), {
       service: this.serviceName({ pluginConfig: this.config }),
       resource: `${params.method} ${quantizePath(params.path)}`,
       type: 'elasticsearch',
       kind: 'client',
-      meta: {
-        'db.type': this.system,
-        [`${this.system}.url`]: params.path,
-        [`${this.system}.method`]: params.method,
-        [`${this.system}.body`]: body,
-        [`${this.system}.params`]: JSON.stringify(params.querystring || params.query),
-      },
+      meta,
     }, ctx)
 
     return ctx.currentStore

package/packages/datadog-plugin-google-cloud-pubsub/src/pubsub-push-subscription.js

@@ -181,7 +181,7 @@ class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
 
     if (linkContext) {
       if (span.addLink) {
-        span.addLink(linkContext, {})
+        span.addLink({ context: linkContext, attributes: {} })
       } else {
         span._links ??= []
         span._links.push({ context: linkContext, attributes: {} })

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

@@ -17,6 +17,8 @@ class GraphQLExecutePlugin extends TracingPlugin {
     const document = args.document
     const source = this.config.source && document && docSource
 
+    ctx.collapse = this.config.collapse
+
     const span = this.startSpan(this.operationName(), {
       service: this.config.service || this.serviceName(),
       resource: getSignature(document, name, type, this.config.signature),

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

@@ -3,59 +3,61 @@
 const dc = require('dc-polyfill')
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 
-const collapsedPathSym = Symbol('collapsedPaths')
-
 class GraphQLResolvePlugin extends TracingPlugin {
   static id = 'graphql'
   static operation = 'resolve'
 
+  /**
+   * @param {{
+   *   rootCtx: {
+   *     source?: string,
+   *     collapse: boolean,
+   *     collapsedFields?: Map<string, { ctx: object }>,
+   *   },
+   *   args: Record<string, unknown>,
+   *   path: { prev: object | undefined, key: string | number },
+   *   pathString: string,
+   *   fieldName: string,
+   *   returnType: { name: string },
+   *   fieldNode: { loc?: { start: number, end: number }, arguments?: object[], directives?: object[] } | undefined,
+   *   variableValues: Record<string, unknown> | undefined,
+   * }} fieldCtx
+   */
   start (fieldCtx) {
-    const { info, rootCtx, args, path: pathAsArray, pathString } = fieldCtx
-
-    // we need to get the parent span to the field if it exists for correct span parenting
-    // of nested fields
-    const parentField = getParentField(rootCtx, pathString)
-    const childOf = parentField?.ctx?.currentStore?.span
+    if (!shouldInstrument(this.config, fieldCtx.path)) return
 
-    fieldCtx.parent = parentField
+    const { rootCtx, args, path, pathString, fieldName, returnType, fieldNode, variableValues } = fieldCtx
 
-    if (!shouldInstrument(this.config, pathAsArray)) return
-    const computedPathString = this.config.collapse
-      ? buildCollapsedPathString(pathAsArray)
-      : pathString
+    // Siblings 2..N of a collapsed list share the first sibling's span, so
+    // skip span creation here. updateField still fires on the shared ctx and
+    // advances the shared span's finishTime.
+    if (rootCtx.collapse && rootCtx.collapsedFields?.has(pathString)) return
 
-    if (this.config.collapse) {
-      if (rootCtx.fields[computedPathString]) return
-
-      if (!rootCtx[collapsedPathSym]) {
-        rootCtx[collapsedPathSym] = Object.create(null)
-      } else if (rootCtx[collapsedPathSym][computedPathString]) {
-        return
-      }
-
-      rootCtx[collapsedPathSym][computedPathString] = true
-    }
+    const parentField = getParentField(rootCtx, path)
+    const childOf = parentField?.ctx?.currentStore?.span
 
     const document = rootCtx.source
-    const fieldNode = info.fieldNodes[0]
     const loc = this.config.source && document && fieldNode && fieldNode.loc
     const source = loc && document.slice(loc.start, loc.end)
 
+    let namedReturnType = returnType
+    while (namedReturnType.ofType) namedReturnType = namedReturnType.ofType
+
     const span = this.startSpan('graphql.resolve', {
       service: this.config.service,
-      resource: `${info.fieldName}:${info.returnType}`,
+      resource: `${fieldName}:${returnType}`,
       childOf,
       type: 'graphql',
       meta: {
-        'graphql.field.name': info.fieldName,
-        'graphql.field.path': computedPathString,
-        'graphql.field.type': info.returnType.name,
+        'graphql.field.name': fieldName,
+        'graphql.field.path': pathString,
+        'graphql.field.type': namedReturnType.name,
         'graphql.source': source,
       },
     }, fieldCtx)
 
     if (fieldNode && this.config.variables && fieldNode.arguments) {
-      const variables = this.config.variables(info.variableValues)
+      const variables = this.config.variables(variableValues)
 
       for (const arg of fieldNode.arguments) {
         if (arg.value?.name && arg.value.kind === 'Variable' && variables[arg.value.name.value]) {
@@ -66,7 +68,7 @@ class GraphQLResolvePlugin extends TracingPlugin {
     }
 
     if (this.resolverStartCh.hasSubscribers) {
-      this.resolverStartCh.publish({ ctx: rootCtx, resolverInfo: getResolverInfo(info, args) })
+      this.resolverStartCh.publish({ ctx: rootCtx, resolverInfo: getResolverInfo(fieldNode, fieldName, args) })
     }
 
     return fieldCtx.currentStore
@@ -76,11 +78,11 @@ class GraphQLResolvePlugin extends TracingPlugin {
     super(...args)
 
     this.addTraceSub('updateField', (ctx) => {
-      const { field, error, path: pathAsArray } = ctx
+      // start short-circuited on the depth gate, so there is no span to advance.
+      if (ctx.currentStore === undefined) return
 
-      if (!shouldInstrument(this.config, pathAsArray)) return
-
-      const span = ctx?.currentStore?.span || this.activeSpan
+      const { field, error } = ctx
+      const span = ctx.currentStore.span
       field.finishTime = span._getTime ? span._getTime() : 0
       field.error = field.error || error
     })
@@ -105,38 +107,38 @@ class GraphQLResolvePlugin extends TracingPlugin {
 
 // helpers
 
-function shouldInstrument (config, pathAsArray) {
-  if (config.depth < 0) return true
+/**
+ * @param {{ depth: number, collapse: boolean }} config
+ * @param {{ prev: object | undefined, key: string | number }} path
+ */
+function shouldInstrument (config, path) {
+  const depth = config.depth
+  if (depth < 0) return true
 
-  let depth = 0
+  let count = 0
   if (config.collapse) {
-    depth = pathAsArray.length
+    for (let curr = path; curr; curr = curr.prev) count += 1
   } else {
-    for (const segment of pathAsArray) {
-      if (typeof segment === 'string') depth += 1
+    for (let curr = path; curr; curr = curr.prev) {
+      if (typeof curr.key === 'string') count += 1
     }
   }
-
-  return config.depth >= depth
-}
-
-function buildCollapsedPathString (pathAsArray) {
-  let result = ''
-  for (const segment of pathAsArray) {
-    if (result.length > 0) result += '.'
-    result += typeof segment === 'number' ? '*' : segment
-  }
-  return result
+  return depth >= count
 }
 
-function getResolverInfo (info, args) {
+/**
+ * @param {object | undefined} fieldNode
+ * @param {string} fieldName
+ * @param {Record<string, unknown> | undefined} args
+ */
+function getResolverInfo (fieldNode, fieldName, args) {
   let resolverVars
 
   if (args && Object.keys(args).length > 0) {
     resolverVars = { ...args }
   }
 
-  const directives = info.fieldNodes?.[0]?.directives
+  const directives = fieldNode?.directives
   if (Array.isArray(directives)) {
     for (const directive of directives) {
       if (directive.arguments.length === 0) continue
@@ -151,23 +153,18 @@ function getResolverInfo (info, args) {
     }
   }
 
-  return resolverVars === undefined ? null : { [info.fieldName]: resolverVars }
+  return resolverVars === undefined ? null : { [fieldName]: resolverVars }
 }
 
-function getParentField (parentCtx, pathToString) {
-  let current = pathToString
-
-  while (current) {
-    const lastJoin = current.lastIndexOf('.')
-    if (lastJoin === -1) break
-
-    current = current.slice(0, lastJoin)
-    const field = parentCtx.fields[current]
-
+/**
+ * @param {{ fields: Map<object, { error: unknown, ctx: object }> }} rootCtx
+ * @param {{ prev: object | undefined }} path
+ */
+function getParentField (rootCtx, path) {
+  for (let curr = path.prev; curr; curr = curr.prev) {
+    const field = rootCtx.fields.get(curr)
     if (field) return field
   }
-
-  return null
 }
 
 module.exports = GraphQLResolvePlugin

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

@@ -7,7 +7,10 @@ function extractErrorIntoSpanEvent (config, span, exc) {
     attributes.type = exc.name
   }
 
-  if (exc.stack) {
+  // graphql-js validation errors carry a lazy `.stack` accessor; reading it
+  // here is the only consumer in the pipeline and pays full V8 symbolisation.
+  const isValidationOnly = exc.locations && !exc.path && !exc.originalError?.stack
+  if (!isValidationOnly && exc.stack) {
     attributes.stacktrace = exc.stack
   }
 

package/packages/datadog-plugin-http/src/server.js

@@ -14,30 +14,35 @@ class HttpServerPlugin extends ServerPlugin {
 
   static prefix = 'apm:http:server:request'
 
+  /** @type {string | undefined} */
+  #operationName
+
+  /** @type {object | undefined} */
+  #startConfig
+
+  /** @type {string | undefined} */
+  #serviceSource
+
   constructor (...args) {
     super(...args)
     this.addTraceSub('exit', message => this.exit(message))
   }
 
-  start ({ req, res, abortController }) {
+  start (ctx) {
+    const { req, res } = ctx
     let store = legacyStorage.getStore()
-    const { name: schemaServiceName, source: schemaServiceSource } = this.serviceName()
-    const service = this.config.service || schemaServiceName
-    const serviceSource = (this.config.service && service !== this.tracer._service)
-      ? 'opt.plugin'
-      : (service === this.tracer._service ? undefined : schemaServiceSource)
+    if (this.#startConfig === undefined) {
+      this.#refreshStartCache()
+    }
     const span = web.startSpan(
       this.tracer,
-      {
-        ...this.config,
-        service,
-      },
+      this.#startConfig,
       req,
       res,
-      this.operationName()
+      this.#operationName
     )
-    if (serviceSource !== undefined) {
-      span.setTag(SVC_SRC_KEY, serviceSource)
+    if (this.#serviceSource !== undefined) {
+      span.setTag(SVC_SRC_KEY, this.#serviceSource)
     }
     span.setTag(COMPONENT, this.constructor.id)
     span._integrationName = this.constructor.id
@@ -60,7 +65,10 @@ class HttpServerPlugin extends ServerPlugin {
     }
 
     if (appsecActive) {
-      incomingHttpRequestStart.publish({ req, res, abortController }) // TODO: no need to make a new object here
+      // Reuse the ctx allocated by the HTTP server instrumentation rather
+      // than a fresh `{ req, res, abortController }` per request; the AppSec
+      // subscriber only reads from the message.
+      incomingHttpRequestStart.publish(ctx)
     }
   }
 
@@ -93,7 +101,24 @@ class HttpServerPlugin extends ServerPlugin {
   }
 
   configure (config) {
-    return super.configure(web.normalizeConfig(config))
+    const result = super.configure(web.normalizeConfig(config))
+    // Invalidate the start-cache; the next `start` refills it. Resolving
+    // service / operation eagerly here would pin nomenclature lookups to
+    // the order plugins and tracer initialise.
+    this.#startConfig = undefined
+    return result
+  }
+
+  #refreshStartCache () {
+    const { name: schemaServiceName, source: schemaServiceSource } = this.serviceName()
+    const tracerService = this.tracer._service
+    const configService = this.config.service
+    const service = configService || schemaServiceName
+    this.#serviceSource = (configService && service !== tracerService)
+      ? 'opt.plugin'
+      : (service === tracerService ? undefined : schemaServiceSource)
+    this.#operationName = this.operationName()
+    this.#startConfig = { ...this.config, service }
   }
 }
 

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

@@ -16,7 +16,6 @@ const {
   getTestSuiteCommonTags,
   addIntelligentTestRunnerSpanTags,
   TEST_PARAMETERS,
-  TEST_COMMAND,
   TEST_FRAMEWORK_VERSION,
   TEST_SOURCE_START,
   TEST_ITR_UNSKIPPABLE,
@@ -115,7 +114,9 @@ class JestPlugin extends CiPlugin {
       isSuitesSkipped,
       isSuitesSkippingEnabled,
       isCodeCoverageEnabled,
+      isCoverageReportUploadEnabled,
       testCodeCoverageLinesTotal,
+      testSessionCoverageFiles,
       numSkippedSuites,
       hasUnskippableSuites,
       hasForcedToRunSuites,
@@ -149,6 +150,13 @@ class JestPlugin extends CiPlugin {
           }
         )
 
+        if (testSessionCoverageFiles?.length && isCoverageReportUploadEnabled) {
+          this.tracer._exporter.exportCoverage({
+            sessionId: this.testSessionSpan.context()._traceId,
+            files: testSessionCoverageFiles,
+          })
+        }
+
         if (isEarlyFlakeDetectionEnabled) {
           this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
         }
@@ -194,7 +202,7 @@ class JestPlugin extends CiPlugin {
       for (const config of configs) {
         config._ddTestSessionId = this.testSessionSpan.context().toTraceId()
         config._ddTestModuleId = this.testModuleSpan.context().toSpanId()
-        config._ddTestCommand = this.testSessionSpan.context()._tags[TEST_COMMAND]
+        config._ddTestCommand = this.command
         config._ddRequestErrorTags = this.getSessionRequestErrorTags()
         config._ddItrCorrelationId = this.itrCorrelationId
         config._ddIsEarlyFlakeDetectionEnabled = !!this.libraryConfig?.isEarlyFlakeDetectionEnabled
@@ -596,7 +604,7 @@ class JestPlugin extends CiPlugin {
       extraTags[TEST_HAS_DYNAMIC_NAME] = 'true'
     }
     const testSuiteSpan = this.testSuiteSpanPerTestSuiteAbsolutePath.get(testSuiteAbsolutePath) || this.testSuiteSpan
-    const skippingEnabled = testSuiteSpan?.context()._tags?.[TEST_ITR_SKIPPING_ENABLED]
+    const skippingEnabled = testSuiteSpan?.context()?.getTag?.(TEST_ITR_SKIPPING_ENABLED)
     if (skippingEnabled !== undefined) {
       extraTags[TEST_ITR_SKIPPING_ENABLED] = skippingEnabled
     }

package/packages/datadog-plugin-jest/src/util.js

@@ -41,11 +41,16 @@ function getFormattedJestTestParameters (testParameters) {
   return formattedParameters
 }
 
-// Support for `@fast-check/jest`: this library modifies the test name to include the seed
-// A test name that keeps changing breaks some Test Optimization's features.
+// @fast-check/jest appends a random seed to the reported test name. A test name that keeps changing
+// breaks some Test Optimization features, so normalize this narrow suffix regardless of import style.
 const SEED_SUFFIX_RE = /\s*\(with seed=-?\d+\)\s*$/i
+
+function removeSeedSuffixFromTestName (testName) {
+  return testName.replace(SEED_SUFFIX_RE, '')
+}
+
 // https://github.com/facebook/jest/blob/3e38157ad5f23fb7d24669d24fae8ded06a7ab75/packages/jest-circus/src/utils.ts#L396
-function getJestTestName (test, shouldStripSeed = false) {
+function getRawJestTestName (test) {
   const titles = []
   let parent = test
   do {
@@ -54,11 +59,11 @@ function getJestTestName (test, shouldStripSeed = false) {
 
   titles.shift() // remove TOP_DESCRIBE_BLOCK_NAME
 
-  const testName = titles.join(' ')
-  if (shouldStripSeed) {
-    return testName.replace(SEED_SUFFIX_RE, '')
-  }
-  return testName
+  return titles.join(' ')
+}
+
+function getJestTestName (test) {
+  return removeSeedSuffixFromTestName(getRawJestTestName(test))
 }
 
 const globalDocblockRegExp = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/
@@ -170,6 +175,8 @@ module.exports = {
   SEED_SUFFIX_RE,
   getFormattedJestTestParameters,
   getJestTestName,
+  getRawJestTestName,
   getJestSuitesToRun,
   isMarkedAsUnskippable,
+  removeSeedSuffixFromTestName,
 }

package/packages/datadog-plugin-kafkajs/src/batch-consumer.js

@@ -34,7 +34,7 @@ class KafkajsBatchConsumerPlugin extends ConsumerPlugin {
       if (headers) {
         const childOf = this.tracer.extract('text_map', headers)
         if (childOf) {
-          span.addLink(childOf)
+          span.addLink({ context: childOf })
         }
       }
 

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

@@ -91,6 +91,41 @@ class KafkajsProducerPlugin extends ProducerPlugin {
     }
   }
 
+  finish (ctx) {
+    const span = ctx?.currentStore?.span
+    const result = ctx?.result
+    if (span && Array.isArray(result) && result.length > 0) {
+      // The broker response is one entry per (topic, partition). Each entry
+      // carries a `baseOffset` — the offset assigned to the first record sent
+      // to that partition. We don't know per-partition record counts from the
+      // response, only the starting offset.
+      const offsets = []
+      for (const entry of result) {
+        // sendBatch hands the same multi-topic response to every per-topic
+        // ctx; the span only owns its own topic's entries.
+        if (entry.topicName !== ctx.topic) continue
+        const offsetAsLong = entry.offset ?? entry.baseOffset
+        if (entry.partition === undefined || offsetAsLong === undefined) continue
+        // Kafka offsets are 64-bit; coercing to Number loses precision past
+        // 2^53. Keep them as strings so the tag matches the exact offset on
+        // long-lived/high-throughput topics.
+        offsets.push({ partition: entry.partition, start_offset: String(offsetAsLong) })
+      }
+      if (offsets.length > 0) {
+        offsets.sort((a, b) => a.partition - b.partition)
+        span.setTag('kafka.messages.offsets', JSON.stringify(offsets))
+      }
+      // Single-message send: the one entry's partition/offset describes the
+      // exact record. Also expose them as flat tags for easy filtering.
+      if (offsets.length === 1 && ctx.messages?.length === 1) {
+        span.setTag('kafka.partition', offsets[0].partition)
+        // Set as a string meta tag (not a metric) to preserve full 64-bit precision.
+        span.setTag('kafka.message.offset', offsets[0].start_offset)
+      }
+    }
+    super.finish(ctx)
+  }
+
   bindStart (ctx) {
     const { topic, messages, bootstrapServers, clusterId, disableHeaderInjection } = ctx
     const span = this.startSpan({

package/packages/datadog-plugin-langgraph/src/stream.js

@@ -20,7 +20,7 @@ class PregelStreamPlugin extends TracingPlugin {
 }
 class NextStreamPlugin extends TracingPlugin {
   static id = 'langgraph_stream_next'
-  static prefix = 'tracing:orchestrion:@langchain/langgraph:Pregel_stream_next'
+  static prefix = 'tracing:orchestrion:@langchain/langgraph:Pregel_stream:next'
 
   bindStart (ctx) {
     return ctx.currentStore