dd-trace 2.25.1 → 2.26.0

package/packages/dd-trace/src/appsec/sdk/index.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const { trackUserLoginSuccessEvent, trackUserLoginFailureEvent, trackCustomEvent } = require('./track_event')
+
+class AppsecSdk {
+  constructor (tracer) {
+    this._tracer = tracer
+  }
+
+  trackUserLoginSuccessEvent (user, metadata) {
+    return trackUserLoginSuccessEvent(this._tracer, user, metadata)
+  }
+
+  trackUserLoginFailureEvent (userId, exists, metadata) {
+    return trackUserLoginFailureEvent(this._tracer, userId, exists, metadata)
+  }
+
+  trackCustomEvent (eventName, metadata) {
+    return trackCustomEvent(this._tracer, eventName, metadata)
+  }
+}
+
+module.exports = AppsecSdk

package/packages/dd-trace/src/appsec/sdk/noop.js

@@ -0,0 +1,11 @@
+'use strict'
+
+class NoopAppsecSdk {
+  trackUserLoginSuccessEvent () {}
+
+  trackUserLoginFailureEvent () {}
+
+  trackCustomEvent () {}
+}
+
+module.exports = NoopAppsecSdk

package/packages/dd-trace/src/appsec/sdk/track_event.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const log = require('../../log')
+const { getRootSpan } = require('./utils')
+const { MANUAL_KEEP } = require('../../../../../ext/tags')
+
+function trackUserLoginSuccessEvent (tracer, user, metadata) {
+  // TODO: better user check here and in _setUser() ?
+  if (!user || !user.id) {
+    log.warn('Invalid user provided to trackUserLoginSuccessEvent')
+    return
+  }
+
+  const rootSpan = getRootSpan(tracer)
+  if (!rootSpan) {
+    log.warn('Root span not available in trackUserLoginSuccessEvent')
+    return
+  }
+
+  // TODO: use sdk._setUser(user, rootSpan) (available in User Blocking PR #2710)
+  tracer.setUser(user)
+
+  trackEvent(tracer, 'users.login.success', metadata, 'trackUserLoginSuccessEvent', rootSpan)
+}
+
+function trackUserLoginFailureEvent (tracer, userId, exists, metadata) {
+  if (!userId || typeof userId !== 'string') {
+    log.warn('Invalid userId provided to trackUserLoginFailureEvent')
+    return
+  }
+
+  const fields = {
+    'usr.id': userId,
+    'usr.exists': exists ? 'true' : 'false',
+    ...metadata
+  }
+
+  trackEvent(tracer, 'users.login.failure', fields, 'trackUserLoginFailureEvent')
+}
+
+function trackCustomEvent (tracer, eventName, metadata) {
+  if (!eventName || typeof eventName !== 'string') {
+    log.warn('Invalid eventName provided to trackCustomEvent')
+    return
+  }
+
+  trackEvent(tracer, eventName, metadata, 'trackCustomEvent')
+}
+
+function trackEvent (tracer, eventName, fields, sdkMethodName, rootSpan = getRootSpan(tracer)) {
+  if (!rootSpan) {
+    log.warn(`Root span not available in ${sdkMethodName}`)
+    return
+  }
+
+  const tags = {
+    [`appsec.events.${eventName}.track`]: 'true',
+    [MANUAL_KEEP]: 'true'
+  }
+
+  if (fields) {
+    for (const metadataKey of Object.keys(fields)) {
+      tags[`appsec.events.${eventName}.${metadataKey}`] = '' + fields[metadataKey]
+    }
+  }
+
+  rootSpan.addTags(tags)
+}
+
+module.exports = {
+  trackUserLoginSuccessEvent,
+  trackUserLoginFailureEvent,
+  trackCustomEvent
+}

package/packages/dd-trace/src/appsec/sdk/utils.js

@@ -0,0 +1,10 @@
+'use strict'
+
+function getRootSpan (tracer) {
+  const span = tracer.scope().active()
+  return span && span.context()._trace.started[0]
+}
+
+module.exports = {
+  getRootSpan
+}

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -10,7 +10,7 @@ const AgentInfoExporter = require('../../exporters/common/agent-info-exporter')
 
 function getIsTestSessionTrace (trace) {
   return trace.some(span =>
-    span.type === 'test_session_end' || span.type === 'test_suite_end'
+    span.type === 'test_session_end' || span.type === 'test_suite_end' || span.type === 'test_module_end'
   )
 }
 

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

