dd-trace 5.124.0 → 5.126.0

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

@@ -0,0 +1,170 @@
+'use strict'
+
+const { AgentEncoder } = require('./0.4')
+
+const CROSS_PAYLOAD_CACHE_LIMIT = 256
+const CROSS_PAYLOAD_CANDIDATE_LIMIT = 512
+const CROSS_PAYLOAD_LEARNING_PAYLOAD_LIMIT = 8
+const CROSS_PAYLOAD_MISS_LIMIT = 32
+const CROSS_PAYLOAD_STRING_LIMIT = 256
+
+class CrossPayloadAgentEncoder extends AgentEncoder {
+  #disableCrossPayloadCache
+  #crossPayloadState = createCrossPayloadState()
+
+  /**
+   * @param {{ flush: () => void }} writer
+   * @param {() => void} disableCrossPayloadCache
+   */
+  constructor (writer, disableCrossPayloadCache) {
+    super(writer)
+    this.#disableCrossPayloadCache = disableCrossPayloadCache
+  }
+
+  /**
+   * @param {string} value
+   * @param {boolean} [stable]
+   * @returns {Buffer}
+   */
+  _cacheString (value, stable = false) {
+    if (!stable) return super._cacheString(value)
+
+    const crossPayloadState = this.#crossPayloadState
+    if (crossPayloadState === undefined || value.length === 0 || value.length > CROSS_PAYLOAD_STRING_LIMIT) {
+      return super._cacheString(value)
+    }
+
+    const learning = crossPayloadState.learningPayloadCount < CROSS_PAYLOAD_LEARNING_PAYLOAD_LIMIT
+    if (learning) markPayloadString(crossPayloadState, value)
+    const retainedEntry = crossPayloadState.stringMap?.[value]
+    if (retainedEntry !== undefined) {
+      if (!learning && crossPayloadState.hitCount < CROSS_PAYLOAD_MISS_LIMIT) {
+        crossPayloadState.hitCount++
+      }
+      const start = this._stringBytes.length
+      this._stringBytes.set(retainedEntry)
+      const entry = this._stringBytes.buffer.subarray(start, start + retainedEntry.length)
+      this._stringMap[value] = entry
+      return entry
+    }
+    if (!learning && crossPayloadState.missCount < CROSS_PAYLOAD_MISS_LIMIT) {
+      crossPayloadState.missCount++
+    }
+    if (!learning || crossPayloadState.payloadStableStrings?.[value] !== true) {
+      return super._cacheString(value)
+    }
+
+    let entry = super._cacheString(value)
+    if (entry.length > CROSS_PAYLOAD_STRING_LIMIT) return entry
+
+    const previousPayloadStrings = crossPayloadState.previousPayloadStrings
+    if (previousPayloadStrings?.[value] !== undefined &&
+      crossPayloadState.stringCount < CROSS_PAYLOAD_CACHE_LIMIT) {
+      entry = Buffer.from(entry)
+      crossPayloadState.stringMap ??= Object.create(null)
+      crossPayloadState.stringMap[value] = entry
+      crossPayloadState.stringCount++
+    }
+    return entry
+  }
+
+  /** @returns {Buffer} */
+  makePayload () {
+    this.#prepareReset()
+    return super.makePayload()
+  }
+
+  /** @returns {void} */
+  reset () {
+    this.#prepareReset()
+    super.reset()
+  }
+
+  /** @returns {void} */
+  #prepareReset () {
+    const crossPayloadState = this.#crossPayloadState
+    if (crossPayloadState !== undefined && !prepareCrossPayloadReset(crossPayloadState)) {
+      this.#crossPayloadState = undefined
+      this.#disableCrossPayloadCache()
+    }
+  }
+}
+
+/**
+ * @param {{ flush: () => void }} writer
+ * @param {() => void} disableCrossPayloadCache
+ * @returns {AgentEncoder}
+ */
+function createAgentEncoder (writer, disableCrossPayloadCache) {
+  return new CrossPayloadAgentEncoder(writer, disableCrossPayloadCache)
+}
+
+function createCrossPayloadState () {
+  return {
+    hitCount: 0,
+    learningPayloadCount: 0,
+    lowUseCount: 0,
+    missCount: 0,
+    payloadStableStringCount: 0,
+    payloadStableStrings: undefined,
+    previousPayloadStrings: undefined,
+    stringCount: 0,
+    stringMap: undefined,
+  }
+}
+
+/**
+ * @param {ReturnType<typeof createCrossPayloadState>} crossPayloadState
+ * @param {string} value
+ */
+function markPayloadString (crossPayloadState, value) {
+  if (crossPayloadState.payloadStableStringCount >= CROSS_PAYLOAD_CANDIDATE_LIMIT ||
+    crossPayloadState.payloadStableStrings?.[value] !== undefined) {
+    return
+  }
+  crossPayloadState.payloadStableStrings ??= Object.create(null)
+  crossPayloadState.payloadStableStrings[value] = true
+  crossPayloadState.payloadStableStringCount++
+}
+
+/**
+ * @param {ReturnType<typeof createCrossPayloadState>} crossPayloadState
+ * @returns {boolean}
+ */
+function prepareCrossPayloadReset (crossPayloadState) {
+  const learning = crossPayloadState.learningPayloadCount < CROSS_PAYLOAD_LEARNING_PAYLOAD_LIMIT
+  const lowUse = !learning && crossPayloadState.hitCount < crossPayloadState.missCount
+  if (lowUse) {
+    crossPayloadState.lowUseCount++
+    if (crossPayloadState.lowUseCount >= 2) return false
+    crossPayloadState.learningPayloadCount = 0
+    crossPayloadState.stringCount = 0
+    crossPayloadState.stringMap = undefined
+    crossPayloadState.payloadStableStrings = undefined
+    crossPayloadState.payloadStableStringCount = 0
+    crossPayloadState.previousPayloadStrings = undefined
+    crossPayloadState.hitCount = 0
+    crossPayloadState.missCount = 0
+    return true
+  }
+  if (!learning && crossPayloadState.hitCount > 0) {
+    crossPayloadState.lowUseCount = 0
+  }
+
+  if (learning) {
+    crossPayloadState.learningPayloadCount++
+    if (crossPayloadState.learningPayloadCount < CROSS_PAYLOAD_LEARNING_PAYLOAD_LIMIT) {
+      crossPayloadState.previousPayloadStrings = crossPayloadState.payloadStableStrings
+    } else {
+      crossPayloadState.previousPayloadStrings = undefined
+      if (crossPayloadState.stringMap === undefined) return false
+    }
+  }
+  crossPayloadState.payloadStableStrings = undefined
+  crossPayloadState.payloadStableStringCount = 0
+  crossPayloadState.hitCount = 0
+  crossPayloadState.missCount = 0
+  return true
+}
+
+module.exports = { createAgentEncoder }

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

