dd-trace 5.45.0 → 5.47.0

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

@@ -2,34 +2,64 @@
 
 const fs = require('fs')
 
+const { DD_EXTERNAL_ENV } = process.env
+
 // The second part is the PCF / Garden regexp. We currently assume no suffix($) to avoid matching pod UIDs
 // See https://github.com/DataDog/datadog-agent/blob/7.40.x/pkg/util/cgroups/reader.go#L50
 const uuidSource =
 '[0-9a-f]{8}[-_][0-9a-f]{4}[-_][0-9a-f]{4}[-_][0-9a-f]{4}[-_][0-9a-f]{12}|[0-9a-f]{8}(?:-[0-9a-f]{4}){4}$'
 const containerSource = '[0-9a-f]{64}'
 const taskSource = '[0-9a-f]{32}-\\d+'
+const lineReg = /^(\d+):([^:]*):(.+)$/
 const entityReg = new RegExp(`.*(${uuidSource}|${containerSource}|${taskSource})(?:\\.scope)?$`, 'm')
 
+const cgroup = readControlGroup()
 const entityId = getEntityId()
+const inode = getInode()
 
 function getEntityId () {
-  const cgroup = readControlGroup() || ''
-  const match = cgroup.trim().match(entityReg) || []
+  const match = cgroup.match(entityReg) || []
 
   return match[1]
 }
 
