dd-trace 5.106.0 → 5.108.0

package/packages/dd-trace/src/encode/0.4.js

@@ -3,7 +3,7 @@
 const getConfig = require('../config')
 const { MsgpackChunk } = require('../msgpack')
 const log = require('../log')
-const { normalizeSpan } = require('./tags-processors')
+const { normalizeSpan, eventTimeNano } = require('./tags-processors')
 
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
 // Values longer than this byte threshold skip the `_stringMap` lookup and
@@ -114,8 +114,10 @@ const ATTR_PAYLOAD_BOOL_FALSE = Buffer.concat([ATTR_PREFIX_BOOL, Buffer.from([0x
 function formatSpanWithLegacyEvents (span) {
   span = normalizeSpan(span)
   if (span.span_events) {
-    // TODO: this is currently a main cost driver. By unifying it with the formatter
-    // it should be possible to improve performance significantly overall.
+    // Reads the raw `_events` array directly (no formatter pre-reshape) and
+    // serializes to the legacy meta.events JSON string. The serialization is
+    // still the main cost on the legacy path; the native span_events slot
+    // (`#encodeSpanEvents`) avoids it entirely.
     span.meta.events = stringifySpanEvents(span.span_events)
     // `= undefined` over `delete` to keep the span's hidden class — `delete`
     // would push every event-bearing span into V8 dictionary mode.
@@ -125,14 +127,15 @@ function formatSpanWithLegacyEvents (span) {
 }
 
 /**
- * Hand-written stringifier for `span.span_events`. The shape is fixed by
- * `extractSpanEvents` (`{ name, time_unix_nano, attributes? }`) and attribute
- * values are pre-sanitized to primitives or arrays of primitives, so we can
- * skip everything `JSON.stringify` does for the generic case (toJSON probing,
- * key iteration over the prototype chain, replacer hooks). Output matches
- * `JSON.stringify(spanEvents)` byte-for-byte for the post-sanitization shape.
+ * Hand-written stringifier for `span.span_events`. Events arrive in their raw
+ * `{ name, startTime, attributes? }` shape; `time_unix_nano` is derived per
+ * event via `eventTimeNano` and empty attribute objects are dropped, matching
+ * what the formatter used to precompute. Attribute values are pre-sanitized to
+ * primitives or arrays of primitives, so we skip everything `JSON.stringify`
+ * does for the generic case (toJSON probing, prototype-chain key iteration,
+ * replacer hooks).
  *
- * @param {Array<{ name: string, time_unix_nano: number, attributes?: object }>} spanEvents
+ * @param {Array<{ name: unknown, startTime: number, attributes?: object }>} spanEvents
  * @returns {string}
  */
 function stringifySpanEvents (spanEvents) {
@@ -140,17 +143,21 @@ function stringifySpanEvents (spanEvents) {
   for (let index = 0; index < spanEvents.length; index++) {
     if (index > 0) result += ','
     const event = spanEvents[index]
+    // `_sanitizeEventAttributes` leaves `attributes` undefined when empty, so a
+    // present value always has entries — no emptiness probe here.
+    const attributes = event.attributes
     // `addEvent` does not type-check `name`; defer the unusual cases to
-    // `JSON.stringify` so non-string names match the prior behaviour
-    // instead of throwing in `escapeJsonString`.
+    // `JSON.stringify` so non-string names match the prior behaviour instead
+    // of throwing in `escapeJsonString`. Build the wire-shaped object so the
+    // emitted key stays `time_unix_nano`, not the raw `startTime`.
     if (typeof event.name !== 'string') {
-      result += JSON.stringify(event)
+      result += JSON.stringify({ name: event.name, time_unix_nano: eventTimeNano(event), attributes })
       continue
     }
     result += '{"name":' + escapeJsonString(event.name) +
-      ',"time_unix_nano":' + jsonNumber(event.time_unix_nano)
-    if (event.attributes) {
-      result += ',"attributes":' + stringifyAttributes(event.attributes)
+      ',"time_unix_nano":' + jsonNumber(eventTimeNano(event))
+    if (attributes) {
+      result += ',"attributes":' + stringifyAttributes(attributes)
     }
     result += '}'
   }
@@ -241,8 +248,8 @@ class AgentEncoder {
     this.#config = getConfig()
     this.#debugEncoding = this.#config.DD_TRACE_ENCODING_DEBUG
     // Pick the per-span formatter once so the hot loop pays no per-span
-    // config check. The native path doesn't need to reshape `span_events`
-    // because `#encodeSpanEvents` works directly on the raw attributes.
+    // config check. The native path keeps the raw `span_events` slot for
+    // `#encodeSpanEvents`; the legacy path serializes it into meta.events.
     this.#formatSpan = this.#config.DD_TRACE_NATIVE_SPAN_EVENTS
       ? normalizeSpan
       : formatSpanWithLegacyEvents
@@ -320,16 +327,18 @@ class AgentEncoder {
       const resourceLen = resourceEntry.length
       const serviceLen = serviceEntry.length
 
-      // Almost every span carries `error: 0` or `error: 1` AND a nanosecond
-      // `start` timestamp ≥ 2³² (so `start` always encodes as a u64). When
-      // both hold, the block fuses error key+value, the start key + 0xCF
-      // type byte + 8-byte timestamp, and the duration key into the per-span
-      // reserve. The fallback path covers synthetic/test inputs with small
-      // starts and rare non-binary error flags by keeping per-field emits so
-      // each integer picks the shortest msgpack encoding.
-      const errorIsFixint = span.error === 0 || span.error === 1
-      const startFitsU64 = span.start >= 0x1_00_00_00_00
-      const fuseTail = errorIsFixint && startFitsU64
+      // `error` is `0` or `1` on nearly every span, and `start` is a
+      // nanosecond timestamp ≥ 2³² (always a msgpack u64). Decide the fused
+      // error key+value up front (`KEY_ERROR_0` / `KEY_ERROR_1`, or `undefined`
+      // for the rare non-binary flag) so the tail fuses without re-deciding the
+      // error shape twice. The fused tail also needs `start` as a u64; when
+      // either misses (synthetic small `start`, non-binary error) the tail
+      // routes each integer through `writeIntOrFloat` for the shortest
+      // encoding.
+      const errorEntry = span.error === 0
+        ? KEY_ERROR_0
+        : span.error === 1 ? KEY_ERROR_1 : undefined
+      const fuseTail = errorEntry !== undefined && span.start >= 0x1_00_00_00_00
 
       let blockSize = 1 +
         KEY_TRACE_ID_PREFIX.length + 8 +
@@ -340,7 +349,7 @@ class AgentEncoder {
         KEY_SERVICE.length + serviceLen
       if (typeEntry) blockSize += KEY_TYPE.length + typeEntry.length
       if (fuseTail) {
-        blockSize += KEY_ERROR_0.length + KEY_START_PREFIX.length + 8 + KEY_DURATION.length
+        blockSize += errorEntry.length + KEY_START_PREFIX.length + 8 + KEY_DURATION.length
       }
 
       const blockOffset = bytes.length
@@ -377,8 +386,8 @@ class AgentEncoder {
       cursor += serviceLen
 
       if (fuseTail) {
-        target.set(span.error === 0 ? KEY_ERROR_0 : KEY_ERROR_1, cursor)
-        cursor += KEY_ERROR_0.length
+        target.set(errorEntry, cursor)
+        cursor += errorEntry.length
 
         target.set(KEY_START_PREFIX, cursor)
         cursor += KEY_START_PREFIX.length
@@ -389,15 +398,14 @@ class AgentEncoder {
         cursor += 8
 
         target.set(KEY_DURATION, cursor)
+      } else if (errorEntry) {
+        bytes.set(errorEntry)
+        bytes.set(KEY_START)
+        bytes.writeIntOrFloat(span.start)
+        bytes.set(KEY_DURATION)
       } else {
-        if (span.error === 0) {
-          bytes.set(KEY_ERROR_0)
-        } else if (span.error === 1) {
-          bytes.set(KEY_ERROR_1)
-        } else {
-          bytes.set(KEY_ERROR)
-          bytes.writeIntOrFloat(span.error)
-        }
+        bytes.set(KEY_ERROR)
+        bytes.writeIntOrFloat(span.error)
         bytes.set(KEY_START)
         bytes.writeIntOrFloat(span.start)
         bytes.set(KEY_DURATION)
@@ -763,7 +771,7 @@ class AgentEncoder {
    * values — no `formatSpanEvents` pre-pass and no recursive generic walk.
    *
    * @param {MsgpackChunk} bytes
-   * @param {Array<{ name: string, time_unix_nano: number, attributes?: object }>} spanEvents
+   * @param {Array<{ name: unknown, startTime: number, attributes?: object }>} spanEvents
    */
   #encodeSpanEvents (bytes, spanEvents) {
     const offset = bytes.length
@@ -784,7 +792,7 @@ class AgentEncoder {
       bytes.set(KEY_NAME)
       this._encodeString(bytes, event.name)
       bytes.set(KEY_EVENT_TIME)
-      bytes.writeFloat(event.time_unix_nano)
+      bytes.writeFloat(eventTimeNano(event))
 
       const attributes = event.attributes
       if (attributes !== null && typeof attributes === 'object') {

package/packages/dd-trace/src/encode/agentless-json.js

@@ -3,6 +3,7 @@
 const log = require('../log')
 const { TOP_LEVEL_KEY } = require('../constants')
 const { normalizeSpan } = require('./tags-processors')
+const { stringifySpanEvents } = require('./0.4')
 
 // Soft limit for estimated payload size. Triggers an early flush to stay under intake request size limits.
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
@@ -20,7 +21,10 @@ function formatSpan (span, isFirstSpan) {
   delete span.meta['_dd.p.tid']
 
   if (span.span_events) {
-    span.meta.events = JSON.stringify(span.span_events)
+    // Events arrive raw (`{ name, startTime, attributes? }`); stringifySpanEvents
+    // derives `time_unix_nano` and drops empty attributes, matching the JSON the
+    // reshaped array used to produce.
+    span.meta.events = stringifySpanEvents(span.span_events)
     delete span.span_events
   }
 

package/packages/dd-trace/src/encode/tags-processors.js

@@ -46,6 +46,19 @@ function truncateSpanTestOpt (span) {
   return span
 }
 
+/**
+ * Convert a raw span event's `startTime` (milliseconds, sub-millisecond
+ * precision) to the wire `time_unix_nano`. Single source of truth for the
+ * formula so the four encoders that consume `span_events` stay in lockstep;
+ * the formatter no longer reshapes events, it hands the raw array through.
+ *
+ * @param {{ startTime: number }} event
+ * @returns {number}
+ */
+function eventTimeNano (event) {
+  return Math.round(event.startTime * 1e6)
+}
+
 function normalizeSpan (span) {
   span.service = span.service || DEFAULT_SERVICE_NAME
   if (span.service.length > MAX_SERVICE_LENGTH) {
@@ -69,6 +82,7 @@ module.exports = {
   truncateSpan,
   truncateSpanTestOpt,
   normalizeSpan,
+  eventTimeNano,
   MAX_META_KEY_LENGTH,
   MAX_META_VALUE_LENGTH,
   MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION,

package/packages/dd-trace/src/exporters/agent/index.js

@@ -2,7 +2,6 @@
 
 const { URL } = require('url')
 const log = require('../../log')
-const { getAgentUrl } = require('../../agent/url')
 const Writer = require('./writer')
 
 class AgentExporter {
@@ -11,7 +10,7 @@ class AgentExporter {
   constructor (config, prioritySampler) {
     this._config = config
     const { lookup, protocolVersion, stats = {}, apmTracingEnabled } = config
-    this._url = getAgentUrl(config)
+    this._url = config.url
 
     const headers = {}
     if (stats.enabled || apmTracingEnabled === false) {

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

@@ -18,25 +18,21 @@ class AgentlessExporter {
 
   /**
    * @param {object} config - Configuration object
-   * @param {string} [config.site] - The Datadog site. Defaults to 'datadoghq.com'.
-   * @param {string} [config.url] - Override intake URL
+   * @param {string} [config.site] - The Datadog site. Defaults to 'datadoghq.com'.
    * @param {number} [config.flushInterval] - Batch flush interval in ms
    * @param {string} [config.env] - Environment name
    * @param {object} [config.tags] - Tags including runtime-id
    */
   constructor (config) {
     this._config = config
-    const { site = 'datadoghq.com', url } = config
+    const site = config.site ?? 'datadoghq.com'
 
     try {
-      this._url = url ? new URL(url) : new URL(`https://public-trace-http-intake.logs.${site}`)
+      // Agentless traffic carries the Datadog API key, so the intake is always the public https
+      // endpoint; never derive it from config.url (the agent's cleartext http) or the key leaks.
+      this._url = new URL(`https://public-trace-http-intake.logs.${site}`)
     } catch (err) {
-      log.error(
-        'Invalid URL configuration for agentless exporter. url=%s, site=%s. Error: %s',
-        url || 'not set',
-        site,
-        err.message
-      )
+      log.error('Invalid site for agentless exporter. site=%s. Error: %s', site, err.message)
       this._url = null
     }
 

package/packages/dd-trace/src/exporters/common/buffering-exporter.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { incrementCountMetric, TELEMETRY_EVENTS_ENQUEUED_FOR_SERIALIZATION } = require('../../ci-visibility/telemetry')
-const { getAgentUrl } = require('../../agent/url')
 
 /**
  * Base exporter that buffers traces until a writer is initialized.
@@ -14,7 +13,7 @@ class BufferingExporter {
 
   constructor (tracerConfig) {
     this._config = tracerConfig
-    this._url = getAgentUrl(tracerConfig)
+    this._url = tracerConfig.url
   }
 
   export (trace) {

package/packages/dd-trace/src/exporters/common/request.js

@@ -6,6 +6,7 @@
 const { Readable } = require('stream')
 const http = require('http')
 const https = require('https')
+const net = require('net')
 const zlib = require('zlib')
 
 const { storage } = require('../../../../datadog-core')
@@ -45,6 +46,17 @@ function parseUrl (urlObjOrString) {
   return url
 }
 
+/**
+ * @param {string} hostname Host as resolved by {@link parseUrl}; IPv6 is unbracketed (`::1`).
+ */
+function isLoopbackHost (hostname) {
+  // The 127.0.0.0/8 block is loopback, but only when the host is an actual IPv4 literal: a
+  // hostname like `127.evil.com` shares the prefix yet resolves anywhere, so net.isIPv4 gates it.
+  return hostname === 'localhost' ||
+    hostname === '::1' ||
+    (hostname.startsWith('127.') && net.isIPv4(hostname))
+}
+
 /**
  * @param {Buffer|string|Readable|Array<Buffer|string>} data
  * @param {object} options
@@ -67,6 +79,20 @@ function request (data, options, callback) {
     }
   }
 
+  // Never put the Datadog API key on a cleartext connection to a non-loopback host; that would
+  // expose it on the wire. Loopback (local agent, dev proxy, tests) is exempt. Strip the key
+  // rather than drop the request: the agent proxies telemetry with its own key, while an https
+  // intake URL is required to authenticate agentless traffic.
+  const hasApiKey = options.headers['dd-api-key'] !== undefined || options.headers['DD-API-KEY'] !== undefined
+  if (hasApiKey && options.protocol === 'http:' && !isLoopbackHost(options.hostname)) {
+    log.error(
+      'Not sending the Datadog API key over a non-TLS connection to %s. Configure an https intake URL.',
+      options.hostname
+    )
+    delete options.headers['dd-api-key']
+    delete options.headers['DD-API-KEY']
+  }
+
   if (data instanceof Readable) {
     const chunks = []
 

package/packages/dd-trace/src/exporters/span-stats/index.js

@@ -1,11 +1,10 @@
 'use strict'
 
-const { getAgentUrl } = require('../../agent/url')
 const { Writer } = require('./writer')
 
 class SpanStatsExporter {
   constructor (config) {
-    this._url = getAgentUrl(config)
+    this._url = config.url
     this._writer = new Writer({ url: this._url })
   }
 

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

@@ -5,6 +5,7 @@ const {
   getOperation,
   extractMetrics,
   extractMetadata,
+  extractToolDefinitions,
   aggregateStreamingChunks,
   formatInputMessages,
   formatEmbeddingInput,
@@ -79,6 +80,9 @@ class GenAiLLMObsPlugin extends LLMObsPlugin {
     const metadata = extractMetadata(config)
     this._tagger.tagMetadata(span, metadata)
 
+    const toolDefinitions = extractToolDefinitions(config)
+    if (toolDefinitions.length > 0) this._tagger.tagToolDefinitions(span, toolDefinitions)
+
     if (error) {
       this._tagger.tagLLMIO(span, inputMessages, [{ content: '' }])
       return

package/packages/dd-trace/src/llmobs/plugins/genai/util.js

@@ -155,6 +155,50 @@ function extractMetadata (config) {
   return metadata
 }
 
+/**
+ * Extract tool definitions from config
+ * @param {object} config
+ * @returns {Array}
+ */
+function extractToolDefinitions (config) {
+  const toolDefinitions = []
+
+  if (!Array.isArray(config?.tools)) {
+    return toolDefinitions
+  }
+
+  for (const tool of config.tools) {
+    // Only extract tools with valid function declarations
+    if (!Array.isArray(tool?.functionDeclarations)) {
+      continue
+    }
+
+    for (const currDeclaration of tool.functionDeclarations) {
+      // A valid declaration must have a name
+      if (!currDeclaration?.name) {
+        continue
+      }
+
+      const toolDef = { name: currDeclaration.name }
+
+      if (currDeclaration.description !== undefined) {
+        toolDef.description = currDeclaration.description
+      }
+
+      // Parameters can be in two different fields depending on user input
+      if (currDeclaration.parameters !== undefined) {
+        toolDef.schema = currDeclaration.parameters
+      } else if (currDeclaration.parametersJsonSchema !== undefined) {
+        toolDef.schema = currDeclaration.parametersJsonSchema
+      }
+
+      toolDefinitions.push(toolDef)
+    }
+  }
+
+  return toolDefinitions
+}
+
 /**
  * Format function call message
  * @param {Array} parts
@@ -498,6 +542,7 @@ module.exports = {
   getOperation,
   extractMetrics,
   extractMetadata,
+  extractToolDefinitions,
   aggregateStreamingChunks,
   formatInputMessages,
   formatEmbeddingInput,

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

@@ -259,7 +259,7 @@ class LLMObs extends NoopLLMObs {
         throw new Error('LLMObs span must have a span kind specified')
       }
 
-      const { inputData, outputData, metadata, metrics, tags, prompt, costTags } = options
+      const { inputData, outputData, metadata, metrics, tags, prompt, costTags, toolDefinitions } = options
 
       if (inputData || outputData) {
         if (spanKind === 'llm') {
@@ -289,6 +289,9 @@ class LLMObs extends NoopLLMObs {
       if (prompt) {
         this._tagger.tagPrompt(span, prompt)
       }
+      if (toolDefinitions != null) {
+        this._tagger.tagToolDefinitions(span, toolDefinitions)
+      }
     } catch (e) {
       if (e.ddErrorTag) {
         err = e.ddErrorTag

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

@@ -332,8 +332,24 @@ class LLMObsSpanProcessor {
     return tags
   }
 
+  /**
+   * @param {Record<string, unknown>} tags
+   */
   #objectTagsToStringArrayTags (tags) {
-    return Object.entries(tags).map(([key, value]) => `${key}:${value ?? ''}`)
+    const out = []
+    for (const [key, value] of Object.entries(tags)) {
+      // Comma is the intake-side tag delimiter, so a single `"key:v1,v2"`
+      // entry fans into two orphan tags. One-per-element keeps each value
+      // addressable; empty arrays fall through to the scalar branch and
+      // still emit `key:` so `_dd.cost_tags` references keep finding a
+      // wire entry.
+      if (Array.isArray(value) && value.length > 0) {
+        for (const item of value) out.push(`${key}:${item ?? ''}`)
+      } else {
+        out.push(`${key}:${value ?? ''}`)
+      }
+    }
+    return out
   }
 
   /**

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

@@ -43,7 +43,7 @@ const {
   INSTRUMENTATION_METHOD_ANNOTATED,
 } = require('./constants/tags')
 const { storage } = require('./storage')
-const { findGenAIAncestorSpanId, validateCostTags, writeBridgeTags } = require('./util')
+const { findGenAIAncestorSpanId, validateCostTags, writeBridgeTags, validateToolDefinitions } = require('./util')
 
 // global registry of LLMObs spans
 // maps LLMObs spans to their annotations
@@ -176,8 +176,10 @@ class LLMObsTagger {
   }
 
   tagToolDefinitions (span, toolDefinitions) {
-    if (Array.isArray(toolDefinitions) && toolDefinitions.length > 0) {
-      this._setTag(span, TOOL_DEFINITIONS, toolDefinitions)
+    const validatedToolDefinitions = validateToolDefinitions(toolDefinitions)
+
+    if (validatedToolDefinitions.length > 0) {
+      this._setTag(span, TOOL_DEFINITIONS, validatedToolDefinitions)
     } else {
       this.#handleFailure('Tool definitions must be a non-empty array.', 'invalid_tool_definitions')
     }

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

@@ -89,6 +89,59 @@ function validateCostTags (span, costTags, source, spanTags) {
   return [...validatedCostTags]
 }
 
+// Validates tool definition entires
+function validateToolDefinitions (toolDefinitions) {
+  if (!Array.isArray(toolDefinitions)) {
+    log.warn('toolDefinitions must be an array.')
+    return []
+  }
+  const validated = []
+
+  for (let i = 0; i < toolDefinitions.length; i++) {
+    const currToolDef = toolDefinitions[i]
+    if (!currToolDef || typeof currToolDef !== 'object') {
+      log.warn('Tool definition at index %d must be an object. Skipping.', i)
+      continue
+    }
+
+    // Name is not optional
+    if (!currToolDef.name || typeof currToolDef.name !== 'string' || currToolDef.name.length <= 0) {
+      log.warn('Tool definition at index %d must have a non empty string "name". Skipping.', i)
+      continue
+    }
+    const validatedToolDef = { name: currToolDef.name }
+
+    // Description, Schema, and Version are optional types
+    if (currToolDef.description !== undefined) {
+      if (typeof currToolDef.description === 'string') {
+        validatedToolDef.description = currToolDef.description
+      } else {
+        log.warn('Tool definition "description" at index %d must be a string. Skipping field.', i)
+      }
+    }
+
+    if (currToolDef.schema !== undefined) {
+      if (currToolDef.schema !== null && typeof currToolDef.schema === 'object' && !Array.isArray(currToolDef.schema)) {
+        validatedToolDef.schema = currToolDef.schema
+      } else {
+        log.warn('Tool definition "schema" at index %d must be a plain object. Skipping field.', i)
+      }
+    }
+
+    if (currToolDef.version !== undefined) {
+      if (typeof currToolDef.version === 'string') {
+        validatedToolDef.version = currToolDef.version
+      } else {
+        log.warn('Tool definition "version" at index %d must be a string. Skipping field.', i)
+      }
+    }
+
+    validated.push(validatedToolDef)
+  }
+
+  return validated
+}
+
 // extracts the argument names from a function string
 function parseArgumentNames (str) {
   const result = []
@@ -318,4 +371,5 @@ module.exports = {
   safeJsonParse,
   spanHasError,
   writeBridgeTags,
+  validateToolDefinitions,
 }

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

@@ -14,7 +14,6 @@ const {
   EVP_SUBDOMAIN_HEADER_NAME,
   EVP_PROXY_AGENT_BASE_PATH,
 } = require('../constants/writers')
-const { getAgentUrl } = require('../../agent/url')
 const { parseResponseAndLog } = require('./util')
 
 class LLMObsBuffer {
@@ -210,7 +209,7 @@ class BaseLLMObsWriter {
 
     const overrideOriginEnv = getEnvironmentVariable('_DD_LLMOBS_OVERRIDE_ORIGIN')
     const overrideOriginUrl = overrideOriginEnv && new URL(overrideOriginEnv)
-    const base = overrideOriginUrl ?? getAgentUrl(this._config)
+    const base = overrideOriginUrl ?? this._config.url
 
     return {
       url: base,

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

@@ -4,7 +4,6 @@ const logger = require('../../log')
 const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/writers')
 const telemetry = require('../telemetry')
 const { fetchAgentInfo } = require('../../agent/info')
-const { getAgentUrl } = require('../../agent/url')
 
 /**
  * @param {import('../../config/config-base')} config
@@ -17,7 +16,7 @@ function setAgentStrategy (config, setWritersAgentlessValue) {
     return
   }
 
-  fetchAgentInfo(getAgentUrl(config), (err, agentInfo) => {
+  fetchAgentInfo(config.url, (err, agentInfo) => {
     if (err) {
       setWritersAgentlessValue(true)
       return

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

@@ -2,7 +2,6 @@
 
 const request = require('../../exporters/common/request')
 const { safeJSONStringify } = require('../../exporters/common/util')
-const { getAgentUrl } = require('../../agent/url')
 
 const log = require('../../log')
 
@@ -37,7 +36,7 @@ class BaseFFEWriter {
 
     this._config = config
     this._endpoint = endpoint
-    this._baseUrl = agentUrl ?? this._getAgentUrl()
+    this._baseUrl = agentUrl ?? config.url
     this._payloadSizeLimit = payloadSizeLimit
     this._eventSizeLimit = eventSizeLimit
     this._headers = headers || {}
@@ -154,14 +153,6 @@ class BaseFFEWriter {
     }
   }
 
-  /**
-   * @private
-   * @returns {URL} Constructs agent URL from config
-   */
-  _getAgentUrl () {
-    return getAgentUrl(this._config)
-  }
-
   /**
    * @private
    * @param {Array<object>} payload - Payload to encode

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

@@ -3,7 +3,6 @@
 const logger = require('../../log')
 const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/constants')
 const { fetchAgentInfo } = require('../../agent/info')
-const { getAgentUrl } = require('../../agent/url')
 
 /**
  * Determines if the agent supports EVP proxy and sets the writer enabled state accordingly
@@ -11,7 +10,7 @@ const { getAgentUrl } = require('../../agent/url')
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
  */
 function setAgentStrategy (config, setWriterEnabledValue) {
-  fetchAgentInfo(getAgentUrl(config), (err, agentInfo) => {
+  fetchAgentInfo(config.url, (err, agentInfo) => {
     if (err) {
       logger.debug('FFE Writer disabled - error getting agent info:', err.message)
       setWriterEnabledValue(false)