dd-trace 5.103.0 → 5.105.0

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

@@ -11,6 +11,7 @@ const {
   TEST_PARAMETERS,
   finishAllTraceSpans,
   getTestSuitePath,
+  getRelativeCoverageFiles,
   getTestParametersString,
   getTestSuiteCommonTags,
   addIntelligentTestRunnerSpanTags,
@@ -73,8 +74,10 @@ class MochaPlugin extends CiPlugin {
         this.telemetry.count(TELEMETRY_CODE_COVERAGE_EMPTY)
       }
 
-      const relativeCoverageFiles = [...coverageFiles, suiteFile]
-        .map(filename => getTestSuitePath(filename, this.repositoryRoot || this.sourceRoot))
+      const relativeCoverageFiles = [
+        ...getRelativeCoverageFiles(coverageFiles, this.repositoryRoot || this.sourceRoot),
+        getTestSuitePath(suiteFile, this.repositoryRoot || this.sourceRoot),
+      ]
 
       const { _traceId, _spanId } = testSuiteSpan.context()
 
@@ -152,7 +155,7 @@ class MochaPlugin extends CiPlugin {
     this.addSub('ci:mocha:test-suite:finish', ({ testSuiteSpan, status }) => {
       if (testSuiteSpan) {
         // the test status of the suite may have been set in ci:mocha:test-suite:error already
-        if (!testSuiteSpan.context()._tags[TEST_STATUS]) {
+        if (!testSuiteSpan.context().getTag(TEST_STATUS)) {
           testSuiteSpan.setTag(TEST_STATUS, status)
         }
         testSuiteSpan.finish()
@@ -352,6 +355,7 @@ class MochaPlugin extends CiPlugin {
       status,
       isSuitesSkipped,
       testCodeCoverageLinesTotal,
+      testSessionCoverageFiles,
       numSkippedSuites,
       hasForcedToRunSuites,
       hasUnskippableSuites,
@@ -362,7 +366,11 @@ class MochaPlugin extends CiPlugin {
       isParallel,
     }) => {
       if (this.testSessionSpan) {
-        const { isSuitesSkippingEnabled, isCodeCoverageEnabled } = this.libraryConfig || {}
+        const {
+          isSuitesSkippingEnabled,
+          isCodeCoverageEnabled,
+          isCoverageReportUploadEnabled,
+        } = this.libraryConfig || {}
         this.testSessionSpan.setTag(TEST_STATUS, status)
         this.testModuleSpan.setTag(TEST_STATUS, status)
 
@@ -394,6 +402,13 @@ class MochaPlugin 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')
         }

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { isMap, isRegExp } = require('node:util').types
+
 const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 
 class MongodbCorePlugin extends DatabasePlugin {
@@ -20,6 +22,9 @@ class MongodbCorePlugin extends DatabasePlugin {
 
     this.config.heartbeatEnabled = config.heartbeatEnabled ??
       this._tracerConfig.DD_TRACE_MONGODB_HEARTBEAT_ENABLED
+    this.config.obfuscateQuery = normaliseObfuscateQuery(
+      config.obfuscateQuery ?? this._tracerConfig.DD_TRACE_MONGODB_OBFUSCATE_QUERY
+    )
   }
 
   bindStart (ctx) {
@@ -28,7 +33,7 @@ class MongodbCorePlugin extends DatabasePlugin {
     if (!this.config.heartbeatEnabled && isHeartbeat(ops, this.config)) {
       return
     }
-    const query = getQuery(ops)
+    const query = getQuery(ops, this.config.obfuscateQuery)
     const resource = truncate(getResource(this, ns, query, name))
     const serviceResult = this.serviceName({ pluginConfig: this.config })
     const span = this.startSpan(this.operationName(), {
@@ -106,15 +111,19 @@ function extractQuery (statements) {
   return extractedQueries
 }
 
-function getQuery (cmd) {
+/**
+ * @param {Record<string, unknown> | unknown[] | undefined} cmd
+ * @param {'none' | 'types' | 'redact'} mode
+ */
+function getQuery (cmd, mode) {
   if (!cmd || (typeof cmd !== 'object' && !Array.isArray(cmd))) return
 
-  if (Array.isArray(cmd)) return sanitiseAndStringify(extractQuery(cmd))
-  if (cmd.query) return sanitiseAndStringify(cmd.query)
-  if (cmd.filter) return sanitiseAndStringify(cmd.filter)
-  if (cmd.pipeline) return sanitiseAndStringify(cmd.pipeline)
-  if (cmd.deletes) return sanitiseAndStringify(extractQuery(cmd.deletes))
-  if (cmd.updates) return sanitiseAndStringify(extractQuery(cmd.updates))
+  if (Array.isArray(cmd)) return sanitiseAndStringify(extractQuery(cmd), mode)
+  if (cmd.query) return sanitiseAndStringify(cmd.query, mode)
+  if (cmd.filter) return sanitiseAndStringify(cmd.filter, mode)
+  if (cmd.pipeline) return sanitiseAndStringify(cmd.pipeline, mode)
+  if (cmd.deletes) return sanitiseAndStringify(extractQuery(cmd.deletes), mode)
+  if (cmd.updates) return sanitiseAndStringify(extractQuery(cmd.updates), mode)
 }
 
 function getResource (plugin, ns, query, operationName) {
@@ -131,37 +140,304 @@ function truncate (input) {
   return input.length > MAX_QUERY_LENGTH ? input.slice(0, MAX_QUERY_LENGTH) : input
 }
 
-// Single-pass sanitisation. The replacer:
-// - skips functions and coerces bigint to its decimal string,
-// - returns '?' for Buffer / BSON Binary on the *original* value (JSON.stringify already invoked
-//   toJSON before calling us; Buffer / Binary do have toJSON outputs we want to suppress),
-// - lets JSON.stringify call toJSON on other BSON types (ObjectId, Long, Decimal128, Date, Timestamp, ...)
-//   so the result lands here as a primitive or plain object,
-// - returns '?' for BSON types without toJSON (MinKey, MaxKey) where `value === original`,
-// - tracks depth via an ancestor stack so cycles and depth >= MAX_DEPTH collapse to '?'.
-function sanitiseAndStringify (input) {
-  const ancestors = []
-  return JSON.stringify(input, function (key, value) {
-    if (typeof value === 'function') return
-    if (typeof value === 'bigint') return value.toString()
-
-    const original = key === '' ? value : this[key]
-    if (typeof original === 'object' && original !== null) {
-      if (Buffer.isBuffer(original)) return '?'
-      const bsontype = original._bsontype
-      if (bsontype !== undefined && (bsontype === 'Binary' || value === original)) {
-        return '?'
-      }
+// Depth doubles as the cycle bound: a cycle pushes past MAX_DEPTH and bails,
+// after which the slow path catches it via its ancestor stack.
+/** @param {unknown} input */
+function canStringifyDirect (input) {
+  if (input === null ||
+      typeof input !== 'object' ||
+      ArrayBuffer.isView(input) ||
+      input._bsontype !== undefined ||
+      isRegExp(input) ||
+      isMap(input) ||
+      typeof input.toJSON === 'function') {
+    return false
+  }
+  return canStringifyDirectWalk(input, 1)
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {number} depth
+ */
+function canStringifyDirectWalk (value, depth) {
+  if (depth > MAX_DEPTH) return false
+  const children = Array.isArray(value) ? value : Object.values(value)
+  for (const child of children) {
+    if (child === null ||
+        typeof child === 'string' ||
+        typeof child === 'number' ||
+        typeof child === 'boolean') {
+      continue
+    }
+    if (typeof child !== 'object' ||
+        ArrayBuffer.isView(child) ||
+        child._bsontype !== undefined ||
+        isRegExp(child) ||
+        isMap(child) ||
+        typeof child.toJSON === 'function') {
+      return false
+    }
+    if (!canStringifyDirectWalk(child, depth + 1)) return false
+  }
+  return true
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} input
+ * @param {'none' | 'types' | 'redact'} mode
+ */
+function sanitiseAndStringify (input, mode) {
+  if (mode === 'none') {
+    if (canStringifyDirect(input)) return JSON.stringify(input)
+    return buildNone(input, [])
+  }
+  if (mode === 'redact') return buildRedact(input, [])
+  return buildTypes(input, [])
+}
+
+const REDACT_LEAF = '"?"'
+
+/**
+ * @param {RegExp} value
+ * @returns {string}
+ */
+function stringifyRegExp (value) {
+  return `{"$regex":${JSON.stringify(value.source)},"$options":${JSON.stringify(value.flags)}}`
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {object[]} ancestors
+ * @returns {string | undefined}
+ */
+function buildNone (value, ancestors) {
+  // ArrayBuffer views (Buffer, every TypedArray, DataView) and Binary BSON
+  // wrappers redact at the leaf; the walker neither recurses into the bytes
+  // nor invokes any custom conversion.
+  const bsontype = value._bsontype
+  if (ArrayBuffer.isView(value) || bsontype === 'Binary' ||
+      ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+    return REDACT_LEAF
+  }
+
+  if (isRegExp(value)) return stringifyRegExp(value)
+
+  // Mirror JSON.stringify's contract: when `toJSON` is present, walk its
+  // result (wrappers like Timestamp / Decimal128 expand to a small object,
+  // ObjectId / Date flatten to a primitive).
+  if (typeof value.toJSON === 'function') {
+    const json = value.toJSON()
+    if (json === value) return REDACT_LEAF
+    // JSON.stringify keeps a null result as null (an invalid Date's toJSON
+    // returns null); only function / symbol / undefined results drop the key.
+    if (json === null) return 'null'
+    if (typeof json !== 'object') return classifyLeafForNone(json)
+    // A wrapper that exposes binary state through toJSON (Buffer-backed
+    // class with WeakMap state, etc.) returns a TypedArray here. Re-screen
+    // before the per-key walk would expand it element by element.
+    if (ArrayBuffer.isView(json) || json._bsontype === 'Binary') return REDACT_LEAF
+    value = json
+  } else if (bsontype !== undefined) {
+    return REDACT_LEAF
+  }
+
+  // The driver serializes a Map via its entries; mirror that as a document so
+  // the tag matches the wire shape.
+  if (isMap(value)) value = Object.fromEntries(value)
+
+  ancestors.push(value)
+
+  let result
+  if (Array.isArray(value)) {
+    result = '['
+    let sep = ''
+    for (let i = 0; i < value.length; i++) {
+      // JSON.stringify renders unsupported leaves (function, symbol, undefined) as null in arrays.
+      result += sep + (classifyForNone(value[i], ancestors) ?? 'null')
+      sep = ','
+    }
+    result += ']'
+  } else {
+    result = '{'
+    let sep = ''
+    for (const key of Object.keys(value)) {
+      const childResult = classifyForNone(value[key], ancestors)
+      if (childResult === undefined) continue
+      result += sep + JSON.stringify(key) + ':' + childResult
+      sep = ','
+    }
+    result += '}'
+  }
+  ancestors.pop()
+  return result
+}
+
+/**
+ * @param {unknown} child
+ * @param {object[]} ancestors
+ * @returns {string | undefined}
+ */
+function classifyForNone (child, ancestors) {
+  if (typeof child !== 'object') return classifyLeafForNone(child)
+  if (child === null) return 'null'
+  return buildNone(child, ancestors)
+}
+
+/**
+ * @param {unknown} leaf
+ * @returns {string | undefined}
+ */
+function classifyLeafForNone (leaf) {
+  // Implicit `undefined` for function / symbol / undefined matches the
+  // contract callers rely on: JSON.stringify drops those property values
+  // inside objects and writes `null` in arrays.
+  switch (typeof leaf) {
+    case 'string': return JSON.stringify(leaf)
+    case 'number': return Number.isFinite(leaf) ? String(leaf) : 'null'
+    case 'boolean': return leaf ? 'true' : 'false'
+    case 'bigint': return `"${String(leaf)}"`
+  }
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {object[]} ancestors
+ */
+function buildRedact (value, ancestors) {
+  const bsontype = value._bsontype
+  if (ArrayBuffer.isView(value) || bsontype === 'Binary' || isRegExp(value) ||
+      ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+    return REDACT_LEAF
+  }
+
+  // Mirror JSON.stringify: when `toJSON` is present, walk its result (which
+  // wrappers like Timestamp / Decimal128 expand to `{$timestamp: "..."}` etc).
+  // A primitive, null, or self-reference collapses to the sentinel — master's
+  // `value === original` short-circuit.
+  if (typeof value.toJSON === 'function') {
+    const json = value.toJSON()
+    if (typeof json !== 'object' || json === null || json === value) return REDACT_LEAF
+    // Re-screen: toJSON can return a TypedArray or Binary BSON wrapper.
+    if (ArrayBuffer.isView(json) || json._bsontype === 'Binary') return REDACT_LEAF
+    value = json
+  } else if (bsontype !== undefined) {
+    return REDACT_LEAF
+  }
+
+  if (isMap(value)) value = Object.fromEntries(value)
+
+  ancestors.push(value)
+
+  let result
+  if (Array.isArray(value)) {
+    result = '['
+    let sep = ''
+    for (let i = 0; i < value.length; i++) {
+      result += sep + classifyForRedact(value[i], ancestors)
+      sep = ','
     }
+    result += ']'
+  } else {
+    result = '{'
+    let sep = ''
+    for (const key of Object.keys(value)) {
+      result += sep + JSON.stringify(key) + ':' + classifyForRedact(value[key], ancestors)
+      sep = ','
+    }
+    result += '}'
+  }
+  ancestors.pop()
+  return result
+}
 
-    if (value === null || typeof value !== 'object') return value
+/**
+ * @param {unknown} child
+ * @param {object[]} ancestors
+ */
+function classifyForRedact (child, ancestors) {
+  if (typeof child !== 'object' || child === null) return REDACT_LEAF
+  return buildRedact(child, ancestors)
+}
 
-    while (ancestors.length > 0 && ancestors.at(-1) !== this) ancestors.pop()
-    if (ancestors.length >= MAX_DEPTH || ancestors.includes(value)) return '?'
-    ancestors.push(value)
+const TYPE_OBJECT = '"object"'
+const TYPE_NULL = '"null"'
+const TYPE_BY_TYPEOF = {
+  string: '"string"',
+  number: '"number"',
+  boolean: '"boolean"',
+  bigint: '"bigint"',
+  undefined: '"undefined"',
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {object[]} ancestors
+ */
+function buildTypes (value, ancestors) {
+  const bsontype = value._bsontype
+  if (ArrayBuffer.isView(value) || bsontype === 'Binary' || isRegExp(value) ||
+      ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+    return TYPE_OBJECT
+  }
+
+  if (typeof value.toJSON === 'function') {
+    const json = value.toJSON()
+    if (typeof json !== 'object' ||
+        json === null ||
+        json === value ||
+        ArrayBuffer.isView(json) ||
+        json._bsontype === 'Binary') {
+      return TYPE_OBJECT
+    }
+    value = json
+  } else if (bsontype !== undefined) {
+    return TYPE_OBJECT
+  }
+
+  if (isMap(value)) value = Object.fromEntries(value)
+
+  ancestors.push(value)
+
+  let result
+  if (Array.isArray(value)) {
+    result = '['
+    let sep = ''
+    for (let i = 0; i < value.length; i++) {
+      // JSON.stringify renders unsupported leaves (function, symbol) as null in arrays.
+      result += sep + (classifyForTypes(value[i], ancestors) ?? 'null')
+      sep = ','
+    }
+    result += ']'
+  } else {
+    result = '{'
+    let sep = ''
+    for (const key of Object.keys(value)) {
+      const childResult = classifyForTypes(value[key], ancestors)
+      if (childResult === undefined) continue
+      result += sep + JSON.stringify(key) + ':' + childResult
+      sep = ','
+    }
+    result += '}'
+  }
+  ancestors.pop()
+  return result
+}
+
+/**
+ * @param {unknown} child
+ * @param {object[]} ancestors
+ */
+function classifyForTypes (child, ancestors) {
+  if (typeof child !== 'object') return TYPE_BY_TYPEOF[typeof child]
+  if (child === null) return TYPE_NULL
+  return buildTypes(child, ancestors)
+}
 
-    return value
-  })
+/** @param {unknown} value */
+function normaliseObfuscateQuery (value) {
+  if (value === 'types' || value === 'redact') return value
+  return 'none'
 }
 
 function isHeartbeat (ops, config) {

package/packages/datadog-plugin-nats/src/consumer.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { TEXT_MAP } = require('../../../ext/formats')
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const { headersToTextMap } = require('./util')
+
+const MESSAGING_DESTINATION_KEY = 'messaging.destination.name'
+
+class NatsConsumerPlugin extends ConsumerPlugin {
+  static id = 'nats'
+  static operation = 'consume'
+
+  bindStart (ctx) {
+    const { subject: filter, message } = ctx
+    // For wildcard subscriptions (e.g. `orders.*`), `filter` is the subscription
+    // pattern but `message.subject` is the actual delivered subject. Prefer the
+    // delivered one for resource/destination so spans aren't all collapsed under
+    // the wildcard pattern. Fall back to the filter if the message is missing it.
+    const subject = typeof message?.subject === 'string' ? message.subject : filter
+    const carrier = headersToTextMap(message?.headers)
+    const childOf = carrier ? this.tracer.extract(TEXT_MAP, carrier) : null
+
+    const meta = {
+      component: 'nats',
+      'nats.subject': subject,
+      [MESSAGING_DESTINATION_KEY]: subject,
+    }
+    if (filter && filter !== subject) {
+      meta['nats.subscription.subject'] = filter
+    }
+
+    this.startSpan({
+      childOf,
+      resource: subject,
+      type: 'worker',
+      meta,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = NatsConsumerPlugin

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

@@ -0,0 +1,20 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ProducerPlugin = require('./producer')
+const ConsumerPlugin = require('./consumer')
+
+class NatsPlugin extends CompositePlugin {
+  static id = 'nats'
+  // Disabled by default — users must opt in via DD_TRACE_NATS_ENABLED=true
+  // or `tracer.use('nats')`. Matches the feature parity dashboard policy.
+  static experimental = true
+  static get plugins () {
+    return {
+      producer: ProducerPlugin,
+      consumer: ConsumerPlugin,
+    }
+  }
+}
+
+module.exports = NatsPlugin

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

@@ -0,0 +1,62 @@
+'use strict'
+
+const { TEXT_MAP } = require('../../../ext/formats')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { getOperationName } = require('./util')
+
+const MESSAGING_DESTINATION_KEY = 'messaging.destination.name'
+
+class NatsProducerPlugin extends ProducerPlugin {
+  static id = 'nats'
+  static operation = 'publish'
+  static peerServicePrecursors = [MESSAGING_DESTINATION_KEY]
+
+  bindStart (ctx) {
+    const { subject, options, connection, type, createHeaders } = ctx
+    const server = connection?.protocol?.servers?.getCurrent?.() ??
+      connection?.protocol?.servers?.getCurrentServer?.()
+    const operation = getOperationName(type)
+
+    const span = this.startSpan({
+      resource: subject,
+      meta: {
+        component: 'nats',
+        'nats.subject': subject,
+        'nats.operation': operation,
+        [MESSAGING_DESTINATION_KEY]: subject,
+        'out.host': server?.hostname,
+      },
+    }, ctx)
+
+    if (server?.port) {
+      span.setTag(CLIENT_PORT_KEY, server.port)
+    }
+
+    if (this.serverSupportsHeaders(connection)) {
+      let headers = options.headers
+      if (!headers && typeof createHeaders === 'function') {
+        headers = createHeaders()
+        options.headers = headers
+      }
+      if (headers && typeof headers.set === 'function') {
+        const carrier = {}
+        this.tracer.inject(span, TEXT_MAP, carrier)
+        for (const key of Object.keys(carrier)) {
+          headers.set(key, carrier[key])
+        }
+      }
+    }
+
+    return ctx.currentStore
+  }
+
+  serverSupportsHeaders (connection) {
+    const info = connection?.protocol?.info
+    // If info isn't available yet (e.g. publish before INFO), assume supported — modern NATS does.
+    if (!info) return true
+    return info.headers !== false
+  }
+}
+
+module.exports = NatsProducerPlugin

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

@@ -0,0 +1,33 @@
+'use strict'
+
+function headersToTextMap (msgHdrs) {
+  if (!msgHdrs || typeof msgHdrs[Symbol.iterator] !== 'function') return null
+  const textMap = {}
+  for (const [key, values] of msgHdrs) {
+    if (!Array.isArray(values) || values.length === 0) continue
+    // Trace headers are single-valued (injected via `set`, not `append`), so
+    // the first element is always the authoritative value.
+    textMap[key] = values[0]
+  }
+  return textMap
+}
+
+function getOperationName (type) {
+  switch (type) {
+    case 'publish':
+      return 'publish'
+    case 'request':
+    case 'requestMany':
+      return 'request'
+    default:
+      // Surface unrecognized operations explicitly rather than silently
+      // collapsing them into 'publish' — if NATS adds a new outbound API,
+      // this lets us see it in traces and fix the mapping deliberately.
+      return 'unknown'
+  }
+}
+
+module.exports = {
+  headersToTextMap,
+  getOperationName,
+}

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

@@ -33,11 +33,13 @@ class NextPlugin extends ServerPlugin {
         'span.type': 'web',
         'span.kind': 'server',
         'http.method': req.method,
-        ...(serviceSource === undefined ? {} : { [SVC_SRC_KEY]: serviceSource }),
+        ...(serviceSource === undefined ? undefined : { [SVC_SRC_KEY]: serviceSource }),
       },
       integrationName: this.constructor.id,
     })
 
+    this.stampIntegrationService(span, serviceName)
+
     analyticsSampler.sample(span, this.config.measured, true)
 
     return { ...store, span, req }
@@ -60,7 +62,7 @@ class NextPlugin extends ServerPlugin {
     if (!store) return
 
     const span = store.span
-    const error = span.context()._tags.error
+    const error = span.context().getTag('error')
     const requestError = req.error || nextRequest.error
 
     if (requestError) {
@@ -97,7 +99,7 @@ class NextPlugin extends ServerPlugin {
     if (!req) return
 
     // Only use error page names if there's not already a name
-    const current = span.context()._tags['next.page']
+    const current = span.context().getTag('next.page')
     const isErrorPage = errorPages.has(page)
 
     if (current && isErrorPage) {

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

@@ -8,6 +8,7 @@ const Sampler = require('../../dd-trace/src/sampler')
 const { MEASURED } = require('../../../ext/tags')
 
 const { DD_MAJOR } = require('../../../version')
+const { ERROR_TYPE } = require('../../dd-trace/src/constants')
 const {
   convertBuffersToObjects,
   constructCompletionResponseFromStreamedChunks,
@@ -157,7 +158,7 @@ class OpenAiTracingPlugin extends TracingPlugin {
     const span = store?.span
     if (!span) return
 
-    const error = !!span.context()._tags.error
+    const error = !!span.context().getTag('error')
 
     let headers, body, method, path
     if (!error) {
@@ -171,7 +172,7 @@ class OpenAiTracingPlugin extends TracingPlugin {
       headers = Object.fromEntries(headers)
     }
 
-    const resource = span._spanContext._tags['resource.name']
+    const resource = span.context().getTag('resource.name')
     const normalizedMethodName = store.normalizedMethodName
 
     body = coerceResponseBody(body, normalizedMethodName)
@@ -211,6 +212,18 @@ class OpenAiTracingPlugin extends TracingPlugin {
     this.sendMetrics(headers, body, endpoint, span._duration, error, tags)
   }
 
+  error (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    super.error(ctx) // add normal error tag
+
+    const errorType = ctx.error?.type
+    if (errorType) {
+      span.setTag(ERROR_TYPE, errorType)
+    }
+  }
+
   sendMetrics (headers, body, endpoint, duration, error, spanTags) {
     const tags = [`error:${Number(!!error)}`]
     if (error) {