@@ -339,11 +339,11 @@ class AgentEncoder {
       // Replaces up to ten separate `bytes.reserve` calls per span with one.
       let typeEntry
       if (span.type) {
-        typeEntry = stringMap[span.type] ?? this._cacheString(span.type)
+        typeEntry = stringMap[span.type] ?? this._cacheString(span.type, true)
       }
-      const nameEntry = stringMap[span.name] ?? this._cacheString(span.name)
-      const resourceEntry = stringMap[span.resource] ?? this._cacheString(span.resource)
-      const serviceEntry = stringMap[span.service] ?? this._cacheString(span.service)
+      const nameEntry = stringMap[span.name] ?? this._cacheString(span.name, true)
+      const resourceEntry = stringMap[span.resource] ?? this._cacheString(span.resource, true)
+      const serviceEntry = stringMap[span.service] ?? this._cacheString(span.service, true)
       const nameLen = nameEntry.length
       const resourceLen = resourceEntry.length
       const serviceLen = serviceEntry.length
@@ -589,7 +589,7 @@ class AgentEncoder {
       const entryValue = value[key]
       if (typeof entryValue !== 'string' && typeof entryValue !== 'number') continue
 
-      const keyEntry = stringMap[key] ?? this._cacheString(key)
+      const keyEntry = stringMap[key] ?? this._cacheString(key, true)
       const keyEntryLen = keyEntry.length
       const writeOffset = bytes.length
 

package/packages/dd-trace/src/encode/agentless-ci-visibility.js

@@ -69,11 +69,11 @@ function truncateTestLevelMetadataTags (tags) {
 }
 
 class AgentlessCiVisibilityEncoder extends AgentEncoder {
-  constructor (writer, { runtimeId, service, env }) {
+  constructor (writer, { tags }) {
     super(writer, INTAKE_SOFT_LIMIT)
-    this.runtimeId = runtimeId
-    this.service = service
-    this.env = env
+    // Holds a reference to the live `tags` object (instead of copying `env`/`runtime-id` out of it)
+    // so a later change (e.g. a MicroVM clone resume) is picked up at flush time.
+    this.tags = tags
 
     // Used to keep track of the number of encoded events to update the
     // length of `payload.events` when calling `makePayload`
@@ -406,11 +406,12 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
       events: [],
     }
 
-    if (this.env) {
-      payload.metadata['*'].env = this.env
+    if (this.tags.env) {
+      payload.metadata['*'].env = this.tags.env
     }
-    if (this.runtimeId) {
-      payload.metadata['*']['runtime-id'] = this.runtimeId
+    const runtimeId = this.tags['runtime-id']
+    if (runtimeId) {
+      payload.metadata['*']['runtime-id'] = runtimeId
     }
 
     bytes.writeMapPrefix(Object.keys(payload).length)

package/packages/dd-trace/src/evp_proxy/direct.js

@@ -1,9 +1,6 @@
 'use strict'
 
-const { format } = require('node:url')
-
-const { HttpsProxyAgent } = require('../../../../vendor/dist/https-proxy-agent')
-const { getProxyForUrl } = require('../../../../vendor/dist/proxy-from-env')
+const { createSiteUrl } = require('../exporters/common/url')
 const log = require('../log')
 
 /**
@@ -11,7 +8,6 @@ const log = require('../log')
  * @property {URL} url - Direct intake URL
  * @property {string} basePath - Direct intake base path
  * @property {object} headers - Direct intake authentication headers
- * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
  */
 
 /**
@@ -28,25 +24,8 @@ function createDirectEVPRoute (config, intake) {
   if (!apiKey || !config.site) return
 
   try {
-    const hostname = `${intake}.${config.site}`.toLowerCase()
-    const url = new URL(format({
-      protocol: 'https:',
-      hostname,
-    }))
-    if (
-      url.hostname !== hostname ||
-      url.username ||
-      url.password ||
-      url.port ||
-      url.pathname !== '/' ||
-      url.search ||
-      url.hash
-    ) {
-      throw new Error('Invalid direct EVP intake URL')
-    }
-
-    const proxyUrl = getProxyForUrl(url.href)
-    const agent = proxyUrl ? new HttpsProxyAgent(proxyUrl) : undefined
+    const url = createSiteUrl(config.site, intake)
+    if (url === undefined) throw new Error('Invalid direct EVP intake URL')
 
     return {
       url,
@@ -54,7 +33,6 @@ function createDirectEVPRoute (config, intake) {
       headers: {
         'DD-API-KEY': apiKey,
       },
-      ...(agent && { agent }),
     }
   } catch (error) {
     log.debug('Unable to configure direct EVP intake: %s', error.message)

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

@@ -12,7 +12,7 @@ class AgentExporter {
   constructor (config, prioritySampler) {
     this.#serverlessDeliveryTracker = createServerlessDeliveryTracker()
     this._config = config
-    const { lookup, protocolVersion, stats = {}, apmTracingEnabled } = config
+    const { lookup, protocolVersion, stats = {}, apmTracingEnabled, flushInterval } = config
     this._url = config.url
 
     const headers = {}
@@ -25,6 +25,7 @@ class AgentExporter {
       prioritySampler,
       lookup,
       protocolVersion,
+      flushInterval,
       headers,
       deliveryTracker: this.#serverlessDeliveryTracker,
     })

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

@@ -19,18 +19,19 @@ class AgentWriter extends BaseWriter {
   #requestTracker
 
   constructor (...args) {
+    const { isTestOptimization } = args[0]
     super({
       ...args[0],
       beforeFirstFlush: () => firstFlushChannel.publish(),
+      retainOnBackpressure: isTestOptimization,
     })
-    const { prioritySampler, lookup, protocolVersion, headers, isTestOptimization } = args[0]
-    const AgentEncoder = getEncoder(protocolVersion)
+    const { prioritySampler, lookup, protocolVersion, flushInterval, headers } = args[0]
 
     this._prioritySampler = prioritySampler
     this._lookup = lookup
     this._protocolVersion = protocolVersion
     this._headers = headers
-    this._encoder = new AgentEncoder(this)
+    this._encoder = createEncoder(protocolVersion, flushInterval, this)
     if (isTestOptimization) {
       this.#request = require('../../ci-visibility/exporters/request')
       const TestOptimizationRequestTracker = require('../../ci-visibility/exporters/agentless/request-tracker')
@@ -113,10 +114,26 @@ class AgentWriter extends BaseWriter {
   }
 }
 
-function getEncoder (protocolVersion) {
-  return protocolVersion === '0.5'
-    ? require('../../encode/0.5').AgentEncoder
-    : require('../../encode/0.4').AgentEncoder
+/**
+ * @param {string} protocolVersion
+ * @param {number | undefined} flushInterval
+ * @param {AgentWriter} writer
+ * @returns {import('../../encode/0.4').AgentEncoder}
+ */
+function createEncoder (protocolVersion, flushInterval, writer) {
+  if (protocolVersion === '0.5') {
+    const { AgentEncoder } = require('../../encode/0.5')
+    return new AgentEncoder(writer)
+  }
+  if (flushInterval === 0) {
+    const { createAgentEncoder } = require('../../encode/0.4-cross-payload')
+    const disableCrossPayloadCache = () => {
+      writer._encoder = createEncoder('0.4', undefined, writer)
+    }
+    return createAgentEncoder(writer, disableCrossPayloadCache)
+  }
+  const { AgentEncoder } = require('../../encode/0.4')
+  return new AgentEncoder(writer)
 }
 
 function makeRequest (version, data, count, url, headers, lookup, flushOptions, request, requestTracker, cb) {

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

@@ -4,8 +4,7 @@ const { URL } = require('node:url')
 const os = require('node:os')
 
 const log = require('../../log')
-const { entityId } = require('../common/docker')
-const tracerVersion = require('../../../../../package.json').version
+const { containerId } = require('../common/docker')
 const Writer = require('./writer')
 const { computeIntakeUrl } = require('./intake')
 
@@ -23,7 +22,7 @@ class AgentlessExporter {
    * @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
+   * @param {object} config.tags - Tags including runtime-id
    */
   constructor (config) {
     this.#config = config
@@ -40,13 +39,12 @@ class AgentlessExporter {
 
     const metadata = {
       hostname: os.hostname(),
-      env: config.env,
-      languageName: 'nodejs',
-      languageVersion: process.version,
-      tracerVersion,
-      runtimeID: config.tags?.['runtime-id'],
-      ...(entityId ? { containerID: entityId } : {}),
+      // Read live off `config` (instead of copying the value) so a later change
+      // (e.g. a MicroVM clone resume) is picked up by the next data-pipeline export.
+      get env () { return config.env },
+      get runtimeID () { return config.tags['runtime-id'] },
     }
+    if (containerId) metadata.containerId = containerId
 
     this._writer = new Writer({
       url: this._url,

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

@@ -1,42 +1,56 @@
 'use strict'
 
+const { createAgentlessExporter } = require('@datadog/libdatadog')
+
+const { storage } = require('../../../../datadog-core')
 const getConfig = require('../../config')
 const log = require('../../log')
-const request = require('../common/request')
 const tracerVersion = require('../../../../../package.json').version
 
+const { canSendApiKey } = require('../common/url')
+const { getHttpsProxyAgent } = require('../common/proxy')
 const BaseWriter = require('../common/writer')
-const { AgentlessJSONEncoder } = require('../../encode/agentless-json')
+const { AgentEncoder } = require('../../encode/0.4')
 const { computeIntakeUrl, INTAKE_PATH } = require('./intake')
 
+const legacyStorage = storage('legacy')
+
 /**
  * Writer for agentless APM trace intake.
- * Sends traces directly to the Datadog intake endpoint without an agent.
+ * Encodes traces as v0.4 MessagePack and delegates transformation and delivery
+ * to the APM data pipeline.
  */
 class AgentlessWriter extends BaseWriter {
   #apiKeyMissing = false
+  #apiKeyUnsafeReceiver = false
+  #exporter
+  #exporterApiKey
+  #exporterEnv
+  #exporterRuntimeId
+  #metadata
   #urlMissing = false
 
   /**
    * @param {object} options - Writer options
    * @param {URL} [options.url] - The intake URL. If not provided, constructed from site.
    * @param {string} [options.site] - The Datadog site
-   * @param {object} [options.metadata] - Metadata to pass to the encoder (hostname, env, etc.)
+   * @param {object} [options.metadata] - Metadata to pass to the data pipeline
    */
   constructor ({ url, site = 'datadoghq.com', metadata = {} }) {
     super({ url })
-    this._encoder = new AgentlessJSONEncoder(this, metadata)
+    this.#metadata = metadata
+    this._encoder = new AgentEncoder(this)
 
     if (!url) {
       try {
         this._url = new URL(computeIntakeUrl(site))
-      } catch (err) {
+      } catch (error) {
         log.error(
           'Invalid site value for agentless intake: %s. Cannot construct URL. Error: %s',
           site,
-          err.message
+          error.message
         )
-        this._url = null
+        this._url = undefined
       }
     }
 
@@ -46,59 +60,23 @@ class AgentlessWriter extends BaseWriter {
     }
   }
 
+  /**
+   * @param {URL} url - The new intake URL.
+   */
   setUrl (url) {
     super.setUrl(url)
+    this.#closeExporter()
     if (url) {
       this.#urlMissing = false
     }
   }
 
   /**
-   * Flushes accumulated traces to the intake as a single request.
-   * @param {Function} [done] - Callback when send completes
-   */
-  flush (done = () => {}) {
-    if (!request.writable) {
-      const count = this._encoder.count()
-      if (count > 0) {
-        log.error('Maximum number of active requests reached. Dropping %d trace(s).', count)
-      }
-      this._encoder.reset()
-      done()
-      return
-    }
-
-    const count = this._encoder.count()
-
-    if (count === 0) {
-      done()
-      return
-    }
-
-    const payload = this._encoder.makePayload()
-
-    if (payload.length === 0) {
-      log.debug('Skipping send of empty payload')
-      done()
-      return
-    }
-
-    this._sendPayload(payload, count, done)
-  }
-
-  /**
-   * Sends the encoded payload to the intake endpoint.
-   * @param {Buffer} data - The encoded JSON payload
-   * @param {number} count - Number of traces in the payload
-   * @param {Function} done - Callback when complete
+   * @param {Buffer} data - v0.4 MessagePack payload.
+   * @param {number} count - Number of traces in the payload.
+   * @param {() => void} done - Callback invoked after delivery completes or fails.
    */
   _sendPayload (data, count, done) {
-    if (!data || data.length === 0) {
-      log.debug('Skipping send of empty payload')
-      done()
-      return
-    }
-
     if (!this._url) {
       if (!this.#urlMissing) {
         this.#urlMissing = true
@@ -121,81 +99,87 @@ class AgentlessWriter extends BaseWriter {
     }
     this.#apiKeyMissing = false
 
-    const options = {
-      path: INTAKE_PATH,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'dd-api-key': DD_API_KEY,
-        'X-Datadog-Trace-Count': String(count),
-        'Datadog-Meta-Lang': 'nodejs',
-        'Datadog-Meta-Lang-Version': process.version,
-        'Datadog-Meta-Lang-Interpreter': process.versions.bun ? 'JavaScriptCore' : 'v8',
-        'Datadog-Meta-Tracer-Version': tracerVersion,
-      },
-      timeout: 15_000,
-      url: this._url,
+    // The WASM transport performs its HTTP request in JavaScript. Keep that
+    // internal request out of the instrumented application's traces.
+    try {
+      legacyStorage.run({ noop: true }, () => {
+        const exporter = this.#applyConfiguration(DD_API_KEY)
+        if (exporter) {
+          exporter.sendV04(data, done, log)
+        } else {
+          done()
+        }
+      })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      log.error('Failed to send %d trace(s) to the agentless intake: %s', count, message)
+      done()
     }
+  }
 
-    log.debug('Request to the agentless intake: %j', options)
-
-    request(data, options, (err, res, statusCode) => {
-      if (err) {
-        this.#logRequestError(err, statusCode, count)
-        done()
-        return
-      }
-
-      log.debug('Response from the agentless intake: %s', res)
-      done()
-    })
+  /**
+   * @returns {string} The full agentless intake endpoint.
+   */
+  #endpoint () {
+    const endpoint = new URL(this._url)
+    endpoint.pathname = INTAKE_PATH
+    endpoint.search = ''
+    endpoint.hash = ''
+    return endpoint.href
   }
 
   /**
-   * Logs request errors with status-specific guidance.
-   * @param {Error} err - The error object
-   * @param {number} statusCode - HTTP status code (if available)
-   * @param {number} count - Number of traces that were being sent
+   * @param {string} apiKey - Datadog API key.
+   * @returns {import('@datadog/libdatadog').AgentlessExporter|undefined}
    */
-  #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.',
-        count,
-        statusCode
-      )
-    } else if (statusCode === 404) {
-      log.error(
-        'Trace intake endpoint not found (status %s). Verify DD_SITE is correctly configured. %d trace(s) dropped.',
-        statusCode,
-        count
-      )
-    } else if (statusCode === 429) {
-      log.error(
-        'Rate limited by trace intake (status 429). %d trace(s) dropped.',
-        count
-      )
-    } else if (statusCode >= 500) {
-      log.error(
-        'Trace intake server error (status %s). %d trace(s) dropped. This may be transient.',
-        statusCode,
-        count
-      )
-    } else if (statusCode) {
-      log.error(
-        'Error sending agentless payload (status %s): %s. %d trace(s) dropped.',
-        statusCode,
-        err.message,
-        count
-      )
-    } else {
-      log.error(
-        'Network error sending %d trace(s) to %s: %s',
-        count,
-        this._url?.hostname || 'unknown',
-        err.message
-      )
+  #applyConfiguration (apiKey) {
+    if (!canSendApiKey(this._url.protocol, this._url.hostname)) {
+      if (!this.#apiKeyUnsafeReceiver) {
+        this.#apiKeyUnsafeReceiver = true
+        log.warn('DD_API_KEY will not be sent because the configured receiver is neither HTTPS nor loopback.')
+      }
+      return
+    }
+    this.#apiKeyUnsafeReceiver = false
+
+    const { env, runtimeID } = this.#metadata
+    if (
+      this.#exporter &&
+      this.#exporterApiKey === apiKey &&
+      this.#exporterEnv === env &&
+      this.#exporterRuntimeId === runtimeID
+    ) {
+      return this.#exporter
     }
+
+    this.#closeExporter()
+    const config = getConfig()
+    const agent = this._url.protocol === 'https:' ? getHttpsProxyAgent(this._url) : undefined
+    this.#exporter = createAgentlessExporter({
+      endpoint: this.#endpoint(),
+      apiKey,
+      hostname: this.#metadata.hostname,
+      env,
+      service: config.service,
+      version: config.version,
+      runtimeId: runtimeID,
+      containerId: this.#metadata.containerId,
+      tracerVersion,
+      languageVersion: process.version,
+      languageInterpreter: process.versions.bun ? 'JavaScriptCore' : 'v8',
+    }, { agent })
+    this.#exporterApiKey = apiKey
+    this.#exporterEnv = env
+    this.#exporterRuntimeId = runtimeID
+    return this.#exporter
+  }
+
+  #closeExporter () {
+    this.#exporter?.close()
+    this.#exporter = undefined
+    this.#exporterApiKey = undefined
+    this.#exporterEnv = undefined
+    this.#exporterRuntimeId = undefined
   }
 }