dd-trace 5.123.0 → 6.11.0

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

@@ -22,26 +22,6 @@ function hasEntries (value) {
   return false
 }
 
-function validateTagsList (tags) {
-  if (tags == null) return []
-  if (!Array.isArray(tags)) throw new TypeError('Tags must be an array of strings')
-  for (const tag of tags) {
-    if (typeof tag !== 'string') throw new TypeError('Each tag must be a string')
-    if (tag.indexOf(':') <= 0) {
-      throw new Error(`Tag '${tag}' is malformed. Tags must be in 'key:value' format (e.g., 'env:prod').`)
-    }
-  }
-  return [...tags]
-}
-
-function tagOperationsAreEmpty (operations) {
-  return operations == null || (
-    !Object.hasOwn(operations, 'replace') &&
-    !Object.hasOwn(operations, 'add') &&
-    !Object.hasOwn(operations, 'remove')
-  )
-}
-
 /**
  * @param {string} name
  */
@@ -185,20 +165,16 @@ function stringify (value) {
  * @returns {string[]}
  */
 function buildTags (userTags, autoTags) {
-  const tagsByKey = new Map()
+  const tags = new Map()
   if ((userTags) != null) {
     for (const [key, value] of Object.entries(userTags)) {
-      const values = Array.isArray(value) ? value : [value]
-      tagsByKey.set(key, values.map(item => `${key}:${item}`))
+      tags.set(key, `${key}:${value}`)
     }
   }
   for (const [key, value] of Object.entries(autoTags)) {
-    if (value !== undefined && value !== null && value !== '') tagsByKey.set(key, [`${key}:${value}`])
+    if (value !== undefined && value !== null && value !== '') tags.set(key, `${key}:${value}`)
   }
-
-  const tags = []
-  for (const values of tagsByKey.values()) tags.push(...values)
-  return tags
+  return [...tags.values()]
 }
 
 /**
@@ -210,35 +186,6 @@ function mergeTags (baseTags, overrideTags) {
   return { ...baseTags, ...overrideTags }
 }
 
-/**
- * @param {string[] | undefined} tags
- * @returns {Record<string, string | string[]>}
- */
-function recordTagsToObject (tags) {
-  const result = {}
-  if (!Array.isArray(tags)) return result
-  for (const tag of tags) {
-    const separator = tag.indexOf(':')
-    if (separator <= 0) continue
-
-    const key = tag.slice(0, separator)
-    const value = tag.slice(separator + 1)
-    if (!Object.hasOwn(result, key)) {
-      Object.defineProperty(result, key, {
-        configurable: true,
-        enumerable: true,
-        value,
-        writable: true,
-      })
-    } else if (Array.isArray(result[key])) {
-      result[key].push(value)
-    } else {
-      result[key] = [result[key], value]
-    }
-  }
-  return result
-}
-
 /**
  * @param {number} ms
  * @returns {Promise<void>}
@@ -302,11 +249,8 @@ module.exports = {
   mergeTags,
   normalizeEvaluators,
   normalizeJsonMetricValue,
-  recordTagsToObject,
   sleep,
   stringify,
-  tagOperationsAreEmpty,
   timestampMs,
   validateEvaluatorName,
-  validateTagsList,
 }

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

@@ -1,6 +1,24 @@
 'use strict'
 
 module.exports = {
+  /**
+   * @constant
+   * @type {string} Base path for EVP proxy agent endpoint
+   */
+  EVP_PROXY_AGENT_BASE_PATH: '/evp_proxy/v2/',
+
+  /**
+   * @constant
+   * @type {string} HTTP header name for EVP subdomain routing
+   */
+  EVP_SUBDOMAIN_HEADER_NAME: 'X-Datadog-EVP-Subdomain',
+
+  /**
+   * @constant
+   * @type {string} EVP subdomain value for event platform intake
+   */
+  EVP_SUBDOMAIN_VALUE: 'event-platform-intake',
+
   /**
    * @constant
    * @type {string} API endpoint for exposure events EVP track

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

@@ -3,7 +3,7 @@
 const { channel } = require('dc-polyfill')
 const log = require('../log')
 const ExposuresWriter = require('./writers/exposures')
-const { setExposureDeliveryStrategy } = require('./writers/util')
+const { setAgentStrategy } = require('./writers/util')
 
 const exposureSubmitCh = channel('ffe:exposure:submit')
 const flushCh = channel('ffe:writers:flush')
@@ -40,15 +40,12 @@ function enable (config) {
     return
   }
 
-  const writer = new ExposuresWriter(config)
-  exposuresWriter = writer
+  exposuresWriter = new ExposuresWriter(config)
   exposureSubmitCh.subscribe(_handleExposureSubmit)
   flushCh.subscribe(_handleFlush)
 
-  setExposureDeliveryStrategy(config, (enabled, route) => {
-    if (exposuresWriter !== writer) return
-
-    writer.setEnabled(enabled, route)
+  setAgentStrategy(config, hasAgent => {
+    exposuresWriter?.setEnabled(hasAgent)
   })
 }
 

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

@@ -11,52 +11,14 @@ const log = require('../../log')
  * @property {number} [timeout] - Request timeout in milliseconds
  * @property {object} config - Tracer configuration object
  * @property {string} endpoint - API endpoint path
- * @property {URL} [agentUrl] - Initial delivery URL
+ * @property {URL} [agentUrl] - Base URL for the agent
  * @property {number} [payloadSizeLimit] - Maximum payload size in bytes
  * @property {number} [eventSizeLimit] - Maximum individual event size in bytes
  * @property {object} [headers] - Additional HTTP headers
  */
 
 /**
- * @typedef {object} WriterRoute
- * @property {URL} url - Route base URL
- * @property {string} endpoint - Route endpoint
- * @property {object} headers - Route-specific headers
- * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
- */
-
-/**
- * @typedef {object} ActiveWriterRoute
- * @property {URL} url - Route base URL
- * @property {string} endpoint - Route endpoint
- * @property {object} requestOptions - HTTP request options
- */
-
-/**
- * Tests whether a local route definitively rejected an event batch.
- *
- * @param {Error | null} error - Request error
- * @param {number | undefined} statusCode - HTTP response status
- * @returns {boolean} Whether direct retry is safe
- */
-function isDefinitiveRejection (error, statusCode) {
-  return error?.code === 'EAI_AGAIN' || error?.code === 'ECONNREFUSED' ||
-    error?.code === 'ENOENT' || error?.code === 'ENOTFOUND' ||
-    statusCode === 403 || statusCode === 404 || statusCode === 405
-}
-
-/**
- * Tests whether a local route can have accepted an event batch before failing.
- *
- * @param {Error | null} error - Request error
- * @returns {boolean} Whether the delivery result is ambiguous
- */
-function isAmbiguousNetworkFailure (error) {
-  return error?.code === 'ECONNRESET' || error?.code === 'EPIPE' || error?.code === 'ETIMEDOUT'
-}
-
-/**
- * Base writer for Feature Flagging and Experimentation event delivery.
+ * BaseFFEWriter is the base class for sending Feature Flagging & Exposure Events payloads to the Datadog Agent.
  * @class BaseFFEWriter
  */
 class BaseFFEWriter {
@@ -78,7 +40,6 @@ class BaseFFEWriter {
     this._payloadSizeLimit = payloadSizeLimit
     this._eventSizeLimit = eventSizeLimit
     this._headers = headers || {}
-    this._fallbackRoute = undefined
 
     this._requestOptions = {
       headers: {
@@ -86,7 +47,6 @@ class BaseFFEWriter {
         'Content-Type': 'application/json',
       },
       method: 'POST',
-      retry: true,
       timeout: this._timeout,
       url: this._baseUrl,
       path: this._endpoint,
@@ -155,8 +115,15 @@ class BaseFFEWriter {
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `${this.constructor.name} flushing payload: ${safeJSONStringify(payload)}`)
 
-    const route = this.#createActiveRoute()
-    this.#sendRequest(payload, events.length, route, this._fallbackRoute)
+    request(payload, this._requestOptions, (err, resp, code) => {
+      if (err) {
+        log.error('Failed to send events to %s%s', this._baseUrl.href, this._endpoint, err)
+      } else if (code >= 200 && code < 300) {
+        log.debug('Successfully sent %d events', events.length)
+      } else {
+        log.warn('Events request returned status %d', code)
+      }
+    })
   }
 
   /**
@@ -194,115 +161,6 @@ class BaseFFEWriter {
   _encode (payload) {
     return JSON.stringify(payload)
   }
-
-  /**
-   * Applies the active route and an optional direct fallback route.
-   *
-   * @param {WriterRoute} route - Active route
-   * @param {WriterRoute} [fallbackRoute] - Direct fallback route
-   * @returns {void}
-   */
-  _setRoutes (route, fallbackRoute) {
-    this.#activateRoute(this.#createRoute(route))
-    this._fallbackRoute = fallbackRoute ? this.#createRoute(fallbackRoute) : undefined
-  }
-
-  /**
-   * Creates request state for a configured writer route.
-   *
-   * @param {WriterRoute} route - Configured route
-   * @returns {ActiveWriterRoute} Active route state
-   */
-  #createRoute (route) {
-    return {
-      url: route.url,
-      endpoint: route.endpoint,
-      requestOptions: {
-        ...(route.agent && { agent: route.agent }),
-        headers: {
-          ...route.headers,
-          'Content-Type': 'application/json',
-        },
-        method: 'POST',
-        retry: true,
-        timeout: this._timeout,
-        url: route.url,
-        path: route.endpoint,
-      },
-    }
-  }
-
-  /**
-   * Captures the current route for one event batch.
-   *
-   * @returns {ActiveWriterRoute} Active route state
-   */
-  #createActiveRoute () {
-    return {
-      url: this._baseUrl,
-      endpoint: this._endpoint,
-      requestOptions: this._requestOptions,
-    }
-  }
-
-  /**
-   * Makes a route active for future event batches.
-   *
-   * @param {ActiveWriterRoute} route - Route state
-   * @returns {void}
-   */
-  #activateRoute (route) {
-    this._baseUrl = route.url
-    this._endpoint = route.endpoint
-    this._requestOptions = route.requestOptions
-  }
-
-  /**
-   * Sends an encoded batch and retries it through direct intake after a local route failure.
-   *
-   * @param {string} payload - Encoded event batch
-   * @param {number} eventCount - Event count
-   * @param {ActiveWriterRoute} route - Selected route
-   * @param {ActiveWriterRoute} [fallbackRoute] - Direct fallback route
-   * @returns {void}
-   */
-  #sendRequest (payload, eventCount, route, fallbackRoute) {
-    request(payload, route.requestOptions, (error, response, statusCode) => {
-      if (fallbackRoute && isDefinitiveRejection(error, statusCode)) {
-        log.debug(
-          '%s switching from %s%s to direct intake after definitive rejection',
-          this.constructor.name,
-          route.url.href,
-          route.endpoint
-        )
-        this.#activateRoute(fallbackRoute)
-        this._fallbackRoute = undefined
-        this.#sendRequest(payload, eventCount, fallbackRoute)
-        return
-      }
-
-      if (fallbackRoute && isAmbiguousNetworkFailure(error)) {
-        log.debug(
-          '%s retrying through direct intake and switching future batches from %s%s after ambiguous failure',
-          this.constructor.name,
-          route.url.href,
-          route.endpoint
-        )
-        this.#activateRoute(fallbackRoute)
-        this._fallbackRoute = undefined
-        this.#sendRequest(payload, eventCount, fallbackRoute)
-        return
-      }
-
-      if (error) {
-        log.error('Failed to send events to %s%s: %s', route.url.href, route.endpoint, error.message)
-      } else if (statusCode >= 200 && statusCode < 300) {
-        log.debug('Successfully sent %d events', eventCount)
-      } else {
-        log.warn('Events request returned status %d', statusCode)
-      }
-    })
-  }
 }
 
 module.exports = BaseFFEWriter

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