+function getInode () {
+  const match = cgroup.match(lineReg) || []
+
+  return readInode(match[3])
+}
+
 function readControlGroup () {
   try {
-    return fs.readFileSync('/proc/self/cgroup').toString()
+    return fs.readFileSync('/proc/self/cgroup').toString().trim()
+  } catch (err) {
+    return ''
+  }
+}
+
+function readInode (path) {
+  if (!path) return 0
+
+  const strippedPath = path.replace(/^\//, '').replace(/\/$/, '')
+
+  try {
+    return fs.statSync(`/sys/fs/cgroup/${strippedPath}`).ino
   } catch (err) {
-    // ignore
+    return 0
   }
 }
 
 module.exports = {
-  // can be the container ID but not always depending on the orchestrator
-  id () {
-    return entityId
+  inject (carrier) {
+    if (entityId) {
+      carrier['Datadog-Container-Id'] = entityId
+      carrier['Datadog-Entity-ID'] = `ci-${entityId}`
+    } else if (inode) {
+      carrier['Datadog-Entity-ID'] = `in-${inode}`
+    }
+
+    if (DD_EXTERNAL_ENV) {
+      carrier['Datadog-External-Env'] = DD_EXTERNAL_ENV
+    }
   }
 }

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

@@ -15,7 +15,6 @@ const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
 
 const maxActiveRequests = 8
-const containerId = docker.id()
 
 let activeRequests = 0
 
@@ -63,9 +62,7 @@ function request (data, options, callback) {
     options.headers['Content-Length'] = byteLength(dataArray)
   }
 
-  if (containerId) {
-    options.headers['Datadog-Container-ID'] = containerId
-  }
+  docker.inject(options.headers)
 
   options.agent = isSecure ? httpsAgent : httpAgent
 

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

@@ -22,7 +22,9 @@ const PROCESS_ID = constants.PROCESS_ID
 const ERROR_MESSAGE = constants.ERROR_MESSAGE
 const ERROR_STACK = constants.ERROR_STACK
 const ERROR_TYPE = constants.ERROR_TYPE
+const { IGNORE_OTEL_ERROR } = constants
 
+// TODO(BridgeAR)[31.03.2025]: Should these land in the constants file?
 const map = {
   'operation.name': 'name',
   'service.name': 'service',
@@ -69,48 +71,46 @@ function setSingleSpanIngestionTags (span, options) {
 }
 
 function extractSpanLinks (formattedSpan, span) {
-  const links = []
-  if (span._links) {
-    for (const link of span._links) {
-      const { context, attributes } = link
-      const formattedLink = {}
-
-      formattedLink.trace_id = context.toTraceId(true)
-      formattedLink.span_id = context.toSpanId(true)
-
-      if (attributes && Object.keys(attributes).length > 0) {
-        formattedLink.attributes = attributes
-      }
-      if (context?._sampling?.priority >= 0) formattedLink.flags = context._sampling.priority > 0 ? 1 : 0
-      if (context?._tracestate) formattedLink.tracestate = context._tracestate.toString()
+  if (!span._links?.length) {
+    return
+  }
+  const links = span._links.map(link => {
+    const { context, attributes } = link
+    const formattedLink = {
+      trace_id: context.toTraceId(true),
+      span_id: context.toSpanId(true)
+    }
 
-      links.push(formattedLink)
+    if (attributes && Object.keys(attributes).length > 0) {
+      formattedLink.attributes = attributes
     }
-  }
-  if (links.length > 0) { formattedSpan.meta['_dd.span_links'] = JSON.stringify(links) }
+    if (context?._sampling?.priority >= 0) formattedLink.flags = context._sampling.priority > 0 ? 1 : 0
+    if (context?._tracestate) formattedLink.tracestate = context._tracestate.toString()
+
+    return formattedLink
+  })
+  formattedSpan.meta['_dd.span_links'] = JSON.stringify(links)
 }
 
 function extractSpanEvents (formattedSpan, span) {
-  const events = []
-  if (span._events) {
-    for (const event of span._events) {
-      const formattedEvent = {
-        name: event.name,
-        time_unix_nano: Math.round(event.startTime * 1e6),
-        attributes: event.attributes && Object.keys(event.attributes).length > 0 ? event.attributes : undefined
-      }
-
-      events.push(formattedEvent)
-    }
-  }
-  if (events.length > 0) {
-    formattedSpan.span_events = events
+  if (!span._events?.length) {
+    return
   }
+  const events = span._events.map(event => {
+    return {
+      name: event.name,
+      time_unix_nano: Math.round(event.startTime * 1e6),
+      attributes: event.attributes && Object.keys(event.attributes).length > 0 ? event.attributes : undefined
+    }
+  })
+  formattedSpan.span_events = events
 }
 
 function extractTags (formattedSpan, span) {
   const context = span.context()
   const origin = context._trace.origin
+  // TODO(BridgeAR)[31.03.2025]: Look into changing the way we store tags. Using
+  // a map is likely faster short term.
   const tags = context._tags
   const hostname = context._hostname
   const priority = context._sampling.priority
@@ -126,43 +126,48 @@ function extractTags (formattedSpan, span) {
     registerExtraService(tags['service.name'])
   }
 
-  for (const tag in tags) {
+  for (const [tag, value] of Object.entries(tags)) {
+    // TODO(BridgeAR)[31.03.2025]: Check how many tags are defined in average.
+    // In case there are more than 2 tags in average, check for all special
+    // cases up front and loop over the tags afterwards, skipping the already
+    // visited property names by checking a map with these keys.
     switch (tag) {
       case 'service.name':
       case 'span.type':
       case 'resource.name':
-        addTag(formattedSpan, {}, map[tag], tags[tag])
+        addTag(formattedSpan, {}, map[tag], value)
         break
       // HACK: remove when Datadog supports numeric status code
       case 'http.status_code':
-        addTag(formattedSpan.meta, {}, tag, tags[tag] && String(tags[tag]))
+        addTag(formattedSpan.meta, {}, tag, value && String(value))
         break
       case 'analytics.event':
-        addTag({}, formattedSpan.metrics, ANALYTICS, tags[tag] === undefined || tags[tag] ? 1 : 0)
+        addTag({}, formattedSpan.metrics, ANALYTICS, value === undefined || value ? 1 : 0)
         break
       case HOSTNAME_KEY:
       case MEASURED:
-        addTag({}, formattedSpan.metrics, tag, tags[tag] === undefined || tags[tag] ? 1 : 0)
+        addTag({}, formattedSpan.metrics, tag, value === undefined || value ? 1 : 0)
         break
+      // TODO(BridgeAR)[31.03.2025]: How come we use two different ways to pass
+      // through errors? Can we just unify the behavior to always use one way?
       case 'error':
         if (context._name !== 'fs.operation') {
-          extractError(formattedSpan, tags[tag])
+          extractError(formattedSpan, value)
         }
         break
       case ERROR_TYPE:
       case ERROR_MESSAGE:
       case ERROR_STACK:
         // HACK: remove when implemented in the backend
-        if (context._name !== 'fs.operation') {
-          // HACK: to ensure otel.recordException does not influence formattedSpan.error
-          if (tags.setTraceError) {
-            formattedSpan.error = 1
-          }
-        } else {
+        if (context._name === 'fs.operation') {
           break
         }
+        // otel.recordException should not influence trace.error
+        if (!tags[IGNORE_OTEL_ERROR]) {
+          formattedSpan.error = 1
+        }
       default: // eslint-disable-line no-fallthrough
-        addTag(formattedSpan.meta, formattedSpan.metrics, tag, tags[tag])
+        addTag(formattedSpan.meta, formattedSpan.metrics, tag, value)
     }
   }
   setSingleSpanIngestionTags(formattedSpan, context._spanSampling)
@@ -193,8 +198,8 @@ function extractChunkTags (formattedSpan, span) {
 
   if (!isLocalRoot) return
 
-  for (const key in context._trace.tags) {
-    addTag(formattedSpan.meta, formattedSpan.metrics, key, context._trace.tags[key])
+  for (const [key, value] of Object.entries(context._trace.tags)) {
+    addTag(formattedSpan.meta, formattedSpan.metrics, key, value)
   }
 }
 
@@ -205,6 +210,8 @@ function extractError (formattedSpan, error) {
 
   if (isError(error)) {
     // AggregateError only has a code and no message.
+    // TODO(BridgeAR)[31.03.2025]: An AggregateError can have a message. Should
+    // the code just generally be added, if available?
     addTag(formattedSpan.meta, formattedSpan.metrics, ERROR_MESSAGE, error.message || error.code)
     addTag(formattedSpan.meta, formattedSpan.metrics, ERROR_TYPE, error.name)
     addTag(formattedSpan.meta, formattedSpan.metrics, ERROR_STACK, error.stack)
@@ -223,30 +230,21 @@ function addTag (meta, metrics, key, value, nested) {
     case 'boolean':
       metrics[key] = value ? 1 : 0
       break
-    case 'undefined':
-      break
-    case 'object':
-      if (value === null) break
+    default:
+      if (value == null) break
 
       // Special case for Node.js Buffer and URL
+      // TODO(BridgeAR)[31.03.2025]: Figure out if all typed arrays should be treated as buffers.
       if (isNodeBuffer(value) || isUrl(value)) {
         metrics[key] = value.toString()
       } else if (!Array.isArray(value) && !nested) {
-        for (const prop in value) {
-          if (!hasOwn(value, prop)) continue
-
-          addTag(meta, metrics, `${key}.${prop}`, value[prop], true)
+        for (const [prop, val] of Object.entries(value)) {
+          addTag(meta, metrics, `${key}.${prop}`, val, true)
         }
       }
-
-      break
   }
 }
 
-function hasOwn (object, prop) {
-  return Object.prototype.hasOwnProperty.call(object, prop)
-}
-
 function isNodeBuffer (obj) {
   return obj.constructor && obj.constructor.name === 'Buffer' &&
     typeof obj.readInt8 === 'function' &&

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

@@ -37,13 +37,13 @@ class LLMObsPlugin extends TracingPlugin {
     // register options may not be set for operations we do not trace with llmobs
     // ie OpenAI fine tuning jobs, file jobs, etc.
     if (registerOptions) {
-      telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: this.constructor.id })
+      telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: this.constructor.integration })
 
       ctx.llmobs = {} // initialize context-based namespace
       llmobsStorage.enterWith({ span })
       ctx.llmobs.parent = parent
 
-      this._tagger.registerLLMObsSpan(span, { parent, integration: this.constructor.id, ...registerOptions })
+      this._tagger.registerLLMObsSpan(span, { parent, integration: this.constructor.integration, ...registerOptions })
     }
   }
 

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

@@ -20,7 +20,8 @@ const ChatModelHandler = require('./handlers/chat_model')
 const LlmHandler = require('./handlers/llm')
 const EmbeddingHandler = require('./handlers/embedding')
 
-class LangChainLLMObsPlugin extends LLMObsPlugin {
+class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
+  static get integration () { return 'langchain' }
   static get id () { return 'langchain' }
   static get prefix () {
     return 'tracing:apm:langchain:invoke'
@@ -55,8 +56,11 @@ class LangChainLLMObsPlugin extends LLMObsPlugin {
   }
 
   setLLMObsTags (ctx) {
+    ctx.args = ctx.arguments
+    ctx.instance = ctx.self
+
     const span = ctx.currentStore?.span
-    const type = ctx.type // langchain operation type (oneof chain,chat_model,llm,embedding)
+    const type = ctx.type = this.constructor.lcType // langchain operation type (oneof chain,chat_model,llm,embedding)
 
     if (!Object.keys(this._handlers).includes(type)) {
       log.warn(`Unsupported LangChain operation type: ${type}`)
@@ -129,4 +133,59 @@ class LangChainLLMObsPlugin extends LLMObsPlugin {
   }
 }
 
-module.exports = LangChainLLMObsPlugin
+class RunnableSequenceInvokePlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_rs_invoke' }
+  static get lcType () { return 'chain' }
+  static get prefix () {
+    return 'tracing:orchestrion:@langchain/core:RunnableSequence_invoke'
+  }
+}
+
+class RunnableSequenceBatchPlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_rs_batch' }
+  static get lcType () { return 'chain' }
+  static get prefix () {
+    return 'tracing:orchestrion:@langchain/core:RunnableSequence_batch'
+  }
+}
+
+class BaseChatModelGeneratePlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_chat_model_generate' }
+  static get lcType () { return 'chat_model' }
+  static get prefix () {
+    return 'tracing:orchestrion:@langchain/core:BaseChatModel_generate'
+  }
+}
+
+class BaseLLMGeneratePlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_llm_generate' }
+  static get lcType () { return 'llm' }
+  static get prefix () {
+    return 'tracing:orchestrion:@langchain/core:BaseLLM_generate'
+  }
+}
+
+class EmbeddingsEmbedQueryPlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_embeddings_embed_query' }
+  static get lcType () { return 'embedding' }
+  static get prefix () {
+    return 'tracing:apm:@langchain/core:Embeddings_embedQuery'
+  }
+}
+
+class EmbeddingsEmbedDocumentsPlugin extends BaseLangChainLLMObsPlugin {
+  static get id () { return 'llmobs_langchain_embeddings_embed_documents' }
+  static get lcType () { return 'embedding' }
+  static get prefix () {
+    return 'tracing:apm:@langchain/core:Embeddings_embedDocuments'
+  }
+}
+
+module.exports = [
+  RunnableSequenceInvokePlugin,
+  RunnableSequenceBatchPlugin,
+  BaseChatModelGeneratePlugin,
+  BaseLLMGeneratePlugin,
+  EmbeddingsEmbedQueryPlugin,
+  EmbeddingsEmbedDocumentsPlugin
+]

package/packages/dd-trace/src/llmobs/plugins/openai.js

@@ -11,6 +11,7 @@ function isIterable (obj) {
 
 class OpenAiLLMObsPlugin extends LLMObsPlugin {
   static get id () { return 'openai' }
+  static get integration () { return 'openai' }
   static get prefix () {
     return 'tracing:apm:openai:request'
   }

package/packages/dd-trace/src/llmobs/plugins/vertexai.js

@@ -7,7 +7,8 @@ const {
 } = require('../../../../datadog-plugin-google-cloud-vertexai/src/utils')
 
 class VertexAILLMObsPlugin extends LLMObsPlugin {
-  static get id () { return 'vertexai' } // used for llmobs telemetry
+  static get integration () { return 'vertexai' } // used for llmobs telemetry
+  static get id () { return 'vertexai' }
   static get prefix () {
     return 'tracing:apm:vertexai:request'
   }

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

@@ -41,12 +41,12 @@ class LLMObsSpanWriter extends BaseWriter {
   }
 
   makePayload (events) {
-    return {
+    return events.map(event => ({
       '_dd.stage': 'raw',
       '_dd.tracer_version': tracerVersion,
       event_type: this._eventType,
-      spans: events
-    }
+      spans: [event]
+    }))
   }
 
   _truncateSpanEvent (event) {

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

@@ -121,6 +121,8 @@ const log = {
   }
 }
 
+logWriter.setStackTraceLimitFunction(log.error)
+
 log.reset()
 
 log.toggle(log.isEnabled(), log.getLogLevel())

package/packages/dd-trace/src/log/writer.js

@@ -13,6 +13,7 @@ const defaultLogger = {
 let enabled = false
 let logger = defaultLogger
 let logChannel = new LogChannel()
+let stackTraceLimitFunction = onError
 
 function withNoop (fn) {
   const store = storage('legacy').getStore()
@@ -61,12 +62,28 @@ function getErrorLog (err) {
   }
 }
 
+function setStackTraceLimitFunction (fn) {
+  if (typeof fn !== 'function') {
+    throw new TypeError('stackTraceLimitFunction must be a function')
+  }
+  stackTraceLimitFunction = fn
+}
+
 function onError (err) {
   const { formatted, cause } = getErrorLog(err)
 
   // calling twice logger.error() because Error cause is only available in nodejs v16.9.0
   // TODO: replace it with Error(message, { cause }) when cause has broad support
-  if (formatted) withNoop(() => logger.error(new Error(formatted)))
+  if (formatted) {
+    withNoop(() => {
+      const l = Error.stackTraceLimit
+      Error.stackTraceLimit = 0
+      const e = new Error(formatted)
+      Error.stackTraceLimit = l
+      Error.captureStackTrace(e, stackTraceLimitFunction)
+      logger.error(e)
+    })
+  }
   if (cause) withNoop(() => logger.error(cause))
 }
 
@@ -122,4 +139,4 @@ function trace (...args) {
   onTrace(Log.parse(...args))
 }
 
-module.exports = { use, toggle, reset, error, warn, info, debug, trace }
+module.exports = { use, toggle, reset, error, warn, info, debug, trace, setStackTraceLimitFunction }

package/packages/dd-trace/src/opentelemetry/span.js

@@ -9,7 +9,7 @@ const { timeInputToHrTime } = require('@opentelemetry/core')
 
 const tracer = require('../../')
 const DatadogSpan = require('../opentracing/span')
-const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../constants')
+const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK, IGNORE_OTEL_ERROR } = require('../constants')
 const { SERVICE_NAME, RESOURCE_NAME } = require('../../../../ext/tags')
 const kinds = require('../../../../ext/kinds')
 
@@ -237,7 +237,8 @@ class Span {
       this._hasStatus = true
       if (code === 2) {
         this._ddSpan.addTags({
-          [ERROR_MESSAGE]: message
+          [ERROR_MESSAGE]: message,
+          [IGNORE_OTEL_ERROR]: false
         })
       }
     }
@@ -278,12 +279,11 @@ class Span {
   }
 
   recordException (exception, timeInput) {
-    // HACK: identifier is added so that trace.error remains unchanged after a call to otel.recordException
     this._ddSpan.addTags({
       [ERROR_TYPE]: exception.name,
       [ERROR_MESSAGE]: exception.message,
       [ERROR_STACK]: exception.stack,
-      doNotSetTraceError: true
+      [IGNORE_OTEL_ERROR]: this._ddSpan.context()._tags[IGNORE_OTEL_ERROR] ?? true
     })
     const attributes = {}
     if (exception.message) attributes['exception.message'] = exception.message

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

@@ -298,6 +298,7 @@ class TextMapPropagator {
 
   _extractSpanContext (carrier) {
     let context = null
+    let style = ''
     for (const extractor of this._config.tracePropagationStyle.extract) {
       let extractedContext = null
       switch (extractor) {
@@ -331,9 +332,9 @@ class TextMapPropagator {
 
       if (context === null) {
         context = extractedContext
+        style = extractor
         if (this._config.tracePropagationExtractFirst) {
-          this._extractBaggageItems(carrier, context)
-          return context
+          break
         }
       } else {
         // If extractor is tracecontext, add tracecontext specific information to the context
@@ -342,7 +343,7 @@ class TextMapPropagator {
             this._extractTraceparentContext(carrier), context, carrier)
         }
         if (extractedContext._traceId && extractedContext._spanId &&
-           extractedContext.toTraceId(true) !== context.toTraceId(true)) {
+          extractedContext.toTraceId(true) !== context.toTraceId(true)) {
           const link = {
             context: extractedContext,
             attributes: { reason: 'terminated_context', context_headers: extractor }
@@ -354,6 +355,19 @@ class TextMapPropagator {
 
     this._extractBaggageItems(carrier, context)
 
+    if (this._config.tracePropagationBehaviorExtract === 'ignore') {
+      context._links = []
+    } else if (this._config.tracePropagationBehaviorExtract === 'restart') {
+      context._links = []
+      context._links.push({
+        context,
+        attributes:
+        {
+          reason: 'propagation_behavior_extract', context_headers: style
+        }
+      })
+    }
+
     return context || this._extractSqsdContext(carrier)
   }
 

package/packages/dd-trace/src/opentracing/span.js

@@ -319,6 +319,12 @@ class DatadogSpan {
     let spanContext
     let startTime
 
+    let baggage = {}
+    if (parent && parent._isRemote && this._parentTracer?._config?.tracePropagationBehaviorExtract !== 'continue') {
+      baggage = parent._baggageItems
+      parent = null
+    }
+
     if (fields.context) {
       spanContext = fields.context
       if (!spanContext._trace.startTime) {
@@ -352,6 +358,10 @@ class DatadogSpan {
           .padStart(8, '0')
           .padEnd(16, '0')
       }
+
+      if (this._parentTracer?._config?.tracePropagationBehaviorExtract === 'restart') {
+        spanContext._baggageItems = baggage
+      }
     }
 
     spanContext._trace.ticks = spanContext._trace.ticks || now()

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

@@ -133,6 +133,7 @@ module.exports = class PluginManager {
       dbmPropagationMode,
       dsmEnabled,
       clientIpEnabled,
+      clientIpHeader,
       memcachedCommandEnabled,
       ciVisibilityTestSessionName,
       ciVisAgentlessLogSubmissionEnabled,
@@ -148,6 +149,7 @@ module.exports = class PluginManager {
       site,
       url,
       headers: headerTags || [],
+      clientIpHeader,
       ciVisibilityTestSessionName,
       ciVisAgentlessLogSubmissionEnabled,
       isTestDynamicInstrumentationEnabled,

package/packages/dd-trace/src/plugins/util/test.js

@@ -96,6 +96,9 @@ const CUCUMBER_WORKER_TRACE_PAYLOAD_CODE = 70
 // mocha worker variables
 const MOCHA_WORKER_TRACE_PAYLOAD_CODE = 80
 
+// playwright worker variables
+const PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE = 90
+
 // Early flake detection util strings
 const EFD_STRING = "Retried by Datadog's Early Flake Detection"
 const EFD_TEST_NAME_REGEX = new RegExp(EFD_STRING + ' \\(#\\d+\\): ', 'g')
@@ -117,6 +120,12 @@ const TEST_LEVEL_EVENT_TYPES = [
   'test_module_end',
   'test_session_end'
 ]
+const TEST_RETRY_REASON_TYPES = {
+  efd: 'early_flake_detection',
+  atr: 'auto_test_retry',
+  atf: 'attempt_to_fix',
+  ext: 'external'
+}
 
 const DD_TEST_IS_USER_PROVIDED_SERVICE = '_dd.test.is_user_provided_service'
 
@@ -162,6 +171,7 @@ module.exports = {
   JEST_WORKER_LOGS_PAYLOAD_CODE,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
+  PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
   TEST_SOURCE_START,
   TEST_SKIPPED_BY_ITR,
   TEST_IS_NEW,
@@ -223,6 +233,7 @@ module.exports = {
   DD_CAPABILITIES_TEST_MANAGEMENT_DISABLE,
   DD_CAPABILITIES_TEST_MANAGEMENT_ATTEMPT_TO_FIX,
   TEST_LEVEL_EVENT_TYPES,
+  TEST_RETRY_REASON_TYPES,
   getNumFromKnownTests,
   getFileAndLineNumberFromError,
   DI_ERROR_DEBUG_INFO_CAPTURED,

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

@@ -14,7 +14,7 @@ module.exports = {
       debug: (message) => log.debug(message),
       info: (message) => log.info(message),
       warn: (message) => log.warn(message),
-      error: (message) => log.error(message)
+      error: (...args) => log.error(...args)
     }
 
     const libraryInjected = injectionEnabled.length > 0