@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,99 @@
+'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' }
+  static get prefix () { return 'tracing:ws:send' }
+  static get type () { return 'websocket' }
+  static get kind () { return 'producer' }
+
+  bindStart (ctx) {
+    const { byteLength, socket, binary } = ctx
+    if (!socket.spanContext) return
+
+    const spanTags = socket.spanTags
+    const path = spanTags['resource.name'].split(' ')[1]
+    const opCode = binary ? 'binary' : 'text'
+    const service = this.serviceName({ pluginConfig: this.config })
+    const span = this.startSpan(this.operationName(), {
+      service,
+      meta: {
+        'span.type': 'websocket',
+        'span.kind': 'producer',
+        'resource.name': `websocket ${path}`,
+        'websocket.message.type': opCode,
+
+      },
+      metrics: {
+        'websocket.message.length': byteLength,
+      },
+
+    }, ctx)
+
+    ctx.span = span
+    return ctx.currentStore
+  }
+
+  bindAsyncStart (ctx) {
+    ctx.span.finish()
+    return ctx.parentStore
+  }
+
+  asyncStart (ctx) {
+    ctx.span.finish()
+  }
+
+  end (ctx) {
+    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.spanContext) {
+        const handshakeContext = ctx.socket.spanContext
+
+        // Only add span pointers if distributed tracing is enabled and handshake has distributed context
+        if (hasDistributedTracingContext(handshakeContext, ctx.socket)) {
+          const counter = incrementWebSocketCounter(ctx.socket, 'sendCounter')
+
+          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: linkAttributes,
+      })
+    }
+
+    ctx.span.finish()
+    return ctx.parentStore
+  }
+}
+
+module.exports = WSProducerPlugin

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

@@ -0,0 +1,110 @@
+'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' }
+  static get prefix () { return 'tracing:ws:receive' }
+  static get type () { return 'websocket' }
+  static get kind () { return 'consumer' }
+
+  bindStart (ctx) {
+    const {
+      traceWebsocketMessagesInheritSampling,
+      traceWebsocketMessagesSeparateTraces,
+    } = this.config
+
+    const { byteLength, socket, binary } = ctx
+    if (!socket.spanContext) return
+
+    const spanTags = socket.spanTags
+    const path = spanTags['resource.name'].split(' ')[1]
+    const opCode = binary ? 'binary' : 'text'
+
+    const service = this.serviceName({ pluginConfig: this.config })
+    const span = this.startSpan(this.operationName(), {
+      service,
+      meta: {
+        'span.type': 'websocket',
+        'span.kind': 'consumer',
+        'resource.name': `websocket ${path}`,
+        'websocket.duration.style': 'handler',
+        'websocket.message.type': opCode,
+      },
+      metrics: {
+        'websocket.message.length': byteLength,
+      },
+
+    }, ctx)
+
+    if (traceWebsocketMessagesInheritSampling && traceWebsocketMessagesSeparateTraces) {
+      span.setTag('_dd.dm.service', spanTags['service.name'] || service)
+      span.setTag('_dd.dm.resource', spanTags['resource.name'] || `websocket ${path}`)
+      span.setTag('_dd.dm.inherited', 1)
+    }
+
+    ctx.span = span
+    return ctx.currentStore
+  }
+
+  bindAsyncStart (ctx) {
+    return ctx.parentStore
+  }
+
+  asyncStart (ctx) {
+    ctx.span.finish()
+  }
+
+  end (ctx) {
+    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.spanContext) {
+        const handshakeContext = ctx.socket.spanContext
+
+        // Only add span pointers if distributed tracing is enabled and handshake has distributed context
+        if (hasDistributedTracingContext(handshakeContext, ctx.socket)) {
+          const counter = incrementWebSocketCounter(ctx.socket, 'receiveCounter')
+
+          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: linkAttributes,
+      })
+    }
+
+    ctx.span.finish()
+    return ctx.parentStore
+  }
+}
+
+module.exports = WSReceiverPlugin

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