@@ -178,7 +178,13 @@ class Config {
       parseInt(process.env.DD_TRACE_PARTIAL_FLUSH_MIN_SPANS),
       1000
     )
+    const DD_TRACE_CLIENT_IP_ENABLED = coalesce(
+      options.clientIpEnabled,
+      process.env.DD_TRACE_CLIENT_IP_ENABLED && isTrue(process.env.DD_TRACE_CLIENT_IP_ENABLED),
+      false
+    )
     const DD_TRACE_CLIENT_IP_HEADER = coalesce(
+      options.clientIpHeader,
       process.env.DD_TRACE_CLIENT_IP_HEADER,
       null
     )
@@ -369,6 +375,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.flushMinSpans = DD_TRACE_PARTIAL_FLUSH_MIN_SPANS
     this.sampleRate = coalesce(Math.min(Math.max(sampler.sampleRate, 0), 1), 1)
     this.queryStringObfuscation = DD_TRACE_OBFUSCATION_QUERY_STRING_REGEXP
+    this.clientIpEnabled = DD_TRACE_CLIENT_IP_ENABLED
     this.clientIpHeader = DD_TRACE_CLIENT_IP_HEADER
     this.plugins = !!coalesce(options.plugins, true)
     this.service = DD_SERVICE

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

@@ -5,9 +5,10 @@ const { version: ddTraceVersion } = require('../../../../package.json')
 const id = require('../../../dd-trace/src/id')
 const ENCODING_VERSION = 1
 
-const ALLOWED_CONTENT_TYPES = ['test_session_end', 'test_suite_end', 'test']
+const ALLOWED_CONTENT_TYPES = ['test_session_end', 'test_module_end', 'test_suite_end', 'test']
 
-const TEST_SUITE_KEYS_LENGTH = 11
+const TEST_SUITE_KEYS_LENGTH = 12
+const TEST_MODULE_KEYS_LENGTH = 11
 const TEST_SESSION_KEYS_LENGTH = 10
 
 const INTAKE_SOFT_LIMIT = 2 * 1024 * 1024 // 2MB
@@ -46,6 +47,9 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeString(bytes, 'test_session_id')
     this._encodeId(bytes, content.trace_id)
 
+    this._encodeString(bytes, 'test_module_id')
+    this._encodeId(bytes, content.parent_id)
+
     this._encodeString(bytes, 'test_suite_id')
     this._encodeId(bytes, content.span_id)
 
@@ -67,6 +71,35 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeMap(bytes, content.metrics)
   }
 
