dd-trace 5.108.0 → 5.109.0

package/packages/dd-trace/src/exporters/agentless/writer.js

@@ -7,6 +7,7 @@ const tracerVersion = require('../../../../../package.json').version
 
 const BaseWriter = require('../common/writer')
 const { AgentlessJSONEncoder } = require('../../encode/agentless-json')
+const { computeIntakeUrl, INTAKE_PATH } = require('./intake')
 
 /**
  * Writer for agentless APM trace intake.
@@ -28,7 +29,7 @@ class AgentlessWriter extends BaseWriter {
 
     if (!url) {
       try {
-        this._url = new URL(`https://public-trace-http-intake.logs.${site}`)
+        this._url = new URL(computeIntakeUrl(site))
       } catch (err) {
         log.error(
           'Invalid site value for agentless intake: %s. Cannot construct URL. Error: %s',
@@ -121,7 +122,7 @@ class AgentlessWriter extends BaseWriter {
     this.#apiKeyMissing = false
 
     const options = {
-      path: '/v1/input',
+      path: INTAKE_PATH,
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -140,7 +141,7 @@ class AgentlessWriter extends BaseWriter {
 
     request(data, options, (err, res, statusCode) => {
       if (err) {
-        this._logRequestError(err, statusCode, count)
+        this.#logRequestError(err, statusCode, count)
         done()
         return
       }
@@ -156,7 +157,7 @@ class AgentlessWriter extends BaseWriter {
    * @param {number} statusCode - HTTP status code (if available)
    * @param {number} count - Number of traces that were being sent
    */