@@ -2,15 +2,12 @@
 
 const {
   EXPOSURES_ENDPOINT,
+  EVP_PROXY_AGENT_BASE_PATH,
+  EVP_SUBDOMAIN_HEADER_NAME,
+  EVP_SUBDOMAIN_VALUE,
   EVP_PAYLOAD_SIZE_LIMIT,
   EVP_EVENT_SIZE_LIMIT,
 } = require('../constants/constants')
-const {
-  EVP_EVENT_PLATFORM_SUBDOMAIN,
-  EVP_PROXY_PATH_V2,
-  EVP_SUBDOMAIN_HEADER_NAME,
-} = require('../../evp_proxy/constants')
-const { joinEVPProxyPath } = require('../../evp_proxy/path')
 const log = require('../../log')
 const BaseFFEWriter = require('./base')
 
@@ -19,15 +16,6 @@ const BaseFFEWriter = require('./base')
 // drop emits a warning and `droppedEventCount` accumulates the cumulative loss.
 const PENDING_MAX_EVENTS = 1000
 
-/**
- * @typedef {object} ExposureRoute
- * @property {URL} url - Route base URL
- * @property {string} basePath - EVP base path
- * @property {object} [headers] - Route-specific headers
- * @property {import('node:https').Agent} [agent] - Optional HTTPS proxy agent
- * @property {ExposureRoute} [fallback] - Optional direct fallback route
- */
-
 /**
  * @typedef {object} ExposureEvent
  * @property {number} timestamp - Unix timestamp in milliseconds
@@ -57,10 +45,10 @@ const PENDING_MAX_EVENTS = 1000
  */
 
 /**
- * Sends exposure events through the selected local EVP proxy or direct intake route.
+ * ExposuresWriter is responsible for sending exposure events to the Datadog Agent.
  */
 class ExposuresWriter extends BaseFFEWriter {
-  // Disabled until route selection resolves.
+  // Disabled until the agent strategy probe resolves.
   #enabled = false
 
   /** @type {ExposureEvent[]} */
@@ -73,27 +61,22 @@ class ExposuresWriter extends BaseFFEWriter {
 
   /**
    * @param {import('../../config/config-base')} config - Tracer configuration object
-   * @param {ExposureRoute} [route] - Caller-supplied route
    */
-  constructor (config, route) {
-    route ??= { url: config.url, basePath: EVP_PROXY_PATH_V2 }
-    const headers = route.headers ?? {
-      [EVP_SUBDOMAIN_HEADER_NAME]: EVP_EVENT_PLATFORM_SUBDOMAIN,
-    }
+  constructor (config) {
+    const basePath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/$/, '')
+    const endpoint = EXPOSURES_ENDPOINT.replace(/^\/+/, '')
+    const fullEndpoint = `${basePath}/${endpoint}`
 
     super({
       config,
-      agentUrl: route.url,
-      endpoint: joinEVPProxyPath(route.basePath, EXPOSURES_ENDPOINT),
+      endpoint: fullEndpoint,
       payloadSizeLimit: EVP_PAYLOAD_SIZE_LIMIT,
       eventSizeLimit: EVP_EVENT_SIZE_LIMIT,
-      headers,
+      headers: {
+        [EVP_SUBDOMAIN_HEADER_NAME]: EVP_SUBDOMAIN_VALUE,
+      },
     })
 
-    if (route.agent || route.fallback) {
-      this.#setRoute({ ...route, headers })
-    }
-
     /** @type {ExposureContext} */
     const context = {
       service: config.service,
@@ -112,14 +95,8 @@ class ExposuresWriter extends BaseFFEWriter {
 
   /**
    * @param {boolean} enabled - Whether to enable the writer
-   * @param {ExposureRoute} [route] - Selected EVP route
-   * @returns {void}
    */
-  setEnabled (enabled, route) {
-    if (route) {
-      this.#setRoute(route)
-    }
-
+  setEnabled (enabled) {
     this.#enabled = enabled
 
     if (enabled && this.#pendingEvents.length > 0) {
@@ -129,31 +106,6 @@ class ExposuresWriter extends BaseFFEWriter {
     }
   }
 
-  /**
-   * Applies caller-supplied route data without performing discovery.
-   *
-   * @param {ExposureRoute} route - Selected EVP route
-   * @returns {void}
-   */
-  #setRoute (route) {
-    const fallbackRoute = route.fallback && {
-      url: route.fallback.url,
-      endpoint: joinEVPProxyPath(route.fallback.basePath, EXPOSURES_ENDPOINT),
-      headers: route.fallback.headers ?? {},
-      agent: route.fallback.agent,
-    }
-    const headers = route.headers ?? {
-      [EVP_SUBDOMAIN_HEADER_NAME]: EVP_EVENT_PLATFORM_SUBDOMAIN,
-    }
-
-    this._setRoutes({
-      url: route.url,
-      endpoint: joinEVPProxyPath(route.basePath, EXPOSURES_ENDPOINT),
-      headers,
-      agent: route.agent,
-    }, fallbackRoute)
-  }
-
   /**
    * Appends exposure event(s) to the buffer
    * @param {ExposureEvent|ExposureEvent[]} events - Exposure event(s) to append

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

@@ -1,51 +1,30 @@
 'use strict'
 
-const {
-  EVP_EVENT_PLATFORM_SUBDOMAIN,
-  EVP_PROXY_PATH_V2,
-  EVP_PROXY_PATH_V4,
-  EVP_SUBDOMAIN_HEADER_NAME,
-} = require('../../evp_proxy/constants')
-const { createDirectEVPRoute } = require('../../evp_proxy/direct')
-const { discoverEVPProxy } = require('../../evp_proxy/discovery')
 const logger = require('../../log')
-
-let missingRouteWarningLogged = false
+const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/constants')
+const { fetchAgentInfo } = require('../../agent/info')
 
 /**
- * Logs the unavailable exposure-delivery warning once.
- *
- * @returns {void}
- */
-function warnExposureDeliveryUnavailable () {
-  if (missingRouteWarningLogged) return
-  missingRouteWarningLogged = true
-  logger.warn(
-    'Feature Flags exposure delivery is disabled because no compatible local EVP route or direct intake ' +
-    'credentials are available.'
-  )
-}
-
-/**
- * Preserves Agent exposure delivery for the Remote Configuration source.
- *
+ * Determines if the agent supports EVP proxy and sets the writer enabled state accordingly
  * @param {import('../../config')} config - Tracer configuration object
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
- * @returns {void}
  */
 function setAgentStrategy (config, setWriterEnabledValue) {
-  discoverEVPProxy(config.url, {
-    supportedPaths: [EVP_PROXY_PATH_V2],
-  }, (error, route) => {
-    if (error) {
-      logger.debug('FFE Writer disabled - error getting agent info: %s', error.message)
+  fetchAgentInfo(config.url, (err, agentInfo) => {
+    if (err) {
+      logger.debug('FFE Writer disabled - error getting agent info:', err.message)
       setWriterEnabledValue(false)
       return
     }
 
-    if (route) {
+    const endpoints = agentInfo.endpoints
+    const normalizedPath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/$/, '')
+    const hasEndpoint = Array.isArray(endpoints) &&
+      endpoints.includes(normalizedPath) || endpoints.includes(normalizedPath + '/')
+
+    if (hasEndpoint) {
       logger.debug('FFE Writer enabled - agent has EVP proxy support')
-      setWriterEnabledValue(true, route)
+      setWriterEnabledValue(true)
     } else {
       logger.debug('FFE Writer disabled - agent does not have EVP proxy support')
       setWriterEnabledValue(false)
@@ -53,67 +32,6 @@ function setAgentStrategy (config, setWriterEnabledValue) {
   })
 }
 
-/**
- * Selects a local serverless receiver or authenticated direct intake.
- *
- * Local discovery is optional for delivery. A missing listener, discovery
- * error, or incompatible receiver selects direct intake when credentials exist.
- *
- * @param {import('../../config')} config - Tracer configuration object
- * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
- * @returns {void}
- */
-function setAgentlessStrategy (config, setWriterEnabledValue) {
-  const directRoute = createDirectEVPRoute(config, EVP_EVENT_PLATFORM_SUBDOMAIN)
-
-  discoverEVPProxy(config.url, {
-    supportedPaths: [EVP_PROXY_PATH_V4, EVP_PROXY_PATH_V2],
-  }, (error, localRoute) => {
-    if (localRoute) {
-      const route = {
-        ...localRoute,
-        headers: {
-          [EVP_SUBDOMAIN_HEADER_NAME]: EVP_EVENT_PLATFORM_SUBDOMAIN,
-        },
-        ...(directRoute && { fallback: directRoute }),
-      }
-      logger.debug('FFE Writer enabled with local EVP route %s', route.basePath)
-      setWriterEnabledValue(true, route)
-      return
-    }
-
-    if (directRoute) {
-      if (error) {
-        logger.debug('FFE Writer using direct EVP intake after local discovery failed: %s', error.message)
-      } else {
-        logger.debug('FFE Writer using direct EVP intake because no compatible local route was advertised')
-      }
-      setWriterEnabledValue(true, directRoute)
-      return
-    }
-
-    if (error) {
-      logger.debug('FFE Writer disabled - error getting local receiver info: %s', error.message)
-    }
-    warnExposureDeliveryUnavailable()
-    setWriterEnabledValue(false)
-  })
+module.exports = {
+  setAgentStrategy,
 }
-
-/**
- * Applies the exposure-delivery strategy for the configured Feature Flags source.
- *
- * @param {import('../../config')} config - Tracer configuration object
- * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
- * @returns {void}
- */
-function setExposureDeliveryStrategy (config, setWriterEnabledValue) {
-  if (config.featureFlags?.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE === 'agentless') {
-    setAgentlessStrategy(config, setWriterEnabledValue)
-    return
-  }
-
-  setAgentStrategy(config, setWriterEnabledValue)
-}
-
-module.exports = { setExposureDeliveryStrategy }

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -543,8 +543,7 @@ class TextMapPropagator {
     this._extractOrigin(carrier, spanContext)
     this._extractLegacyBaggageItems(carrier, spanContext)
     this._extractSamplingPriority(carrier, spanContext)
-    const traceTags = this._extractTags(carrier)
-    if (traceTags) spanContext._trace.tags = traceTags
+    this._extractTags(carrier, spanContext)
 
     if (this._config.DD_TRACE_PROPAGATION_EXTRACT_FIRST) return spanContext
 
@@ -866,45 +865,37 @@ class TextMapPropagator {
     }
   }
 
-  /**
-   * @param {Record<string, unknown>} carrier
-   * @returns {Record<string, string> | undefined}
-   */
-  _extractTags (carrier) {
+  _extractTags (carrier, spanContext) {
     const header = readDatadogTags(carrier)
     if (!header) return
 
+    const trace = spanContext._trace
+
     if (this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH === 0) {
       log.debug('Trace tag propagation is disabled, skipping extraction.')
     } else if (header.length > this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH) {
       log.error('Trace tags from carrier are too large, skipping extraction.')
     } else {
+      const pairs = header.split(',')
       const tags = {}
-      let start = 0
-      let separator = header.indexOf('=')
 
-      while (start <= header.length) {
-        const comma = header.indexOf(',', start)
-        const end = comma === -1 ? header.length : comma
-        const hasSeparator = separator !== -1 && separator < end
-        const key = header.slice(start, hasSeparator ? separator : end)
-        const value = hasSeparator ? header.slice(separator + 1, end) : ''
+      for (const pair of pairs) {
+        const [key, ...rest] = pair.split('=')
+        const value = rest.join('=')
 
         if (!this._validateTagKey(key) || !this._validateTagValue(value)) {
           log.error('Trace tags from carrier are invalid, skipping extraction.')
           return
         }
-        if (key === '_dd.p.tid' && !hex16.test(value)) {
+        // Check if value is a valid 16 character lower-case hexadecimal encoded number as per spec
+        if (key === '_dd.p.tid' && !(hex16.test(value))) {
           log.error('Invalid _dd.p.tid tag %s, skipping', value)
-        } else {
-          tags[key] = value
+          continue
         }
-
-        start = end + 1
-        if (hasSeparator) separator = header.indexOf('=', start)
+        tags[key] = value
       }
 
-      return tags
+      Object.assign(trace.tags, tags)
     }
   }