dd-trace 6.15.0 → 6.17.0

package/packages/datadog-plugin-supabase/src/supabase-auth-js-gotrueclient-getuser.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+const { extractPathFromUrl } = require('../../dd-trace/src/plugins/util/url')
+const { stripQueryAndFragment } = require('../../dd-trace/src/util')
+const normalizeError = require('./error')
+const getHostname = require('./url')
+
+/**
+ * @typedef {{
+ *   self: { url: string },
+ *   currentStore?: { span: import('../../..').Span },
+ *   result?: { error?: (Error & { status?: number }) | null },
+ *   error?: Error & { status?: number }
+ * }} AuthContext
+ */
+
+class SupabaseGoTrueClientGetUserPlugin extends ClientPlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/auth-js:GoTrueClient_getUser'
+
+  /** @param {AuthContext} ctx */
+  bindStart (ctx) {
+    const method = 'GET'
+    const url = stripQueryAndFragment(`${ctx.self?.url}/user`)
+
+    this.startSpan('supabase.http.getuser', {
+      service: { name: this.tracer._service },
+      type: 'http',
+      resource: `${method} ${extractPathFromUrl(url)}`,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'client',
+        'http.method': method,
+        'http.url': url,
+        'out.host': getHostname(url),
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  /** @param {AuthContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  // You may modify this method, but the guard below is REQUIRED and MUST NOT be removed!
+  /** @param {AuthContext} ctx */
+  finish (ctx) {
+    // CRITICAL GUARD - DO NOT REMOVE: Ensures span only finishes when operation completes
+    if (!ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+
+    const error = normalizeError(ctx.result?.error, 'AuthError')
+    if (error) {
+      ctx.error = error
+      super.error(ctx)
+    }
+
+    const status = ctx.result?.error?.status ??
+      ctx.error?.status ??
+      (ctx.result && !ctx.result.error ? 200 : undefined)
+    if (status) ctx.currentStore?.span.setTag('http.status_code', status)
+
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabaseGoTrueClientGetUserPlugin

package/packages/datadog-plugin-supabase/src/supabase-functions-js-functionsclient-invoke.js

@@ -0,0 +1,70 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+const { extractPathFromUrl } = require('../../dd-trace/src/plugins/util/url')
+const { stripQueryAndFragment } = require('../../dd-trace/src/util')
+const normalizeError = require('./error')
+const getHostname = require('./url')
+
+/**
+ * @typedef {{
+ *   arguments: { [index: number]: unknown, length: number, 0?: string, 1?: { method?: string } },
+ *   self: { url: string },
+ *   currentStore?: { span: import('../../..').Span },
+ *   result?: { error?: Error | { message?: string } | null, response?: { status?: number } },
+ *   error?: unknown
+ * }} FunctionsContext
+ */
+
+class SupabaseFunctionsClientInvokePlugin extends ClientPlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/functions-js:FunctionsClient_invoke'
+
+  /** @param {FunctionsContext} ctx */
+  bindStart (ctx) {
+    const functionName = ctx.arguments?.[0]
+    const method = String(ctx.arguments?.[1]?.method || 'POST').toUpperCase()
+    const url = stripQueryAndFragment(`${ctx.self?.url}/${functionName}`)
+
+    this.startSpan('supabase.http.invoke', {
+      service: { name: this.tracer._service },
+      type: 'http',
+      resource: `${method} ${extractPathFromUrl(url)}`,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'client',
+        'http.method': method,
+        'http.url': url,
+        'out.host': getHostname(url),
+        'faas.invoked_name': functionName,
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  /** @param {FunctionsContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  // You may modify this method, but the guard below is REQUIRED and MUST NOT be removed!
+  /** @param {FunctionsContext} ctx */
+  finish (ctx) {
+    // CRITICAL GUARD - DO NOT REMOVE: Ensures span only finishes when operation completes
+    if (!ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+
+    const error = normalizeError(ctx.result?.error, 'FunctionsError')
+    if (error) {
+      ctx.error = error
+      super.error(ctx)
+    }
+
+    const status = ctx.result?.response?.status
+    if (status) ctx.currentStore?.span.setTag('http.status_code', status)
+
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabaseFunctionsClientInvokePlugin

package/packages/datadog-plugin-supabase/src/supabase-postgrest-js-postgrestbuilder-then.js

@@ -0,0 +1,122 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const log = require('../../dd-trace/src/log')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+const { extractPathFromUrl } = require('../../dd-trace/src/plugins/util/url')
+const { stripQueryAndFragment } = require('../../dd-trace/src/util')
+const normalizeError = require('./error')
+
+const spanFinished = Symbol('spanFinished')
+
+const operationByMethod = {
+  DELETE: 'DELETE',
+  GET: 'SELECT',
+  HEAD: 'SELECT',
+  PATCH: 'UPDATE',
+  POST: 'INSERT',
+}
+
+/**
+ * @typedef {{
+ *   arguments: { [index: number]: unknown, length: number, 0?: Function, 1?: Function },
+ *   self: { method: string, url: URL, schema?: string },
+ *   currentStore?: { span: import('../../..').Span },
+ *   parentStore: import('../../datadog-core/src/storage').Store<unknown>,
+ *   result?: { error?: Error | { message?: string } | null },
+ *   error?: unknown
+ * } & Record<symbol, boolean | undefined>} PostgrestContext
+ */
+
+function finishSafely (plugin, ctx, hasError = false) {
+  try {
+    if (hasError) plugin.error(ctx)
+    plugin.finish(ctx)
+  } catch (error) {
+    log.error('Error in plugin handler:', error)
+    log.info('Disabling plugin: %s', plugin.constructor.name)
+    plugin.configure(false)
+  }
+}
+
+class SupabasePostgrestBuilderThenPlugin extends DatabasePlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/postgrest-js:PostgrestBuilder_then'
+
+  /** @param {PostgrestContext} ctx */
+  bindStart (ctx) {
+    const method = ctx.self?.method
+    const requestUrl = ctx.self?.url
+    const url = stripQueryAndFragment(String(requestUrl))
+    const path = extractPathFromUrl(url)
+    const operation = path.includes('/rpc/') ? 'CALL' : operationByMethod[method] || method
+    const resource = `${operation} ${path.slice(path.lastIndexOf('/') + 1)}`
+
+    this.startSpan('supabase.database.query', {
+      service: { name: this.tracer._service },
+      type: 'sql',
+      resource,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'client',
+        'db.type': 'postgres',
+        'db.name': ctx.self?.schema || 'public',
+        'db.operation': operation,
+        'out.host': requestUrl?.hostname,
+      },
+    }, ctx)
+
+    // PostgrestBuilder.then owns both the request and consumer callbacks. Finish the request span and
+    // restore its parent before invoking a callback so application failures and latency stay outside it.
+    const onFulfilled = ctx.arguments?.[0]
+    if (typeof onFulfilled === 'function') {
+      const plugin = this
+      ctx.arguments[0] = function (result) {
+        ctx.result = result
+        finishSafely(plugin, ctx)
+        return storage('legacy').run(ctx.parentStore, () => onFulfilled.apply(this, arguments))
+      }
+    }
+
+    const onRejected = ctx.arguments?.[1]
+    if (typeof onRejected === 'function') {
+      const plugin = this
+      ctx.arguments[1] = function (error) {
+        ctx.error = error
+        finishSafely(plugin, ctx, true)
+        return storage('legacy').run(ctx.parentStore, () => onRejected.apply(this, arguments))
+      }
+    }
+
+    return ctx.currentStore
+  }
+
+  /** @param {PostgrestContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  /** @param {PostgrestContext} ctx */
+  error (ctx) {
+    if (ctx[spanFinished]) return
+    super.error(ctx)
+  }
+
+  // You may modify this method, but the guard below is REQUIRED and MUST NOT be removed!
+  /** @param {PostgrestContext} ctx */
+  finish (ctx) {
+    // CRITICAL GUARD - DO NOT REMOVE: Ensures span only finishes when operation completes
+    if (ctx[spanFinished] || !ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+
+    const error = normalizeError(ctx.result?.error, 'PostgrestError')
+    if (error) {
+      ctx.error = error
+      super.error(ctx)
+    }
+
+    ctx[spanFinished] = true
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabasePostgrestBuilderThenPlugin

package/packages/datadog-plugin-supabase/src/supabase-realtime-js-realtimechannel-send.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const normalizeError = require('./error')
+
+/**
+ * @typedef {{
+ *   self: { subTopic: string },
+ *   currentStore?: { span: import('../../..').Span },
+ *   result?: 'ok' | 'error' | 'timed out',
+ *   error?: unknown
+ * }} RealtimeContext
+ */
+
+class SupabaseRealtimeChannelSendPlugin extends ProducerPlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/realtime-js:RealtimeChannel_send'
+  static peerServicePrecursors = ['messaging.destination.name']
+
+  /** @param {RealtimeContext} ctx */
+  bindStart (ctx) {
+    const destination = ctx.self?.subTopic
+
+    this.startSpan({
+      service: { name: this.tracer._service },
+      type: 'messaging',
+      resource: destination,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'producer',
+        'messaging.system': 'supabase',
+        'messaging.destination.name': destination,
+        'messaging.destination.kind': 'topic',
+        'messaging.operation': 'send',
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  operationName () {
+    return 'supabase.messaging.send'
+  }
+
+  /** @param {RealtimeContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  // You may modify this method, but the guard below is REQUIRED and MUST NOT be removed!
+  /** @param {RealtimeContext} ctx */
+  finish (ctx) {
+    // CRITICAL GUARD - DO NOT REMOVE: Ensures span only finishes when operation completes
+    if (!ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+
+    const result = ctx.result
+    if (result === 'error' || result === 'timed out') {
+      ctx.error = normalizeError(result, 'RealtimeSendError', `Realtime send returned ${result}`)
+      super.error(ctx)
+    }
+
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabaseRealtimeChannelSendPlugin

package/packages/datadog-plugin-supabase/src/supabase-storage-js-handle-request.js

@@ -0,0 +1,93 @@
+'use strict'
+
+const StoragePlugin = require('../../dd-trace/src/plugins/storage')
+const { extractPathFromUrl } = require('../../dd-trace/src/plugins/util/url')
+const { stripQueryAndFragment } = require('../../dd-trace/src/util')
+const getHostname = require('./url')
+
+/**
+ * @typedef {{
+ *   arguments: { [index: number]: unknown, length: number, 1: string, 2: string | URL },
+ *   currentStore?: { span: import('../../..').Span },
+ *   result?: unknown,
+ *   error?: Error & { status?: number }
+ * }} StorageContext
+ */
+
+const storageRoutes = [
+  'object/upload/sign',
+  'object/list-v2',
+  'object/list',
+  'object/sign',
+  'object/info',
+  'object/copy',
+  'object/move',
+  'render/image',
+  'bucket',
+  'object',
+  'cdn',
+]
+
+/**
+ * Returns a low-cardinality storage route for a request URL.
+ *
+ * @param {string|URL} url Request URL.
+ */
+function getStorageRoute (url) {
+  const path = extractPathFromUrl(stripQueryAndFragment(String(url)))
+  const marker = '/storage/v1/'
+  const markerIndex = path.indexOf(marker)
+  const storagePath = markerIndex === -1 ? path.replace(/^\/+/, '') : path.slice(markerIndex + marker.length)
+
+  for (const route of storageRoutes) {
+    if (storagePath === route || storagePath.startsWith(`${route}/`)) return route
+  }
+
+  return 'storage'
+}
+
+class SupabaseStorageHandleRequestPlugin extends StoragePlugin {
+  static id = 'supabase'
+  static prefix = 'tracing:orchestrion:@supabase/storage-js:handleRequest'
+
+  /** @param {StorageContext} ctx */
+  bindStart (ctx) {
+    const method = String(ctx.arguments?.[1] || 'GET').toUpperCase()
+    const url = ctx.arguments?.[2]
+
+    this.startSpan('supabase.storage.request', {
+      service: { name: this.tracer._service },
+      type: 'storage',
+      resource: `${method} ${getStorageRoute(url)}`,
+      meta: {
+        component: 'supabase',
+        'span.kind': 'client',
+        'http.method': method,
+        'http.url': stripQueryAndFragment(String(url)),
+        'out.host': getHostname(url),
+      },
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  /** @param {StorageContext} ctx */
+  error (ctx) {
+    const status = ctx.error?.status
+    if (status) ctx.currentStore?.span.setTag('http.status_code', status)
+    super.error(ctx)
+  }
+
+  /** @param {StorageContext} ctx */
+  asyncEnd (ctx) {
+    this.finish(ctx)
+  }
+
+  /** @param {StorageContext} ctx */
+  finish (ctx) {
+    if (!ctx.hasOwnProperty('result') && !ctx.hasOwnProperty('error')) return
+    super.finish(ctx)
+  }
+}
+
+module.exports = SupabaseStorageHandleRequestPlugin

package/packages/datadog-plugin-supabase/src/url.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { URL } = require('node:url')
+
+/**
+ * Extracts a hostname without allowing malformed SDK input to break instrumentation.
+ *
+ * @param {string|URL} url Request URL.
+ * @returns {string|undefined} Parsed hostname.
+ */
+function getHostname (url) {
+  try {
+    return new URL(url).hostname
+  } catch {}
+}
+
+module.exports = getHostname

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

@@ -44,6 +44,7 @@ const {
   TEST_ITR_UNSKIPPABLE,
   TEST_ITR_FORCED_RUN,
   ITR_CORRELATION_ID,
+  setExpectedEmptyTestSessionTags,
 } = require('../../dd-trace/src/plugins/util/test')
 const { COMPONENT } = require('../../dd-trace/src/constants')
 const id = require('../../dd-trace/src/id')
@@ -579,6 +580,7 @@ class VitestPlugin extends CiPlugin {
       requestErrorTags,
       vitestPool,
       isVitestNoWorkerInitActive,
+      isExpectedEmptySession,
       onDone,
     }) => {
       for (const [tag, value] of Object.entries(requestErrorTags)) {
@@ -587,6 +589,14 @@ class VitestPlugin extends CiPlugin {
       }
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
+      if (isExpectedEmptySession) {
+        setExpectedEmptyTestSessionTags(
+          this.testSessionSpan,
+          this.testModuleSpan,
+          'No tests were executed',
+          'zero_tests'
+        )
+      }
       if (error) {
         this.testModuleSpan.setTag('error', error)
         this.testSessionSpan.setTag('error', error)

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

@@ -36,7 +36,6 @@ function createWebSocketSpanContext (spanContext) {
 /**
  * Returns whether distributed trace headers are present.
  * @param {Record<string, string | string[] | undefined>} headers
- * @returns {boolean}
  */
 function hasTraceHeaders (headers) {
   return !!(headers && (readDatadogTraceId(headers) || readTraceparent(headers)))
@@ -59,7 +58,6 @@ function initWebSocketMessageCounters (socket) {
  * 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)) {
@@ -81,7 +79,6 @@ function incrementWebSocketCounter (socket, counterType) {
  * @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
@@ -110,7 +107,6 @@ function buildWebSocketSpanPointerHash (handshakeTraceId, handshakeSpanId, count
  *
  * @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