dd-trace 6.11.0 → 6.12.0

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

@@ -22,6 +22,26 @@ 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
  */
@@ -165,16 +185,20 @@ function stringify (value) {
  * @returns {string[]}
  */
 function buildTags (userTags, autoTags) {
-  const tags = new Map()
+  const tagsByKey = new Map()
   if ((userTags) != null) {
     for (const [key, value] of Object.entries(userTags)) {
-      tags.set(key, `${key}:${value}`)
+      const values = Array.isArray(value) ? value : [value]
+      tagsByKey.set(key, values.map(item => `${key}:${item}`))
     }
   }
   for (const [key, value] of Object.entries(autoTags)) {
-    if (value !== undefined && value !== null && value !== '') tags.set(key, `${key}:${value}`)
+    if (value !== undefined && value !== null && value !== '') tagsByKey.set(key, [`${key}:${value}`])
   }
-  return [...tags.values()]
+
+  const tags = []
+  for (const values of tagsByKey.values()) tags.push(...values)
+  return tags
 }
 
 /**
@@ -186,6 +210,35 @@ 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>}
@@ -249,8 +302,11 @@ module.exports = {
   mergeTags,
   normalizeEvaluators,
   normalizeJsonMetricValue,
+  recordTagsToObject,
   sleep,
   stringify,
+  tagOperationsAreEmpty,
   timestampMs,
   validateEvaluatorName,
+  validateTagsList,
 }

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

@@ -1,24 +1,6 @@
 '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 { setAgentStrategy } = require('./writers/util')
+const { setExposureDeliveryStrategy } = require('./writers/util')
 
 const exposureSubmitCh = channel('ffe:exposure:submit')
 const flushCh = channel('ffe:writers:flush')
@@ -40,12 +40,15 @@ function enable (config) {
     return
   }
 
-  exposuresWriter = new ExposuresWriter(config)
+  const writer = new ExposuresWriter(config)
+  exposuresWriter = writer
   exposureSubmitCh.subscribe(_handleExposureSubmit)
   flushCh.subscribe(_handleFlush)
 
-  setAgentStrategy(config, hasAgent => {
-    exposuresWriter?.setEnabled(hasAgent)
+  setExposureDeliveryStrategy(config, (enabled, route) => {
+    if (exposuresWriter !== writer) return
+
+    writer.setEnabled(enabled, route)
   })
 }
 

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

@@ -11,14 +11,52 @@ 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] - Base URL for the agent
+ * @property {URL} [agentUrl] - Initial delivery URL
  * @property {number} [payloadSizeLimit] - Maximum payload size in bytes
  * @property {number} [eventSizeLimit] - Maximum individual event size in bytes
  * @property {object} [headers] - Additional HTTP headers
  */
 
 /**
- * BaseFFEWriter is the base class for sending Feature Flagging & Exposure Events payloads to the Datadog Agent.
+ * @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.
  * @class BaseFFEWriter
  */
 class BaseFFEWriter {
@@ -40,6 +78,7 @@ class BaseFFEWriter {
     this._payloadSizeLimit = payloadSizeLimit
     this._eventSizeLimit = eventSizeLimit
     this._headers = headers || {}
+    this._fallbackRoute = undefined
 
     this._requestOptions = {
       headers: {
@@ -47,6 +86,7 @@ class BaseFFEWriter {
         'Content-Type': 'application/json',
       },
       method: 'POST',
+      retry: true,
       timeout: this._timeout,
       url: this._baseUrl,
       path: this._endpoint,
@@ -115,15 +155,8 @@ class BaseFFEWriter {
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `${this.constructor.name} flushing payload: ${safeJSONStringify(payload)}`)
 
-    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)
-      }
-    })
+    const route = this.#createActiveRoute()
+    this.#sendRequest(payload, events.length, route, this._fallbackRoute)
   }
 
   /**
@@ -161,6 +194,115 @@ 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,12 +2,15 @@
 
 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')
 
@@ -16,6 +19,15 @@ 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
@@ -45,10 +57,10 @@ const PENDING_MAX_EVENTS = 1000
  */
 
 /**
- * ExposuresWriter is responsible for sending exposure events to the Datadog Agent.
+ * Sends exposure events through the selected local EVP proxy or direct intake route.
  */
 class ExposuresWriter extends BaseFFEWriter {
-  // Disabled until the agent strategy probe resolves.
+  // Disabled until route selection resolves.
   #enabled = false
 
   /** @type {ExposureEvent[]} */
@@ -61,22 +73,27 @@ class ExposuresWriter extends BaseFFEWriter {
 
   /**
    * @param {import('../../config/config-base')} config - Tracer configuration object
+   * @param {ExposureRoute} [route] - Caller-supplied route
    */
-  constructor (config) {
-    const basePath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/$/, '')
-    const endpoint = EXPOSURES_ENDPOINT.replace(/^\/+/, '')
-    const fullEndpoint = `${basePath}/${endpoint}`
+  constructor (config, route) {
+    route ??= { url: config.url, basePath: EVP_PROXY_PATH_V2 }
+    const headers = route.headers ?? {
+      [EVP_SUBDOMAIN_HEADER_NAME]: EVP_EVENT_PLATFORM_SUBDOMAIN,
+    }
 
     super({
       config,
-      endpoint: fullEndpoint,
+      agentUrl: route.url,
+      endpoint: joinEVPProxyPath(route.basePath, EXPOSURES_ENDPOINT),
       payloadSizeLimit: EVP_PAYLOAD_SIZE_LIMIT,
       eventSizeLimit: EVP_EVENT_SIZE_LIMIT,
-      headers: {
-        [EVP_SUBDOMAIN_HEADER_NAME]: EVP_SUBDOMAIN_VALUE,
-      },
+      headers,
     })
 
+    if (route.agent || route.fallback) {
+      this.#setRoute({ ...route, headers })
+    }
+
     /** @type {ExposureContext} */
     const context = {
       service: config.service,
@@ -95,8 +112,14 @@ class ExposuresWriter extends BaseFFEWriter {
 
   /**
    * @param {boolean} enabled - Whether to enable the writer
+   * @param {ExposureRoute} [route] - Selected EVP route
+   * @returns {void}
    */
-  setEnabled (enabled) {
+  setEnabled (enabled, route) {
+    if (route) {
+      this.#setRoute(route)
+    }
+
     this.#enabled = enabled
 
     if (enabled && this.#pendingEvents.length > 0) {
@@ -106,6 +129,31 @@ 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,30 +1,51 @@
 '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')
-const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/constants')
-const { fetchAgentInfo } = require('../../agent/info')
+
+let missingRouteWarningLogged = false
 
 /**
- * Determines if the agent supports EVP proxy and sets the writer enabled state accordingly
+ * 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.
+ *
  * @param {import('../../config')} config - Tracer configuration object
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
+ * @returns {void}
  */
 function setAgentStrategy (config, setWriterEnabledValue) {
-  fetchAgentInfo(config.url, (err, agentInfo) => {
-    if (err) {
-      logger.debug('FFE Writer disabled - error getting agent info:', err.message)
+  discoverEVPProxy(config.url, {
+    supportedPaths: [EVP_PROXY_PATH_V2],
+  }, (error, route) => {
+    if (error) {
+      logger.debug('FFE Writer disabled - error getting agent info: %s', error.message)
       setWriterEnabledValue(false)
       return
     }
 
-    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) {
+    if (route) {
       logger.debug('FFE Writer enabled - agent has EVP proxy support')
-      setWriterEnabledValue(true)
+      setWriterEnabledValue(true, route)
     } else {
       logger.debug('FFE Writer disabled - agent does not have EVP proxy support')
       setWriterEnabledValue(false)
@@ -32,6 +53,67 @@ function setAgentStrategy (config, setWriterEnabledValue) {
   })
 }
 
-module.exports = {
-  setAgentStrategy,
+/**
+ * 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)
+  })
 }
+
+/**
+ * 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,7 +543,8 @@ class TextMapPropagator {
     this._extractOrigin(carrier, spanContext)
     this._extractLegacyBaggageItems(carrier, spanContext)
     this._extractSamplingPriority(carrier, spanContext)
-    this._extractTags(carrier, spanContext)
+    const traceTags = this._extractTags(carrier)
+    if (traceTags) spanContext._trace.tags = traceTags
 
     if (this._config.DD_TRACE_PROPAGATION_EXTRACT_FIRST) return spanContext
 
@@ -865,37 +866,45 @@ class TextMapPropagator {
     }
   }
 
-  _extractTags (carrier, spanContext) {
+  /**
+   * @param {Record<string, unknown>} carrier
+   * @returns {Record<string, string> | undefined}
+   */
+  _extractTags (carrier) {
     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('=')
 
-      for (const pair of pairs) {
-        const [key, ...rest] = pair.split('=')
-        const value = rest.join('=')
+      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) : ''
 
         if (!this._validateTagKey(key) || !this._validateTagValue(value)) {
           log.error('Trace tags from carrier are invalid, skipping extraction.')
           return
         }
-        // Check if value is a valid 16 character lower-case hexadecimal encoded number as per spec
-        if (key === '_dd.p.tid' && !(hex16.test(value))) {
+        if (key === '_dd.p.tid' && !hex16.test(value)) {
           log.error('Invalid _dd.p.tid tag %s, skipping', value)
-          continue
+        } else {
+          tags[key] = value
         }
-        tags[key] = value
+
+        start = end + 1
+        if (hasSeparator) separator = header.indexOf('=', start)
       }
 
-      Object.assign(trace.tags, tags)
+      return tags
     }
   }