dd-trace 5.48.0 → 5.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.48.0",
+  "version": "5.49.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -48,6 +48,7 @@
     "test:integration:cucumber": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/cucumber/*.spec.js\"",
     "test:integration:cypress": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/cypress/*.spec.js\"",
     "test:integration:debugger": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/debugger/*.spec.js\"",
+    "test:integration:esbuild": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/esbuild/*.spec.js\"",
     "test:integration:jest": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/jest/*.spec.js\"",
     "test:integration:mocha": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/mocha/*.spec.js\"",
     "test:integration:playwright": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/playwright/*.spec.js\"",
@@ -90,7 +91,7 @@
     "@datadog/native-metrics": "^3.1.1",
     "@datadog/pprof": "5.7.1",
     "@datadog/sketches-js": "^2.1.0",
-    "@datadog/wasm-js-rewriter": "4.0.0",
+    "@datadog/wasm-js-rewriter": "4.0.1",
     "@isaacs/ttlcache": "^1.4.1",
     "@opentelemetry/api": ">=1.0.0 <1.9.0",
     "@opentelemetry/core": "^1.14.0",

package/packages/datadog-esbuild/index.js

@@ -47,8 +47,7 @@ const DEBUG = !!process.env.DD_TRACE_DEBUG
 // Those packages will still be handled via RITM
 // Attempting to instrument them would fail as they have no package.json file
 for (const pkg of INSTRUMENTED) {
-  if (builtins.has(pkg)) continue
-  if (pkg.startsWith('node:')) continue
+  if (builtins.has(pkg) || pkg.startsWith('node:')) continue
   modulesOfInterest.add(pkg)
 }
 
@@ -71,7 +70,9 @@ module.exports.setup = function (build) {
     }
 
     // TODO: Should this also check for namespace === 'file'?
-    if (args.path.startsWith('@') && !args.importer.includes('node_modules/')) {
+    if (!modulesOfInterest.has(args.path) &&
+        args.path.startsWith('@') &&
+        !args.importer.includes('node_modules/')) {
       // This is the Next.js convention for loading local files
       if (DEBUG) console.log(`@LOCAL: ${args.path}`)
       return

package/packages/datadog-instrumentations/src/orchestrion-config/index.js

@@ -1,5 +1,54 @@
-const path = require('path')
-const fs = require('fs')
-
-// TODO this needs to be inlined to prevent issues in bundling
-module.exports = fs.readFileSync(path.join(__dirname, '../../orchestrion.yml'), 'utf8')
+module.exports = `
+version: 1
+dc_module: dc-polyfill
+instrumentations:
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/runnables/base.js
+    function_query:
+      name: invoke
+      type: method
+      kind: async
+      class: RunnableSequence
+    operator: tracePromise
+    channel_name: "RunnableSequence_invoke"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/runnables/base.js
+    function_query:
+      name: batch
+      type: method
+      kind: async
+      class: RunnableSequence
+    operator: tracePromise
+    channel_name: "RunnableSequence_batch"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/language_models/chat_models.js
+    function_query:
+      name: generate
+      type: method
+      kind: async
+      class: BaseChatModel
+    operator: tracePromise
+    channel_name: "BaseChatModel_generate"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/language_models/llms.js
+    function_query:
+      name: generate
+      type: method
+      kind: async
+    operator: tracePromise
+    channel_name: "BaseLLM_generate"
+  - module_name: "@langchain/core"
+    version_range: ">=0.1.0"
+    file_path: dist/embeddings.js
+    function_query:
+      name: constructor
+      type: method
+      kind: sync
+      class: Embeddings
+    operator: traceSync
+    channel_name: "Embeddings_constructor"
+`

package/packages/datadog-instrumentations/src/playwright.js

@@ -761,9 +761,17 @@ addHook({
     return rootSuite
   }
 
-  loadUtilsPackage.createRootSuite = newCreateRootSuite
+  // We need to proxy the createRootSuite function because the function is not configurable
+  const proxy = new Proxy(loadUtilsPackage, {
+    get (target, prop) {
+      if (prop === 'createRootSuite') {
+        return newCreateRootSuite
+      }
+      return target[prop]
+    }
+  })
 
-  return loadUtilsPackage
+  return proxy
 })
 
 // main process hook
@@ -805,19 +813,25 @@ addHook({
 
     const page = this
 
-    const isRumActive = await page.evaluate(() => {
-      if (window.DD_RUM && window.DD_RUM.getInternalContext) {
-        return !!window.DD_RUM.getInternalContext()
-      } else {
-        return false
-      }
-    })
+    try {
+      if (page) {
+        const isRumActive = await page.evaluate(() => {
+          if (window.DD_RUM && window.DD_RUM.getInternalContext) {
+            return !!window.DD_RUM.getInternalContext()
+          } else {
+            return false
+          }
+        })
 
-    if (isRumActive) {
-      testPageGotoCh.publish({
-        isRumActive,
-        page
-      })
+        if (isRumActive) {
+          testPageGotoCh.publish({
+            isRumActive,
+            page
+          })
+        }
+      }
+    } catch (e) {
+      // ignore errors such as redirects, context destroyed, etc
     }
 
     return response

package/packages/datadog-shimmer/src/shimmer.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const log = require('../../dd-trace/src/log')
-
 function copyProperties (original, wrapped) {
   // TODO getPrototypeOf is not fast. Should we instead do this in specific
   // instrumentations where needed?
@@ -24,9 +22,7 @@ function copyProperties (original, wrapped) {
 function wrapFunction (original, wrapper) {
   if (typeof original === 'function') assertNotClass(original)
 
-  const wrapped = safeMode
-    ? safeWrapper(original, wrapper)
-    : wrapper(original)
+  const wrapped = wrapper(original)
 
   if (typeof original === 'function') copyProperties(original, wrapped)
 
@@ -37,36 +33,6 @@ const wrapFn = function (original, delegate) {
   throw new Error('calling `wrap()` with 2 args is deprecated. Use wrapFunction instead.')
 }
 
-// This is only used in safe mode. It's a simple state machine to track if the
-// original method was called and if it returned. We need this to determine if
-// an error was thrown by the original method, or by us. We'll use one of these
-// per call to a wrapped method.
-class CallState {
-  constructor () {
-    this.called = false
-    this.completed = false
-    this.retVal = undefined
-  }
-
-  startCall () {
-    this.called = true
-  }
-
-  endCall (retVal) {
-    this.completed = true
-    this.retVal = retVal
-  }
-}
-
-function isPromise (obj) {
-  return obj && typeof obj === 'object' && typeof obj.then === 'function'
-}
-
-let safeMode = !!process.env.DD_INEJCTION_ENABLED
-function setSafe (value) {
-  safeMode = value
-}
-
 function wrapMethod (target, name, wrapper, noAssert) {
   if (!noAssert) {
     assertMethod(target, name)
@@ -74,9 +40,7 @@ function wrapMethod (target, name, wrapper, noAssert) {
   }
 
   const original = target[name]
-  const wrapped = safeMode && original
-    ? safeWrapper(original, wrapper)
-    : wrapper(original)
+  const wrapped = wrapper(original)
 
   const descriptor = Object.getOwnPropertyDescriptor(target, name)
 
@@ -110,94 +74,6 @@ function wrapMethod (target, name, wrapper, noAssert) {
   return target
 }
 
-function safeWrapper (original, wrapper) {
-  // In this mode, we make a best-effort attempt to handle errors that are thrown
-  // by us, rather than wrapped code. With such errors, we log them, and then attempt
-  // to return the result as if no wrapping was done at all.
-  //
-  // Caveats:
-  //   * If the original function is called in a later iteration of the event loop,
-  //     and we throw _then_, then it won't be caught by this. In practice, we always call
-  //     the original function synchronously, so this is not a problem.
-  //   * While async errors are dealt with here, errors in callbacks are not. This
-  //     is because we don't necessarily know _for sure_ that any function arguments
-  //     are wrapped by us. We could wrap them all anyway and just make that assumption,
-  //     or just assume that the last argument is always a callback set by us if it's a
-  //     function, but those don't seem like things we can rely on. We could add a
-  //     `shimmer.markCallbackAsWrapped()` function that's a no-op outside safe-mode,
-  //     but that means modifying every instrumentation. Even then, the complexity of
-  //     this code increases because then we'd need to effectively do the reverse of
-  //     what we're doing for synchronous functions. This is a TODO.
-
-  // We're going to hold on to current callState in this variable in this scope,
-  // which is fine because any time we reference it, we're referencing it synchronously.
-  // We'll use it in the our wrapper (which, again, is called syncrhonously), and in the
-  // errorHandler, which will already have been bound to this callState.
-  let currentCallState
-
-  // Rather than calling the original function directly from the shim wrapper, we wrap
-  // it again so that we can track if it was called and if it returned. This is because
-  // we need to know if an error was thrown by the original function, or by us.
-  // We could do this inside the `wrapper` function defined below, which would simplify
-  // managing the callState, but then we'd be calling `wrapper` on each invocation, so
-  // instead we do it here, once.
-  const innerWrapped = wrapper(function (...args) {
-    // We need to stash the callState here because of recursion.
-    const callState = currentCallState
-    callState.startCall()
-    const retVal = original.apply(this, args)
-    if (isPromise(retVal)) {
-      retVal.then(callState.endCall.bind(callState))
-    } else {
-      callState.endCall(retVal)
-    }
-    return retVal
-  })
-
-  // This is the crux of what we're doing in safe mode. It handles errors
-  // that _we_ cause, by logging them, and transparently providing results
-  // as if no wrapping was done at all. That means detecting (via callState)
-  // whether the function has already run or not, and if it has, returning
-  // the result, and otherwise calling the original function unwrapped.
-  const handleError = function (args, callState, e) {
-    if (callState.completed) {
-      // error was thrown after original function returned/resolved, so
-      // it was us. log it.
-      log.error('Shimmer error was thrown after original function returned/resolved', e)
-      // original ran and returned something. return it.
-      return callState.retVal
-    }
-
-    if (!callState.called) {
-      // error was thrown before original function was called, so
-      // it was us. log it.
-      log.error('Shimmer error was thrown before original function was called', e)
-      // original never ran. call it unwrapped.
-      return original.apply(this, args)
-    }
-
-    // error was thrown during original function execution, so
-    // it was them. throw.
-    throw e
-  }
-
-  // The wrapped function is the one that will be called by the user.
-  // It calls our version of the original function, which manages the
-  // callState. That way when we use the errorHandler, it can tell where
-  // the error originated.
-  return function (...args) {
-    currentCallState = new CallState()
-    const errorHandler = handleError.bind(this, args, currentCallState)
-
-    try {
-      const retVal = innerWrapped.apply(this, args)
-      return isPromise(retVal) ? retVal.catch(errorHandler) : retVal
-    } catch (e) {
-      return errorHandler(e)
-    }
-  }
-}
-
 function wrap (target, name, wrapper) {
   return typeof name === 'function'
     ? wrapFn(target, name)
@@ -256,6 +132,5 @@ function assertNotClass (target) {
 module.exports = {
   wrap,
   wrapFunction,
-  massWrap,
-  setSafe
+  massWrap
 }

package/packages/dd-trace/src/config.js

@@ -530,7 +530,7 @@ class Config {
     this._setValue(defaults, 'isManualApiEnabled', false)
     this._setValue(defaults, 'langchain.spanCharLimit', 128)
     this._setValue(defaults, 'langchain.spanPromptCompletionSampleRate', 1.0)
-    this._setValue(defaults, 'llmobs.agentlessEnabled', false)
+    this._setValue(defaults, 'llmobs.agentlessEnabled', undefined)
     this._setValue(defaults, 'llmobs.enabled', false)
     this._setValue(defaults, 'llmobs.mlApp', undefined)
     this._setValue(defaults, 'ciVisibilityTestSessionName', '')
@@ -825,7 +825,7 @@ class Config {
     this._setValue(env, 'baggageMaxBytes', DD_TRACE_BAGGAGE_MAX_BYTES)
     this._setValue(env, 'baggageMaxItems', DD_TRACE_BAGGAGE_MAX_ITEMS)
     this._setBoolean(env, 'clientIpEnabled', DD_TRACE_CLIENT_IP_ENABLED)
-    this._setString(env, 'clientIpHeader', DD_TRACE_CLIENT_IP_HEADER)
+    this._setString(env, 'clientIpHeader', DD_TRACE_CLIENT_IP_HEADER?.toLowerCase())
     this._setBoolean(env, 'crashtracking.enabled', coalesce(
       DD_CRASHTRACKING_ENABLED,
       !this._isInServerlessEnvironment()
@@ -1032,7 +1032,7 @@ class Config {
     this._setValue(opts, 'appsec.wafTimeout', maybeInt(options.appsec.wafTimeout))
     this._optsUnprocessed['appsec.wafTimeout'] = options.appsec.wafTimeout
     this._setBoolean(opts, 'clientIpEnabled', options.clientIpEnabled)
-    this._setString(opts, 'clientIpHeader', options.clientIpHeader)
+    this._setString(opts, 'clientIpHeader', options.clientIpHeader?.toLowerCase())
     this._setValue(opts, 'baggageMaxBytes', options.baggageMaxBytes)
     this._setValue(opts, 'baggageMaxItems', options.baggageMaxItems)
     this._setBoolean(opts, 'codeOriginForSpans.enabled', options.codeOriginForSpans?.enabled)

package/packages/dd-trace/src/llmobs/constants/writers.js

@@ -1,12 +1,16 @@
 'use strict'
 
 module.exports = {
-  EVP_PROXY_AGENT_BASE_PATH: 'evp_proxy/v2',
-  EVP_PROXY_AGENT_ENDPOINT: 'evp_proxy/v2/api/v2/llmobs',
+  EVP_PROXY_AGENT_BASE_PATH: '/evp_proxy/v2/',
   EVP_SUBDOMAIN_HEADER_NAME: 'X-Datadog-EVP-Subdomain',
-  EVP_SUBDOMAIN_HEADER_VALUE: 'llmobs-intake',
-  AGENTLESS_SPANS_ENDPOINT: '/api/v2/llmobs',
-  AGENTLESS_EVALULATIONS_ENDPOINT: '/api/intake/llm-obs/v1/eval-metric',
+
+  SPANS_EVENT_TYPE: 'span',
+  SPANS_INTAKE: 'llmobs-intake',
+  SPANS_ENDPOINT: '/api/v2/llmobs',
+
+  EVALUATIONS_INTAKE: 'api',
+  EVALUATIONS_EVENT_TYPE: 'evaluation_metric',
+  EVALUATIONS_ENDPOINT: '/api/intake/llm-obs/v1/eval-metric',
 
   EVP_PAYLOAD_SIZE_LIMIT: 5 << 20, // 5MB (actual limit is 5.1MB)
   EVP_EVENT_SIZE_LIMIT: (1 << 20) - 1024 // 999KB (actual limit is 1MB)

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

@@ -13,9 +13,9 @@ const evalMetricAppendCh = channel('llmobs:eval-metric:append')
 const flushCh = channel('llmobs:writers:flush')
 const injectCh = channel('dd-trace:span:inject')
 
-const LLMObsAgentlessSpanWriter = require('./writers/spans/agentless')
-const LLMObsAgentProxySpanWriter = require('./writers/spans/agentProxy')
 const LLMObsEvalMetricsWriter = require('./writers/evaluations')
+const LLMObsSpanWriter = require('./writers/spans')
+const { setAgentStrategy } = require('./writers/util')
 
 /**
  * Setting writers and processor globally when LLMObs is enabled
@@ -25,8 +25,14 @@ const LLMObsEvalMetricsWriter = require('./writers/evaluations')
  * if the tracer is `init`ed. But, in those cases, we don't want to start writers or subscribe
  * to channels.
  */
