dd-trace 6.15.0 → 6.17.0

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

@@ -0,0 +1,144 @@
+'use strict'
+
+const { MEASURED } = require('../../../ext/tags')
+const { ERROR_MESSAGE, ERROR_TYPE } = require('../../dd-trace/src/constants')
+const { storage } = require('../../datadog-core')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+/**
+ * APM spans for the phases of one OpenAI Realtime turn.
+ *
+ * The turn is replayed as a back-dated tree once it is complete, so every span here is created with
+ * an explicit `startTime` and finished with an explicit `finishTime` rather than measuring wall
+ * clock. Nesting falls out of the synchronous scoping of the instrumentation's `traceSync` calls:
+ * the phase spans are created inside the turn root's callback, so `startSpan` picks the root up as
+ * their parent from the active store.
+ */
+class RealtimeTracingPlugin extends TracingPlugin {
+  // `component` defaults to the plugin id, which differs per phase here, so pin both explicitly to
+  // keep `component:openai` consistent with every other span the integration emits.
+  static component = 'openai'
+  static system = 'openai'
+
+  /**
+   * Whether a failed response marks this span errored. True for the model's own work and for the
+   * turn as a whole; false for the speaking windows, which describe when audio moved rather than
+   * whether the model succeeded.
+   */
+  static flagsFailure = true
+
+  /**
+   * The APM resource name for this phase. Implemented by every subclass.
+   *
+   * @param {object} ctx
+   * @throws {Error} When a subclass has not implemented it.
+   */
+  resource (ctx) {
+    throw new Error(`resource must be implemented by ${this.constructor.name}`)
+  }
+
+  /**
+   * @param {object} ctx
+   * @returns {object}
+   */
+  bindStart (ctx) {
+    this.startSpan('openai.request', {
+      service: this.config.service,
+      resource: this.resource(ctx),
+      type: 'openai',
+      kind: 'client',
+      meta: {
+        [MEASURED]: 1,
+        'openai.request.model': ctx.turn.model,
+      },
+      startTime: ctx.startTime,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  /**
+   * @param {object} ctx
+   */
+  end (ctx) {
+    const span = ctx.currentStore?.span
+    if (span === undefined) return
+
+    if (ctx.turn.failed && this.constructor.flagsFailure) {
+      span.setTag('error', 1)
+
+      // The provider's own account of the failure, when `response.done` carried one. Without it the
+      // span says only that a realtime call broke. The LLM Observability error event reads these
+      // same tags, so setting them here serves both.
+      const { error } = ctx.turn
+      if (error !== undefined) {
+        if (error.type !== undefined) span.setTag(ERROR_TYPE, error.type)
+        const message = error.message ?? error.code
+        if (message !== undefined) span.setTag(ERROR_MESSAGE, message)
+      }
+    }
+    span.finish(ctx.finishTime)
+  }
+}
+
+/** The whole perceived turn, and the root of this turn's trace. */
+class RealtimeTurnTracingPlugin extends RealtimeTracingPlugin {
+  static id = 'openai_realtime_turn'
+  static operation = 'turn'
+  static prefix = 'tracing:apm:openai:realtime:turn'
+
+  constructor (...args) {
+    super(...args)
+
+    // Captured at `response.created`, replayed at finalize: by then the active context belongs to
+    // the WebSocket message handler, not to the caller who opened the connection. The LLM
+    // Observability plugin composes its own store on top of whatever this sets.
+    this.addSub('dd-trace:openai:realtime:capture-context', turn => {
+      const store = storage('legacy').getStore()
+      const previous = turn.runInContext
+      turn.runInContext = previous === undefined
+        ? fn => storage('legacy').run(store, fn)
+        : fn => previous(() => storage('legacy').run(store, fn))
+    })
+  }
+
+  resource () {
+    return 'createRealtimeTurn'
+  }
+}
+
+/** The model's generation work: opens at the end of user speech, closes at `response.done`. */
+class RealtimeResponseTracingPlugin extends RealtimeTracingPlugin {
+  static id = 'openai_realtime_response'
+  static operation = 'response'
+  static prefix = 'tracing:apm:openai:realtime:response'
+
+  resource () {
+    return 'createRealtimeResponse'
+  }
+}
+
+/**
+ * A speaking window — the human's or the agent's. One plugin covers both: they differ only by
+ * resource and name, which is data, not a type.
+ */
+class RealtimeSpeechTracingPlugin extends RealtimeTracingPlugin {
+  static id = 'openai_realtime_speech'
+  static operation = 'speech'
+  static prefix = 'tracing:apm:openai:realtime:speech'
+  // A speaking window happened regardless of whether the model's response failed.
+  static flagsFailure = false
+
+  /**
+   * @param {{ phase: { operation: string } }} ctx
+   */
+  resource (ctx) {
+    return ctx.phase.operation
+  }
+}
+
+module.exports = [
+  RealtimeTurnTracingPlugin,
+  RealtimeResponseTracingPlugin,
+  RealtimeSpeechTracingPlugin,
+]

package/packages/datadog-plugin-openai-agents/src/integration.js

@@ -578,7 +578,6 @@ class OpenAIAgentsIntegration {
    *
    * @param {string | undefined | null} spanId agents-core spanId to start from
    * @param {string} ancestorId agents-core ancestor spanId
-   * @returns {boolean}
    */
   #hasUntracedPathToAncestor (spanId, ancestorId) {
     let currentId = spanId
@@ -596,7 +595,6 @@ class OpenAIAgentsIntegration {
    * mistaken for top-level, or an error would finalize the workflow span early.
    *
    * @param {object} oaiSpan
-   * @returns {boolean}
    */
   #isTopLevelSpan (oaiSpan) {
     let currentId = oaiSpan.parentId
@@ -681,7 +679,6 @@ class OpenAIAgentsIntegration {
    * Read the mutable tracer configuration so remote/runtime enablement is
    * reflected without reconstructing the plugin.
    *
-   * @returns {boolean}
    */
   #isLLMObsEnabled () {
     return this.#llmobsEnabled && !!this.#config.llmobs?.DD_LLMOBS_ENABLED
@@ -690,7 +687,6 @@ class OpenAIAgentsIntegration {
   /**
    * Resolve model provider from the model invocation's async-local context.
    *
-   * @returns {string}
    */
   #getCurrentModelProvider () {
     const baseURL = legacyStorage.getStore()?.[MODEL_BASE_URL_STORE_KEY]

package/packages/datadog-plugin-openai-agents/src/util.js

@@ -14,7 +14,6 @@ const AGENTS_ERROR_TYPE = 'AgentsCoreError'
  * missing).
  *
  * @param {object} oaiSpan
- * @returns {string}
  */
 function deriveSpanName (oaiSpan) {
   const spanData = oaiSpan.spanData

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

@@ -56,6 +56,7 @@ const {
   TEST_HAS_DYNAMIC_NAME,
   DYNAMIC_NAME_RE,
   TEST_FINAL_STATUS,
+  setExpectedEmptyTestSessionTags,
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT } = require('../../dd-trace/src/constants')
@@ -69,13 +70,16 @@ const log = require('../../dd-trace/src/log')
 
 const PLAYWRIGHT_FAILURE_SCREENSHOT_RE = /^test-failed-\d+\.png$/
 const PLAYWRIGHT_VIDEO_CONTENT_TYPES = new Set(['video/mp4', 'video/webm'])
+const EMPTY_SHARD_SKIP_REASON = 'No tests were assigned to this shard'
+const EMPTY_SHARD_REASON = 'zero_test_shard'
+const RETRY_TEST_ID = '_dd.playwright.retry_test_id'
+const DEFER_FINAL_STATUS = '_dd.playwright.defer_final_status'
 const noop = () => {}
 
 /**
  * Returns whether an attachment is an automatic Playwright failure screenshot.
  *
  * @param {object} attachment - Playwright test attachment
- * @returns {boolean}
  */
 function isPlaywrightFailureScreenshot (attachment) {
   return attachment?.name === 'screenshot' &&
@@ -88,7 +92,6 @@ function isPlaywrightFailureScreenshot (attachment) {
  * Returns whether an attachment is a Playwright test video.
  *
  * @param {object} attachment - Playwright test attachment
- * @returns {boolean}
  */
 function isPlaywrightFailureVideo (attachment) {
   return attachment?.name === 'video' &&
@@ -102,6 +105,7 @@ class PlaywrightPlugin extends CiPlugin {
   #isFinalizingAfterError = false
   #finishPendingTestFinishes
   #pendingTestFinishCallbacks = new Map()
+  #pendingRetryTestFinishes = new Map()
 
   constructor (...args) {
     super(...args)
@@ -182,9 +186,13 @@ class PlaywrightPlugin extends CiPlugin {
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
+      isExpectedEmptyShard,
       error,
       onDone,
     }) => {
+      for (const finish of this.#pendingRetryTestFinishes.values()) finish(true)
+      this.#pendingRetryTestFinishes.clear()
+
       if (error) {
         this.#isFinalizingAfterError = true
         for (const testSuiteSpan of this._testSuiteSpansByTestSuiteAbsolutePath.values()) {
@@ -204,6 +212,15 @@ class PlaywrightPlugin extends CiPlugin {
         this.testModuleSpan.setTag(TEST_STATUS, status)
         this.testSessionSpan.setTag(TEST_STATUS, status)
 
+        if (isExpectedEmptyShard) {
+          setExpectedEmptyTestSessionTags(
+            this.testSessionSpan,
+            this.testModuleSpan,
+            EMPTY_SHARD_SKIP_REASON,
+            EMPTY_SHARD_REASON
+          )
+        }
+
         if (isEarlyFlakeDetectionEnabled) {
           this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
         }
@@ -372,12 +389,37 @@ class PlaywrightPlugin extends CiPlugin {
         formattedTraces.push(formattedTrace)
       }
 
+      const retryTestId = formattedTestSpan?.meta[RETRY_TEST_ID]
+      const deferFinalStatus = formattedTestSpan?.meta[DEFER_FINAL_STATUS] === 'true'
+      if (retryTestId !== undefined) {
+        delete formattedTestSpan.meta[RETRY_TEST_ID]
+        delete formattedTestSpan.meta[DEFER_FINAL_STATUS]
+      }
+      let readyToExport = false
+      let isFinalExecution
       const exportTraces = () => {
+        readyToExport = true
+        if (deferFinalStatus && isFinalExecution === undefined) return
         for (const trace of formattedTraces) {
           this.tracer._exporter.export(trace)
         }
       }
 
+      if (retryTestId !== undefined) {
+        // Keep at most one execution while another attempt is possible. Media uploads
+        // can finish before or after finality is known, so track readiness separately.
+        const finishPrevious = this.#pendingRetryTestFinishes.get(retryTestId)
+        finishPrevious?.(false)
+        this.#pendingRetryTestFinishes.delete(retryTestId)
+        if (deferFinalStatus) {
+          this.#pendingRetryTestFinishes.set(retryTestId, (isFinal) => {
+            isFinalExecution = isFinal
+            if (!isFinal) delete formattedTestSpan.meta[TEST_FINAL_STATUS]
+            if (readyToExport) exportTraces()
+          })
+        }
+      }
+
       if (!formattedTestSpan || (!screenshots && !videos) || this.#isFinalizingAfterError) {
         exportTraces()
         return
@@ -501,6 +543,8 @@ class PlaywrightPlugin extends CiPlugin {
       isAtrRetry,
       isModified,
       finalStatus,
+      retryTestId,
+      deferFinalStatus,
       earlyFlakeAbortReason,
       onDone,
     }) => {
@@ -510,6 +554,8 @@ class PlaywrightPlugin extends CiPlugin {
       }
 
       const isRUMActive = span.context().getTag(TEST_IS_RUM_ACTIVE)
+      const isDeferredMainTest = !this._tracerConfig.DD_PLAYWRIGHT_WORKER &&
+        retryTestId !== undefined && deferFinalStatus
 
       span.setTag(TEST_STATUS, testStatus)
 
@@ -565,9 +611,14 @@ class PlaywrightPlugin extends CiPlugin {
           span.setTag(TEST_RETRY_REASON, TEST_RETRY_REASON_TYPES.efd)
         }
       }
-      if (finalStatus) {
+      if (finalStatus && !isDeferredMainTest) {
         span.setTag(TEST_FINAL_STATUS, finalStatus)
       }
+      if (retryTestId !== undefined && this._tracerConfig.DD_PLAYWRIGHT_WORKER) {
+        // This identifier is removed by the main process before exporting the trace.
+        span.setTag(RETRY_TEST_ID, retryTestId)
+        if (deferFinalStatus) span.setTag(DEFER_FINAL_STATUS, 'true')
+      }
       if (earlyFlakeAbortReason) {
         span.setTag(TEST_EARLY_FLAKE_ABORT_REASON, earlyFlakeAbortReason)
       }
@@ -591,10 +642,6 @@ class PlaywrightPlugin extends CiPlugin {
         }
         stepSpan.finish(stepStartTime + stepDuration)
       }
-      if (finalStatus === 'fail') {
-        this.numFailedTests++
-      }
-
       this.telemetry.ciVisEvent(
         TELEMETRY_EVENT_FINISHED,
         'test',
@@ -608,6 +655,28 @@ class PlaywrightPlugin extends CiPlugin {
           isModified,
         }
       )
+      if (retryTestId !== undefined && !this._tracerConfig.DD_PLAYWRIGHT_WORKER) {
+        const finishPrevious = this.#pendingRetryTestFinishes.get(retryTestId)
+        finishPrevious?.(false)
+        this.#pendingRetryTestFinishes.delete(retryTestId)
+        if (isDeferredMainTest) {
+          // Legacy spans have no worker report. Retain the last execution until a
+          // successor arrives or session end confirms that its retry was canceled.
+          const finishTime = span._getTime()
+          finishAllTraceSpans(span)
+          this.#pendingRetryTestFinishes.set(retryTestId, (isFinal) => {
+            if (isFinal) {
+              span.setTag(TEST_FINAL_STATUS, finalStatus)
+              if (finalStatus === 'fail') this.numFailedTests++
+            }
+            span.finish(finishTime)
+          })
+          return
+        }
+      }
+      if (finalStatus === 'fail') {
+        this.numFailedTests++
+      }
       span.finish()
 
       finishAllTraceSpans(span)
@@ -682,7 +751,6 @@ class PlaywrightPlugin extends CiPlugin {
    * @param {string} options.traceId - Test trace id used as the screenshot key
    * @param {AbortSignal} options.signal - Signal used to cancel uploads during error finalization
    * @param {(result: string|undefined) => void} onDone - Completion callback
-   * @returns {boolean} Whether at least one upload was started
    */
   uploadTestScreenshots ({ screenshots, traceId, signal }, onDone) {
     const exporter = this.tracer?._exporter
@@ -735,7 +803,6 @@ class PlaywrightPlugin extends CiPlugin {
    * @param {string} options.traceId - Test trace id used as the video key
    * @param {AbortSignal} options.signal - Signal used to cancel uploads during error finalization
    * @param {(result: string|undefined) => void} onDone - Completion callback
-   * @returns {boolean} Whether at least one upload was started
    */
   uploadTestVideos ({ videos, traceId, signal }, onDone) {
     const exporter = this.tracer?._exporter

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

@@ -0,0 +1,167 @@
+'use strict'
+
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const DatabasePlugin = require('../../dd-trace/src/plugins/database')
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+
+const PREPARE_START_CHANNEL = 'tracing:orchestrion:postgres:query:prepare:start'
+
+/**
+ * @typedef {object} PostgresContext
+ * @property {{ span: import('../../..').Span }} currentStore
+ * @property {string} database
+ * @property {unknown} [error]
+ * @property {string} [host]
+ * @property {number} [pid]
+ * @property {number} [port]
+ * @property {PostgresQuery} query
+ * @property {string} [statement]
+ * @property {string} user
+ *
+ * @typedef {object} PostgresDbmState
+ * @property {string} service
+ * @property {string} [statement]
+ *
+ * @typedef {object} PostgresPreparationContext
+ * @property {boolean} prepared
+ * @property {PostgresQuery} query
+ * @property {string} statement
+ *
+ * @typedef {object} PostgresQuery
+ */
+
+class PostgresPreparationPlugin extends Plugin {
+  static id = 'postgres'
+
+  /**
+   * @param {(ctx: PostgresPreparationContext) => void} prepare
+   * @param {object} tracer
+   * @param {import('../../dd-trace/src/config/config-base')} tracerConfig
+   */
+  constructor (prepare, tracer, tracerConfig) {
+    super(tracer, tracerConfig)
+    this.addSub(PREPARE_START_CHANNEL, prepare)
+  }
+}
+
+class PostgresPlugin extends DatabasePlugin {
+  static id = 'postgres'
+  static prefix = 'tracing:orchestrion:postgres:query'
+
+  /** @type {boolean} */
+  #dbmEnabled = false
+
+  /** @type {WeakMap<PostgresQuery, PostgresDbmState>} */
+  #dbmQueries = new WeakMap()
+
+  /** @type {PostgresPreparationPlugin} */
+  #preparation
+
+  /** @type {{ name: string, source: string | undefined }} */
+  #service
+
+  /** @type {WeakMap<PostgresQuery, import('../../..').Span>} */
+  #spans = new WeakMap()
+
+  /**
+   * @param {object} tracer
+   * @param {import('../../dd-trace/src/config/config-base')} tracerConfig
+   */
+  constructor (tracer, tracerConfig) {
+    super(tracer, tracerConfig)
+    this.#preparation = new PostgresPreparationPlugin(this.#prepare.bind(this), tracer, tracerConfig)
+  }
+
+  /**
+   * @override
+   * @param {boolean | import('../../dd-trace/src/config/config-base') & {enabled: boolean}} config
+   */
+  configure (config) {
+    super.configure(config)
+
+    this.#service = this.serviceName({ pluginConfig: this.config })
+    const mode = this.config.dbmPropagationMode
+    this.#dbmEnabled = mode === 'service' || mode === 'full' || mode === 'dynamic_service'
+    this.#preparation.configure(this.config.enabled === true && this.#dbmEnabled)
+  }
+
+  /**
+   * @param {PostgresContext} ctx
+   * @returns {object}
+   */
+  bindStart (ctx) {
+    const { database, host, port, query, user } = ctx
+    const service = this.#service
+
+    const span = this.startSpan(this.operationName(), {
+      service,
+      type: 'sql',
+      kind: 'client',
+      meta: {
+        'db.type': this.system,
+        'db.name': database,
+        'db.user': user,
+      },
+    }, ctx)
+
+    if (host !== undefined) {
+      span.addTags({
+        'out.host': host,
+        [CLIENT_PORT_KEY]: port,
+      })
+    }
+
+    this.#spans.set(query, span)
+    if (this.#dbmEnabled) {
+      this.#dbmQueries.set(query, { service: service.name })
+    }
+    return ctx.currentStore
+  }
+
+  /**
+   * @param {PostgresPreparationContext} ctx
+   */
+  #prepare (ctx) {
+    const state = this.#dbmQueries.get(ctx.query)
+    const span = this.#spans.get(ctx.query)
+    if (state === undefined || span === undefined) return
+
+    state.statement = ctx.statement
+    span.setTag('resource.name', this.maybeTruncate(ctx.statement))
+    ctx.statement = this.injectDbmQuery(span, ctx.statement, state.service, ctx.prepared)
+  }
+
+  /**
+   * @param {PostgresContext} ctx
+   */
+  error (ctx) {
+    const span = this.#spans.get(ctx.query)
+    if (span !== undefined) {
+      this.addError(ctx.error, span)
+    }
+  }
+
+  /**
+   * @param {PostgresContext} result
+   */
+  asyncEnd (result) {
+    const { query } = result
+    const dbmState = this.#dbmQueries.get(query)
+    const span = this.#spans.get(query)
+
+    this.#dbmQueries.delete(query)
+    if (span === undefined) return
+
+    this.#spans.delete(query)
+
+    const statement = dbmState?.statement ?? result.statement
+    if (dbmState?.statement === undefined && typeof statement === 'string') {
+      span.setTag('resource.name', this.maybeTruncate(statement))
+    }
+
+    span.setTag('db.pid', result.pid)
+    this.finish({ currentStore: { span } })
+  }
+}
+
+module.exports = PostgresPlugin

package/packages/datadog-plugin-prisma/src/datadog-tracing-helper.js

@@ -31,7 +31,6 @@ class DatadogTracingHelper {
    * Needs a sampled tracecontext to generate engine spans
    *
    * @param {object} [context]
-   * @returns {string}
    */
   getTraceParent (context) {
     const store = storage('legacy').getStore()

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

@@ -3,8 +3,10 @@
 const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const CachePlugin = require('../../dd-trace/src/plugins/cache')
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
+const { truncateString } = require('../../dd-trace/src/util')
 
 const MAX_ARG_LENGTH = 100
+const MAX_ARG_LENGTH_WITHOUT_COPY = 256
 const MAX_COMMAND_LENGTH = 1000
 
 class RedisPlugin extends CachePlugin {
@@ -95,15 +97,27 @@ function formatCommand (command, args, argsStartIndex = 0) {
   return result
 }
 
+/**
+ * @param {unknown} arg
+ */
 function formatArg (arg) {
   if (typeof arg === 'string') {
-    return arg.length > MAX_ARG_LENGTH ? arg.slice(0, MAX_ARG_LENGTH - 3) + '...' : arg
+    return arg.length > MAX_ARG_LENGTH ? truncateArg(arg) : arg
   }
   // Number stringification is bounded (~23 chars max), so it never hits MAX_ARG_LENGTH.
   if (typeof arg === 'number') return String(arg)
   return '?'
 }
 
+/**
+ * @param {string} arg
+ */
+function truncateArg (arg) {
+  return arg.length > MAX_ARG_LENGTH_WITHOUT_COPY
+    ? truncateString(arg, MAX_ARG_LENGTH, '...')
+    : arg.slice(0, MAX_ARG_LENGTH - 3) + '...'
+}
+
 function normalizeConfig (config) {
   if (config.allowlist) uppercaseAllEntries(config.allowlist)
   if (config.whitelist) uppercaseAllEntries(config.whitelist)

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

@@ -0,0 +1,18 @@
+'use strict'
+
+/**
+ * @param {Error | { message?: string } | string | null | undefined} error Supabase operation error.
+ * @param {string} type Error type used for non-Error SDK results.
+ * @param {string} [message] Error message used for non-Error SDK results.
+ * @returns {Error | undefined}
+ */
+function normalizeError (error, type, message) {
+  if (!error) return
+  if (error instanceof Error) return error
+
+  const normalizedError = new Error(message || error?.message || String(error))
+  normalizedError.name = type
+  return normalizedError
+}
+
+module.exports = normalizeError

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

@@ -0,0 +1,21 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const SupabaseGoTrueClientGetUserPlugin = require('./supabase-auth-js-gotrueclient-getuser')
+const SupabaseStorageHandleRequestPlugin = require('./supabase-storage-js-handle-request')
+const SupabaseRealtimeChannelSendPlugin = require('./supabase-realtime-js-realtimechannel-send')
+const SupabaseFunctionsClientInvokePlugin = require('./supabase-functions-js-functionsclient-invoke')
+const SupabasePostgrestBuilderThenPlugin = require('./supabase-postgrest-js-postgrestbuilder-then')
+
+class SupabasePlugin extends CompositePlugin {
+  static id = 'supabase'
+  static plugins = {
+    SupabaseGoTrueClientGetUserPlugin,
+    SupabaseStorageHandleRequestPlugin,
+    SupabaseRealtimeChannelSendPlugin,
+    SupabaseFunctionsClientInvokePlugin,
+    SupabasePostgrestBuilderThenPlugin,
+  }
+}
+
+module.exports = SupabasePlugin