dd-trace 5.87.0 → 5.89.0

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

@@ -46,8 +46,6 @@ module.exports = {
   SCHEMA_TOPIC: 'schema.topic',
   SCHEMA_OPERATION: 'schema.operation',
   SCHEMA_NAME: 'schema.name',
-  GRPC_CLIENT_ERROR_STATUSES: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-  GRPC_SERVER_ERROR_STATUSES: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
   DYNAMODB_PTR_KIND: 'aws.dynamodb.item',
   S3_PTR_KIND: 'aws.s3.object',
   WEBSOCKET_PTR_KIND: 'websocket',

package/packages/dd-trace/src/crashtracking/crashtracker.js

@@ -52,6 +52,12 @@ class Crashtracker {
   #getConfig (config) {
     const url = getAgentUrl(config)
 
+    // Out-of-process symbolication currently (crashtracker 27.0.0) works on
+    // Linux only, does not work on Mac.
+    const resolveMode = require('os').platform === 'linux'
+      ? 'EnabledWithSymbolsInReceiver'
+      : 'EnabledWithInprocessSymbols'
+
     return {
       additional_files: [],
       create_alt_stack: true,
@@ -67,9 +73,10 @@ class Crashtracker {
         },
         timeout_ms: 3000,
       },
-      timeout_ms: 5000,
-      // TODO: Use `EnabledWithSymbolsInReceiver` instead for Linux when fixed.
-      resolve_frames: 'EnabledWithInprocessSymbols',
+      timeout: { secs: 5, nanos: 0 },
+      demangle_names: false,
+      signals: [],
+      resolve_frames: resolveMode,
     }
   }
 

package/packages/dd-trace/src/datastreams/checkpointer.js

@@ -60,6 +60,19 @@ class DataStreamsCheckpointer {
 
     return ctx
   }