@@ -0,0 +1,106 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing.js')
+const tags = require('../../../ext/tags.js')
+const { HTTP_HEADERS } = require('../../../ext/formats')
+const {
+  createWebSocketSpanContext,
+  hasTraceHeaders,
+  initWebSocketMessageCounters,
+} = require('./util')
+
+const HTTP_STATUS_CODE = tags.HTTP_STATUS_CODE
+
+class WSServerPlugin extends TracingPlugin {
+  static get id () { return 'ws' }
+  static get prefix () { return 'tracing:ws:server:connect' }
+  static get type () { return 'websocket' }
+  static get kind () { return 'request' }
+
+  constructor (...args) {
+    super(...args)
+
+    // Bind the setSocket channel so internal ws event handlers (data, close)
+    // don't capture their async context.
+    this.addBind('tracing:ws:server:connect:setSocket', () => {})
+  }
+
+  bindStart (ctx) {
+    const req = ctx.req
+
+    const options = {}
+    const headers = Object.entries(req.headers)
+    options.headers = Object.fromEntries(headers)
+    options.method = req.method
+
+    const protocol = `${getRequestProtocol(req)}:`
+    const host = options.headers.host
+    const url = req.url
+    const indexOfParam = url.indexOf('?')
+    const route = indexOfParam === -1 ? url : url.slice(0, indexOfParam)
+    const uri = `${protocol}//${host}${route}`
+    const resourceName = `${options.method} ${route}`
+
+    ctx.args = { options }
+
+    // Extract distributed tracing context from request headers
+    const childOf = this.tracer.extract(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',
+        'http.method': options.method,
+        'http.url': uri,
+        'resource.name': resourceName,
+        'span.kind': 'server',
+      },
+
+    }, ctx)
+    ctx.span = span
+
+    ctx.socket.spanTags = {
+      'resource.name': resourceName,
+      'service.name': service,
+    }
+    ctx.socket.spanContext = createWebSocketSpanContext(ctx.span._spanContext)
+    ctx.socket.hasTraceHeaders = hasTraceHeaders(req.headers)
+
+    // Initialize message counters for span pointers
+    initWebSocketMessageCounters(ctx.socket)
+
+    return ctx.currentStore
+  }
+
+  bindAsyncStart (ctx) {
+    ctx.span.setTag(HTTP_STATUS_CODE, ctx.req.resStatus)
+
+    return ctx.parentStore
+  }
+
+  asyncStart (ctx) {
+    ctx.span.finish()
+  }
+}
+
+function getRequestProtocol (req, fallback = 'ws') {
+  // 1. Check if the underlying TLS socket has 'encrypted'
+  if (req.socket && req.socket.encrypted) {
+    return 'wss'
+  }
+
+  // 2. Check for a trusted header set by a proxy
+  if (req.headers && req.headers['x-forwarded-proto']) {
+    const proto = req.headers['x-forwarded-proto'].split(',')[0].trim()
+    if (proto === 'https') return 'wss'
+    if (proto === 'http') return 'ws'
+  }
+
+  // 3. Fallback to ws
+  return fallback
+}
+
+module.exports = WSServerPlugin

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

@@ -0,0 +1,139 @@
+'use strict'
+
+const DatadogSpanContext = require('../../dd-trace/src/opentracing/span_context')
+
+const TRACE_ID_UPPER_TAG = '_dd.p.tid'
+
+// WeakMap to store message counters per socket without mutating the socket object
+const socketCounters = new WeakMap()
+
+/**
+ * Creates a minimal span context for span links without retaining the full trace.
+ * @param {DatadogSpanContext} spanContext
+ * @returns {DatadogSpanContext | undefined}
+ */
+function createWebSocketSpanContext (spanContext) {
+  if (!spanContext) return
+
+  const traceIdUpper = spanContext._trace?.tags?.[TRACE_ID_UPPER_TAG]
+  const trace = traceIdUpper
+    ? { started: [], finished: [], tags: { [TRACE_ID_UPPER_TAG]: traceIdUpper } }
+    : undefined
+
+  return new DatadogSpanContext({
+    traceId: spanContext._traceId,
+    spanId: spanContext._spanId,
+    parentId: spanContext._parentId,
+    sampling: spanContext._sampling,
+    traceparent: spanContext._traceparent,
+    tracestate: spanContext._tracestate,
+    isRemote: spanContext._isRemote,
+    trace,
+  })
+}
+
+/**
+ * Returns whether distributed trace headers are present.
+ * @param {Record<string, string | string[] | undefined>} headers
+ * @returns {boolean}
+ */
+function hasTraceHeaders (headers) {
+  return !!(headers && (headers['x-datadog-trace-id'] || headers.traceparent))
+}
+
+/**
+ * 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 {DatadogSpanContext} spanContext - The handshake span context
+ * @param {{ hasTraceHeaders?: boolean } | undefined} socket - The WebSocket socket object
+ * @returns {boolean} True if the span has distributed tracing context
+ */
+function hasDistributedTracingContext (spanContext, socket) {
+  if (!spanContext) 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 (spanContext._parentId !== null) {
+    return true
+  }
+
+  return !!socket?.hasTraceHeaders
+}
+
+module.exports = {
+  createWebSocketSpanContext,
+  hasTraceHeaders,
+  initWebSocketMessageCounters,
+  incrementWebSocketCounter,
+  buildWebSocketSpanPointerHash,
+  hasDistributedTracingContext,
+}

package/packages/datadog-shimmer/index.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./src/shimmer')