dd-trace 6.2.0 → 6.3.0

package/README.md

@@ -28,7 +28,7 @@ Most of the documentation for `dd-trace` is available on these webpages:
 | [`v2`](https://github.com/DataDog/dd-trace-js/tree/v2.x) | ![npm v2](https://img.shields.io/npm/v/dd-trace/latest-node12?color=white&label=%20&style=flat-square) | `>= v12` | NO | NO | **EOL** | 2022-01-28     | 2023-08-15  |
 | [`v3`](https://github.com/DataDog/dd-trace-js/tree/v3.x) | ![npm v3](https://img.shields.io/npm/v/dd-trace/latest-node14?color=white&label=%20&style=flat-square) | `>= v14` | NO | YES | **EOL** | 2022-08-15     | 2024-05-15  |
 | [`v4`](https://github.com/DataDog/dd-trace-js/tree/v4.x) | ![npm v4](https://img.shields.io/npm/v/dd-trace/latest-node16?color=white&label=%20&style=flat-square) | `>= v16` | YES | YES | **EOL**     | 2023-05-12     | 2025-01-11     |
-| [`v5`](https://github.com/DataDog/dd-trace-js/tree/v5.x) | ![npm v5](https://img.shields.io/npm/v/dd-trace/latest-node18?color=white&label=%20&style=flat-square)  | `>= v18` | YES | YES | **Maintenance** | 2024-01-11     | Unknown     |
+| [`v5`](https://github.com/DataDog/dd-trace-js/tree/v5.x) | ![npm v5](https://img.shields.io/npm/v/dd-trace/latest-node18?color=white&label=%20&style=flat-square)  | `>= v18` | YES | YES | **Maintenance** | 2024-01-11     | 2027-07-02     |
 | [`v6`](https://github.com/DataDog/dd-trace-js/tree/v6.x) | ![npm v6](https://img.shields.io/npm/v/dd-trace/latest?color=white&label=%20&style=flat-square)         | `>= v22` | YES | YES | **Current**     | 2026-07-02     | Unknown     |
 
 * EOL = End-of-life

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "6.2.0",
+  "version": "6.3.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -23,7 +23,7 @@
     "lint:inspect": "npx @eslint/config-inspector@latest",
     "lint:codeowners": "codeowners-audit",
     "lint:codeowners:ci": "codeowners-audit --glob='**/*.spec.js' --glob='benchmark/sirun/**' --glob='.agents/**' --glob='.claude/**' --glob='integration-tests/**'",
-    "lint:editorconfig": "editorconfig-checker",
+    "lint:editorconfig": "docker build -q -t ec .github/editorconfig-checker && docker run --rm --volume=$PWD:/check ec",
     "release:proposal": "node scripts/release/proposal",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
     "test": "echo '\nError: The root \"npm test\" command is intentionally disabled.\n\nInstead, run specific test suites:\n  - npm run test:trace:core\n  - npm run test:appsec\n  - etc.\n\nOr run individual test files:\n  npx mocha path/to/test.spec.js\n\nSee CONTRIBUTING.md (Testing section) for more details.\n' && exit 1",
@@ -198,11 +198,10 @@
     "bun": "1.3.14",
     "c8": "^11.0.0",
     "codeowners-audit": "^2.9.0",
-    "editorconfig-checker": "^6.1.1",
     "eslint": "^9.39.2",
     "eslint-plugin-cypress": "^6.4.2",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jsdoc": "^63.0.10",
+    "eslint-plugin-jsdoc": "^63.0.12",
     "eslint-plugin-mocha": "^11.3.0",
     "eslint-plugin-n": "^18.2.1",
     "eslint-plugin-promise": "^7.3.0",

package/packages/datadog-instrumentations/src/cookie.js

@@ -15,7 +15,13 @@ function wrapParse (originalParse) {
   }
 }
 
+/** @param {typeof import('cookie')} cookie */
 addHook({ name: 'cookie', versions: ['>=0.4'] }, cookie => {
-  shimmer.wrap(cookie, 'parse', wrapParse)
+  for (const name of ['parse', 'parseCookie']) {
+    if (typeof cookie[name] === 'function') {
+      // shimmer returns a mutable replacement when an ESM namespace export is non-configurable.
+      cookie = shimmer.wrap(cookie, name, wrapParse)
+    }
+  }
   return cookie
 })

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -20,7 +20,7 @@ module.exports = {
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
   '@langchain/langgraph': { esmFirst: true, fn: () => require('../langgraph') },
-  '@modelcontextprotocol/sdk': () => require('../modelcontextprotocol-sdk'),
+  '@modelcontextprotocol/sdk': { esmFirst: true, fn: () => require('../modelcontextprotocol-sdk') },
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@aws/durable-execution-sdk-js': () => require('../aws-durable-execution-sdk-js'),

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/modelcontextprotocol-sdk.js

@@ -1,59 +1,35 @@
 'use strict'
 
-// NOTE: Protocol.request (dist/esm|cjs/shared/protocol.js) is intentionally not instrumented here.
-// It will be used for distributed tracing header injection when server-side coverage is added.
+const CLIENT_METHODS = [
+  'callTool',
+  'listTools',
+  'listResources',
+  'readResource',
+  'listPrompts',
+  'getPrompt',
+]
+
+const SERVER_METHODS = [
+  'executeToolHandler',
+]
+
+function clientEntries (methodName) {
+  return ['dist/esm/client/index.js', 'dist/cjs/client/index.js'].map(filePath => ({
+    module: { name: '@modelcontextprotocol/sdk', versionRange: '>=1.27.1', filePath },
+    functionQuery: { methodName, className: 'Client', kind: 'Async' },
+    channelName: `Client_${methodName}`,
+  }))
+}
+
+function serverEntries (methodName) {
+  return ['dist/esm/server/mcp.js', 'dist/cjs/server/mcp.js'].map(filePath => ({
+    module: { name: '@modelcontextprotocol/sdk', versionRange: '>=1.27.1', filePath },
+    functionQuery: { methodName, className: 'McpServer', kind: 'Async' },
+    channelName: `McpServer_${methodName}`,
+  }))
+}
 
 module.exports = [
-  {
-    module: {
-      name: '@modelcontextprotocol/sdk',
-      versionRange: '>=1.27.1',
-      filePath: 'dist/esm/client/index.js',
-    },
-    functionQuery: {
-      methodName: 'callTool',
-      className: 'Client',
-      kind: 'Async',
-    },
-    channelName: 'Client_callTool',
-  },
-  {
-    module: {
-      name: '@modelcontextprotocol/sdk',
-      versionRange: '>=1.27.1',
-      filePath: 'dist/cjs/client/index.js',
-    },
-    functionQuery: {
-      methodName: 'callTool',
-      className: 'Client',
-      kind: 'Async',
-    },
-    channelName: 'Client_callTool',
-  },
-  {
-    module: {
-      name: '@modelcontextprotocol/sdk',
-      versionRange: '>=1.27.1',
-      filePath: 'dist/esm/client/index.js',
-    },
-    functionQuery: {
-      methodName: 'listTools',
-      className: 'Client',
-      kind: 'Async',
-    },
-    channelName: 'Client_listTools',
-  },
-  {
-    module: {
-      name: '@modelcontextprotocol/sdk',
-      versionRange: '>=1.27.1',
-      filePath: 'dist/cjs/client/index.js',
-    },
-    functionQuery: {
-      methodName: 'listTools',
-      className: 'Client',
-      kind: 'Async',
-    },
-    channelName: 'Client_listTools',
-  },
+  ...CLIENT_METHODS.flatMap(clientEntries),
+  ...SERVER_METHODS.flatMap(serverEntries),
 ]

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

@@ -13,6 +13,7 @@ const finishServerCh = channel('apm:http:server:request:finish')
 const startWriteHeadCh = channel('apm:http:server:response:writeHead:start')
 const finishSetHeaderCh = channel('datadog:http:server:response:set-header:finish')
 const startSetHeaderCh = channel('datadog:http:server:response:set-header:start')
+const startInformationalResponseCh = channel('datadog:http:server:informational-response:start')
 
 const requestFinishedSet = new WeakSet()
 
@@ -24,10 +25,19 @@ addHook({ name: 'http' }, http => {
   shimmer.wrap(http.ServerResponse.prototype, 'end', wrapEnd)
   shimmer.wrap(http.ServerResponse.prototype, 'setHeader', wrapSetHeader)
   shimmer.wrap(http.ServerResponse.prototype, 'removeHeader', wrapAppendOrRemoveHeader)
+  if (http.ServerResponse.prototype.writeContinue) {
+    shimmer.wrap(http.ServerResponse.prototype, 'writeContinue', wrapInformationalResponse)
+  }
+  if (http.ServerResponse.prototype.writeProcessing) {
+    shimmer.wrap(http.ServerResponse.prototype, 'writeProcessing', wrapInformationalResponse)
+  }
   // Added in node v16.17.0
   if (http.ServerResponse.prototype.appendHeader) {
     shimmer.wrap(http.ServerResponse.prototype, 'appendHeader', wrapAppendOrRemoveHeader)
   }
+  if (http.ServerResponse.prototype.writeEarlyHints) {
+    shimmer.wrap(http.ServerResponse.prototype, 'writeEarlyHints', wrapInformationalResponse)
+  }
   return http
 })
 
@@ -212,6 +222,23 @@ function wrapAppendOrRemoveHeader (originalMethod) {
   }
 }
 
+function wrapInformationalResponse (originalMethod) {
+  return function wrappedInformationalResponse (...args) {
+    if (!startInformationalResponseCh.hasSubscribers) {
+      return Reflect.apply(originalMethod, this, args)
+    }
+
+    const abortController = new AbortController()
+    startInformationalResponseCh.publish({ res: this, abortController })
+
+    if (abortController.signal.aborted) {
+      return
+    }
+
+    return Reflect.apply(originalMethod, this, args)
+  }
+}
+
 function wrapEnd (end) {
   return function wrappedEnd (...args) {
     if (!startWriteHeadCh.hasSubscribers) {

package/packages/datadog-instrumentations/src/modelcontextprotocol-sdk.js

@@ -1,7 +1,254 @@
 'use strict'
 
-const { addHook, getHooks } = require('./helpers/instrument')
+const { tracingChannel } = require('dc-polyfill')
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel, getHooks } = require('./helpers/instrument')
 
 for (const hook of getHooks('@modelcontextprotocol/sdk')) {
   addHook(hook, exports => exports)
 }
+
+const serverRequestCh = tracingChannel('apm:mcp:server:request')
+const clientRequestInjectCh = channel('apm:mcp:client:request:inject')
+const serverToolRegisteredCh = channel('apm:mcp:server:tool:registered')
+
+const DISTRIBUTED_TRACE_META_KEY = '_dd_trace_context'
+const TRACED_METHOD_PREFIX = /^(?:tools|resources|prompts)\//
+
+// Maps Protocol instance → Map<requestId, ctx>. Shares the ctx object between
+// _onrequest (span start, in the correct HTTP async context), the SDK request
+// handler wrapper (result/error capture), and the SDK cleanup path (span finish).
+const pendingContexts = new WeakMap()
+const wrappedAbortControllerMaps = new WeakSet()
+const wrappedRequestHandlerMaps = new WeakSet()
+const wrappedRequestHandlers = new WeakSet()
+
+function addTraceContextToRequest (request, traceContext) {
+  return {
+    ...request,
+    params: {
+      ...request.params,
+      _meta: {
+        ...request.params?._meta,
+        [DISTRIBUTED_TRACE_META_KEY]: traceContext,
+      },
+    },
+  }
+}
+
+function getPendingContext (protocol, requestId) {
+  return pendingContexts.get(protocol)?.get(requestId)
+}
+
+function finishServerRequest (protocol, requestId) {
+  const pending = pendingContexts.get(protocol)
+  const ctx = pending?.get(requestId)
+  if (!ctx) return
+
+  pending.delete(requestId)
+  serverRequestCh.asyncEnd.publish(ctx)
+}
+
+function wrapRequestHandler (protocol, handler) {
+  if (wrappedRequestHandlers.has(handler)) return handler
+
+  const wrappedHandler = function requestHandlerWithTrace (request, extra) {
+    const ctx = getPendingContext(protocol, extra?.requestId)
+    if (!ctx) return handler.apply(this, arguments)
+
+    let result
+    try {
+      result = handler.apply(this, arguments)
+    } catch (err) {
+      ctx.error = err
+      throw err
+    }
+
+    if (result && typeof result.then === 'function') {
+      result.then(result => {
+        ctx.result = result
+      }, err => {
+        ctx.error = err
+      })
+      return result
+    }
+
+    ctx.result = result
+    return result
+  }
+
+  wrappedRequestHandlers.add(wrappedHandler)
+  return wrappedHandler
+}
+
+function wrapRequestHandlers (protocol) {
+  const handlers = protocol._requestHandlers
+  if (!handlers || wrappedRequestHandlerMaps.has(handlers)) return
+
+  wrappedRequestHandlerMaps.add(handlers)
+  shimmer.wrap(handlers, 'set', function (original) {
+    return function setRequestHandlerWithTrace (method, handler) {
+      if (typeof handler === 'function') {
+        return original.call(this, method, wrapRequestHandler(protocol, handler))
+      }
+
+      return original.apply(this, arguments)
+    }
+  })
+}
+
+function wrapAbortControllers (protocol) {
+  const controllers = protocol._requestHandlerAbortControllers
+  if (!controllers || wrappedAbortControllerMaps.has(controllers)) return
+
+  wrappedAbortControllerMaps.add(controllers)
+  shimmer.wrap(controllers, 'delete', function (original) {
+    return function deleteAbortControllerWithTrace (requestId) {
+      finishServerRequest(protocol, requestId)
+      return original.apply(this, arguments)
+    }
+  })
+  shimmer.wrap(controllers, 'clear', function (original) {
+    return function clearAbortControllersWithTrace () {
+      for (const requestId of this.keys()) {
+        finishServerRequest(protocol, requestId)
+      }
+      return original.apply(this, arguments)
+    }
+  })
+}
+
+function wrapProtocol (Protocol) {
+  // Inject trace context into MCP request metadata so out-of-process MCP servers
+  // can parent server spans to the client operation span.
+  shimmer.wrap(Protocol.prototype, 'request', function (original) {
+    return function requestWithTraceContext (request, resultSchema, options) {
+      if (!clientRequestInjectCh.hasSubscribers || !TRACED_METHOD_PREFIX.test(request?.method)) {
+        return original.apply(this, arguments)
+      }
+
+      const ctx = {}
+      clientRequestInjectCh.publish(ctx)
+
+      if (!ctx.traceContext) {
+        return original.apply(this, arguments)
+      }
+
+      return original.call(this, addTraceContextToRequest(request, ctx.traceContext), resultSchema, options)
+    }
+  })
+
+  // Start spans in _onrequest — this runs inside the express POST /mcp handler's
+  // async context, so ALS correctly parents server spans under the HTTP span.
+  shimmer.wrap(Protocol.prototype, '_onrequest', function (original) {
+    return function _onrequestWithTrace (request, extra) {
+      if (!serverRequestCh.hasSubscribers || !TRACED_METHOD_PREFIX.test(request.method)) {
+        return original.call(this, request, extra)
+      }
+
+      wrapAbortControllers(this)
+      const ctx = { request, extra }
+      serverRequestCh.start.runStores(ctx, () => {
+        let pending = pendingContexts.get(this)
+        if (!pending) {
+          pending = new Map()
+          pendingContexts.set(this, pending)
+        }
+        pending.set(request.id, ctx)
+
+        try {
+          original.call(this, request, extra)
+        } catch (err) {
+          ctx.error = err
+          finishServerRequest(this, request.id)
+          throw err
+        }
+
+        // The SDK registers an AbortController only when it actually dispatches a handler.
+        // If none was registered (MethodNotFound path), no handler will run and our
+        // SDK cleanup hook will never fire — finish the span immediately.
+        if (!this._requestHandlerAbortControllers?.has(request.id)) {
+          ctx.error = { name: 'McpError', message: 'Method not found' }
+          finishServerRequest(this, request.id)
+        }
+      })
+    }
+  })
+
+  // The SDK's handler closure Zod-parses the request, stripping the JSON-RPC `id`.
+  // Use `extra.requestId` (the SDK's fullExtra field) to correlate with the pending ctx.
+  shimmer.wrap(Protocol.prototype, 'setRequestHandler', function (original) {
+    return function setRequestHandlerWithTrace () {
+      wrapRequestHandlers(this)
+      return original.apply(this, arguments)
+    }
+  })
+
+  return Protocol
+}
+
+function wrapMcpServer (McpServer) {
+  // Both public registration methods (tool/registerTool) delegate here — one hook covers both.
+  // Publishes to serverToolRegisteredCh so tracing.js can build a WeakMap of tool → name
+  // for O(1) lookup in McpServerToolCallPlugin (executeToolHandler receives the tool object,
+  // not the name string).
+  shimmer.wrap(McpServer.prototype, '_createRegisteredTool', function (original) {
+    return function (name) {
+      const result = original.apply(this, arguments)
+      if (serverToolRegisteredCh.hasSubscribers) {
+        const tool = this._registeredTools?.[name]
+        if (tool) {
+          serverToolRegisteredCh.publish({ tool, name })
+          shimmer.wrap(tool, 'update', function (update) {
+            return function updateWithTrace (updates) {
+              const result = update.apply(this, arguments)
+              if (updates && Object.hasOwn(updates, 'name')) {
+                serverToolRegisteredCh.publish({ tool, name: updates.name || undefined })
+              }
+              return result
+            }
+          })
+        }
+      }
+      return result
+    }
+  })
+
+  return McpServer
+}
+
+addHook({
+  name: '@modelcontextprotocol/sdk',
+  versions: ['>=1.27.1'],
+  file: 'dist/cjs/shared/protocol.js',
+}, exports => {
+  wrapProtocol(exports.Protocol)
+  return exports
+})
+
+addHook({
+  name: '@modelcontextprotocol/sdk',
+  versions: ['>=1.27.1'],
+  file: 'dist/esm/shared/protocol.js',
+}, exports => {
+  wrapProtocol(exports.Protocol)
+  return exports
+})
+
+addHook({
+  name: '@modelcontextprotocol/sdk',
+  versions: ['>=1.27.1'],
+  file: 'dist/cjs/server/mcp.js',
+}, exports => {
+  wrapMcpServer(exports.McpServer)
+  return exports
+})
+
+addHook({
+  name: '@modelcontextprotocol/sdk',
+  versions: ['>=1.27.1'],
+  file: 'dist/esm/server/mcp.js',
+}, exports => {
+  wrapMcpServer(exports.McpServer)
+  return exports
+})

package/packages/datadog-instrumentations/src/playwright.js

@@ -105,6 +105,7 @@ const efdStartedOriginalTestKeys = new Set()
 const efdSlowAbortedTests = new Set()
 const ddPropertiesByTestId = new Map()
 const ddPropertiesRequestsByTestId = new Map()
+const disabledTestIds = new Set()
 let rootDir = ''
 let sessionProjects = []
 
@@ -113,6 +114,8 @@ const EFD_RETRY_COUNT_REQUEST = 'ddEfdRetryCountRequest'
 const EFD_RETRY_COUNT_RESPONSE = 'ddEfdRetryCountResponse'
 const DD_PROPERTIES_REQUEST = 'ddPropertiesRequest'
 const DD_PROPERTIES_RESPONSE = 'ddProperties'
+const kDdPlaywrightDisabledTestIds = Symbol('ddPlaywrightDisabledTestIds')
+const kDdPlaywrightWorkerHostInstrumented = Symbol('ddPlaywrightWorkerHostInstrumented')
 const kDdPlaywrightWorkerInstrumented = Symbol('ddPlaywrightWorkerInstrumented')
 
 function isValidKnownTests (receivedKnownTests) {
@@ -991,14 +994,36 @@ function onDispatcherCreateWorker (dispatcher, worker) {
   const projects = getProjectsFromDispatcher(dispatcher)
   sessionProjects = projects
 
+  if (disabledTestIds.size && !worker[kDdPlaywrightWorkerHostInstrumented] &&
+      typeof worker.runTestGroup === 'function') {
+    Object.defineProperty(worker, kDdPlaywrightWorkerHostInstrumented, { value: true })
+    shimmer.wrap(worker, 'runTestGroup', runTestGroup => function (runPayload) {
+      // Serial retries can restore disabled tests that were filtered from the initial dispatcher groups.
+      let disabledIds
+      for (const { testId } of runPayload.entries) {
+        if (disabledTestIds.has(testId)) {
+          disabledIds ??= []
+          disabledIds.push(testId)
+        }
+      }
+      if (disabledIds) {
+        runPayload._ddDisabledTestIds = disabledIds
+      }
+      return runTestGroup.apply(this, arguments)
+    })
+  }
+
   worker.on('testBegin', ({ testId }) => {
     const test = getTestByTestId(dispatcher, testId)
+    if (!test) return
+
     const browser = getBrowserNameFromProjects(projects, test)
     const shouldCreateTestSpan = test.expectedStatus === 'skipped'
     testBeginHandler(test, browser, shouldCreateTestSpan)
   })
   worker.on('testEnd', ({ testId, status, errors, annotations }) => {
     const test = getTestByTestId(dispatcher, testId)
+    if (!test) return
 
     const isTimeout = status === 'timedOut'
     const testStatus = STATUS_TO_TEST_STATUS[status]
@@ -1308,6 +1333,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     efdSlowAbortedTests.clear()
     ddPropertiesByTestId.clear()
     ddPropertiesRequestsByTestId.clear()
+    disabledTestIds.clear()
 
     // TODO: we can trick playwright into thinking the session passed by returning
     // 'passed' here. We might be able to use this for both EFD and Test Management tests.
@@ -1552,6 +1578,7 @@ function processRootSuite (createRootSuiteReturnValue) {
       if (testProperties.disabled) {
         test._ddIsDisabled = true
         if (!testProperties.attemptToFix) {
+          disabledTestIds.add(test.id)
           test.expectedStatus = 'skipped'
           // setting test.expectedStatus to 'skipped' does not work for every case,
           // so we need to filter out disabled tests in dispatcherRunWrapperNew,
@@ -1795,7 +1822,17 @@ function instrumentWorkerMainMethods (workerMain) {
   let steps = []
   const stepInfoByStepId = {}
 
+  shimmer.wrap(workerMain, 'runTestGroup', runTestGroup => function (runPayload) {
+    const disabledIds = runPayload._ddDisabledTestIds
+    this[kDdPlaywrightDisabledTestIds] = disabledIds ? new Set(disabledIds) : undefined
+    return runTestGroup.apply(this, arguments)
+  })
+
   shimmer.wrap(workerMain, '_runTest', _runTest => async function (test) {
+    if (this[kDdPlaywrightDisabledTestIds]?.has(test.id)) {
+      test._ddIsDisabled = true
+      test.expectedStatus = 'skipped'
+    }
     await waitForEfdRetryCount(test)
     if (shouldSkipEfdRetry(test)) {
       test._ddShouldSkipEfdRetry = true
@@ -2042,9 +2079,9 @@ function generateSummaryWrapper (generateSummary) {
   return function (...args) {
     for (const test of this.suite.allTests()) {
       // https://github.com/microsoft/playwright/blob/bf92ffecff6f30a292b53430dbaee0207e0c61ad/packages/playwright/src/reporters/base.ts#L279
-      const didNotRun = test.outcome() === 'skipped' &&
-        (!test.results.length || test.expectedStatus !== 'skipped')
-      if (didNotRun && !testsReportedInGenerateSummary.has(test)) {
+      const shouldReportAsSkipped = test.outcome() === 'skipped' &&
+        (disabledTestIds.has(test.id) || !test.results.length || test.expectedStatus !== 'skipped')
+      if (shouldReportAsSkipped && !testsReportedInGenerateSummary.has(test)) {
         testsReportedInGenerateSummary.add(test)
         const {
           _requireFile: testSuiteAbsolutePath,

package/packages/datadog-plugin-azure-functions/src/index.js

@@ -65,6 +65,7 @@ class AzureFunctionsPlugin extends TracingPlugin {
         service: this.serviceName(),
         type: 'serverless',
         meta,
+        childOf: null,
       }, ctx)
 
       if (isMessagingService) {
@@ -142,7 +143,7 @@ function mapTriggerTag (methodName) {
 // message & messages & batch with cardinality of 1 == applicationProperties
 // messages with cardinality of many == applicationPropertiesArray
 function setSpanLinks (triggerType, tracer, span, ctx) {
-  const cardinality = ctx.invocationContext.options.trigger.cardinality
+  const cardinality = ctx.invocationContext.options.trigger.cardinality ?? 'one'
   const triggerMetadata = ctx.invocationContext.triggerMetadata
   const isServiceBus = triggerType === 'ServiceBus'
 

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

@@ -82,7 +82,7 @@ class GraphQLRequestPlugin extends TracingPlugin {
     if (result?.errors?.length) {
       span.setTag('error', result.errors[0])
       for (const error of result.errors) {
-        extractErrorIntoSpanEvent(this._tracerConfig, span, error)
+        extractErrorIntoSpanEvent(this.config, span, error)
       }
     }