dd-trace 5.96.0 → 5.98.0

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

@@ -1,5 +1,9 @@
 'use strict'
 
+// Capture real timers at module load, before any test can install fake timers.
+const { performance } = require('perf_hooks')
+const dateNow = Date.now
+
 const {
   TEST_STATUS,
   TEST_IS_RUM_ACTIVE,
@@ -53,6 +57,7 @@ const {
   DYNAMIC_NAME_RE,
   logDynamicNamesWarning,
   getPullRequestBaseBranch,
+  TEST_FINAL_STATUS,
 } = require('../../dd-trace/src/plugins/util/test')
 const { isMarkedAsUnskippable } = require('../../datadog-plugin-jest/src/util')
 const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
@@ -240,6 +245,58 @@ function getSuiteStatus (suiteStats) {
   return 'pass'
 }
 
+const FINAL_STATUS_RETRY_KIND = {
+  none: 'none',
+  atr: 'atr',
+  efd: 'efd',
+  atf: 'atf',
+}
+
+function getFinalStatusRetryKind ({ finishedTest, finishedTestAttempts, flakyTestRetriesCount }) {
+  // Infer retry kind from the executions we actually saw so ATR enabled with
+  // a retry count of 0 is still treated as a single final execution.
+  if (finishedTest.isAttemptToFix) {
+    return FINAL_STATUS_RETRY_KIND.atf
+  }
+
+  if (finishedTestAttempts.some(testAttempt => testAttempt.isEfdRetry)) {
+    return FINAL_STATUS_RETRY_KIND.efd
+  }
+
+  if (finishedTestAttempts.length > 1 && flakyTestRetriesCount > 0) {
+    return FINAL_STATUS_RETRY_KIND.atr
+  }
+
+  return FINAL_STATUS_RETRY_KIND.none
+}
+
+function getFinalStatus ({
+  status,
+  retryKind,
+  hasFailedAllRetries,
+  hasPassedAllAtfRetries,
+  isQuarantined,
+  isDisabled,
+}) {
+  // If the test is quarantined or disabled, regardless of its actual execution result or active retry features,
+  // the final status of its last execution should be reported as 'skip'.
+  if (isQuarantined || isDisabled || status === 'skip') {
+    return 'skip'
+  }
+
+  switch (retryKind) {
+    case FINAL_STATUS_RETRY_KIND.atr:
+    case FINAL_STATUS_RETRY_KIND.efd:
+      // These modes report the aggregate result across attempts.
+      return hasFailedAllRetries ? 'fail' : 'pass'
+    case FINAL_STATUS_RETRY_KIND.atf:
+      // Attempt-to-fix only passes if every execution passed.
+      return hasPassedAllAtfRetries ? 'pass' : 'fail'
+    default:
+      return status
+  }
+}
+
 class CypressPlugin {
   _isInit = false
   testEnvironmentMetadata = getTestEnvironmentMetadata(TEST_FRAMEWORK_NAME)
@@ -307,10 +364,68 @@ class CypressPlugin {
     }
   }
 
+  /**
+   * Resets state that is scoped to a single Cypress run so the singleton plugin
+   * can be reused safely across multiple programmatic cypress.run() calls.
+   *
+   * @returns {void}
+   */
+  resetRunState () {
+    this._isInit = false
+    this.finishedTestsByFile = {}
+    this.testStatuses = {}
+    this.isTestsSkipped = false
+    this.isSuitesSkippingEnabled = false
+    this.isCodeCoverageEnabled = false
+    this.isFlakyTestRetriesEnabled = false
+    this.flakyTestRetriesCount = 0
+    this.isEarlyFlakeDetectionEnabled = false
+    this.isKnownTestsEnabled = false
+    this.earlyFlakeDetectionNumRetries = 0
+    this.testsToSkip = []
+    this.skippedTests = []
+    this.hasForcedToRunSuites = false
+    this.hasUnskippableSuites = false
+    this.unskippableSuites = []
+    this.knownTests = []
+    this.knownTestsByTestSuite = undefined
+    this.isTestManagementTestsEnabled = false
+    this.testManagementAttemptToFixRetries = 0
+    this.testManagementTests = undefined
+    this.isImpactedTestsEnabled = false
+    this.modifiedFiles = []
+    this.activeTestSpan = null
+    this.testSuiteSpan = null
+    this.testModuleSpan = null
+    this.testSessionSpan = null
+    this.command = undefined
+    this.frameworkVersion = undefined
+    this.rootDir = undefined
+    this.itrCorrelationId = undefined
+    this.isTestIsolationEnabled = undefined
+    this.rumFlushWaitMillis = undefined
+    this._pendingRequestErrorTags = []
+    this.libraryConfigurationPromise = undefined
+    this._timeOrigin = 0
+    this._perfOrigin = 0
+  }
+
+  /**
+   * Returns the current time in the same coordinate system used by span
+   * start/finish. Captured at session span creation so it shares the same
+   * epoch as the trace without reaching into span internals.
+   *
+   * @returns {number}
+   */
+  _now () {
+    return this._timeOrigin + performance.now() - this._perfOrigin
+  }
+
   // Init function returns a promise that resolves with the Cypress configuration
   // Depending on the received configuration, the Cypress configuration can be modified:
   // for example, to enable retries for failed tests.
   init (tracer, cypressConfig) {
+    this.resetRunState()
     this._isInit = true
     this.tracer = tracer
     this.cypressConfig = cypressConfig
@@ -620,6 +735,13 @@ class CypressPlugin {
       this.tracer._tracer._exporter.addMetadataTags(metadataTags)
     }
 
+    // Capture time references that match what startSpan records internally
+    // (trace.startTime = Date.now(), trace.ticks = performance.now()).
+    // This lets _now() produce values in the same coordinate system as
+    // span._startTime without accessing span internals.
+    this._timeOrigin = dateNow()
+    this._perfOrigin = performance.now()
+
     this.testSessionSpan = this.tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test_session`, {
       childOf,
       tags: {
@@ -694,20 +816,27 @@ class CypressPlugin {
     }
 
     return new Promise(resolve => {
+      const finishAfterRun = () => {
+        this._isInit = false
+        appClosingTelemetry()
+        resolve(null)
+      }
+
       const exporter = this.tracer._tracer._exporter
       if (!exporter) {
-        return resolve(null)
+        finishAfterRun()
+        return
       }
       if (exporter.flush) {
         exporter.flush(() => {
-          appClosingTelemetry()
-          resolve(null)
+          finishAfterRun()
         })
       } else if (exporter._writer) {
         exporter._writer.flush(() => {
-          appClosingTelemetry()
-          resolve(null)
+          finishAfterRun()
         })
+      } else {
+        finishAfterRun()
       }
     })
   }
@@ -745,6 +874,7 @@ class CypressPlugin {
         : spec.relative
 
       const skippedTestSpan = this.getTestSpan({ testName: cypressTestName, testSuite: spec.relative, testSourceFile })
+      skippedTestSpan.setTag(TEST_FINAL_STATUS, 'skip')
 
       skippedTestSpan.setTag(TEST_STATUS, 'skip')
       if (isSkippedByItr) {
@@ -834,6 +964,36 @@ class CypressPlugin {
           finishedTest.testSpan.setTag(TEST_CODE_OWNERS, codeOwners)
         }
 
+        // We can check if this is the last attempt regardless of the retry mechanism
+        const isLastAttempt = attemptIndex === finishedTestAttempts.length - 1
+        if (isLastAttempt) {
+          const testSpanTags = finishedTest.testSpan.context()._tags
+          const retryKind = getFinalStatusRetryKind({
+            finishedTest,
+            finishedTestAttempts,
+            flakyTestRetriesCount: this.flakyTestRetriesCount,
+          })
+
+          const hasFailedAllRetries = testSpanTags[TEST_HAS_FAILED_ALL_RETRIES] === 'true'
+          const hasPassedAllAtfRetries =
+            testSpanTags[TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED] === 'true'
+          const isQuarantined = testSpanTags[TEST_MANAGEMENT_IS_QUARANTINED] === 'true'
+          const isDisabled = testSpanTags[TEST_MANAGEMENT_IS_DISABLED] === 'true'
+
+          const finalStatus = getFinalStatus({
+            status: cypressTestStatus,
+            retryKind,
+            hasFailedAllRetries,
+            hasPassedAllAtfRetries,
+            isQuarantined,
+            isDisabled,
+          })
+
+          if (finalStatus) {
+            finishedTest.testSpan.setTag(TEST_FINAL_STATUS, finalStatus)
+          }
+        }
+
         finishedTest.testSpan.finish(finishedTest.finishTime)
       }
     }
@@ -1051,7 +1211,7 @@ class CypressPlugin {
         const finishedTest = {
           testName,
           testStatus,
-          finishTime: this.activeTestSpan._getTime(), // we store the finish time here
+          finishTime: this._now(),
           testSpan: this.activeTestSpan,
           isEfdRetry,
           isAttemptToFix,

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

@@ -1,11 +1,68 @@
 'use strict'
 
+const NoopTracer = require('../../dd-trace/src/noop/tracer')
 const Plugin = require('../../dd-trace/src/plugins/plugin')
 
-// Cypress plugin does not patch any library. This is just a placeholder to
-// follow the structure of the plugins
+/**
+ * Cypress plugin handles setup-node-events from the instrumentation layer
+ * via a diagnostic channel, keeping the instrumentation free of tracer references.
+ */
 class CypressPlugin extends Plugin {
   static id = 'cypress'
+
+  constructor (...args) {
+    super(...args)
+
+    this.addSub('ci:cypress:setup-node-events', (payload) => {
+      // Bail out if the tracer failed to init (e.g. invalid DD_SITE).
+      // Mirrors the guard in the manual plugin entrypoint (plugin.js).
+      if (this._tracer._tracer instanceof NoopTracer) return
+
+      const { on, config, userAfterSpecHandlers, userAfterRunHandlers, cleanupWrapper } = payload
+
+      const registerAfterRunWithCleanup = (afterRunHandler) => {
+        on('after:run', (results) => {
+          const chain = userAfterRunHandlers.reduce(
+            (p, h) => p.then(() => h(results)),
+            Promise.resolve()
+          )
+          if (afterRunHandler) {
+            return chain.then(() => afterRunHandler(results)).finally(cleanupWrapper)
+          }
+          return chain.finally(cleanupWrapper)
+        })
+      }
+
+      const cypressPlugin = require('./cypress-plugin')
+
+      if (cypressPlugin._isInit) {
+        // Already initialized by manual plugin call — just chain user handlers
+        for (const h of userAfterSpecHandlers) on('after:spec', h)
+        registerAfterRunWithCleanup()
+        payload.registered = true
+        return
+      }
+
+      on('before:run', cypressPlugin.beforeRun.bind(cypressPlugin))
+
+      on('after:spec', (spec, results) => {
+        const chain = userAfterSpecHandlers.reduce(
+          (p, h) => p.then(() => h(spec, results)),
+          Promise.resolve()
+        )
+        return chain.then(() => cypressPlugin.afterSpec(spec, results))
+      })
+
+      registerAfterRunWithCleanup((results) => cypressPlugin.afterRun(results))
+
+      on('task', cypressPlugin.getTasks())
+
+      payload.registered = true
+      // cypressPlugin.init expects the proxy tracer (with ._tracer._exporter),
+      // not the unwrapped internal tracer that this.tracer returns.
+      payload.configPromise = Promise.resolve(cypressPlugin.init(this._tracer, config)).then(() => config)
+    })
+  }
 }
 
 module.exports = CypressPlugin

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

@@ -11,7 +11,7 @@ class FsPlugin extends TracingPlugin {
   }
 
   bindStart (ctx) {
-    if (!this.activeSpan) return this.skip()
+    if (!this.activeSpan) return { noop: true }
 
     const { operation, ...params } = ctx
     const lowerOp = operation.toLowerCase()

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

@@ -123,7 +123,8 @@ class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
     const topicName = topic?.slice(topic.lastIndexOf('/') + 1) ??
       subscription.name.slice(subscription.name.lastIndexOf('/') + 1)
     const baseService = this.tracer._service || 'unknown'
-    const serviceName = this.config.service || `${baseService}-pubsub`
+    const serviceName = this.config.service || { name: `${baseService}-pubsub`, source: baseService }
+
     const meta = {
       'gcloud.project_id': subscription.pubsub.projectId,
       'pubsub.topic': topic,

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

@@ -145,17 +145,12 @@ class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
     const subscriptionName = subscription?.slice(subscription.lastIndexOf('/') + 1) ?? subscription
     const publishStartTime = attrs['x-dd-publish-start-time']
     const startTime = publishStartTime ? Number.parseInt(publishStartTime, 10) : undefined
-
-    // Get the base service name and construct the pubsub service override
-    const baseService = this.tracer._service
-    const serviceOverride = this.config.service ?? `${baseService}-pubsub`
-
     // Use this.startSpan() which automatically activates the span
     const span = this.startSpan('pubsub.push.receive', {
       childOf: parentContext,
       startTime,
       kind: 'consumer',
-      service: serviceOverride,
+      service: this.config.service || { name: `${this.tracer._service}-pubsub`, source: this.tracer._service },
       meta: {
         component: 'google-cloud-pubsub',
         'pubsub.method': 'receive',
@@ -163,7 +158,7 @@ class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
         'pubsub.message_id': message.messageId,
         'pubsub.subscription_type': 'push',
         'pubsub.topic': topicName,
-        '_dd.base_service': baseService,
+        '_dd.base_service': this.tracer._service,
         '_dd.serviceoverride.type': 'integration',
         'resource.name': `Push Subscription ${subscriptionName}`,
       },

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

@@ -28,7 +28,7 @@ class GraphQLResolvePlugin extends TracingPlugin {
       if (rootCtx.fields[computedPathString]) return
 
       if (!rootCtx[collapsedPathSym]) {
-        rootCtx[collapsedPathSym] = {}
+        rootCtx[collapsedPathSym] = Object.create(null)
       } else if (rootCtx[collapsedPathSym][computedPathString]) {
         return
       }

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

@@ -40,10 +40,10 @@ class HttpClientPlugin extends ClientPlugin {
     const span = this.startSpan(this.operationName(), {
       childOf,
       integrationName: this.constructor.id,
+      service: this.serviceName({ pluginConfig: this.config, sessionDetails: extractSessionDetails(options) }),
       meta: {
         [COMPONENT]: this.constructor.id,
         'span.kind': 'client',
-        'service.name': this.serviceName({ pluginConfig: this.config, sessionDetails: extractSessionDetails(options) }),
         'resource.name': method,
         'span.type': 'http',
         'http.method': method,

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

@@ -4,7 +4,7 @@ const ServerPlugin = require('../../dd-trace/src/plugins/server')
 const { storage } = require('../../datadog-core')
 const web = require('../../dd-trace/src/plugins/util/web')
 const { incomingHttpRequestStart, incomingHttpRequestEnd } = require('../../dd-trace/src/appsec/channels')
-const { COMPONENT } = require('../../dd-trace/src/constants')
+const { COMPONENT, SVC_SRC_KEY } = require('../../dd-trace/src/constants')
 
 class HttpServerPlugin extends ServerPlugin {
   static id = 'http'
@@ -18,16 +18,24 @@ class HttpServerPlugin extends ServerPlugin {
 
   start ({ req, res, abortController }) {
     let store = storage('legacy').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)
     const span = web.startSpan(
       this.tracer,
       {
         ...this.config,
-        service: this.config.service || this.serviceName(),
+        service,
       },
       req,
       res,
       this.operationName()
     )
+    if (serviceSource !== undefined) {
+      span.setTag(SVC_SRC_KEY, serviceSource)
+    }
     span.setTag(COMPONENT, this.constructor.id)
     span._integrationName = this.constructor.id
 

package/packages/datadog-plugin-http2/src/client.js

@@ -41,10 +41,10 @@ class Http2ClientPlugin extends ClientPlugin {
     const span = this.startSpan(this.operationName(), {
       childOf,
       integrationName: this.constructor.id,
+      service: this.serviceName({ pluginConfig: this.config, sessionDetails }),
       meta: {
         [COMPONENT]: this.constructor.id,
         [SPAN_KIND]: CLIENT,
-        'service.name': this.serviceName({ pluginConfig: this.config, sessionDetails }),
         'resource.name': method,
         'span.type': 'http',
         'http.method': method,

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

@@ -4,7 +4,7 @@
 
 const ServerPlugin = require('../../dd-trace/src/plugins/server')
 const web = require('../../dd-trace/src/plugins/util/web')
-const { COMPONENT } = require('../../dd-trace/src/constants')
+const { COMPONENT, SVC_SRC_KEY } = require('../../dd-trace/src/constants')
 
 class Http2ServerPlugin extends ServerPlugin {
   constructor (tracer, config) {
@@ -19,17 +19,25 @@ class Http2ServerPlugin extends ServerPlugin {
   bindStart (ctx) {
     const { req, res } = ctx
 
+    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)
     const span = web.startSpan(
       this.tracer,
       {
         ...this.config,
-        service: this.config.service || this.serviceName(),
+        service,
       },
       req,
       res,
       this.operationName(),
       ctx
     )
+    if (serviceSource !== undefined) {
+      span.setTag(SVC_SRC_KEY, serviceSource)
+    }
 
     span.setTag(COMPONENT, this.constructor.id)
     span._integrationName = this.constructor.id

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

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
@@ -60,8 +63,7 @@ const CHILD_MESSAGE_END = 2
 
 function withTimeout (promise, timeoutMs) {
   return new Promise(resolve => {
-    // Set a timeout to resolve after 1s
-    setTimeout(resolve, timeoutMs)
+    realSetTimeout(resolve, timeoutMs)
 
     // Also resolve if the original promise resolves
     promise.then(resolve)

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

@@ -8,20 +8,47 @@ class KafkajsBatchConsumerPlugin extends ConsumerPlugin {
   static id = 'kafkajs'
   static operation = 'consume-batch'
 
-  start (ctx) {
-    const { topic, messages, groupId, clusterId } = ctx.extractedArgs || ctx
+  bindStart (ctx) {
+    const { topic, partition, messages, groupId, clusterId } = ctx.extractedArgs || ctx
+
+    const span = this.startSpan({
+      resource: topic,
+      type: 'worker',
+      meta: {
+        component: this.constructor.id,
+        'kafka.topic': topic,
+        'kafka.cluster_id': clusterId,
+        'messaging.destination.name': topic,
+        'messaging.system': 'kafka',
+      },
+      metrics: {
+        'kafka.partition': partition,
+        'messaging.batch.message_count': messages.length,
+      },
+    }, ctx)
 
-    if (!this.config.dsmEnabled) return
     for (const message of messages) {
       if (!message || !message.headers) continue
+
+      const headers = convertToTextMap(message.headers)
+      if (headers) {
+        const childOf = this.tracer.extract('text_map', headers)
+        if (childOf) {
+          span.addLink(childOf)
+        }
+      }
+
+      if (!this.config.dsmEnabled) continue
       const payloadSize = getMessageSize(message)
-      this.tracer.decodeDataStreamsContext(convertToTextMap(message.headers))
+      this.tracer.decodeDataStreamsContext(headers)
       const edgeTags = ['direction:in', `group:${groupId}`, `topic:${topic}`, 'type:kafka']
       if (clusterId) {
         edgeTags.push(`kafka_cluster_id:${clusterId}`)
       }
       this.tracer.setCheckpoint(edgeTags, null, payloadSize)
     }
+
+    return ctx.currentStore
   }
 }
 

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

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real Date.now at module load time, before any test can install fake timers.
+const realDateNow = Date.now.bind(Date)
+
 const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
 const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
@@ -323,8 +326,8 @@ class MochaPlugin extends CiPlugin {
             this.runningTestProbe = { file, line }
             this.testErrorStackIndex = stackIndex
             test._ddShouldWaitForHitProbe = true
-            const waitUntil = Date.now() + BREAKPOINT_SET_GRACE_PERIOD_MS
-            while (Date.now() < waitUntil) {
+            const waitUntil = realDateNow() + BREAKPOINT_SET_GRACE_PERIOD_MS
+            while (realDateNow() < waitUntil) {
               // TODO: To avoid a race condition, we should wait until `probeInformation.setProbePromise` has resolved.
               // However, Mocha doesn't have a mechanism for waiting asyncrounously here, so for now, we'll have to
               // fall back to a fixed syncronous delay.

package/packages/datadog-plugin-mongodb-core/src/index.js

@@ -35,9 +35,9 @@ class MongodbCorePlugin extends DatabasePlugin {
     }
     const query = getQuery(ops)
     const resource = truncate(getResource(this, ns, query, name))
-    const service = this.serviceName({ pluginConfig: this.config })
+    const serviceResult = this.serviceName({ pluginConfig: this.config })
     const span = this.startSpan(this.operationName(), {
-      service,
+      service: serviceResult,
       resource,
       type: 'mongodb',
       kind: 'client',
@@ -49,7 +49,7 @@ class MongodbCorePlugin extends DatabasePlugin {
         'out.port': options.port,
       },
     }, ctx)
-    const comment = this.injectDbmComment(span, ops.comment, service)
+    const comment = this.injectDbmComment(span, ops.comment, serviceResult.name)
     if (comment) {
       ops.comment = comment
     }

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

@@ -33,7 +33,7 @@ class MySQLPlugin extends DatabasePlugin {
         [CLIENT_PORT_KEY]: ctx.conf.port,
       },
     }, ctx)
-    ctx.sql = this.injectDbmQuery(span, ctx.sql, service)
+    ctx.sql = this.injectDbmQuery(span, ctx.sql, service.name)
 
     return ctx.currentStore
   }

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

@@ -3,14 +3,13 @@
 const ServerPlugin = require('../../dd-trace/src/plugins/server')
 const { storage } = require('../../datadog-core')
 const analyticsSampler = require('../../dd-trace/src/analytics_sampler')
-const { COMPONENT } = require('../../dd-trace/src/constants')
+const { COMPONENT, SVC_SRC_KEY } = require('../../dd-trace/src/constants')
 const web = require('../../dd-trace/src/plugins/util/web')
 
 const errorPages = new Set(['/404', '/500', '/_error', '/_not-found', '/_not-found/page'])
 
 class NextPlugin extends ServerPlugin {
   static id = 'next'
-  #requestsBySpanId = new WeakMap()
 
   constructor (...args) {
     super(...args)
@@ -20,26 +19,28 @@ class NextPlugin extends ServerPlugin {
   bindStart ({ req, res }) {
     const store = storage('legacy').getStore()
     const childOf = store ? store.span : store
+    const { name: schemaServiceName, source: schemaServiceSource } = this.serviceName()
+    const serviceName = this.config.service || schemaServiceName
+    let serviceSource = this.config.service ? 'opt.plugin' : schemaServiceSource
+    if (!serviceName || serviceName === this.tracer._service) serviceSource = undefined
+
     const span = this.tracer.startSpan(this.operationName(), {
       childOf,
       tags: {
         [COMPONENT]: this.constructor.id,
-        'service.name': this.config.service || this.serviceName(),
+        'service.name': serviceName,
         'resource.name': req.method,
         'span.type': 'web',
         'span.kind': 'server',
         'http.method': req.method,
+        ...(serviceSource === undefined ? {} : { [SVC_SRC_KEY]: serviceSource }),
       },
       integrationName: this.constructor.id,
     })
 
     analyticsSampler.sample(span, this.config.measured, true)
 
-    // Store request by span ID to handle cases where child spans are activated
-    const spanId = span.context()._spanId
-    this.#requestsBySpanId.set(spanId, req)
-
-    return { ...store, span }
+    return { ...store, span, req }
   }
 
   error ({ span, error }) {
@@ -90,14 +91,7 @@ class NextPlugin extends ServerPlugin {
 
     if (!store) return
 
-    const span = store.span
-
-    const spanId = span.context()._spanId
-    const parentSpanId = span.context()._parentId
-
-    // Try current span first, then parent span.
-    // This handles cases where pageLoad runs in a child span context
-    const req = this.#requestsBySpanId.get(spanId) ?? this.#requestsBySpanId.get(parentSpanId)
+    const { span, req } = store
 
     // safeguard against missing req in complicated timeout scenarios
     if (!req) return

package/packages/datadog-plugin-openai/src/services.js

@@ -20,6 +20,7 @@ module.exports.init = function (tracerConfig) {
         `env:${tracerConfig.tags.env}`,
         `version:${tracerConfig.tags.version}`,
       ],
+      lookup: tracerConfig.lookup,
     })
     : new NoopDogStatsDClient()