dd-trace 5.28.0 → 5.29.1

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

@@ -3,7 +3,7 @@
 const { channel } = require('dc-polyfill')
 
 const Level = {
-  trace: 20,
+  trace: 10,
   debug: 20,
   info: 30,
   warn: 40,
@@ -12,6 +12,7 @@ const Level = {
   off: 100
 }
 
+const traceChannel = channel('datadog:log:trace')
 const debugChannel = channel('datadog:log:debug')
 const infoChannel = channel('datadog:log:info')
 const warnChannel = channel('datadog:log:warn')
@@ -31,6 +32,9 @@ class LogChannel {
   }
 
   subscribe (logger) {
+    if (Level.trace >= this._level) {
+      traceChannel.subscribe(logger.trace)
+    }
     if (Level.debug >= this._level) {
       debugChannel.subscribe(logger.debug)
     }
@@ -46,6 +50,9 @@ class LogChannel {
   }
 
   unsubscribe (logger) {
+    if (traceChannel.hasSubscribers) {
+      traceChannel.unsubscribe(logger.trace)
+    }
     if (debugChannel.hasSubscribers) {
       debugChannel.unsubscribe(logger.debug)
     }
@@ -63,7 +70,7 @@ class LogChannel {
 
 module.exports = {
   LogChannel,
-
+  traceChannel,
   debugChannel,
   infoChannel,
   warnChannel,

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

@@ -2,7 +2,7 @@
 
 const coalesce = require('koalas')
 const { isTrue } = require('../util')
-const { debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
+const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
 const { Log } = require('./log')
 
@@ -56,6 +56,16 @@ const log = {
     return this
   },
 
+  trace (...args) {
+    if (traceChannel.hasSubscribers) {
+      const logRecord = {}
+      Error.captureStackTrace(logRecord, this.trace)
+      const stack = logRecord.stack.split('\n')[1].replace(/^\s+at ([^\s]) .+/, '$1')
+      traceChannel.publish(Log.parse('Trace', args, { stack }))
+    }
+    return this
+  },
+
   debug (...args) {
     if (debugChannel.hasSubscribers) {
       debugChannel.publish(Log.parse(...args))

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

@@ -4,6 +4,7 @@ const { storage } = require('../../../datadog-core')
 const { LogChannel } = require('./channels')
 const { Log } = require('./log')
 const defaultLogger = {
+  trace: msg => console.trace(msg), /* eslint-disable-line no-console */
   debug: msg => console.debug(msg), /* eslint-disable-line no-console */
   info: msg => console.info(msg), /* eslint-disable-line no-console */
   warn: msg => console.warn(msg), /* eslint-disable-line no-console */
@@ -23,7 +24,7 @@ function withNoop (fn) {
 }
 
 function unsubscribeAll () {
-  logChannel.unsubscribe({ debug: onDebug, info: onInfo, warn: onWarn, error: onError })
+  logChannel.unsubscribe({ trace: onTrace, debug: onDebug, info: onInfo, warn: onWarn, error: onError })
 }
 
 function toggleSubscription (enable, level) {
@@ -31,7 +32,7 @@ function toggleSubscription (enable, level) {
 
   if (enable) {
     logChannel = new LogChannel(level)
-    logChannel.subscribe({ debug: onDebug, info: onInfo, warn: onWarn, error: onError })
+    logChannel.subscribe({ trace: onTrace, debug: onDebug, info: onInfo, warn: onWarn, error: onError })
   }
 }
 
@@ -88,6 +89,12 @@ function onDebug (log) {
   if (cause) withNoop(() => logger.debug(cause))
 }
 
+function onTrace (log) {
+  const { formatted, cause } = getErrorLog(log)
+  if (formatted) withNoop(() => logger.trace(formatted))
+  if (cause) withNoop(() => logger.trace(cause))
+}
+
 function error (...args) {
   onError(Log.parse(...args))
 }
@@ -110,4 +117,8 @@ function debug (...args) {
   onDebug(Log.parse(...args))
 }
 
-module.exports = { use, toggle, reset, error, warn, info, debug }
+function trace (...args) {
+  onTrace(Log.parse(...args))
+}
+
+module.exports = { use, toggle, reset, error, warn, info, debug, trace }

package/packages/dd-trace/src/{encode → msgpack}/chunk.js

@@ -10,6 +10,7 @@ const DEFAULT_MIN_SIZE = 2 * 1024 * 1024 // 2MB
 class Chunk {
   constructor (minSize = DEFAULT_MIN_SIZE) {
     this.buffer = Buffer.allocUnsafe(minSize)
+    this.view = new DataView(this.buffer.buffer)
     this.length = 0
     this._minSize = minSize
   }
@@ -20,11 +21,9 @@ class Chunk {
 
     if (length < 0x20) { // fixstr
       this.reserve(length + 1)
-      this.length += 1
       this.buffer[offset] = length | 0xa0
     } else if (length < 0x100000000) { // str 32
       this.reserve(length + 5)
-      this.length += 5
       this.buffer[offset] = 0xdb
       this.buffer[offset + 1] = length >> 24
       this.buffer[offset + 2] = length >> 16
@@ -32,7 +31,7 @@ class Chunk {
       this.buffer[offset + 4] = length
     }
 
-    this.length += this.buffer.utf8Write(value, this.length, length)
+    this.buffer.utf8Write(value, this.length - length, length)
 
     return this.length - offset
   }
@@ -42,22 +41,26 @@ class Chunk {
   }
 
   set (array) {
+    const length = this.length
+
     this.reserve(array.length)
 
-    this.buffer.set(array, this.length)
-    this.length += array.length
+    this.buffer.set(array, length)
   }
 
   reserve (size) {
     if (this.length + size > this.buffer.length) {
       this._resize(this._minSize * Math.ceil((this.length + size) / this._minSize))
     }
+
+    this.length += size
   }
 
   _resize (size) {
     const oldBuffer = this.buffer
 
     this.buffer = Buffer.allocUnsafe(size)
+    this.view = new DataView(this.buffer.buffer)
 
     oldBuffer.copy(this.buffer, 0, 0, this.length)
   }

package/packages/dd-trace/src/msgpack/encoder.js

@@ -0,0 +1,309 @@
+'use strict'
+
+const Chunk = require('./chunk')
+
+class MsgpackEncoder {
+  encode (value) {
+    const bytes = new Chunk()
+
+    this.encodeValue(bytes, value)
+
+    return bytes.buffer.subarray(0, bytes.length)
+  }
+
+  encodeValue (bytes, value) {
+    switch (typeof value) {
+      case 'bigint':
+        this.encodeBigInt(bytes, value)
+        break
+      case 'boolean':
+        this.encodeBoolean(bytes, value)
+        break
+      case 'number':
+        this.encodeNumber(bytes, value)
+        break
+      case 'object':
+        if (value === null) {
+          this.encodeNull(bytes, value)
+        } else if (Array.isArray(value)) {
+          this.encodeArray(bytes, value)
+        } else if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) {
+          this.encodeBin(bytes, value)
+        } else {
+          this.encodeMap(bytes, value)
+        }
+        break
+      case 'string':
+        this.encodeString(bytes, value)
+        break
+      case 'symbol':
+        this.encodeString(bytes, value.toString())
+        break
+      default: // function, symbol, undefined
+        this.encodeNull(bytes, value)
+        break
+    }
+  }
+
+  encodeNull (bytes) {
+    const offset = bytes.length
+
+    bytes.reserve(1)
+    bytes.buffer[offset] = 0xc0
+  }
+
+  encodeBoolean (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(1)
+    bytes.buffer[offset] = value ? 0xc3 : 0xc2
+  }
+
+  encodeString (bytes, value) {
+    bytes.write(value)
+  }
+
+  encodeFixArray (bytes, size = 0) {
+    const offset = bytes.length
+
+    bytes.reserve(1)
+    bytes.buffer[offset] = 0x90 + size
+  }
+
+  encodeArrayPrefix (bytes, value) {
+    const length = value.length
+    const offset = bytes.length
+
+    bytes.reserve(5)
+    bytes.buffer[offset] = 0xdd
+    bytes.buffer[offset + 1] = length >> 24
+    bytes.buffer[offset + 2] = length >> 16
+    bytes.buffer[offset + 3] = length >> 8
+    bytes.buffer[offset + 4] = length
+  }
+
+  encodeArray (bytes, value) {
+    if (value.length < 16) {
+      this.encodeFixArray(bytes, value.length)
+    } else {
+      this.encodeArrayPrefix(bytes, value)
+    }
+
+    for (const item of value) {
+      this.encodeValue(bytes, item)
+    }
+  }
+
+  encodeFixMap (bytes, size = 0) {
+    const offset = bytes.length
+
+    bytes.reserve(1)
+    bytes.buffer[offset] = 0x80 + size
+  }
+
+  encodeMapPrefix (bytes, keysLength) {
+    const offset = bytes.length
+
+    bytes.reserve(5)
+    bytes.buffer[offset] = 0xdf
+    bytes.buffer[offset + 1] = keysLength >> 24
+    bytes.buffer[offset + 2] = keysLength >> 16
+    bytes.buffer[offset + 3] = keysLength >> 8
+    bytes.buffer[offset + 4] = keysLength
+  }
+
+  encodeByte (bytes, value) {
+    bytes.reserve(1)
+    bytes.buffer[bytes.length - 1] = value
+  }
+
+  encodeBin (bytes, value) {
+    const offset = bytes.length
+
+    if (value.byteLength < 256) {
+      bytes.reserve(2)
+      bytes.buffer[offset] = 0xc4
+      bytes.buffer[offset + 1] = value.byteLength
+    } else if (value.byteLength < 65536) {
+      bytes.reserve(3)
+      bytes.buffer[offset] = 0xc5
+      bytes.buffer[offset + 1] = value.byteLength >> 8
+      bytes.buffer[offset + 2] = value.byteLength
+    } else {
+      bytes.reserve(5)
+      bytes.buffer[offset] = 0xc6
+      bytes.buffer[offset + 1] = value.byteLength >> 24
+      bytes.buffer[offset + 2] = value.byteLength >> 16
+      bytes.buffer[offset + 3] = value.byteLength >> 8
+      bytes.buffer[offset + 4] = value.byteLength
+    }
+
+    bytes.set(value)
+  }
+
+  encodeInteger (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(5)
+    bytes.buffer[offset] = 0xce
+    bytes.buffer[offset + 1] = value >> 24
+    bytes.buffer[offset + 2] = value >> 16
+    bytes.buffer[offset + 3] = value >> 8
+    bytes.buffer[offset + 4] = value
+  }
+
+  encodeShort (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(3)
+    bytes.buffer[offset] = 0xcd
+    bytes.buffer[offset + 1] = value >> 8
+    bytes.buffer[offset + 2] = value
+  }
+
+  encodeLong (bytes, value) {
+    const offset = bytes.length
+    const hi = (value / Math.pow(2, 32)) >> 0
+    const lo = value >>> 0
+
+    bytes.reserve(9)
+    bytes.buffer[offset] = 0xcf
+    bytes.buffer[offset + 1] = hi >> 24
+    bytes.buffer[offset + 2] = hi >> 16
+    bytes.buffer[offset + 3] = hi >> 8
+    bytes.buffer[offset + 4] = hi
+    bytes.buffer[offset + 5] = lo >> 24
+    bytes.buffer[offset + 6] = lo >> 16
+    bytes.buffer[offset + 7] = lo >> 8
+    bytes.buffer[offset + 8] = lo
+  }
+
+  encodeNumber (bytes, value) {
+    if (Number.isNaN(value)) {
+      value = 0
+    }
+    if (Number.isInteger(value)) {
+      if (value >= 0) {
+        this.encodeUnsigned(bytes, value)
+      } else {
+        this.encodeSigned(bytes, value)
+      }
+    } else {
+      this.encodeFloat(bytes, value)
+    }
+  }
+
+  encodeSigned (bytes, value) {
+    const offset = bytes.length
+
+    if (value >= -0x20) {
+      bytes.reserve(1)
+      bytes.buffer[offset] = value
+    } else if (value >= -0x80) {
+      bytes.reserve(2)
+      bytes.buffer[offset] = 0xd0
+      bytes.buffer[offset + 1] = value
+    } else if (value >= -0x8000) {
+      bytes.reserve(3)
+      bytes.buffer[offset] = 0xd1
+      bytes.buffer[offset + 1] = value >> 8
+      bytes.buffer[offset + 2] = value
+    } else if (value >= -0x80000000) {
+      bytes.reserve(5)
+      bytes.buffer[offset] = 0xd2
+      bytes.buffer[offset + 1] = value >> 24
+      bytes.buffer[offset + 2] = value >> 16
+      bytes.buffer[offset + 3] = value >> 8
+      bytes.buffer[offset + 4] = value
+    } else {
+      const hi = Math.floor(value / Math.pow(2, 32))
+      const lo = value >>> 0
+
+      bytes.reserve(9)
+      bytes.buffer[offset] = 0xd3
+      bytes.buffer[offset + 1] = hi >> 24
+      bytes.buffer[offset + 2] = hi >> 16
+      bytes.buffer[offset + 3] = hi >> 8
+      bytes.buffer[offset + 4] = hi
+      bytes.buffer[offset + 5] = lo >> 24
+      bytes.buffer[offset + 6] = lo >> 16
+      bytes.buffer[offset + 7] = lo >> 8
+      bytes.buffer[offset + 8] = lo
+    }
+  }
+
+  encodeUnsigned (bytes, value) {
+    const offset = bytes.length
+
+    if (value <= 0x7f) {
+      bytes.reserve(1)
+      bytes.buffer[offset] = value
+    } else if (value <= 0xff) {
+      bytes.reserve(2)
+      bytes.buffer[offset] = 0xcc
+      bytes.buffer[offset + 1] = value
+    } else if (value <= 0xffff) {
+      bytes.reserve(3)
+      bytes.buffer[offset] = 0xcd
+      bytes.buffer[offset + 1] = value >> 8
+      bytes.buffer[offset + 2] = value
+    } else if (value <= 0xffffffff) {
+      bytes.reserve(5)
+      bytes.buffer[offset] = 0xce
+      bytes.buffer[offset + 1] = value >> 24
+      bytes.buffer[offset + 2] = value >> 16
+      bytes.buffer[offset + 3] = value >> 8
+      bytes.buffer[offset + 4] = value
+    } else {
+      const hi = (value / Math.pow(2, 32)) >> 0
+      const lo = value >>> 0
+
+      bytes.reserve(9)
+      bytes.buffer[offset] = 0xcf
+      bytes.buffer[offset + 1] = hi >> 24
+      bytes.buffer[offset + 2] = hi >> 16
+      bytes.buffer[offset + 3] = hi >> 8
+      bytes.buffer[offset + 4] = hi
+      bytes.buffer[offset + 5] = lo >> 24
+      bytes.buffer[offset + 6] = lo >> 16
+      bytes.buffer[offset + 7] = lo >> 8
+      bytes.buffer[offset + 8] = lo
+    }
+  }
+
+  // TODO: Support BigInt larger than 64bit.
+  encodeBigInt (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(9)
+
+    if (value >= 0n) {
+      bytes.buffer[offset] = 0xcf
+      bytes.view.setBigUint64(offset + 1, value)
+    } else {
+      bytes.buffer[offset] = 0xd3
+      bytes.view.setBigInt64(offset + 1, value)
+    }
+  }
+
+  encodeMap (bytes, value) {
+    const keys = Object.keys(value)
+
+    this.encodeMapPrefix(bytes, keys.length)
+
+    for (const key of keys) {
+      this.encodeValue(bytes, key)
+      this.encodeValue(bytes, value[key])
+    }
+  }
+
+  encodeFloat (bytes, value) {
+    const offset = bytes.length
+
+    bytes.reserve(9)
+    bytes.buffer[offset] = 0xcb
+    bytes.view.setFloat64(offset + 1, value)
+  }
+}
+
+module.exports = { MsgpackEncoder }

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

@@ -0,0 +1,6 @@
+'use strict'
+
+const Chunk = require('./chunk')
+const { MsgpackEncoder } = require('./encoder')
+
+module.exports = { Chunk, MsgpackEncoder }

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const { AsyncLocalStorage } = require('async_hooks')
+const { storage } = require('../../../datadog-core')
 const { trace, ROOT_CONTEXT } = require('@opentelemetry/api')
 const DataDogSpanContext = require('../opentracing/span_context')
 
@@ -9,7 +9,7 @@ const tracer = require('../../')
 
 class ContextManager {
   constructor () {
-    this._store = new AsyncLocalStorage()
+    this._store = storage('opentelemetry')
   }
 
   active () {

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

@@ -300,14 +300,17 @@ class TextMapPropagator {
         case 'tracecontext':
           extractedContext = this._extractTraceparentContext(carrier)
           break
-        case 'b3' && this
-          ._config
-          .tracePropagationStyle
-          .otelPropagators: // TODO: should match "b3 single header" in next major
         case 'b3 single header': // TODO: delete in major after singular "b3"
           extractedContext = this._extractB3SingleContext(carrier)
           break
         case 'b3':
+          if (this._config.tracePropagationStyle.otelPropagators) {
+            // TODO: should match "b3 single header" in next major
+            extractedContext = this._extractB3SingleContext(carrier)
+          } else {
+            extractedContext = this._extractB3MultiContext(carrier)
+          }
+          break
         case 'b3multi':
           extractedContext = this._extractB3MultiContext(carrier)
           break
@@ -339,11 +342,11 @@ class TextMapPropagator {
           context._links.push(link)
         }
       }
+    }
 
-      if (this._config.tracePropagationStyle.extract.includes('baggage') && carrier.baggage) {
-        context = context || new DatadogSpanContext()
-        this._extractBaggageItems(carrier, context)
-      }
+    if (this._hasPropagationStyle('extract', 'baggage') && carrier.baggage) {
+      context = context || new DatadogSpanContext()
+      this._extractBaggageItems(carrier, context)
     }
 
     return context || this._extractSqsdContext(carrier)
@@ -496,7 +499,7 @@ class TextMapPropagator {
   }
 
   _extractGenericContext (carrier, traceKey, spanKey, radix) {
-    if (carrier[traceKey] && carrier[spanKey]) {
+    if (carrier && carrier[traceKey] && carrier[spanKey]) {
       if (invalidSegment.test(carrier[traceKey])) return null
 
       return new DatadogSpanContext({

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

@@ -214,7 +214,7 @@ class DatadogSpan {
 
     if (DD_TRACE_EXPERIMENTAL_STATE_TRACKING === 'true') {
       if (!this._spanContext._tags['service.name']) {
-        log.error(`Finishing invalid span: ${this}`)
+        log.error('Finishing invalid span: %s', this)
       }
     }
 

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

@@ -91,7 +91,7 @@ class DatadogTracer {
       }
       this._propagators[format].inject(context, carrier)
     } catch (e) {
-      log.error(e)
+      log.error('Error injecting trace', e)
       runtimeMetrics.increment('datadog.tracer.node.inject.errors', true)
     }
   }
@@ -100,7 +100,7 @@ class DatadogTracer {
     try {
       return this._propagators[format].extract(carrier)
     } catch (e) {
-      log.error(e)
+      log.error('Error extracting trace', e)
       runtimeMetrics.increment('datadog.tracer.node.extract.errors', true)
       return null
     }

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

@@ -138,7 +138,8 @@ module.exports = class PluginManager {
       clientIpEnabled,
       memcachedCommandEnabled,
       ciVisibilityTestSessionName,
-      ciVisAgentlessLogSubmissionEnabled
+      ciVisAgentlessLogSubmissionEnabled,
+      isTestDynamicInstrumentationEnabled
     } = this._tracerConfig
 
     const sharedConfig = {
@@ -149,7 +150,8 @@ module.exports = class PluginManager {
       url,
       headers: headerTags || [],
       ciVisibilityTestSessionName,
-      ciVisAgentlessLogSubmissionEnabled
+      ciVisAgentlessLogSubmissionEnabled,
+      isTestDynamicInstrumentationEnabled
     }
 
     if (logInjection !== undefined) {

package/packages/dd-trace/src/plugins/ci_plugin.js

@@ -21,7 +21,9 @@ const {
   ITR_CORRELATION_ID,
   TEST_SOURCE_FILE,
   TEST_LEVEL_EVENT_TYPES,
-  TEST_SUITE
+  TEST_SUITE,
+  getFileAndLineNumberFromError,
+  getTestSuitePath
 } = require('./util/test')
 const Plugin = require('./plugin')
 const { COMPONENT } = require('../constants')
@@ -47,7 +49,7 @@ module.exports = class CiPlugin extends Plugin {
       }
       this.tracer._exporter.getLibraryConfiguration(this.testConfiguration, (err, libraryConfig) => {
         if (err) {
-          log.error(`Library configuration could not be fetched. ${err.message}`)
+          log.error('Library configuration could not be fetched. %s', err.message)
         } else {
           this.libraryConfig = libraryConfig
         }
@@ -61,7 +63,7 @@ module.exports = class CiPlugin extends Plugin {
       }
       this.tracer._exporter.getSkippableSuites(this.testConfiguration, (err, skippableSuites, itrCorrelationId) => {
         if (err) {
-          log.error(`Skippable suites could not be fetched. ${err.message}`)
+          log.error('Skippable suites could not be fetched. %s', err.message)
         } else {
           this.itrCorrelationId = itrCorrelationId
         }
@@ -150,7 +152,7 @@ module.exports = class CiPlugin extends Plugin {
       }
       this.tracer._exporter.getKnownTests(this.testConfiguration, (err, knownTests) => {
         if (err) {
-          log.error(`Known tests could not be fetched. ${err.message}`)
+          log.error('Known tests could not be fetched. %s', err.message)
           this.libraryConfig.isEarlyFlakeDetectionEnabled = false
         }
         onDone({ err, knownTests })
@@ -180,6 +182,12 @@ module.exports = class CiPlugin extends Plugin {
 
   configure (config) {
     super.configure(config)
+
+    if (config.isTestDynamicInstrumentationEnabled) {
+      const testVisibilityDynamicInstrumentation = require('../ci-visibility/dynamic-instrumentation')
+      this.di = testVisibilityDynamicInstrumentation
+    }
+
     this.testEnvironmentMetadata = getTestEnvironmentMetadata(this.constructor.id, this.config)
 
     const {
@@ -283,4 +291,39 @@ module.exports = class CiPlugin extends Plugin {
 
     return testSpan
   }
+
+  // TODO: If the test finishes and the probe is not hit, we should remove the breakpoint
+  addDiProbe (err, probe) {
+    const [file, line] = getFileAndLineNumberFromError(err)
+
+    const relativePath = getTestSuitePath(file, this.repositoryRoot)
+
+    const [
+      snapshotId,
+      setProbePromise,
+      hitProbePromise
+    ] = this.di.addLineProbe({ file: relativePath, line })
+
+    if (probe) { // not all frameworks may sync with the set probe promise
+      probe.setProbePromise = setProbePromise
+    }
+
+    hitProbePromise.then(({ snapshot }) => {
+      // TODO: handle race conditions for this.retriedTestIds
+      const { traceId, spanId } = this.retriedTestIds
+      this.tracer._exporter.exportDiLogs(this.testEnvironmentMetadata, {
+        debugger: { snapshot },
+        dd: {
+          trace_id: traceId,
+          span_id: spanId
+        }
+      })
+    })
+
+    return {
+      snapshotId,
+      file: relativePath,
+      line
+    }
+  }
 }