+  _encodeTestModule (bytes, content) {
+    this._encodeMapPrefix(bytes, TEST_MODULE_KEYS_LENGTH)
+    this._encodeString(bytes, 'type')
+    this._encodeString(bytes, content.type)
+
+    this._encodeString(bytes, 'test_session_id')
+    this._encodeId(bytes, content.trace_id)
+
+    this._encodeString(bytes, 'test_module_id')
+    this._encodeId(bytes, content.span_id)
+
+    this._encodeString(bytes, 'error')
+    this._encodeNumber(bytes, content.error)
+    this._encodeString(bytes, 'name')
+    this._encodeString(bytes, content.name)
+    this._encodeString(bytes, 'service')
+    this._encodeString(bytes, content.service)
+    this._encodeString(bytes, 'resource')
+    this._encodeString(bytes, content.resource)
+    this._encodeString(bytes, 'start')
+    this._encodeNumber(bytes, content.start)
+    this._encodeString(bytes, 'duration')
+    this._encodeNumber(bytes, content.duration)
+    this._encodeString(bytes, 'meta')
+    this._encodeMap(bytes, content.meta)
+    this._encodeString(bytes, 'metrics')
+    this._encodeMap(bytes, content.metrics)
+  }
+
   _encodeTestSession (bytes, content) {
     this._encodeMapPrefix(bytes, TEST_SESSION_KEYS_LENGTH)
     this._encodeString(bytes, 'type')
@@ -95,8 +128,9 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
 
   _encodeEventContent (bytes, content) {
     const keysLength = Object.keys(content).length
+
     if (content.meta.test_session_id) {
-      this._encodeMapPrefix(bytes, keysLength + 2)
+      this._encodeMapPrefix(bytes, keysLength + 3)
     } else {
       this._encodeMapPrefix(bytes, keysLength)
     }
@@ -137,6 +171,10 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
       this._encodeId(bytes, id(content.meta.test_session_id, 10))
       delete content.meta.test_session_id
 
+      this._encodeString(bytes, 'test_module_id')
+      this._encodeId(bytes, id(content.meta.test_module_id, 10))
+      delete content.meta.test_module_id
+
       this._encodeString(bytes, 'test_suite_id')
       this._encodeId(bytes, id(content.meta.test_suite_id, 10))
       delete content.meta.test_suite_id
@@ -160,6 +198,8 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
       this._encodeEventContent(bytes, event.content)
     } else if (event.type === 'test_suite_end') {
       this._encodeTestSuite(bytes, event.content)
+    } else if (event.type === 'test_module_end') {
+      this._encodeTestModule(bytes, event.content)
     } else if (event.type === 'test_session_end') {
       this._encodeTestSession(bytes, event.content)
     }
@@ -200,7 +240,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     const rawEvents = trace.map(formatSpan)
 
     const testSessionEvents = rawEvents.filter(
-      event => event.type === 'test_session_end' || event.type === 'test_suite_end'
+      event => event.type === 'test_session_end' || event.type === 'test_suite_end' || event.type === 'test_module_end'
     )
 
     const isTestSessionTrace = !!testSessionEvents.length

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

@@ -1,56 +1,35 @@
 'use strict'
 const { AgentEncoder } = require('./0.4')
 const Chunk = require('./chunk')
-const log = require('../log')
 
 const FormData = require('../exporters/common/form-data')
 
-const COVERAGE_PAYLOAD_VERSION = 1
-const COVERAGE_KEYS_LENGTH = 4
-const MAXIMUM_NUM_COVERAGE_FILES = 100
+const COVERAGE_PAYLOAD_VERSION = 2
+const COVERAGE_KEYS_LENGTH = 2
 
 class CoverageCIVisibilityEncoder extends AgentEncoder {
   constructor () {
     super(...arguments)
     this._coverageBytes = new Chunk()
     this.form = new FormData()
-    this.fileIndex = 1
+    this._coveragesCount = 0
     this.reset()
   }
 
   count () {
-    return this.fileIndex - 1
+    return this._coveragesCount
   }
 
   encode (coverage) {
-    const bytes = this._coverageBytes
-    const coverageBuffer = this.encodeCodeCoverage(bytes, coverage)
-    const coverageFilename = `coverage${this.fileIndex++}`
-
-    this.form.append(
-      coverageFilename,
-      coverageBuffer,
-      {
-        filename: `${coverageFilename}.msgpack`,
-        contentType: 'application/msgpack'
-      }
-    )
-
-    if (this.fileIndex === MAXIMUM_NUM_COVERAGE_FILES) {
-      log.debug('Coverage buffer reached the limit, flushing')
-      this._writer.flush()
-    }
-
-    this.reset()
+    this._coveragesCount++
+    this.encodeCodeCoverage(this._coverageBytes, coverage)
   }
 
   encodeCodeCoverage (bytes, coverage) {
-    this._encodeMapPrefix(bytes, COVERAGE_KEYS_LENGTH)
-    this._encodeString(bytes, 'version')
-    this._encodeInteger(bytes, COVERAGE_PAYLOAD_VERSION)
-    this._encodeString(bytes, 'trace_id')
+    this._encodeMapPrefix(bytes, 3)
+    this._encodeString(bytes, 'test_session_id')
     this._encodeId(bytes, coverage.traceId)
-    this._encodeString(bytes, 'span_id')
+    this._encodeString(bytes, 'test_suite_id')
     this._encodeId(bytes, coverage.spanId)
     this._encodeString(bytes, 'files')
     this._encodeArrayPrefix(bytes, coverage.files)
@@ -59,12 +38,6 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
       this._encodeString(bytes, 'filename')
       this._encodeString(bytes, filename)
     }
-    const traceSize = bytes.length
-    const buffer = Buffer.allocUnsafe(traceSize)
-
-    bytes.buffer.copy(buffer, 0, 0, bytes.length)
-
-    return buffer
   }
 
   reset () {
@@ -72,9 +45,51 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
     if (this._coverageBytes) {
       this._coverageBytes.length = 0
     }
+    this._coveragesCount = 0
+    this._encodePayloadStart(this._coverageBytes)
+  }
+
+  _encodePayloadStart (bytes) {
+    const payload = {
+      version: COVERAGE_PAYLOAD_VERSION,
+      coverages: []
+    }
+    this._encodeMapPrefix(bytes, COVERAGE_KEYS_LENGTH)
+    this._encodeString(bytes, 'version')
+    this._encodeInteger(bytes, payload.version)
+    this._encodeString(bytes, 'coverages')
+    // Get offset of the coverages list to update the length of the array when calling `makePayload`
+    this._coveragesOffset = bytes.length
+    bytes.reserve(5)
+    bytes.length += 5
   }
 
   makePayload () {
+    const bytes = this._coverageBytes
+
+    const coveragesOffset = this._coveragesOffset
+    const coveragesCount = this._coveragesCount
+
+    // update with number of coverages
+    bytes.buffer[coveragesOffset] = 0xdd
+    bytes.buffer[coveragesOffset + 1] = coveragesCount >> 24
+    bytes.buffer[coveragesOffset + 2] = coveragesCount >> 16
+    bytes.buffer[coveragesOffset + 3] = coveragesCount >> 8
+    bytes.buffer[coveragesOffset + 4] = coveragesCount
+
+    const traceSize = bytes.length
+    const buffer = Buffer.allocUnsafe(traceSize)
+
+    bytes.buffer.copy(buffer, 0, 0, bytes.length)
+
+    this.form.append(
+      'coverage1',
+      buffer,
+      {
+        filename: `coverage1.msgpack`,
+        contentType: 'application/msgpack'
+      }
+    )
     this.form.append(
       'event',
       // The intake requires a populated dictionary here. Simply having {} is not valid.
@@ -86,7 +101,7 @@ class CoverageCIVisibilityEncoder extends AgentEncoder {
     const form = this.form
 
     this.form = new FormData()
-    this.fileIndex = 1
+    this.reset()
 
     return form
   }

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

@@ -0,0 +1,47 @@
+'use strict'
+
+const dc = require('diagnostics_channel')
+
+const Level = {
+  Debug: 'debug',
+  Info: 'info',
+  Warn: 'warn',
+  Error: 'error'
+}
+
+const defaultLevel = Level.Debug
+
+class LogChannel extends dc.Channel {
+  constructor (name, logLevel) {
+    super(`datadog:log:${name}`)
+    this.logLevel = logLevel
+  }
+}
+
+// based on: https://github.com/trentm/node-bunyan#levels
+const logChannels = {
+  [Level.Debug]: new LogChannel(Level.Debug, 20),
+  [Level.Info]: new LogChannel(Level.Info, 30),
+  [Level.Warn]: new LogChannel(Level.Warn, 40),
+  [Level.Error]: new LogChannel(Level.Error, 50)
+}
+
+function getChannelLogLevel (level) {
+  let logChannel
+  if (level && typeof level === 'string') {
+    logChannel = logChannels[level.toLowerCase().trim()] || logChannels[defaultLevel]
+  } else {
+    logChannel = logChannels[defaultLevel]
+  }
+  return logChannel.logLevel
+}
+
+module.exports = {
+  Level,
+  getChannelLogLevel,
+
+  debugChannel: logChannels[Level.Debug],
+  infoChannel: logChannels[Level.Info],
+  warnChannel: logChannels[Level.Warn],
+  errorChannel: logChannels[Level.Error]
+}

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

@@ -0,0 +1,79 @@
+'use strict'
+
+const { debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
+const logWriter = require('./writer')
+
+const memoize = func => {
+  const cache = {}
+  const memoized = function (key) {
+    if (!cache[key]) {
+      cache[key] = func.apply(this, arguments)
+    }
+
+    return cache[key]
+  }
+
+  return memoized
+}
+
+function processMsg (msg) {
+  return typeof msg === 'function' ? msg() : msg
+}
+
+const log = {
+  use (logger) {
+    logWriter.use(logger)
+    return this
+  },
+
+  toggle (enabled, logLevel) {
+    logWriter.toggle(enabled, logLevel)
+    return this
+  },
+
+  reset () {
+    logWriter.reset()
+    this._deprecate = memoize((code, message) => {
+      errorChannel.publish(message)
+      return true
+    })
+
+    return this
+  },
+
+  debug (message) {
+    if (debugChannel.hasSubscribers) {
+      debugChannel.publish(processMsg(message))
+    }
+    return this
+  },
+
+  info (message) {
+    if (infoChannel.hasSubscribers) {
+      infoChannel.publish(processMsg(message))
+    }
+    return this
+  },
+
+  warn (message) {
+    if (warnChannel.hasSubscribers) {
+      warnChannel.publish(processMsg(message))
+    }
+    return this
+  },
+
+  error (err) {
+    if (errorChannel.hasSubscribers) {
+      errorChannel.publish(processMsg(err))
+    }
+    return this
+  },
+
+  deprecate (code, message) {
+    return this._deprecate(code, message)
+  }
+}
+
+log.reset()
+
+module.exports = log

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

@@ -0,0 +1,108 @@
+'use strict'
+
+const { storage } = require('../../../datadog-core')
+const { getChannelLogLevel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
+
+const defaultLogger = {
+  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 */
+  error: msg => console.error(msg) /* eslint-disable-line no-console */
+}
+
+let enabled = false
+let logger = defaultLogger
+let logLevel = getChannelLogLevel()
+
+function withNoop (fn) {
+  const store = storage.getStore()
+
+  storage.enterWith({ noop: true })
+  fn()
+  storage.enterWith(store)
+}
+
+function unsubscribeAll () {
+  debugChannel.unsubscribe(onDebug)
+  infoChannel.unsubscribe(onInfo)
+  warnChannel.unsubscribe(onWarn)
+  errorChannel.unsubscribe(onError)
+}
+
+function toggleSubscription (enable) {
+  unsubscribeAll()
+
+  if (enable) {
+    if (debugChannel.logLevel >= logLevel) {
+      debugChannel.subscribe(onDebug)
+    }
+    if (infoChannel.logLevel >= logLevel) {
+      infoChannel.subscribe(onInfo)
+    }
+    if (warnChannel.logLevel >= logLevel) {
+      warnChannel.subscribe(onWarn)
+    }
+    if (errorChannel.logLevel >= logLevel) {
+      errorChannel.subscribe(onError)
+    }
+  }
+}
+
+function toggle (enable, level) {
+  if (level !== undefined) {
+    logLevel = getChannelLogLevel(level)
+  }
+  enabled = enable
+  toggleSubscription(enabled)
+}
+
+function use (newLogger) {
+  if (newLogger && newLogger.debug instanceof Function && newLogger.error instanceof Function) {
+    logger = newLogger
+  }
+}
+
+function reset () {
+  logger = defaultLogger
+  enabled = false
+  logLevel = getChannelLogLevel()
+  toggleSubscription(false)
+}
+
+function onError (err) {
+  if (enabled) {
+    if (typeof err !== 'object' || !err) {
+      err = String(err)
+    } else if (!err.stack) {
+      err = String(err.message || err)
+    }
+
+    if (typeof err === 'string') {
+      err = new Error(err)
+    }
+
+    withNoop(() => logger.error(err))
+  }
+}
+
+function onWarn (message) {
+  if (!logger.warn) return onDebug(message)
+  if (enabled) {
+    withNoop(() => logger.warn(message))
+  }
+}
+
+function onInfo (message) {
+  if (!logger.info) return onDebug(message)
+  if (enabled) {
+    withNoop(() => logger.info(message))
+  }
+}
+
+function onDebug (message) {
+  if (enabled) {
+    withNoop(() => logger.debug(message))
+  }
+}
+
+module.exports = { use, toggle, reset }

package/packages/dd-trace/src/noop/proxy.js

@@ -1,12 +1,15 @@
 'use strict'
 
 const NoopTracer = require('./tracer')
+const NoopAppsecSdk = require('../appsec/sdk/noop')
 
 const noop = new NoopTracer()
+const noopAppsec = new NoopAppsecSdk()
 
 class Tracer {
   constructor () {
     this._tracer = noop
+    this.appsec = noopAppsec
   }
 
   init () {

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

@@ -2,6 +2,7 @@
 
 module.exports = {
   get '@cucumber/cucumber' () { return require('../../../datadog-plugin-cucumber/src') },
+  get '@playwright/test' () { return require('../../../datadog-plugin-playwright/src') },
   get '@elastic/elasticsearch' () { return require('../../../datadog-plugin-elasticsearch/src') },
   get '@elastic/transport' () { return require('../../../datadog-plugin-elasticsearch/src') },
   get '@google-cloud/pubsub' () { return require('../../../datadog-plugin-google-cloud-pubsub/src') },