+
+/** @type {LLMObsSpanProcessor | null} */
 let spanProcessor
+
+/** @type {LLMObsSpanWriter | null} */
 let spanWriter
+
+/** @type {LLMObsEvalMetricsWriter | null} */
 let evalWriter
 
 function enable (config) {
@@ -34,7 +40,7 @@ function enable (config) {
   // create writers and eval writer append and flush channels
   // span writer append is handled by the span processor
   evalWriter = new LLMObsEvalMetricsWriter(config)
-  spanWriter = createSpanWriter(config)
+  spanWriter = new LLMObsSpanWriter(config)
 
   evalMetricAppendCh.subscribe(handleEvalMetricAppend)
   flushCh.subscribe(handleFlush)
@@ -46,7 +52,20 @@ function enable (config) {
 
   // distributed tracing for llmobs
   injectCh.subscribe(handleLLMObsParentIdInjection)
-  telemetry.recordLLMObsEnabled(startTime, config)
+
+  setAgentStrategy(config, useAgentless => {
+    if (useAgentless && !(config.apiKey && config.site)) {
+      throw new Error(
+        'Cannot send LLM Observability data without a running agent or without both a Datadog API key and site.\n' +
+        'Ensure these configurations are set before running your application.'
+      )
+    }
+
+    evalWriter?.setAgentless(useAgentless)
+    spanWriter?.setAgentless(useAgentless)
+
+    telemetry.recordLLMObsEnabled(startTime, config)
+  })
 }
 
 function disable () {
@@ -74,11 +93,6 @@ function handleLLMObsParentIdInjection ({ carrier }) {
   carrier['x-datadog-tags'] += `,${PROPAGATED_PARENT_ID_KEY}=${parentId}`
 }
 
-function createSpanWriter (config) {
-  const SpanWriter = config.llmobs.agentlessEnabled ? LLMObsAgentlessSpanWriter : LLMObsAgentProxySpanWriter
-  return new SpanWriter(config)
-}
-
 function handleFlush () {
   try {
     spanWriter.flush()

package/packages/dd-trace/src/llmobs/sdk.js

@@ -287,13 +287,6 @@ class LLMObs extends NoopLLMObs {
   submitEvaluation (llmobsSpanContext, options = {}) {
     if (!this.enabled) return
 
-    if (!this._config.apiKey) {
-      throw new Error(
-        'DD_API_KEY is required for sending evaluation metrics. Evaluation metric data will not be sent.\n' +
-        'Ensure this configuration is set before running your application.'
-      )
-    }
-
     const { traceId, spanId } = llmobsSpanContext
     if (!traceId || !spanId) {
       throw new Error(

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -1,16 +1,22 @@
 'use strict'
 
 const request = require('../../exporters/common/request')
-const { URL, format } = require('url')
+const { URL, format } = require('node:url')
+const path = require('node:path')
 
 const logger = require('../../log')
 
 const { encodeUnicode } = require('../util')
 const telemetry = require('../telemetry')
 const log = require('../../log')
+const {
+  EVP_SUBDOMAIN_HEADER_NAME,
+  EVP_PROXY_AGENT_BASE_PATH
+} = require('../constants/writers')
+const { parseResponseAndLog } = require('./util')
 
 class BaseLLMObsWriter {
-  constructor ({ interval, timeout, endpoint, intake, eventType, protocol, port }) {
+  constructor ({ interval, timeout, eventType, config, endpoint, intake }) {
     this._interval = interval || 1000 // 1s
     this._timeout = timeout || 5000 // 5s
     this._eventType = eventType
@@ -19,28 +25,20 @@ class BaseLLMObsWriter {
     this._bufferLimit = 1000
     this._bufferSize = 0
 
-    this._url = new URL(format({
-      protocol: protocol || 'https:',
-      hostname: intake,
-      port: port || 443,
-      pathname: endpoint
-    }))
-
-    this._headers = {
-      'Content-Type': 'application/json'
-    }
+    this._config = config
+    this._endpoint = endpoint
+    this._intake = intake
 
     this._periodic = setInterval(() => {
       this.flush()
     }, this._interval).unref()
 
-    process.once('beforeExit', () => {
+    this._beforeExitHandler = () => {
       this.destroy()
-    })
+    }
+    process.once('beforeExit', this._beforeExitHandler)
 
     this._destroyed = false
-
-    logger.debug(`Started ${this.constructor.name} to ${this._url}`)
   }
 
   append (event, byteLength) {
@@ -55,7 +53,9 @@ class BaseLLMObsWriter {
   }
 
   flush () {
-    if (this._buffer.length === 0) {
+    const noAgentStrategy = this._agentless == null
+
+    if (this._buffer.length === 0 || noAgentStrategy) {
       return
     }
 
@@ -64,29 +64,12 @@ class BaseLLMObsWriter {
     this._bufferSize = 0
     const payload = this._encode(this.makePayload(events))
 
-    const options = {
-      headers: this._headers,
-      method: 'POST',
-      url: this._url,
-      timeout: this._timeout
-    }
-
     log.debug(`Encoded LLMObs payload: ${payload}`)
 
+    const options = this._getOptions()
+
     request(payload, options, (err, resp, code) => {
-      if (err) {
-        logger.error(
-          'Error sending %d LLMObs %s events to %s: %s', events.length, this._eventType, this._url, err.message, err
-        )
-        telemetry.recordDroppedPayload(events.length, this._eventType, 'request_error')
-      } else if (code >= 300) {
-        logger.error(
-          'Error sending %d LLMObs %s events to %s: %s', events.length, this._eventType, this._url, code
-        )
-        telemetry.recordDroppedPayload(events.length, this._eventType, 'http_error')
-      } else {
-        logger.debug(`Sent ${events.length} LLMObs ${this._eventType} events to ${this._url}`)
-      }
+      parseResponseAndLog(err, code, events.length, options.url.href, this._eventType)
     })
   }
 
@@ -96,12 +79,57 @@ class BaseLLMObsWriter {
     if (!this._destroyed) {
       logger.debug(`Stopping ${this.constructor.name}`)
       clearInterval(this._periodic)
-      process.removeListener('beforeExit', this.destroy)
+      process.removeListener('beforeExit', this._beforeExitHandler)
       this.flush()
       this._destroyed = true
     }
   }
 
+  setAgentless (agentless) {
+    this._agentless = agentless
+    this._url = this._getUrl()
+    logger.debug(`Configuring ${this.constructor.name} to ${this._url.href}`)
+  }
+
+  _getUrl () {
+    if (this._agentless) {
+      return new URL(format({
+        protocol: 'https:',
+        hostname: `${this._intake}.${this._config.site}`,
+        pathname: this._endpoint
+      }))
+    }
+
+    const { hostname, port } = this._config
+    const base = this._config.url || new URL(format({
+      protocol: 'http:',
+      hostname,
+      port
+    }))
+
+    const proxyPath = path.join(EVP_PROXY_AGENT_BASE_PATH, this._endpoint)
+    return new URL(proxyPath, base)
+  }
+
+  _getOptions () {
+    const options = {
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      method: 'POST',
+      timeout: this._timeout,
+      url: this._url
+    }
+
+    if (this._agentless) {
+      options.headers['DD-API-KEY'] = this._config.apiKey || ''
+    } else {
+      options.headers[EVP_SUBDOMAIN_HEADER_NAME] = this._intake
+    }
+
+    return options
+  }
+
   _encode (payload) {
     return JSON.stringify(payload, (key, value) => {
       if (typeof value === 'string') {

package/packages/dd-trace/src/llmobs/writers/evaluations.js

@@ -1,17 +1,20 @@
 'use strict'
 
-const { AGENTLESS_EVALULATIONS_ENDPOINT } = require('../constants/writers')
+const {
+  EVALUATIONS_ENDPOINT,
+  EVALUATIONS_EVENT_TYPE,
+  EVALUATIONS_INTAKE
+} = require('../constants/writers')
 const BaseWriter = require('./base')
 
 class LLMObsEvalMetricsWriter extends BaseWriter {
   constructor (config) {
     super({
-      endpoint: AGENTLESS_EVALULATIONS_ENDPOINT,
-      intake: `api.${config.site}`,
-      eventType: 'evaluation_metric'
+      config,
+      intake: EVALUATIONS_INTAKE,
+      eventType: EVALUATIONS_EVENT_TYPE,
+      endpoint: EVALUATIONS_ENDPOINT
     })
-
-    this._headers['DD-API-KEY'] = config.apiKey
   }
 
   makePayload (events) {

package/packages/dd-trace/src/llmobs/writers/{spans/base.js → spans.js}

@@ -1,19 +1,27 @@
 'use strict'
 
-const { EVP_EVENT_SIZE_LIMIT, EVP_PAYLOAD_SIZE_LIMIT } = require('../../constants/writers')
-const { DROPPED_VALUE_TEXT } = require('../../constants/text')
-const { DROPPED_IO_COLLECTION_ERROR } = require('../../constants/tags')
-const BaseWriter = require('../base')
-const telemetry = require('../../telemetry')
-const logger = require('../../../log')
+const {
+  EVP_EVENT_SIZE_LIMIT,
+  EVP_PAYLOAD_SIZE_LIMIT,
+  SPANS_ENDPOINT,
+  SPANS_EVENT_TYPE,
+  SPANS_INTAKE
+} = require('../constants/writers')
+const { DROPPED_VALUE_TEXT } = require('../constants/text')
+const { DROPPED_IO_COLLECTION_ERROR } = require('../constants/tags')
+const BaseWriter = require('./base')
+const telemetry = require('../telemetry')
+const logger = require('../../log')
 
-const tracerVersion = require('../../../../../../package.json').version
+const tracerVersion = require('../../../../../package.json').version
 
 class LLMObsSpanWriter extends BaseWriter {
-  constructor (options) {
+  constructor (config) {
     super({
-      ...options,
-      eventType: 'span'
+      config,
+      eventType: SPANS_EVENT_TYPE,
+      intake: SPANS_INTAKE,
+      endpoint: SPANS_ENDPOINT
     })
   }
 
@@ -33,11 +41,11 @@ class LLMObsSpanWriter extends BaseWriter {
     telemetry.recordLLMObsSpanSize(event, processedEventSizeBytes, shouldTruncate)
 
     if (this._bufferSize + eventSizeBytes > EVP_PAYLOAD_SIZE_LIMIT) {
-      logger.debug('Flusing queue because queing next event will exceed EvP payload limit')
+      logger.debug('Flushing queue because queuing next event will exceed EvP payload limit')
       this.flush()
     }
 
-    super.append(event, eventSizeBytes)
+    super.append(event, processedEventSizeBytes)
   }
 
   makePayload (events) {

package/packages/dd-trace/src/llmobs/writers/util.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const logger = require('../../log')
+const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/writers')
+const telemetry = require('../telemetry')
+
+const AgentInfoExporter = require('../../exporters/common/agent-info-exporter')
+/** @type {AgentInfoExporter} */
+let agentInfoExporter
+
+function setAgentStrategy (config, setWritersAgentlessValue) {
+  const agentlessEnabled = config.llmobs.agentlessEnabled
+
+  if (agentlessEnabled != null) {
+    setWritersAgentlessValue(agentlessEnabled)
+    return
+  }
+
+  if (!agentInfoExporter) {
+    agentInfoExporter = new AgentInfoExporter(config)
+  }
+
+  agentInfoExporter.getAgentInfo((err, agentInfo) => {
+    if (err) {
+      setWritersAgentlessValue(true)
+      return
+    }
+
+    const endpoints = agentInfo.endpoints
+    const hasEndpoint = Array.isArray(endpoints) && endpoints.some(endpoint => endpoint === EVP_PROXY_AGENT_BASE_PATH)
+    setWritersAgentlessValue(!hasEndpoint)
+  })
+}
+
+function parseResponseAndLog (err, code, eventsLength, url, eventType) {
+  if (code === 403 && err.message.includes('API key is invalid')) {
+    logger.error(
+      '[LLMObs] The provided Datadog API key is invalid (likely due to an API key and DD_SITE mismatch). ' +
+      'Please verify your API key and DD_SITE are correct.'
+    )
+    telemetry.recordDroppedPayload(eventsLength, eventType, 'request_error')
+  } else if (err) {
+    logger.error(
+      'Error sending %d LLMObs %s events to %s: %s', eventsLength, eventType, url, err.message, err
+    )
+    telemetry.recordDroppedPayload(eventsLength, eventType, 'request_error')
+  } else if (code >= 300) {
+    logger.error(
+      'Error sending %d LLMObs %s events to %s: %s', eventsLength, eventType, url, code
+    )
+    telemetry.recordDroppedPayload(eventsLength, eventType, 'http_error')
+  } else {
+    logger.debug(`Sent ${eventsLength} LLMObs ${eventType} events to ${url}`)
+  }
+}
+
+module.exports = {
+  setAgentStrategy,
+  parseResponseAndLog
+}

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

@@ -17,6 +17,11 @@ function messageProxy (message, holder) {
         return holder.dd
       }
 
+      // This is a workaround for a V8 bug that surfaced in Node.js 22
+      if (p === 'stack') {
+        return target.stack
+      }
+
       return Reflect.get(target, p, receiver)
     },
     ownKeys (target) {

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -115,8 +115,6 @@ class NativeWallProfiler {
   start ({ mapper } = {}) {
     if (this._started) return
 
-    ensureChannelsActivated()
-
     this._mapper = mapper
     this._pprof = require('@datadog/pprof')
     kSampleCount = this._pprof.time.constants.kSampleCount
@@ -147,6 +145,8 @@ class NativeWallProfiler {
         this._profilerState = this._pprof.time.getState()
         this._lastSampleCount = 0
 
+        ensureChannelsActivated()
+
         beforeCh.subscribe(this._enter)
         enterCh.subscribe(this._enter)
         spanFinishCh.subscribe(this._spanFinished)

package/packages/datadog-instrumentations/orchestrion.yml

@@ -1,52 +0,0 @@
-version: 1
-dc_module: dc-polyfill
-instrumentations:
-  - module_name: "@langchain/core"
-    version_range: ">=0.1.0"
-    file_path: dist/runnables/base.js
-    function_query:
-      name: invoke
-      type: method
-      kind: async
-      class: RunnableSequence
-    operator: tracePromise
-    channel_name: "RunnableSequence_invoke"
-  - module_name: "@langchain/core"
-    version_range: ">=0.1.0"
-    file_path: dist/runnables/base.js
-    function_query:
-      name: batch
-      type: method
-      kind: async
-      class: RunnableSequence
-    operator: tracePromise
-    channel_name: "RunnableSequence_batch"
-  - module_name: "@langchain/core"
-    version_range: ">=0.1.0"
-    file_path: dist/language_models/chat_models.js
-    function_query:
-      name: generate
-      type: method
-      kind: async
-      class: BaseChatModel
-    operator: tracePromise
-    channel_name: "BaseChatModel_generate"
-  - module_name: "@langchain/core"
-    version_range: ">=0.1.0"
-    file_path: dist/language_models/llms.js
-    function_query:
-      name: generate
-      type: method
-      kind: async
-    operator: tracePromise
-    channel_name: "BaseLLM_generate"
-  - module_name: "@langchain/core"
-    version_range: ">=0.1.0"
-    file_path: dist/embeddings.js
-    function_query:
-      name: constructor
-      type: method
-      kind: sync
-      class: Embeddings
-    operator: traceSync
-    channel_name: "Embeddings_constructor"

package/packages/dd-trace/src/llmobs/writers/spans/agentProxy.js

@@ -1,23 +0,0 @@
-'use strict'
-
-const {
-  EVP_SUBDOMAIN_HEADER_NAME,
-  EVP_SUBDOMAIN_HEADER_VALUE,
-  EVP_PROXY_AGENT_ENDPOINT
-} = require('../../constants/writers')
-const LLMObsBaseSpanWriter = require('./base')
-
-class LLMObsAgentProxySpanWriter extends LLMObsBaseSpanWriter {
-  constructor (config) {
-    super({
-      intake: config.url?.hostname || config.hostname || 'localhost',
-      protocol: config.url?.protocol || 'http:',
-      endpoint: EVP_PROXY_AGENT_ENDPOINT,
-      port: config.url?.port || config.port
-    })
-
-    this._headers[EVP_SUBDOMAIN_HEADER_NAME] = EVP_SUBDOMAIN_HEADER_VALUE
-  }
-}
-
-module.exports = LLMObsAgentProxySpanWriter

package/packages/dd-trace/src/llmobs/writers/spans/agentless.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { AGENTLESS_SPANS_ENDPOINT } = require('../../constants/writers')
-const LLMObsBaseSpanWriter = require('./base')
-
-class LLMObsAgentlessSpanWriter extends LLMObsBaseSpanWriter {
-  constructor (config) {
-    super({
-      intake: `llmobs-intake.${config.site}`,
-      endpoint: AGENTLESS_SPANS_ENDPOINT
-    })
-
-    this._headers['DD-API-KEY'] = config.apiKey
-  }
-}
-
-module.exports = LLMObsAgentlessSpanWriter