dd-trace 5.81.0 → 5.82.0

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { URL } = require('url')
+
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
 const { storage } = require('../../datadog-core')
 const tags = require('../../../ext/tags')
@@ -9,7 +11,6 @@ const HTTP_HEADERS = formats.HTTP_HEADERS
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
 const log = require('../../dd-trace/src/log')
 const { CLIENT_PORT_KEY, COMPONENT, ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../dd-trace/src/constants')
-const { URL } = require('url')
 
 const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
 const HTTP_REQUEST_HEADERS = tags.HTTP_REQUEST_HEADERS

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

@@ -1,16 +1,36 @@
 'use strict'
 
-const HttpServerPlugin = require('./server')
-const HttpClientPlugin = require('./client')
+const PushSubscriptionPlugin = require('../../datadog-plugin-google-cloud-pubsub/src/pubsub-push-subscription')
 const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const { enableGCPPubSubPushSubscription } = require('../../dd-trace/src/serverless')
+const log = require('../../dd-trace/src/log')
+const HttpClientPlugin = require('./client')
+const HttpServerPlugin = require('./server')
 
+/**
+ * HTTP Plugin loads server/client plugins with optional GCP Pub/Sub Push support.
+ * Plugin order is critical: PushSubscriptionPlugin must load FIRST to intercept
+ * Pub/Sub push requests and activate delivery spans before HTTP spans are created.
+ */
 class HttpPlugin extends CompositePlugin {
   static id = 'http'
   static get plugins () {
-    return {
-      server: HttpServerPlugin,
-      client: HttpClientPlugin
+    const plugins = {}
+
+    // Load push subscription plugin first (if enabled) for GCP Cloud Run
+    if (enableGCPPubSubPushSubscription()) {
+      try {
+        plugins['pubsub-push-subscription'] = PushSubscriptionPlugin
+        log.debug('Loaded GCP Pub/Sub Push Subscription plugin for HTTP requests')
+      } catch (e) {
+        log.debug(`Failed to load GCP Pub/Sub Push Subscription plugin: ${e.message}`)
+      }
     }
+
+    plugins.server = HttpServerPlugin
+    plugins.client = HttpClientPlugin
+
+    return plugins
   }
 }
 

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

@@ -1,9 +1,9 @@
 'use strict'
 
+const URL = require('url').URL
+
 const { storage } = require('../../datadog-core')
 const ClientPlugin = require('../../dd-trace/src/plugins/client')
-
-const URL = require('url').URL
 const log = require('../../dd-trace/src/log')
 const tags = require('../../../ext/tags')
 const kinds = require('../../../ext/kinds')

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

@@ -1,8 +1,8 @@
 'use strict'
 
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const Http2ServerPlugin = require('./server')
 const Http2ClientPlugin = require('./client')
-const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 
 class Http2Plugin extends CompositePlugin {
   static id = 'http2'

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

@@ -1,9 +1,9 @@
 'use strict'
 
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const ProducerPlugin = require('./producer')
 const ConsumerPlugin = require('./consumer')
 const BatchConsumerPlugin = require('./batch-consumer')
-const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 
 class KafkajsPlugin extends CompositePlugin {
   static id = 'kafkajs'

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

@@ -1,8 +1,8 @@
 'use strict'
 
-const langChainTracingPlugins = require('./tracing')
 const langChainLLMObsPlugins = require('../../dd-trace/src/llmobs/plugins/langchain')
 const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const langChainTracingPlugins = require('./tracing')
 
 const plugins = {}
 

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

@@ -2,9 +2,9 @@
 
 // TODO: support https://moleculer.services/docs/0.13/actions.html#Streaming
 
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const MoleculerServerPlugin = require('./server')
 const MoleculerClientPlugin = require('./client')
-const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 
 class MoleculerPlugin extends CompositePlugin {
   static id = 'moleculer'

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

@@ -204,8 +204,12 @@ function isBinary (val) {
 }
 
 function isHeartbeat (ops, config) {
-  // Check if it's a heartbeat command hello: 1 or helloOk: 1
-  return ops && typeof ops === 'object' && (ops.hello === 1 || ops.helloOk === true)
+  // Check if it's a heartbeat command https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.md
+  return (
+    ops &&
+    typeof ops === 'object' &&
+    (ops.hello === 1 || ops.helloOk === true || ops.ismaster === 1 || ops.isMaster === 1)
+  )
 }
 
 module.exports = MongodbCorePlugin

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

@@ -1,8 +1,8 @@
 'use strict'
 
 const CompositePlugin = require('../../dd-trace/src/plugins/composite')
-const OpenAiTracingPlugin = require('./tracing')
 const OpenAiLLMObsPlugin = require('../../dd-trace/src/llmobs/plugins/openai')
+const OpenAiTracingPlugin = require('./tracing')
 
 class OpenAiPlugin extends CompositePlugin {
   static id = 'openai'

package/packages/datadog-plugin-openai/src/stream-helpers.js

@@ -1,10 +1,30 @@
 'use strict'
 
+/**
+ * @typedef {Record<string, unknown>} JsonObject
+ *
+ * @typedef {{ function: { arguments: string } }} ToolCall
+ * @typedef {{ content?: string, tool_calls?: ToolCall[] }} ChatDelta
+ *
+ * @typedef {{
+ *   index: number,
+ *   finish_reason?: string | null,
+ *   text?: string,
+ *   delta?: ChatDelta
+ * }} StreamChoice
+ *
+ * @typedef {JsonObject & { choices: StreamChoice[], usage?: unknown }} StreamChunk
+ * @typedef {JsonObject & { choices: Array<StreamChoice | undefined>, usage?: unknown }} StreamResponseBody
+ *
+ * @typedef {JsonObject & { status?: string }} ResponsesApiResponse
+ * @typedef {JsonObject & { response?: ResponsesApiResponse }} ResponsesApiChunk
+ */
+
 /**
  * Combines legacy OpenAI streamed chunks into a single object.
  * These legacy chunks are returned as buffers instead of individual objects.
  * @param {readonly Uint8Array[]} chunks
- * @returns {Array<Record<string, any>>}
+ * @returns {JsonObject[]}
  */
 function convertBuffersToObjects (chunks) {
   return Buffer
@@ -21,10 +41,10 @@ function convertBuffersToObjects (chunks) {
  * The shared logic will add a new choice index entry if it doesn't exist, and otherwise
  * hand off to a onChoice handler to add that choice to the previously stored choice.
  *
- * @param {Array<Record<string, any>>} chunks
+ * @param {StreamChunk[]} chunks
  * @param {number} n
- * @param {function(Record<string, any>, Record<string, any>): void} onChoice
- * @returns {Record<string, any>}
+ * @param {(newChoice: StreamChoice, existingChoice: StreamChoice) => void} onChoice
+ * @returns {StreamResponseBody}
  */
 function constructResponseFromStreamedChunks (chunks, n, onChoice) {
   const body = { ...chunks[0], choices: Array.from({ length: n }) }
@@ -54,9 +74,9 @@ function constructResponseFromStreamedChunks (chunks, n, onChoice) {
 /**
  * Constructs the entire response from a stream of OpenAI completion chunks,
  * mainly combining the text choices of each chunk into a single string per choice.
- * @param {Array<Record<string, any>>} chunks
+ * @param {StreamChunk[]} chunks
  * @param {number} n the number of choices to expect in the response
- * @returns {Record<string, any>}
+ * @returns {StreamResponseBody}
  */
 function constructCompletionResponseFromStreamedChunks (chunks, n) {
   return constructResponseFromStreamedChunks(chunks, n, (choice, oldChoice) => {
@@ -74,9 +94,9 @@ function constructCompletionResponseFromStreamedChunks (chunks, n) {
 /**
  * Constructs the entire response from a stream of OpenAI chat completion chunks,
  * mainly combining the text choices of each chunk into a single string per choice.
- * @param {Array<Record<string, any>>} chunks
+ * @param {StreamChunk[]} chunks
  * @param {number} n the number of choices to expect in the response
- * @returns {Record<string, any>}
+ * @returns {StreamResponseBody}
  */
 function constructChatCompletionResponseFromStreamedChunks (chunks, n) {
   return constructResponseFromStreamedChunks(chunks, n, (choice, oldChoice) => {
@@ -110,8 +130,8 @@ function constructChatCompletionResponseFromStreamedChunks (chunks, n) {
 /**
  * Constructs the entire response from a stream of OpenAI responses chunks.
  * The responses API uses event-based streaming with delta chunks.
- * @param {Array<Record<string, any>>} chunks
- * @returns {Record<string, any>|undefined}
+ * @param {ResponsesApiChunk[]} chunks
+ * @returns {ResponsesApiResponse|undefined}
  */
 function constructResponseResponseFromStreamedChunks (chunks) {
   // The responses API streams events with different types:

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

@@ -4,10 +4,10 @@ const path = require('path')
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
 const { storage } = require('../../datadog-core')
-const services = require('./services')
 const Sampler = require('../../dd-trace/src/sampler')
 const { MEASURED } = require('../../../ext/tags')
 
+const { DD_MAJOR } = require('../../../version')
 const {
   convertBuffersToObjects,
   constructCompletionResponseFromStreamedChunks,
@@ -15,7 +15,7 @@ const {
   constructResponseResponseFromStreamedChunks
 } = require('./stream-helpers')
 
-const { DD_MAJOR } = require('../../../version')
+const services = require('./services')
 
 class OpenAiTracingPlugin extends TracingPlugin {
   static id = 'openai'

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

@@ -1,8 +1,8 @@
 'use strict'
 
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 const ProducerPlugin = require('./producer')
 const ConsumerPlugin = require('./consumer')
-const CompositePlugin = require('../../dd-trace/src/plugins/composite')
 
 class RheaPlugin extends CompositePlugin {
   static id = 'rhea'

package/packages/datadog-plugin-ws/src/close.js

@@ -1,6 +1,16 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing.js')
+const {
+  WEBSOCKET_PTR_KIND,
+  SPAN_POINTER_DIRECTION,
+  SPAN_POINTER_DIRECTION_NAME
+} = require('../../dd-trace/src/constants')
+const {
+  incrementWebSocketCounter,
+  buildWebSocketSpanPointerHash,
+  hasDistributedTracingContext
+} = require('./util')
 
 class WSClosePlugin extends TracingPlugin {
   static get id () { return 'ws' }
@@ -10,11 +20,9 @@ class WSClosePlugin extends TracingPlugin {
 
   bindStart (ctx) {
     const {
-      traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
       traceWebsocketMessagesSeparateTraces
     } = this.config
-    if (!traceWebsocketMessagesEnabled) return
 
     const { code, data, socket, isPeerClose } = ctx
     if (!socket?.spanContext) return
@@ -60,7 +68,52 @@ class WSClosePlugin extends TracingPlugin {
   end (ctx) {
     if (!Object.hasOwn(ctx, 'result') || !ctx.span) return
 
-    if (ctx.socket.spanContext) ctx.span.addLink({ context: ctx.socket.spanContext })
+    if (ctx.socket.spanContext) {
+      const linkAttributes = {}
+
+      // Determine link kind based on whether this is peer close (incoming) or self close (outgoing)
+      const isIncoming = ctx.isPeerClose
+      linkAttributes['dd.kind'] = isIncoming ? 'executed_by' : 'resuming'
+
+      // Add span pointer for context propagation
+      if (this.config.traceWebsocketMessagesEnabled && ctx.socket.handshakeSpan) {
+        const handshakeSpan = ctx.socket.handshakeSpan
+
+        // Only add span pointers if distributed tracing is enabled and handshake has distributed context
+        if (hasDistributedTracingContext(handshakeSpan, ctx.socket)) {
+          const counterType = isIncoming ? 'receiveCounter' : 'sendCounter'
+          const counter = incrementWebSocketCounter(ctx.socket, counterType)
+          const handshakeContext = handshakeSpan.context()
+
+          const ptrHash = buildWebSocketSpanPointerHash(
+            handshakeContext._traceId,
+            handshakeContext._spanId,
+            counter,
+            true, // isServer
+            isIncoming
+          )
+
+          const directionName = isIncoming
+            ? SPAN_POINTER_DIRECTION_NAME.UPSTREAM
+            : SPAN_POINTER_DIRECTION_NAME.DOWNSTREAM
+          const direction = isIncoming
+            ? SPAN_POINTER_DIRECTION.UPSTREAM
+            : SPAN_POINTER_DIRECTION.DOWNSTREAM
+
+          // Add span pointer attributes to link
+          linkAttributes['link.name'] = directionName
+          linkAttributes['dd.kind'] = 'span-pointer'
+          linkAttributes['ptr.kind'] = WEBSOCKET_PTR_KIND
+          linkAttributes['ptr.dir'] = direction
+          linkAttributes['ptr.hash'] = ptrHash
+        }
+      }
+
+      ctx.span.addLink({
+        context: ctx.socket.spanContext,
+        attributes: linkAttributes
+      })
+    }
 
     ctx.span.finish()
   }

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

@@ -19,6 +19,10 @@ class WSPlugin extends CompositePlugin {
   }
 
   configure (config) {
+    if (!config.traceWebsocketMessagesEnabled) {
+      super.configure(false)
+      return
+    }
     return super.configure(config)
   }
 }

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

@@ -1,6 +1,16 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing.js')
+const {
+  WEBSOCKET_PTR_KIND,
+  SPAN_POINTER_DIRECTION,
+  SPAN_POINTER_DIRECTION_NAME
+} = require('../../dd-trace/src/constants')
+const {
+  incrementWebSocketCounter,
+  buildWebSocketSpanPointerHash,
+  hasDistributedTracingContext
+} = require('./util')
 
 class WSProducerPlugin extends TracingPlugin {
   static get id () { return 'ws' }
@@ -9,9 +19,6 @@ class WSProducerPlugin extends TracingPlugin {
   static get kind () { return 'producer' }
 
   bindStart (ctx) {
-    const messagesEnabled = this.config.traceWebsocketMessagesEnabled
-    if (!messagesEnabled) return
-
     const { byteLength, socket, binary } = ctx
     if (!socket.spanContext) return
 
@@ -51,9 +58,37 @@ class WSProducerPlugin extends TracingPlugin {
     if (!Object.hasOwn(ctx, 'result') || !ctx.span) return
 
     if (ctx.socket.spanContext) {
+      const linkAttributes = { 'dd.kind': 'resuming' }
+
+      // Add span pointer for context propagation
+      if (this.config.traceWebsocketMessagesEnabled && ctx.socket.handshakeSpan) {
+        const handshakeSpan = ctx.socket.handshakeSpan
+
+        // Only add span pointers if distributed tracing is enabled and handshake has distributed context
+        if (hasDistributedTracingContext(handshakeSpan, ctx.socket)) {
+          const counter = incrementWebSocketCounter(ctx.socket, 'sendCounter')
+          const handshakeContext = handshakeSpan.context()
+
+          const ptrHash = buildWebSocketSpanPointerHash(
+            handshakeContext._traceId,
+            handshakeContext._spanId,
+            counter,
+            true, // isServer
+            false // isIncoming (this is outgoing)
+          )
+
+          // Add span pointer attributes to link
+          linkAttributes['link.name'] = SPAN_POINTER_DIRECTION_NAME.DOWNSTREAM
+          linkAttributes['dd.kind'] = 'span-pointer'
+          linkAttributes['ptr.kind'] = WEBSOCKET_PTR_KIND
+          linkAttributes['ptr.dir'] = SPAN_POINTER_DIRECTION.DOWNSTREAM
+          linkAttributes['ptr.hash'] = ptrHash
+        }
+      }
+
       ctx.span.addLink({
         context: ctx.socket.spanContext,
-        attributes: { 'dd.kind': 'resuming' },
+        attributes: linkAttributes,
       })
     }
 

package/packages/datadog-plugin-ws/src/receiver.js

@@ -1,6 +1,16 @@
 'use strict'
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing.js')
+const {
+  WEBSOCKET_PTR_KIND,
+  SPAN_POINTER_DIRECTION,
+  SPAN_POINTER_DIRECTION_NAME
+} = require('../../dd-trace/src/constants')
+const {
+  incrementWebSocketCounter,
+  buildWebSocketSpanPointerHash,
+  hasDistributedTracingContext
+} = require('./util')
 
 class WSReceiverPlugin extends TracingPlugin {
   static get id () { return 'ws' }
@@ -10,11 +20,9 @@ class WSReceiverPlugin extends TracingPlugin {
 
   bindStart (ctx) {
     const {
-      traceWebsocketMessagesEnabled,
       traceWebsocketMessagesInheritSampling,
       traceWebsocketMessagesSeparateTraces
     } = this.config
-    if (!traceWebsocketMessagesEnabled) return
 
     const { byteLength, socket, binary } = ctx
     if (!socket.spanContext) return
@@ -61,9 +69,37 @@ class WSReceiverPlugin extends TracingPlugin {
     if (!Object.hasOwn(ctx, 'result') || !ctx.span) return
 
     if (ctx.socket.spanContext) {
+      const linkAttributes = { 'dd.kind': 'executed_by' }
+
+      // Add span pointer for context propagation
+      if (this.config.traceWebsocketMessagesEnabled && ctx.socket.handshakeSpan) {
+        const handshakeSpan = ctx.socket.handshakeSpan
+
+        // Only add span pointers if distributed tracing is enabled and handshake has distributed context
+        if (hasDistributedTracingContext(handshakeSpan, ctx.socket)) {
+          const counter = incrementWebSocketCounter(ctx.socket, 'receiveCounter')
+          const handshakeContext = handshakeSpan.context()
+
+          const ptrHash = buildWebSocketSpanPointerHash(
+            handshakeContext._traceId,
+            handshakeContext._spanId,
+            counter,
+            true, // isServer
+            true // isIncoming
+          )
+
+          // Add span pointer attributes to link
+          linkAttributes['link.name'] = SPAN_POINTER_DIRECTION_NAME.UPSTREAM
+          linkAttributes['dd.kind'] = 'span-pointer'
+          linkAttributes['ptr.kind'] = WEBSOCKET_PTR_KIND
+          linkAttributes['ptr.dir'] = SPAN_POINTER_DIRECTION.UPSTREAM
+          linkAttributes['ptr.hash'] = ptrHash
+        }
+      }
+
       ctx.span.addLink({
         context: ctx.socket.spanContext,
-        attributes: { 'dd.kind': 'executed_by' },
+        attributes: linkAttributes,
       })
     }
 

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

@@ -2,6 +2,8 @@
 
 const TracingPlugin = require('../../dd-trace/src/plugins/tracing.js')
 const tags = require('../../../ext/tags.js')
+const { FORMAT_HTTP_HEADERS } = require('../../../ext/formats')
+const { initWebSocketMessageCounters } = require('./util')
 
 const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
 
@@ -28,9 +30,13 @@ class WSServerPlugin extends TracingPlugin {
 
     ctx.args = { options }
 
+    // Extract distributed tracing context from request headers
+    const childOf = this.tracer.extract(FORMAT_HTTP_HEADERS, req.headers)
+
     const service = this.serviceName({ pluginConfig: this.config })
     const span = this.startSpan(this.operationName(), {
       service,
+      childOf,
       meta: {
         'span.type': 'websocket',
         'http.upgraded': 'websocket',
@@ -38,7 +44,6 @@ class WSServerPlugin extends TracingPlugin {
         'http.url': uri,
         'resource.name': `${options.method} ${route}`,
         'span.kind': 'server'
-
       }
 
     }, ctx)
@@ -46,6 +51,13 @@ class WSServerPlugin extends TracingPlugin {
 
     ctx.socket.spanContext = ctx.span._spanContext
     ctx.socket.spanContext.spanTags = ctx.span._spanContext._tags
+    // Store the handshake span for use in message span pointers
+    ctx.socket.handshakeSpan = ctx.span
+    // Store the request headers for distributed tracing check
+    ctx.socket.requestHeaders = req.headers
+
+    // Initialize message counters for span pointers
+    initWebSocketMessageCounters(ctx.socket)
 
     return ctx.currentStore
   }

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

@@ -0,0 +1,107 @@
+'use strict'
+
+// WeakMap to store message counters per socket without mutating the socket object
+const socketCounters = new WeakMap()
+
+/**
+ * Initializes WebSocket message counters for a socket.
+ * @param {object} socket - The WebSocket socket object
+ */
+function initWebSocketMessageCounters (socket) {
+  if (!socketCounters.has(socket)) {
+    socketCounters.set(socket, {
+      receiveCounter: 0,
+      sendCounter: 0
+    })
+  }
+}
+
+/**
+ * Increments and returns the WebSocket message counter.
+ * @param {object} socket - The WebSocket socket object
+ * @param {string} counterType - Either 'receiveCounter' or 'sendCounter'
+ * @returns {number} The incremented counter value
+ */
+function incrementWebSocketCounter (socket, counterType) {
+  if (!socketCounters.has(socket)) {
+    initWebSocketMessageCounters(socket)
+  }
+  const counters = socketCounters.get(socket)
+  counters[counterType]++
+  return counters[counterType]
+}
+
+/**
+ * Builds a WebSocket span pointer hash.
+ *
+ * Format: <prefix><128 bit hex trace id><64 bit hex span id><32 bit hex counter>
+ * Prefix: 'S' for server outgoing or client incoming, 'C' for server incoming or client outgoing
+ *
+ * @param {bigint} handshakeTraceId - The trace ID from the handshake span (as a BigInt)
+ * @param {bigint} handshakeSpanId - The span ID from the handshake span (as a BigInt)
+ * @param {number} counter - The message counter
+ * @param {boolean} isServer - Whether this is a server (true) or client (false)
+ * @param {boolean} isIncoming - Whether this is an incoming message (true) or outgoing (false)
+ * @returns {string} The span pointer hash
+ */
+function buildWebSocketSpanPointerHash (handshakeTraceId, handshakeSpanId, counter, isServer, isIncoming) {
+  // Determine prefix based on server/client and incoming/outgoing
+  // Server outgoing or client incoming: 'S'
+  // Server incoming or client outgoing: 'C'
+  const prefix = (isServer && !isIncoming) || (!isServer && isIncoming) ? 'S' : 'C'
+
+  // Pad trace ID to 32 hex chars (128 bits)
+  const traceIdHex = handshakeTraceId.toString(16).padStart(32, '0')
+
+  // Pad span ID to 16 hex chars (64 bits)
+  const spanIdHex = handshakeSpanId.toString(16).padStart(16, '0')
+
+  // Pad counter to 8 hex chars (32 bits)
+  const counterHex = counter.toString(16).padStart(8, '0')
+
+  return `${prefix}${traceIdHex}${spanIdHex}${counterHex}`
+}
+
+/**
+ * Checks if the handshake span has extracted distributed tracing context.
+ * A websocket server must not set the span pointer if the handshake has not extracted a context.
+ *
+ * A span has distributed tracing context if it has a parent context that was
+ * extracted from headers (remote parent).
+ *
+ * @param {object} span - The handshake span
+ * @param {object} socket - The WebSocket socket object
+ * @returns {boolean} True if the span has distributed tracing context
+ */
+function hasDistributedTracingContext (span, socket) {
+  if (!span) return false
+  const context = span.context()
+  if (!context) return false
+
+  // Check if this span has a parent. If the parent was extracted from remote headers,
+  // then this span is part of a distributed trace.
+  // We check if the span has a parent by looking at _parentId.
+  // In the JavaScript tracer, when a context is extracted from headers and a child span
+  // is created, the child will have _parentId set to the extracted parent's span ID.
+  //
+  // For testing purposes, we also check if Datadog trace headers are present in the socket's
+  // upgrade request, which indicates distributed tracing context was sent by the client.
+  if (context._parentId !== null) {
+    return true
+  }
+
+  // Fallback check: look for distributed tracing headers in the stored request headers
+  if (socket && socket.requestHeaders) {
+    const headers = socket.requestHeaders
+    return !!(headers['x-datadog-trace-id'] || headers.traceparent)
+  }
+
+  return false
+}
+
+module.exports = {
+  initWebSocketMessageCounters,
+  incrementWebSocketCounter,
+  buildWebSocketSpanPointerHash,
+  hasDistributedTracingContext
+}

package/packages/datadog-shimmer/src/shimmer.js

@@ -91,7 +91,7 @@ function wrapFunction (original, wrapper) {
  * @param {Record<string | symbol, unknown> | Function | undefined} target - The target
  * object.
  * @param {string | symbol} name - The property key of the method to wrap.
- * @param {(original: Function) => (...args: unknown[]) => any} wrapper - The wrapper function.
+ * @param {(original: Function) => (...args: unknown[]) => unknown} wrapper - The wrapper function.
  * @param {{ replaceGetter?: boolean }} [options] - If `replaceGetter` is set to
  * true, the getter is accessed and the getter is replaced with one that just
  * returns the earlier retrieved value. Use with care! This may only be done in
@@ -214,7 +214,7 @@ function wrap (target, name, wrapper, options) {
  *         Record<string | symbol, unknown> |
  *         Function} targets - The target objects.
  * @param {Array<string | symbol> | string | symbol} names - The property keys of the methods to wrap.
- * @param {(original: Function) => (...args: unknown[]) => any} wrapper - The wrapper function.
+ * @param {(original: Function) => (...args: unknown[]) => unknown} wrapper - The wrapper function.
  */
 function massWrap (targets, names, wrapper) {
   targets = toArray(targets)