-  _logRequestError (err, statusCode, count) {
+  #logRequestError (err, statusCode, count) {
     if (statusCode === 401 || statusCode === 403) {
       log.error(
         'Authentication failed sending %d trace(s) (status %s). Verify DD_API_KEY is valid.',

package/packages/dd-trace/src/openfeature/flagging_provider.js

@@ -1,12 +1,19 @@
 'use strict'
 
-const { DatadogNodeServerProvider } = require('@datadog/openfeature-node-server')
 const { channel } = require('dc-polyfill')
 const log = require('../log')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
 const EvalMetricsHook = require('./eval-metrics-hook')
 const SpanEnrichmentHook = require('./span-enrichment-hook')
 
+// Bundler-opaque require for the optional peer chain
+// `@datadog/openfeature-node-server` -> `@openfeature/server-sdk` ->
+// `@openfeature/core`. Same shape as `helpers/rewriter/compiler.js`.
+// Refs: https://github.com/DataDog/dd-trace-js/issues/8635
+// eslint-disable-next-line camelcase, no-undef
+const runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require
+const { DatadogNodeServerProvider } = runtimeRequire(['@datadog/openfeature', 'node', 'server'].join('-'))
+
 /**
  * OpenFeature provider that integrates with Datadog's feature flagging system.
  * Extends DatadogNodeServerProvider to add tracer integration and configuration management.

package/packages/dd-trace/src/plugins/ci_plugin.js

@@ -442,6 +442,28 @@ module.exports = class CiPlugin extends Plugin {
     }
   }
 
+  /**
+   * Updates repository-root-dependent state when a worker receives the root from
+   * the coordinator process after plugin configuration.
+   *
+   * @param {string|undefined} repositoryRoot - Repository root discovered by the coordinator process.
+   * @param {Array<{ pattern: string, owners: string[] }>|null|undefined} codeOwnersEntries
+   * Parsed CODEOWNERS entries discovered by the coordinator process.
+   * @returns {void}
+   */
+  _setRepositoryRoot (repositoryRoot, codeOwnersEntries) {
+    if (codeOwnersEntries !== undefined) {
+      this.codeOwnersEntries = codeOwnersEntries
+    }
+
+    if (!repositoryRoot || repositoryRoot === this.repositoryRoot) return
+
+    this.repositoryRoot = repositoryRoot
+    if (codeOwnersEntries === undefined) {
+      this.codeOwnersEntries = getCodeOwnersFileEntries(this.repositoryRoot)
+    }
+  }
+
   /**
    * Returns request error tags from the test session span for propagation to module, suite and test spans.
    * @returns {Record<string, string>}
@@ -610,6 +632,8 @@ module.exports = class CiPlugin extends Plugin {
     const workerTestFramework = WORKER_EXPORTER_TO_TEST_FRAMEWORK[exporter]
     this.shouldSkipGitMetadataExtraction = workerTestFramework &&
       TEST_FRAMEWORKS_TO_SKIP_GIT_METADATA_EXTRACTION.has(workerTestFramework)
+    const shouldDeferCodeOwnersEntries = workerTestFramework === 'vitest'
+    const shouldDeferRepositoryRoot = workerTestFramework === 'vitest'
 
     this.testEnvironmentMetadata = getTestEnvironmentMetadata(
       this.constructor.id,
@@ -635,9 +659,10 @@ module.exports = class CiPlugin extends Plugin {
       [GIT_COMMIT_HEAD_MESSAGE]: commitHeadMessage,
     } = this.testEnvironmentMetadata
 
-    this.repositoryRoot = repositoryRoot || getRepositoryRoot() || process.cwd()
+    this.repositoryRoot = repositoryRoot ||
+      (shouldDeferRepositoryRoot ? process.cwd() : getRepositoryRoot() || process.cwd())
 
-    this.codeOwnersEntries = getCodeOwnersFileEntries(this.repositoryRoot)
+    this.codeOwnersEntries = shouldDeferCodeOwnersEntries ? null : getCodeOwnersFileEntries(this.repositoryRoot)
 
     this.ciProviderName = ciProviderName
 

package/packages/dd-trace/src/plugins/index.js

@@ -8,6 +8,7 @@ const plugins = {
   get '@azure/event-hubs' () { return require('../../../datadog-plugin-azure-event-hubs/src') },
   get '@azure/functions' () { return require('../../../datadog-plugin-azure-functions/src') },
   get '@modelcontextprotocol/sdk' () { return require('../../../datadog-plugin-modelcontextprotocol-sdk/src') },
+  get '@aws/durable-execution-sdk-js' () { return require('../../../datadog-plugin-aws-durable-execution-sdk-js/src') },
   get 'durable-functions' () { return require('../../../datadog-plugin-azure-durable-functions/src') },
   get '@azure/service-bus' () { return require('../../../datadog-plugin-azure-service-bus/src') },
   get '@cucumber/cucumber' () { return require('../../../datadog-plugin-cucumber/src') },
@@ -55,6 +56,7 @@ const plugins = {
   get express () { return require('../../../datadog-plugin-express/src') },
   get fastify () { return require('../../../datadog-plugin-fastify/src') },
   get 'find-my-way' () { return require('../../../datadog-plugin-find-my-way/src') },
+  get fs () { return require('../../../datadog-plugin-fs/src') },
   get 'global:fetch' () { return require('../../../datadog-plugin-fetch/src') },
   get graphql () { return require('../../../datadog-plugin-graphql/src') },
   get grpc () { return require('../../../datadog-plugin-grpc/src') },
@@ -97,6 +99,7 @@ const plugins = {
   get net () { return require('../../../datadog-plugin-net/src') },
   get next () { return require('../../../datadog-plugin-next/src') },
   get 'node:dns' () { return require('../../../datadog-plugin-dns/src') },
+  get 'node:fs' () { return require('../../../datadog-plugin-fs/src') },
   get 'node:http' () { return require('../../../datadog-plugin-http/src') },
   get 'node:http2' () { return require('../../../datadog-plugin-http2/src') },
   get 'node:https' () { return require('../../../datadog-plugin-http/src') },

package/packages/dd-trace/src/service-naming/schemas/v0/serverless.js

@@ -13,6 +13,18 @@ const serverless = {
       serviceName: identityService,
     },
   },
+  client: {
+    'aws-durable-execution-sdk-js': {
+      opName: () => 'aws.durable.invoke',
+      serviceName: identityService,
+    },
+  },
+  internal: {
+    'aws-durable-execution-sdk-js': {
+      opName: () => 'aws.durable.execute',
+      serviceName: identityService,
+    },
+  },
 }
 
 module.exports = serverless

package/packages/dd-trace/src/service-naming/schemas/v1/serverless.js

@@ -13,6 +13,18 @@ const serverless = {
       serviceName: identityService,
     },
   },
+  client: {
+    'aws-durable-execution-sdk-js': {
+      opName: () => 'aws.durable.invoke',
+      serviceName: identityService,
+    },
+  },
+  internal: {
+    'aws-durable-execution-sdk-js': {
+      opName: () => 'aws.durable.execute',
+      serviceName: identityService,
+    },
+  },
 }
 
 module.exports = serverless

package/packages/datadog-instrumentations/src/helpers/openai-ai-guard.js

@@ -1,284 +0,0 @@
-'use strict'
-
-const dc = require('dc-polyfill')
-const shimmer = require('../../../datadog-shimmer')
-const {
-  convertOpenAIResponseItemsToMessages,
-  convertOpenAIResponsePromptToMessages,
-  normalizeOpenAIChatMessages,
-} = require('./ai-messages')
-
-// TODO: this channel name is incorrect, instrumentations publish with THEIR name, not with their subscribers names.
-const aiguardChannel = dc.channel('dd-trace:ai:aiguard')
-
-/**
- * @typedef {object} ResourceHandler
- * @property {(callArgs: object) => (Array<object>|undefined)} getInputMessages
- * @property {(body: object) => Array<object>} getOutputMessages
- * @property {(inputMessages: Array<object>, outputMessages: Array<object>, parentSpan?: object)
- *   => Promise<unknown>} publishOutputEvaluation
- */
-
-/**
- * @typedef {object} Guard
- * @property {ResourceHandler} handler
- * @property {Array<object>} inputMessages
- * @property {() => Promise<void>} getInputEval
- * @property {object} [parentSpan] - LLM span (`openai.request`) to nest `ai_guard` spans under.
- *   Set by the instrumentation once the LLM span is active.
- */
-
-/**
- * Publishes already-converted AI-style messages to the AI Guard evaluation channel.
- *
- * Subscribers push async work into `pending` and abort `abortController` to block.
- *
- * @param {Array<object>} messages - AI-style messages to evaluate.
- * @param {object} [parentSpan] - LLM span to use as the `ai_guard` span's parent.
- * @returns {Promise<void>}
- */
-function publishEvaluation (messages, parentSpan) {
-  const abortController = new AbortController()
-  const ctx = { messages, integration: 'openai', parentSpan, abortController, pending: [] }
-
-  aiguardChannel.publish(ctx)
-
-  return Promise.all(ctx.pending).then(() => {
-    if (abortController.signal.aborted) {
-      throw abortController.signal.reason
-    }
-  })
-}
-
-/**
- * Extracts OpenAI input messages from a `chat.completions.create` call.
- *
- * @param {object} callArgs - First argument passed to the wrapped method
- * @returns {Array<object>|undefined}
- */
-function getChatCompletionsInputMessages (callArgs) {
-  return normalizeOpenAIChatMessages(callArgs?.messages)
-}
-
-/**
- * Extracts OpenAI output messages from a `chat.completions.create` parsed body.
- * Includes any choice whose message carries content (including empty string),
- * `tool_calls`, a `refusal` field, or the deprecated `function_call` field. GPT-4o
- * emits `{content: null, refusal: "..."}` on policy refusals, and pre-tool-call
- * SDK paths still produce `function_call`-only output — AI Guard must still see them.
- *
- * @param {object} body - Parsed response body
- * @returns {Array<object>}
- */
-function getChatCompletionsOutputMessages (body) {
-  const eligible = []
-  const choices = Array.isArray(body?.choices) ? body.choices : []
-  for (const choice of choices) {
-    const message = choice?.message
-    if (
-      message?.content != null ||
-      message?.tool_calls?.length ||
-      message?.refusal != null ||
-      message?.function_call != null
-    ) {
-      eligible.push(message)
-    }
-  }
-  return normalizeOpenAIChatMessages(eligible) ?? []
-}
-
-/**
- * Publishes AI Guard After Model evaluation for `chat.completions` output.
- *
- * Chat completions may return multiple choices when `n > 1`. Screen every choice
- * concurrently so any unsafe assistant output rejects `.parse()`, regardless of
- * which choice the caller ends up using.
- *
- * @param {Array<object>} inputMessages
- * @param {Array<object>} outputMessages - One entry per choice
- * @param {object} [parentSpan]
- * @returns {Promise<Array<void>>}
- */
-function publishChatCompletionsOutputEvaluation (inputMessages, outputMessages, parentSpan) {
-  const evals = []
-  for (const message of outputMessages) {
-    evals.push(publishEvaluation([...inputMessages, message], parentSpan))
-  }
-  return Promise.all(evals)
-}
-
-/**
- * Extracts OpenAI input messages from a `responses.create` call. The `instructions`
- * field is treated as a developer prompt — it directly steers model behavior and the
- * LLMObs OpenAI plugin already surfaces it as one — so AI Guard must screen it too.
- *
- * AI Guard `/evaluate` accepts a single leading system/developer message; if the
- * caller's `input` already begins with one, prepend the `instructions` text to its
- * content rather than emit a second developer turn.
- *
- * @param {object} callArgs - First argument passed to the wrapped method
- * @returns {Array<object>|undefined}
- */
-function getResponsesInputMessages (callArgs) {
-  const messages = [
-    ...convertOpenAIResponseItemsToMessages(callArgs?.input, 'user'),
-    ...convertOpenAIResponsePromptToMessages(callArgs?.prompt),
-  ]
-
-  const instructions = typeof callArgs?.instructions === 'string' && callArgs.instructions.length
-    ? callArgs.instructions
-    : null
-  if (!instructions) return messages.length ? messages : undefined
-
-  const first = messages[0]
-  if (first && (first.role === 'developer' || first.role === 'system')) {
-    const merged = { role: 'developer', content: mergeInstructionsWithContent(instructions, first.content) }
-    return [merged, ...messages.slice(1)]
-  }
-  return [{ role: 'developer', content: instructions }, ...messages]
-}
-
-/**
- * Merges Responses API instructions with an existing leading developer/system content value.
- *
- * @param {string} instructions
- * @param {string|Array<object>|undefined} content
- * @returns {string|Array<object>}
- */
-function mergeInstructionsWithContent (instructions, content) {
-  if (Array.isArray(content)) return [{ type: 'text', text: instructions }, ...content]
-  if (typeof content === 'string' && content.length) return `${instructions}\n\n${content}`
-  return instructions
-}
-
-/**
- * Extracts OpenAI output messages from a `responses.create` parsed body.
- *
- * @param {object} body - Parsed response body
- * @returns {Array<object>}
- */
-function getResponsesOutputMessages (body) {
-  return convertOpenAIResponseItemsToMessages(body?.output, 'assistant')
-}
-
-/**
- * Publishes AI Guard After Model evaluation for `responses` output.
- *
- * The Responses API returns a single conversation turn whose `output` items form one
- * coherent message (reasoning steps + final assistant message + tool calls + ...);
- * they are screened together as a single evaluation.
- *
- * @param {Array<object>} inputMessages
- * @param {Array<object>} outputMessages
- * @param {object} [parentSpan]
- * @returns {Promise<void>}
- */
-function publishResponsesOutputEvaluation (inputMessages, outputMessages, parentSpan) {
-  return publishEvaluation([...inputMessages, ...outputMessages], parentSpan)
-}
-
-/**
- * Per-resource handlers describing how AI Guard reads inputs and screens outputs for
- * each LLM-prompt-accepting OpenAI endpoint. The keys also serve as the set of
- * resources eligible for AI Guard evaluation.
- *
- * @type {Record<string, ResourceHandler>}
- */
-const RESOURCE_HANDLERS = {
-  'chat.completions': {
-    getInputMessages: getChatCompletionsInputMessages,
-    getOutputMessages: getChatCompletionsOutputMessages,
-    publishOutputEvaluation: publishChatCompletionsOutputEvaluation,
-  },
-  responses: {
-    getInputMessages: getResponsesInputMessages,
-    getOutputMessages: getResponsesOutputMessages,
-    publishOutputEvaluation: publishResponsesOutputEvaluation,
-  },
-}
-
-/**
- * Reports whether the AI Guard channel has subscribers. The OpenAI instrumentation
- * uses this to decide whether to take the AI Guard path at all.
- *
- * @returns {boolean}
- */
-function hasSubscribers () {
-  return aiguardChannel.hasSubscribers
-}
-
-/**
- * Builds a guard handle when AI Guard is enabled and applicable to this call. The
- * handle binds the per-resource handler so downstream functions never re-dispatch
- * on `baseResource`. Returns null when AI Guard does not apply (no subscribers,
- * non-eligible resource, streaming, or no input messages).
- *
- * @param {string} baseResource - e.g. `'chat.completions'` or `'responses'`
- * @param {object} callArgs - First argument passed to the wrapped OpenAI method
- * @param {boolean} stream - Whether the caller asked for a streamed response
- * @returns {Guard|null}
- */
-function createGuard (baseResource, callArgs, stream) {
-  // Streaming AI Guard support lands in a follow-up PR. For now, provider-level AI
-  // Guard only evaluates non-streaming responses.
-  if (stream || !aiguardChannel.hasSubscribers) return null
-  const handler = RESOURCE_HANDLERS[baseResource]
-  if (!handler) return null
-
-  const inputMessages = handler.getInputMessages(callArgs)
-  if (!inputMessages) return null
-
-  let inputEvalPromise
-  const guard = { handler, inputMessages, parentSpan: undefined }
-  guard.getInputEval = () => (inputEvalPromise ??= publishEvaluation(inputMessages, guard.parentSpan))
-  return guard
-}
-
-/**
- * Wraps `apiProm.asResponse` so callers that consume the raw `Response` object still
- * receive the Before Model verdict. After Model evaluation is not performed on this
- * path because the response body has not been parsed.
- *
- * @param {object} apiProm - APIPromise returned from the OpenAI SDK method
- * @param {Guard} guard
- */
-function wrapAsResponse (apiProm, guard) {
-  if (typeof apiProm.asResponse !== 'function') return
-  shimmer.wrap(apiProm, 'asResponse', origAsResponse => function (...args) {
-    const responsePromise = origAsResponse.apply(this, args)
-    return Promise.all([guard.getInputEval(), responsePromise]).then(([, response]) => response)
-  })
-}
-
-/**
- * Gates the parsed-body promise on Before Model evaluation. Resolves to the SDK's
- * result only once the Before Model verdict is in.
- *
- * @param {Promise<unknown>} parsedPromise
- * @param {Guard} guard
- * @returns {Promise<unknown>}
- */
-function gateParse (parsedPromise, guard) {
-  return Promise.all([guard.getInputEval(), parsedPromise]).then(([, result]) => result)
-}
-
-/**
- * Runs After Model evaluation against the response body.
- *
- * @param {Guard} guard
- * @param {object} body - Parsed OpenAI response body
- * @returns {Promise<unknown>}
- */
-function evaluateOutput (guard, body) {
-  const outputMessages = guard.handler.getOutputMessages(body)
-  if (!outputMessages.length) return Promise.resolve()
-  return guard.handler.publishOutputEvaluation(guard.inputMessages, outputMessages, guard.parentSpan)
-}
-
-module.exports = {
-  hasSubscribers,
-  createGuard,
-  wrapAsResponse,
-  gateParse,
-  evaluateOutput,
-}