+
+  /**
+   * Records a transaction ID at a named checkpoint without pathway propagation.
+   * Tags the active span (or the provided span) with the transaction ID and checkpoint name.
+   * @param {string} transactionId - The transaction identifier to track.
+   * @param {string} checkpointName - The logical checkpoint name.
+   * @param {object|null} [span=null] - Span to tag. Defaults to the currently active span.
+   */
+  trackTransaction (transactionId, checkpointName, span = null) {
+    if (!this.config.dsmEnabled) return
+    const activeSpan = span ?? this.tracer.scope().active()
+    this.dsmProcessor.trackTransaction(transactionId, checkpointName, activeSpan)
+  }
 }
 
 module.exports = {

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

@@ -71,6 +71,7 @@ const DsmPathwayCodec = lazyClass(() => require('./pathway').DsmPathwayCodec, []
 const DataStreamsCheckpointer = lazyClass(() => require('./checkpointer').DataStreamsCheckpointer, [
   'setProduceCheckpoint',
   'setConsumeCheckpoint',
+  'trackTransaction',
 ])
 
 /**
@@ -79,6 +80,7 @@ const DataStreamsCheckpointer = lazyClass(() => require('./checkpointer').DataSt
 const DataStreamsManager = lazyClass(() => require('./manager').DataStreamsManager, [
   'setCheckpoint',
   'decodeDataStreamsContext',
+  'trackTransaction',
 ])
 
 // TODO: Are all those methods actually public?
@@ -92,6 +94,7 @@ const DataStreamsProcessor = lazyClass(() => require('./processor').DataStreamsP
   'setCheckpoint',
   'recordOffset',
   'setOffset',
+  'trackTransaction',
   'setUrl',
   'trySampleSchema',
   'canSampleSchema',

package/packages/dd-trace/src/datastreams/manager.js

@@ -22,6 +22,15 @@ class DataStreamsManager {
     DataStreamsContext.setDataStreamsContext(ctx)
     return ctx
   }
+
+  /**
+   * @param {string} transactionId
+   * @param {string} checkpointName
+   * @param {object|null} [span=null]
+   */
+  trackTransaction (transactionId, checkpointName, span = null) {
+    this._dataStreamsProcessor.trackTransaction(transactionId, checkpointName, span)
+  }
 }
 
 module.exports = { DataStreamsManager }

package/packages/dd-trace/src/datastreams/pathway.js

@@ -26,17 +26,36 @@ function shaHash (checkpointString) {
  * @param {string} env
  * @param {string[]} edgeTags
  * @param {Buffer} parentHash
+ * @param {bigint | null} propagationHashBigInt - Optional propagation hash for process/container tags
  */
-function computeHash (service, env, edgeTags, parentHash) {
+function computeHash (service, env, edgeTags, parentHash, propagationHashBigInt = null) {
   edgeTags.sort()
   const hashableEdgeTags = edgeTags.filter(item => item !== 'manual_checkpoint:true')
 
-  const key = `${service}${env}${hashableEdgeTags.join('')}${parentHash}`
+  // Cache key includes parentHash to handle fan-in/fan-out scenarios where the same
+  // service+env+tags+propagationHash can have different parents. This ensures we cache
+  // the complete pathway context, not just the current node's identity.
+  const propagationPart = propagationHashBigInt ? `:${propagationHashBigInt.toString(16)}` : ''
+  const key = `${service}${env}${hashableEdgeTags.join('')}${parentHash}${propagationPart}`
+
   let value = cache.get(key)
   if (value) {
     return value
   }
-  const currentHash = shaHash(`${service}${env}` + hashableEdgeTags.join(''))
+
+  // Key vs hashInput distinction:
+  // - 'key' (above) is used for caching and includes parentHash to differentiate pathways
+  //   with the same node but different parents (e.g., multiple queues feeding one consumer)
+  // - 'hashInput' (below) excludes parentHash to compute only the current node's identity hash,
+  //   which is then XORed with parentHash (line 54) to build the complete pathway hash
+  // This two-step approach (hash current node independently, then combine with parent) is
+  // required for proper pathway construction in the DSM protocol.
+  const baseString = `${service}${env}` + hashableEdgeTags.join('')
+  const hashInput = propagationHashBigInt
+    ? `${baseString}:${propagationHashBigInt.toString(16)}`
+    : baseString
+
+  const currentHash = shaHash(hashInput)
   const buf = Buffer.concat([currentHash, parentHash], 16)
   value = shaHash(buf.toString())
   cache.set(key, value)

package/packages/dd-trace/src/datastreams/processor.js

@@ -4,8 +4,10 @@ const os = require('os')
 const pkg = require('../../../../package.json')
 
 const { LogCollapsingLowestDenseDDSketch } = require('../../../../vendor/dist/@datadog/sketches-js')
-const { PATHWAY_HASH } = require('../../../../ext/tags')
+const { PATHWAY_HASH, DSM_TRANSACTION_ID, DSM_TRANSACTION_CHECKPOINT } = require('../../../../ext/tags')
 const log = require('../log')
+const processTags = require('../process-tags')
+const propagationHash = require('../propagation-hash')
 const { DsmPathwayCodec } = require('./pathway')
 const { DataStreamsWriter } = require('./writer')
 const { computePathwayHash } = require('./pathway')
@@ -67,10 +69,66 @@ class Backlog {
   }
 }
 
+/**
+ * Maps checkpoint name strings to single-byte IDs (1–254).
+ * ID 0 is reserved; 254 is the maximum number of unique names.
+ * Scope is per-processor so IDs are stable across bucket boundaries within a process lifetime.
+ */
+class CheckpointRegistry {
+  /** @type {Map<string, number>} */
+  #nameToId = new Map()
+  #nextId = 1
+  /** @type {Buffer[]} Pre-built [id uint8][nameLen uint8][name bytes] entries, one per registered name. */
+  #entryBuffers = []
+  /** @type {Buffer | null} Cached concat of #entryBuffers; reset when a new name is added. */
+  #encodedKeysCache = null
+
+  /**
+   * Returns the byte ID for the given checkpoint name, assigning one if not seen before.
+   * Returns undefined when registry is full (254 entries exhausted).
+   * @param {string} name
+   * @returns {number | undefined}
+   */
+  getId (name) {
+    const existing = this.#nameToId.get(name)
+    if (existing !== undefined) return existing
+    if (this.#nextId > 254) return
+    const id = this.#nextId++
+    this.#nameToId.set(name, id)
+    // Build the wire entry now with a bounded write so long names never materialise
+    // their full UTF-8 encoding — buf.write() stops at the supplied byte limit.
+    const nameBuf = Buffer.allocUnsafe(255)
+    const nameByteLen = nameBuf.write(name, 0, 255, 'utf8')
+    const entry = Buffer.allocUnsafe(2 + nameByteLen)
+    entry.writeUInt8(id, 0)
+    entry.writeUInt8(nameByteLen, 1)
+    nameBuf.copy(entry, 2, 0, nameByteLen)
+    this.#entryBuffers.push(entry)
+    this.#encodedKeysCache = null
+    return id
+  }
+
+  /**
+   * Returns a Buffer encoding all registered names as [id uint8][nameLen uint8][name bytes].
+   * Names are truncated to 255 UTF-8 bytes.
+   * Result is cached and only recomputed when new names are registered.
+   * @returns {Buffer}
+   */
+  get encodedKeys () {
+    if (this.#encodedKeysCache !== null) return this.#encodedKeysCache
+    this.#encodedKeysCache = this.#entryBuffers.length > 0
+      ? Buffer.concat(this.#entryBuffers)
+      : Buffer.alloc(0)
+    return this.#encodedKeysCache
+  }
+}
+
 class StatsBucket {
   constructor () {
     this._checkpoints = new Map()
     this._backlogs = new Map()
+    /** @type {Buffer[]} Accumulated transaction byte chunks, concatenated lazily. */
+    this._transactionChunks = []
   }
 
   get checkpoints () {
@@ -81,6 +139,16 @@ class StatsBucket {
     return this._backlogs
   }
 
+  /**
+   * Returns the concatenated transaction bytes, or null if no transactions have been added.
+   * Concatenation is deferred to read time to avoid O(N²) copies during accumulation.
+   * @returns {Buffer | null}
+   */
+  get transactions () {
+    if (this._transactionChunks.length === 0) return null
+    return Buffer.concat(this._transactionChunks)
+  }
+
   forCheckpoint ({ hash, parentHash, edgeTags }) {
     let checkpoint = this._checkpoints.get(hash)
     if (!checkpoint) {
@@ -91,6 +159,14 @@ class StatsBucket {
     return checkpoint
   }
 
+  /**
+   * Appends pre-encoded transaction bytes to this bucket.
+   * @param {Buffer} bytes
+   */
+  addTransaction (bytes) {
+    this._transactionChunks.push(bytes)
+  }
+
   /**
    * Conditionally add a backlog to the bucket. If there is currently an offset
    * matching the backlog's tags, overwrite the offset IFF the backlog's offset
@@ -151,6 +227,7 @@ class DataStreamsProcessor {
     this.sequence = 0
     this.flushInterval = flushInterval
     this._schemaSamplers = {}
+    this._checkpointRegistry = new CheckpointRegistry()
 
     if (this.enabled) {
       this.timer = setInterval(this.onInterval.bind(this), flushInterval)
@@ -162,6 +239,7 @@ class DataStreamsProcessor {
   onInterval () {
     const { Stats } = this._serializeBuckets()
     if (Stats.length === 0) return
+
     const payload = {
       Env: this.env,
       Service: this.service,
@@ -171,6 +249,12 @@ class DataStreamsProcessor {
       Lang: 'javascript',
       Tags: Object.entries(this.tags).map(([key, value]) => `${key}:${value}`),
     }
+
+    // Add ProcessTags only if feature is enabled and process tags exist
+    if (propagationHash.isEnabled() && processTags.serialized) {
+      payload.ProcessTags = processTags.serialized.split(',')
+    }
+
     this.writer.flush(payload)
   }
 
@@ -234,7 +318,11 @@ class DataStreamsProcessor {
         edgeTags
       )
     }
-    const hash = computePathwayHash(this.service, this.env, edgeTags, parentHash)
+
+    // Get propagation hash if enabled
+    const propagationHashValue = propagationHash.isEnabled() ? propagationHash.getHash() : null
+
+    const hash = computePathwayHash(this.service, this.env, edgeTags, parentHash, propagationHashValue)
     const edgeLatencyNs = nowNs - edgeStartNs
     const pathwayLatencyNs = nowNs - pathwayStartNs
     const dataStreamsContext = {
@@ -281,9 +369,47 @@ class DataStreamsProcessor {
     this.recordOffset(backlogData)
   }
 
+  /**
+   * Records a transaction ID at a named checkpoint using the binary wire format shared with Go/Java tracers.
+   *
+   * Wire format per entry: [checkpointId uint8][timestamp int64 big-endian 8 bytes][idLen uint8][id bytes]
+   *
+   * @param {string} transactionId - Truncated to 255 UTF-8 bytes.
+   * @param {string} checkpointName - Mapped to a stable 1-byte ID; silently dropped if registry full.
+   * @param {import('../opentelemetry/span').Span|null} [span=null] - Active span to tag with DSM transaction metadata.
+   */
+  trackTransaction (transactionId, checkpointName, span = null) {
+    if (!this.enabled) {
+      log.warn('trackTransaction called but DD_DATA_STREAMS_ENABLED is not set. Transaction will not be tracked.')
+      return
+    }
+
+    const checkpointId = this._checkpointRegistry.getId(checkpointName)
+    if (checkpointId === undefined) return
+
+    const idBytes = Buffer.from(transactionId, 'utf8').subarray(0, 255)
+    // Multiply as BigInt to avoid precision loss past MAX_SAFE_INTEGER
+    const timestampNs = BigInt(Date.now()) * 1_000_000n
+
+    const entry = Buffer.alloc(1 + 8 + 1 + idBytes.length)
+    entry.writeUInt8(checkpointId, 0)
+    entry.writeBigInt64BE(timestampNs, 1)
+    entry.writeUInt8(idBytes.length, 9)
+    idBytes.copy(entry, 10)
+
+    // Number() cast is safe here: 10s bucket granularity tolerates ~0.5ns precision loss
+    this.bucketFromTimestamp(Number(timestampNs)).addTransaction(entry)
+
+    if (span) {
+      span.setTag(DSM_TRANSACTION_ID, transactionId)
+      span.setTag(DSM_TRANSACTION_CHECKPOINT, checkpointName)
+    }
+  }
+
   _serializeBuckets () {
     // TimeBuckets
     const serializedBuckets = []
+    const registrySnapshot = this._checkpointRegistry.encodedKeys
 
     for (const [timeNs, bucket] of this.buckets.entries()) {
       const points = []
@@ -298,12 +424,21 @@ class DataStreamsProcessor {
       for (const backlog of bucket._backlogs.values()) {
         backlogs.push(backlog.encode())
       }
-      serializedBuckets.push({
+
+      const serializedBucket = {
         Start: BigInt(timeNs),
         Duration: BigInt(this.bucketSizeNs),
         Stats: points,
         Backlogs: backlogs,
-      })
+      }
+
+      const transactions = bucket.transactions
+      if (transactions !== null) {
+        serializedBucket.Transactions = transactions
+        serializedBucket.TransactionCheckpointIds = registrySnapshot
+      }
+
+      serializedBuckets.push(serializedBucket)
     }
 
     this.buckets.clear()
@@ -345,6 +480,7 @@ class DataStreamsProcessor {
 }
 
 module.exports = {
+  CheckpointRegistry,
   DataStreamsProcessor,
   StatsPoint,
   StatsBucket,

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

@@ -0,0 +1,155 @@
+'use strict'
+
+const log = require('../log')
+const { TOP_LEVEL_KEY } = require('../constants')
+const { truncateSpan, normalizeSpan } = require('./tags-processors')
+
+/**
+ * Formats a span for JSON encoding.
+ * @param {object} span - The span to format
+ * @param {boolean} isFirstSpan - Whether this is the first span in the trace
+ * @returns {object} The formatted span
+ */
+function formatSpan (span, isFirstSpan) {
+  span = normalizeSpan(truncateSpan(span, false))
+
+  if (span.span_events) {
+    span.meta.events = JSON.stringify(span.span_events)
+    delete span.span_events
+  }
+
+  if (isFirstSpan) {
+    span.meta['_dd.compute_stats'] = '1'
+  }
+
+  if (span.parent_id?.toString(10) === '0') {
+    span.metrics._trace_root = 1
+  }
+
+  if (span.metrics[TOP_LEVEL_KEY]) {
+    span.metrics._top_level = 1
+  }
+
+  return span
+}
+
+/**
+ * Converts a span to JSON-serializable format.
+ * IDs are converted to lowercase hex strings. Start time is converted from
+ * nanoseconds to seconds for the intake format.
+ * @param {object} span - The formatted span
+ * @returns {object} JSON-serializable span object
+ */
+function spanToJSON (span) {
+  const result = {
+    trace_id: span.trace_id.toString(16).toLowerCase(),
+    span_id: span.span_id.toString(16).toLowerCase(),
+    parent_id: span.parent_id.toString(16).toLowerCase(),
+    name: span.name,
+    resource: span.resource,
+    service: span.service,
+    error: span.error,
+    start: Math.floor(span.start / 1e9),
+    duration: span.duration,
+    meta: span.meta,
+    metrics: span.metrics,
+  }
+
+  if (span.type) {
+    result.type = span.type
+  }
+
+  if (span.meta_struct) {
+    result.meta_struct = span.meta_struct
+  }
+
+  if (span.links && span.links.length > 0) {
+    result.links = span.links
+  }
+
+  return result
+}
+
+/**
+ * JSON encoder for agentless span intake.
+ * Encodes a single trace as JSON with the payload format: {"spans": [...]}
+ *
+ * This encoder handles one trace at a time since each trace must be sent as a
+ * separate request to the intake. -- bengl
+ */
+class AgentlessJSONEncoder {
+  constructor () {
+    this._reset()
+  }
+
+  /**
+   * Returns the number of spans encoded.
+   * @returns {number}
+   */
+  count () {
+    return this._spanCount
+  }
+
+  /**
+   * Encodes a trace (array of spans) into the buffer.
+   * @param {object[]} trace - Array of spans to encode
+   */
+  encode (trace) {
+    for (const span of trace) {
+      try {
+        const formattedSpan = formatSpan(span, this._spanCount === 0)
+        const jsonSpan = spanToJSON(formattedSpan)
+
+        this._spans.push(jsonSpan)
+        this._spanCount++
+      } catch (err) {
+        log.error(
+          'Failed to encode span (name: %s, service: %s). Span will be dropped. Error: %s\n%s',
+          span?.name || 'unknown',
+          span?.service || 'unknown',
+          err.message,
+          err.stack
+        )
+      }
+    }
+  }
+
+  /**
+   * Creates the JSON payload for the encoded trace.
+   * @returns {Buffer} JSON payload as a buffer, or empty buffer if no spans
+   */
+  makePayload () {
+    if (this._spans.length === 0) {
+      this._reset()
+      return Buffer.alloc(0)
+    }
+
+    try {
+      const payload = JSON.stringify({ spans: this._spans })
+      this._reset()
+      return Buffer.from(payload, 'utf8')
+    } catch (err) {
+      log.error(
+        'Failed to encode trace as JSON (%d spans). Trace will be dropped. Error: %s',
+        this._spans.length,
+        err.message
+      )
+      this._reset()
+      return Buffer.alloc(0)
+    }
+  }
+
+  /**
+   * Resets the encoder state.
+   */
+  reset () {
+    this._reset()
+  }
+
+  _reset () {
+    this._spans = []
+    this._spanCount = 0
+  }
+}
+
+module.exports = { AgentlessJSONEncoder }

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

@@ -11,6 +11,8 @@ module.exports = function getExporter (name) {
       return require('./exporters/log')
     case exporters.AGENT:
       return require('./exporters/agent')
+    case exporters.AGENTLESS:
+      return require('./exporters/agentless')
     case exporters.DATADOG:
       return require('./ci-visibility/exporters/agentless')
     case exporters.AGENT_PROXY:

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

@@ -1,13 +1,13 @@
 'use strict'
 
-const { inspect } = require('util')
-
+const { inspect } = require('node:util')
 const request = require('../common/request')
-const { startupLog } = require('../../startup-log')
+const { logIntegrations, logAgentError } = require('../../startup-log')
 const runtimeMetrics = require('../../runtime_metrics')
 const log = require('../../log')
 const tracerVersion = require('../../../../../package.json').version
 const BaseWriter = require('../common/writer')
+const propagationHash = require('../../propagation-hash')
 
 const METRIC_PREFIX = 'datadog.tracer.node.exporter.agent'
 
@@ -29,10 +29,7 @@ class AgentWriter extends BaseWriter {
     runtimeMetrics.increment(`${METRIC_PREFIX}.requests`, true)
 
     const { _headers, _lookup, _protocolVersion, _url } = this
-    makeRequest(_protocolVersion, data, count, _url, _headers, _lookup, (err, res, status) => {
-      // Note that logging will only happen once, regardless of how many times this is called.
-      startupLog(status !== 404 && status !== 200 ? { status, message: err?.message ?? inspect(err) } : undefined)
-
+    makeRequest(_protocolVersion, data, count, _url, _headers, _lookup, (err, res, status, headers) => {
       if (status) {
         runtimeMetrics.increment(`${METRIC_PREFIX}.responses`, true)
         runtimeMetrics.increment(`${METRIC_PREFIX}.responses.by.status`, `status:${status}`, true)
@@ -53,6 +50,16 @@ class AgentWriter extends BaseWriter {
 
       log.debug('Response from the agent: %s', res)
 
+      // Capture container tags hash from agent response headers
+      // The hash is sent by the agent only when Datadog-Container-ID is present in the request
+      // (Datadog-Container-ID is automatically injected by docker.inject() in exporters/common/request.js)
+      if (headers) {
+        const containerTagsHash = headers['Datadog-Container-Tags-Hash']
+        if (containerTagsHash) {
+          propagationHash.updateContainerTagsHash(containerTagsHash)
+        }
+      }
+
       try {
         this._prioritySampler.update(JSON.parse(res).rate_by_service)
       } catch (e) {
@@ -91,7 +98,13 @@ function makeRequest (version, data, count, url, headers, lookup, cb) {
 
   log.debug('Request to the agent: %j', options)
 
-  request(data, options, cb)
+  request(data, options, (err, res, status, headers) => {
+    logIntegrations()
+    if (status !== 404 && status !== 200 && err) {
+      logAgentError({ status, message: err.message ?? inspect(err) })
+    }
+    cb(err, res, status, headers)
+  })
 }
 
 module.exports = AgentWriter

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

@@ -0,0 +1,89 @@
+'use strict'
+
+const { URL } = require('node:url')
+
+const log = require('../../log')
+const Writer = require('./writer')
+
+/**
+ * Agentless exporter for APM span intake.
+ * Sends spans directly to the Datadog intake without requiring a local agent.
+ *
+ * Each trace is sent immediately as a separate request. The intake only accepts one trace
+ * per request - requests with spans from different traces return HTTP 200 but silently
+ * drop all spans. By flushing immediately after each export (which contains one trace),
+ * we avoid this limitation entirely. -- bengl
+ */
+class AgentlessExporter {
+  /**
+   * @param {object} config - Configuration object
+   * @param {string} [config.site='datadoghq.com'] - The Datadog site
+   * @param {string} [config.url] - Override intake URL
+   */
+  constructor (config) {
+    this._config = config
+    const { site = 'datadoghq.com', url } = config
+
+    try {
+      this._url = url ? new URL(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
+      )
+      this._url = null
+    }
+
+    this._writer = new Writer({
+      url: this._url,
+      site,
+    })
+
+    const ddTrace = globalThis[Symbol.for('dd-trace')]
+    if (ddTrace?.beforeExitHandlers) {
+      ddTrace.beforeExitHandlers.add(this.flush.bind(this))
+    } else {
+      log.error('dd-trace global not properly initialized. beforeExit handler not registered for agentless exporter.')
+    }
+  }
+
+  /**
+   * Sets the intake URL.
+   * @param {string} urlString - The new intake URL
+   * @returns {boolean} True if URL was set successfully
+   */
+  setUrl (urlString) {
+    try {
+      const url = new URL(urlString)
+      this._url = url
+      this._writer.setUrl(url)
+      return true
+    } catch {
+      log.error('Invalid URL for agentless exporter: %s. Using previous URL: %s', urlString, this._url?.href || 'none')
+      return false
+    }
+  }
+
+  /**
+   * Exports a trace to the intake. Flushes immediately since each trace must be
+   * sent as a separate request.
+   * @param {object[]} spans - Array of spans (all from the same trace)
+   */
+  export (spans) {
+    this._writer.append(spans)
+    this._writer.flush()
+  }
+
+  /**
+   * Flushes any pending spans. With immediate flush per trace, this is mainly
+   * used for the beforeExit handler to ensure nothing is left unsent.
+   * @param {Function} [done] - Callback when flush is complete
+   */
+  flush (done = () => {}) {
+    this._writer.flush(done)
+  }
+}
+
+module.exports = AgentlessExporter