dd-trace 6.16.0 → 6.18.0

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,14 @@ 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 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 +90,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 +103,7 @@ class PlaywrightPlugin extends CiPlugin {
   #isFinalizingAfterError = false
   #finishPendingTestFinishes
   #pendingTestFinishCallbacks = new Map()
+  #pendingRetryTestFinishes = new Map()
 
   constructor (...args) {
     super(...args)
@@ -182,9 +184,13 @@ class PlaywrightPlugin extends CiPlugin {
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
+      testSessionEmptyReason,
       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 +210,14 @@ class PlaywrightPlugin extends CiPlugin {
         this.testModuleSpan.setTag(TEST_STATUS, status)
         this.testSessionSpan.setTag(TEST_STATUS, status)
 
+        if (testSessionEmptyReason) {
+          setExpectedEmptyTestSessionTags(
+            this.testSessionSpan,
+            this.testModuleSpan,
+            testSessionEmptyReason
+          )
+        }
+
         if (isEarlyFlakeDetectionEnabled) {
           this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
         }
@@ -372,12 +386,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
@@ -484,6 +523,8 @@ class PlaywrightPlugin extends CiPlugin {
     this.addSub('ci:playwright:test:finish', ({
       span,
       testStatus,
+      isExpectedFailure,
+      hasNonRetriableError,
       steps,
       error,
       extraTags,
@@ -501,6 +542,8 @@ class PlaywrightPlugin extends CiPlugin {
       isAtrRetry,
       isModified,
       finalStatus,
+      retryTestId,
+      deferFinalStatus,
       earlyFlakeAbortReason,
       onDone,
     }) => {
@@ -510,6 +553,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)
 
@@ -519,6 +564,12 @@ class PlaywrightPlugin extends CiPlugin {
       if (extraTags) {
         span.addTags(extraTags)
       }
+      if (isExpectedFailure) {
+        span.setTag('test.result', 'xfail')
+      }
+      if (hasNonRetriableError === true) {
+        span.setTag('test.playwright.has_non_retriable_error', 'true')
+      }
       if (isNew) {
         span.setTag(TEST_IS_NEW, 'true')
         if (isEfdRetry) {
@@ -565,9 +616,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 +647,6 @@ class PlaywrightPlugin extends CiPlugin {
         }
         stepSpan.finish(stepStartTime + stepDuration)
       }
-      if (finalStatus === 'fail') {
-        this.numFailedTests++
-      }
-
       this.telemetry.ciVisEvent(
         TELEMETRY_EVENT_FINISHED,
         'test',
@@ -608,6 +660,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 +756,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 +808,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

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