dd-trace 5.38.0 → 5.40.0

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

@@ -0,0 +1,126 @@
+'use strict'
+
+const { DD_TELEMETRY_REQUEST_METRICS } = require('./common')
+const { addRaspRequestMetrics, trackRaspMetrics } = require('./rasp')
+const { incrementMissingUserId, incrementMissingUserLogin } = require('./user')
+const {
+  addWafRequestMetrics,
+  trackWafMetrics,
+  incrementWafInit,
+  incrementWafUpdates,
+  incrementWafRequests
+} = require('./waf')
+
+const metricsStoreMap = new WeakMap()
+
+let enabled = false
+
+function enable (telemetryConfig) {
+  enabled = telemetryConfig?.enabled && telemetryConfig.metrics
+}
+
+function disable () {
+  enabled = false
+}
+
+function newStore () {
+  return {
+    [DD_TELEMETRY_REQUEST_METRICS]: {
+      duration: 0,
+      durationExt: 0,
+      raspDuration: 0,
+      raspDurationExt: 0,
+      raspEvalCount: 0
+    }
+  }
+}
+
+function getStore (req) {
+  let store = metricsStoreMap.get(req)
+  if (!store) {
+    store = newStore()
+    metricsStoreMap.set(req, store)
+  }
+  return store
+}
+
+function updateRaspRequestsMetricTags (metrics, req, raspRule) {
+  if (!req) return
+
+  const store = getStore(req)
+
+  // it does not depend on whether telemetry is enabled or not
+  addRaspRequestMetrics(store, metrics)
+
+  if (!enabled) return
+
+  trackRaspMetrics(metrics, raspRule)
+}
+
+function updateWafRequestsMetricTags (metrics, req) {
+  if (!req) return
+
+  const store = getStore(req)
+
+  // it does not depend on whether telemetry is enabled or not
+  addWafRequestMetrics(store, metrics)
+
+  if (!enabled) return
+
+  return trackWafMetrics(store, metrics)
+}
+
+function incrementWafInitMetric (wafVersion, rulesVersion) {
+  if (!enabled) return
+
+  incrementWafInit(wafVersion, rulesVersion)
+}
+
+function incrementWafUpdatesMetric (wafVersion, rulesVersion) {
+  if (!enabled) return
+
+  incrementWafUpdates(wafVersion, rulesVersion)
+}
+
+function incrementWafRequestsMetric (req) {
+  if (!req || !enabled) return
+
+  const store = getStore(req)
+  incrementWafRequests(store)
+
+  metricsStoreMap.delete(req)
+}
+
+function incrementMissingUserLoginMetric (framework, eventType) {
+  if (!enabled) return
+
+  incrementMissingUserLogin(framework, eventType)
+}
+
+function incrementMissingUserIdMetric (framework, eventType) {
+  if (!enabled) return
+
+  incrementMissingUserId(framework, eventType)
+}
+
+function getRequestMetrics (req) {
+  if (req) {
+    const store = getStore(req)
+    return store?.[DD_TELEMETRY_REQUEST_METRICS]
+  }
+}
+
+module.exports = {
+  enable,
+  disable,
+
+  updateWafRequestsMetricTags,
+  updateRaspRequestsMetricTags,
+  incrementWafInitMetric,
+  incrementWafUpdatesMetric,
+  incrementWafRequestsMetric,
+  incrementMissingUserLoginMetric,
+  incrementMissingUserIdMetric,
+
+  getRequestMetrics
+}

package/packages/dd-trace/src/appsec/telemetry/rasp.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const telemetryMetrics = require('../../telemetry/metrics')
+const { DD_TELEMETRY_REQUEST_METRICS } = require('./common')
+
+const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
+
+function addRaspRequestMetrics (store, { duration, durationExt }) {
+  store[DD_TELEMETRY_REQUEST_METRICS].raspDuration += duration || 0
+  store[DD_TELEMETRY_REQUEST_METRICS].raspDurationExt += durationExt || 0
+  store[DD_TELEMETRY_REQUEST_METRICS].raspEvalCount++
+}
+
+function trackRaspMetrics (metrics, raspRule) {
+  const tags = { rule_type: raspRule.type, waf_version: metrics.wafVersion }
+
+  if (raspRule.variant) {
+    tags.rule_variant = raspRule.variant
+  }
+
+  appsecMetrics.count('rasp.rule.eval', tags).inc(1)
+
+  if (metrics.wafTimeout) {
+    appsecMetrics.count('rasp.timeout', tags).inc(1)
+  }
+
+  if (metrics.ruleTriggered) {
+    appsecMetrics.count('rasp.rule.match', tags).inc(1)
+  }
+}
+
+module.exports = {
+  addRaspRequestMetrics,
+  trackRaspMetrics
+}

package/packages/dd-trace/src/appsec/telemetry/user.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const telemetryMetrics = require('../../telemetry/metrics')
+
+const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
+
+function incrementMissingUserLogin (framework, eventType) {
+  appsecMetrics.count('instrum.user_auth.missing_user_login', {
+    framework,
+    event_type: eventType
+  }).inc()
+}
+
+function incrementMissingUserId (framework, eventType) {
+  appsecMetrics.count('instrum.user_auth.missing_user_id', {
+    framework,
+    event_type: eventType
+  }).inc()
+}
+
+module.exports = {
+  incrementMissingUserLogin,
+  incrementMissingUserId
+}

package/packages/dd-trace/src/appsec/telemetry/waf.js

@@ -0,0 +1,92 @@
+'use strict'
+
+const telemetryMetrics = require('../../telemetry/metrics')
+const { tags, getVersionsTags, DD_TELEMETRY_REQUEST_METRICS } = require('./common')
+
+const appsecMetrics = telemetryMetrics.manager.namespace('appsec')
+
+const DD_TELEMETRY_WAF_RESULT_TAGS = Symbol('_dd.appsec.telemetry.waf.result.tags')
+
+function addWafRequestMetrics (store, { duration, durationExt }) {
+  store[DD_TELEMETRY_REQUEST_METRICS].duration += duration || 0
+  store[DD_TELEMETRY_REQUEST_METRICS].durationExt += durationExt || 0
+}
+
+function trackWafDurations ({ duration, durationExt }, versionsTags) {
+  if (duration) {
+    appsecMetrics.distribution('waf.duration', versionsTags).track(duration)
+  }
+
+  if (durationExt) {
+    appsecMetrics.distribution('waf.duration_ext', versionsTags).track(durationExt)
+  }
+}
+
+function trackWafMetrics (store, metrics) {
+  const versionsTags = getVersionsTags(metrics.wafVersion, metrics.rulesVersion)
+
+  trackWafDurations(metrics, versionsTags)
+
+  const metricTags = getOrCreateMetricTags(store, versionsTags)
+
+  const { blockTriggered, ruleTriggered, wafTimeout } = metrics
+
+  if (blockTriggered) {
+    metricTags[tags.REQUEST_BLOCKED] = true
+  }
+
+  if (ruleTriggered) {
+    metricTags[tags.RULE_TRIGGERED] = true
+  }
+
+  if (wafTimeout) {
+    metricTags[tags.WAF_TIMEOUT] = true
+  }
+
+  return metricTags
+}
+
+function getOrCreateMetricTags (store, versionsTags) {
+  let metricTags = store[DD_TELEMETRY_WAF_RESULT_TAGS]
+
+  if (!metricTags) {
+    metricTags = {
+      [tags.REQUEST_BLOCKED]: false,
+      [tags.RULE_TRIGGERED]: false,
+      [tags.WAF_TIMEOUT]: false,
+
+      ...versionsTags
+    }
+    store[DD_TELEMETRY_WAF_RESULT_TAGS] = metricTags
+  }
+
+  return metricTags
+}
+
+function incrementWafInit (wafVersion, rulesVersion) {
+  const versionsTags = getVersionsTags(wafVersion, rulesVersion)
+
+  appsecMetrics.count('waf.init', versionsTags).inc()
+}
+
+function incrementWafUpdates (wafVersion, rulesVersion) {
+  const versionsTags = getVersionsTags(wafVersion, rulesVersion)
+
+  appsecMetrics.count('waf.updates', versionsTags).inc()
+}
+
+function incrementWafRequests (store) {
+  const metricTags = store[DD_TELEMETRY_WAF_RESULT_TAGS]
+
+  if (metricTags) {
+    appsecMetrics.count('waf.requests', metricTags).inc()
+  }
+}
+
+module.exports = {
+  addWafRequestMetrics,
+  trackWafMetrics,
+  incrementWafInit,
+  incrementWafUpdates,
+  incrementWafRequests
+}

package/packages/dd-trace/src/appsec/user_tracking.js

@@ -5,9 +5,8 @@ const log = require('../log')
 const telemetry = require('./telemetry')
 const addresses = require('./addresses')
 const { keepTrace } = require('../priority_sampler')
-const { SAMPLING_MECHANISM_APPSEC } = require('../constants')
-const standalone = require('./standalone')
 const waf = require('./waf')
+const { ASM } = require('../standalone/product')
 
 // the RFC doesn't include '_id', but it's common in MongoDB
 const USER_ID_FIELDS = ['id', '_id', 'email', 'username', 'login', 'user']
@@ -151,8 +150,7 @@ function trackLogin (framework, login, user, success, rootSpan) {
     persistent[addresses.LOGIN_FAILURE] = null
   }
 
-  keepTrace(rootSpan, SAMPLING_MECHANISM_APPSEC)
-  standalone.sample(rootSpan)
+  keepTrace(rootSpan, ASM)
 
   rootSpan.addTags(newTags)
 

package/packages/dd-trace/src/ci-visibility/dynamic-instrumentation/index.js

@@ -9,7 +9,8 @@ const probeIdToResolveBreakpointSet = new Map()
 const probeIdToResolveBreakpointRemove = new Map()
 
 class TestVisDynamicInstrumentation {
-  constructor () {
+  constructor (config) {
+    this._config = config
     this.worker = null
     this._readyPromise = new Promise(resolve => {
       this._onReady = resolve
@@ -32,6 +33,9 @@ class TestVisDynamicInstrumentation {
   // 1. Probe ID
   // 2. Promise that's resolved when the breakpoint is set
   addLineProbe ({ file, line }, onHitBreakpoint) {
+    if (!this.worker) { // not init yet
+      this.start()
+    }
     const probeId = randomUUID()
 
     this.breakpointSetChannel.port2.postMessage(
@@ -52,7 +56,7 @@ class TestVisDynamicInstrumentation {
     return this._readyPromise
   }
 
-  start (config) {
+  start () {
     if (this.worker) return
 
     log.debug('Starting Test Visibility - Dynamic Instrumentation client...')
@@ -77,7 +81,7 @@ class TestVisDynamicInstrumentation {
           DD_TRACE_TELEMETRY_ENABLED: 0
         },
         workerData: {
-          config: config.serialize(),
+          config: this._config.serialize(),
           parentThreadId,
           rcPort: rcChannel.port1,
           configPort: configChannel.port1,
@@ -138,4 +142,12 @@ class TestVisDynamicInstrumentation {
   }
 }
 
-module.exports = new TestVisDynamicInstrumentation()
+let dynamicInstrumentation
+
+module.exports = (config) => {
+  if (dynamicInstrumentation) {
+    return dynamicInstrumentation
+  }
+  dynamicInstrumentation = new TestVisDynamicInstrumentation(config)
+  return dynamicInstrumentation
+}

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

@@ -16,7 +16,7 @@ const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
 const { getGitMetadataFromGitProperties, removeUserSensitiveInfo } = require('./git_properties')
 const { updateConfig } = require('./telemetry')
 const telemetryMetrics = require('./telemetry/metrics')
-const { getIsGCPFunction, getIsAzureFunction } = require('./serverless')
+const { isInServerlessEnvironment, getIsGCPFunction, getIsAzureFunction } = require('./serverless')
 const { ORIGIN_KEY, GRPC_CLIENT_ERROR_STATUSES, GRPC_SERVER_ERROR_STATUSES } = require('./constants')
 const { appendRules } = require('./payload-tagging/config')
 
@@ -419,10 +419,7 @@ class Config {
   }
 
   _isInServerlessEnvironment () {
-    const inAWSLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined
-    const isGCPFunction = getIsGCPFunction()
-    const isAzureFunction = getIsAzureFunction()
-    return inAWSLambda || isGCPFunction || isAzureFunction
+    return isInServerlessEnvironment()
   }
 
   // for _merge to work, every config value must have a default value
@@ -443,6 +440,7 @@ class Config {
 
     const defaults = setHiddenProperty(this, '_defaults', {})
 
+    this._setBoolean(defaults, 'apmTracingEnabled', true)
     this._setValue(defaults, 'appsec.apiSecurity.enabled', true)
     this._setValue(defaults, 'appsec.apiSecurity.sampleDelay', 30)
     this._setValue(defaults, 'appsec.blockedTemplateGraphql', undefined)
@@ -456,7 +454,6 @@ class Config {
     this._setValue(defaults, 'appsec.rateLimit', 100)
     this._setValue(defaults, 'appsec.rules', undefined)
     this._setValue(defaults, 'appsec.sca.enabled', null)
-    this._setValue(defaults, 'appsec.standalone.enabled', undefined)
     this._setValue(defaults, 'appsec.stackTrace.enabled', true)
     this._setValue(defaults, 'appsec.stackTrace.maxDepth', 32)
     this._setValue(defaults, 'appsec.stackTrace.maxStackTraces', 2)
@@ -575,7 +572,8 @@ class Config {
     this._setValue(defaults, 'url', undefined)
     this._setValue(defaults, 'version', pkg.version)
     this._setValue(defaults, 'instrumentation_config_id', undefined)
-    this._setValue(defaults, 'aws.dynamoDb.tablePrimaryKeys', undefined)
+    this._setValue(defaults, 'trace.aws.addSpanPointers', true)
+    this._setValue(defaults, 'trace.dynamoDb.tablePrimaryKeys', undefined)
   }
 
   _applyEnvironment () {
@@ -584,6 +582,7 @@ class Config {
       DD_AGENT_HOST,
       DD_API_SECURITY_ENABLED,
       DD_API_SECURITY_SAMPLE_DELAY,
+      DD_APM_TRACING_ENABLED,
       DD_APPSEC_AUTO_USER_INSTRUMENTATION_MODE,
       DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING,
       DD_APPSEC_ENABLED,
@@ -600,7 +599,6 @@ class Config {
       DD_APPSEC_RASP_ENABLED,
       DD_APPSEC_TRACE_RATE_LIMIT,
       DD_APPSEC_WAF_TIMEOUT,
-      DD_AWS_SDK_DYNAMODB_TABLE_PRIMARY_KEYS,
       DD_CRASHTRACKING_ENABLED,
       DD_CODE_ORIGIN_FOR_SPANS_ENABLED,
       DD_DATA_STREAMS_ENABLED,
@@ -666,10 +664,12 @@ class Config {
       DD_TRACE_AGENT_HOSTNAME,
       DD_TRACE_AGENT_PORT,
       DD_TRACE_AGENT_PROTOCOL_VERSION,
+      DD_TRACE_AWS_ADD_SPAN_POINTERS,
       DD_TRACE_BAGGAGE_MAX_BYTES,
       DD_TRACE_BAGGAGE_MAX_ITEMS,
       DD_TRACE_CLIENT_IP_ENABLED,
       DD_TRACE_CLIENT_IP_HEADER,
+      DD_TRACE_DYNAMODB_TABLE_PRIMARY_KEYS,
       DD_TRACE_ENABLED,
       DD_TRACE_EXPERIMENTAL_EXPORTER,
       DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED,
@@ -720,6 +720,10 @@ class Config {
     tagger.add(tags, DD_TRACE_TAGS)
     tagger.add(tags, DD_TRACE_GLOBAL_TAGS)
 
+    this._setBoolean(env, 'apmTracingEnabled', coalesce(
+      DD_APM_TRACING_ENABLED,
+      DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED && isFalse(DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED)
+    ))
     this._setBoolean(env, 'appsec.apiSecurity.enabled', coalesce(
       DD_API_SECURITY_ENABLED && isTrue(DD_API_SECURITY_ENABLED),
       DD_EXPERIMENTAL_API_SECURITY_ENABLED && isTrue(DD_EXPERIMENTAL_API_SECURITY_ENABLED)
@@ -743,7 +747,6 @@ class Config {
     this._setString(env, 'appsec.rules', DD_APPSEC_RULES)
     // DD_APPSEC_SCA_ENABLED is never used locally, but only sent to the backend
     this._setBoolean(env, 'appsec.sca.enabled', DD_APPSEC_SCA_ENABLED)
-    this._setBoolean(env, 'appsec.standalone.enabled', DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED)
     this._setBoolean(env, 'appsec.stackTrace.enabled', DD_APPSEC_STACK_TRACE_ENABLED)
     this._setValue(env, 'appsec.stackTrace.maxDepth', maybeInt(DD_APPSEC_MAX_STACK_TRACE_DEPTH))
     this._envUnprocessed['appsec.stackTrace.maxDepth'] = DD_APPSEC_MAX_STACK_TRACE_DEPTH
@@ -755,7 +758,10 @@ class Config {
     this._setValue(env, 'baggageMaxItems', DD_TRACE_BAGGAGE_MAX_ITEMS)
     this._setBoolean(env, 'clientIpEnabled', DD_TRACE_CLIENT_IP_ENABLED)
     this._setString(env, 'clientIpHeader', DD_TRACE_CLIENT_IP_HEADER)
-    this._setBoolean(env, 'crashtracking.enabled', DD_CRASHTRACKING_ENABLED)
+    this._setBoolean(env, 'crashtracking.enabled', coalesce(
+      DD_CRASHTRACKING_ENABLED,
+      !this._isInServerlessEnvironment()
+    ))
     this._setBoolean(env, 'codeOriginForSpans.enabled', DD_CODE_ORIGIN_FOR_SPANS_ENABLED)
     this._setString(env, 'dbmPropagationMode', DD_DBM_PROPAGATION_MODE)
     this._setString(env, 'dogstatsd.hostname', DD_DOGSTATSD_HOST || DD_DOGSTATSD_HOSTNAME)
@@ -825,7 +831,11 @@ class Config {
       this._envUnprocessed.peerServiceMapping = DD_TRACE_PEER_SERVICE_MAPPING
     }
     this._setString(env, 'port', DD_TRACE_AGENT_PORT)
-    const profilingEnabledEnv = coalesce(DD_EXPERIMENTAL_PROFILING_ENABLED, DD_PROFILING_ENABLED)
+    const profilingEnabledEnv = coalesce(
+      DD_EXPERIMENTAL_PROFILING_ENABLED,
+      DD_PROFILING_ENABLED,
+      this._isInServerlessEnvironment() ? 'false' : undefined
+    )
     const profilingEnabled = isTrue(profilingEnabledEnv)
       ? 'true'
       : isFalse(profilingEnabledEnv)
@@ -905,7 +915,8 @@ class Config {
     this._setBoolean(env, 'tracing', DD_TRACING_ENABLED)
     this._setString(env, 'version', DD_VERSION || tags.version)
     this._setBoolean(env, 'inferredProxyServicesEnabled', DD_TRACE_INFERRED_PROXY_SERVICES_ENABLED)
-    this._setString(env, 'aws.dynamoDb.tablePrimaryKeys', DD_AWS_SDK_DYNAMODB_TABLE_PRIMARY_KEYS)
+    this._setBoolean(env, 'trace.aws.addSpanPointers', DD_TRACE_AWS_ADD_SPAN_POINTERS)
+    this._setString(env, 'trace.dynamoDb.tablePrimaryKeys', DD_TRACE_DYNAMODB_TABLE_PRIMARY_KEYS)
     this._setArray(env, 'graphqlErrorExtensions', DD_TRACE_GRAPHQL_ERROR_EXTENSIONS)
   }
 
@@ -918,6 +929,10 @@ class Config {
 
     tagger.add(tags, options.tags)
 
+    this._setBoolean(opts, 'apmTracingEnabled', coalesce(
+      options.apmTracingEnabled,
+      options.experimental?.appsec?.standalone && !options.experimental.appsec.standalone.enabled
+    ))
     this._setBoolean(opts, 'appsec.apiSecurity.enabled', options.appsec.apiSecurity?.enabled)
     this._setValue(opts, 'appsec.blockedTemplateGraphql', maybeFile(options.appsec.blockedTemplateGraphql))
     this._setValue(opts, 'appsec.blockedTemplateHtml', maybeFile(options.appsec.blockedTemplateHtml))
@@ -932,7 +947,6 @@ class Config {
     this._setValue(opts, 'appsec.rateLimit', maybeInt(options.appsec.rateLimit))
     this._optsUnprocessed['appsec.rateLimit'] = options.appsec.rateLimit
     this._setString(opts, 'appsec.rules', options.appsec.rules)
-    this._setBoolean(opts, 'appsec.standalone.enabled', options.experimental?.appsec?.standalone?.enabled)
     this._setBoolean(opts, 'appsec.stackTrace.enabled', options.appsec.stackTrace?.enabled)
     this._setValue(opts, 'appsec.stackTrace.maxDepth', maybeInt(options.appsec.stackTrace?.maxDepth))
     this._optsUnprocessed['appsec.stackTrace.maxDepth'] = options.appsec.stackTrace?.maxDepth
@@ -1117,7 +1131,10 @@ class Config {
   }
 
   _isTraceStatsComputationEnabled () {
-    return coalesce(
+    const apmTracingEnabled = this._options.apmTracingEnabled !== false &&
+      this._env.apmTracingEnabled !== false
+
+    return apmTracingEnabled && coalesce(
       this._optionsArg.stats,
       process.env.DD_TRACE_STATS_COMPUTATION_ENABLED,
       getIsGCPFunction() || getIsAzureFunction()

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

@@ -34,7 +34,7 @@ module.exports = {
   SCI_REPOSITORY_URL: '_dd.git.repository_url',
   SCI_COMMIT_SHA: '_dd.git.commit.sha',
   APM_TRACING_ENABLED_KEY: '_dd.apm.enabled',
-  APPSEC_PROPAGATION_KEY: '_dd.p.appsec',
+  TRACE_SOURCE_PROPAGATION_KEY: '_dd.p.ts',
   PAYLOAD_TAG_REQUEST_PREFIX: 'aws.request.body',
   PAYLOAD_TAG_RESPONSE_PREFIX: 'aws.response.body',
   PAYLOAD_TAGGING_MAX_TAGS: 758,

package/packages/dd-trace/src/{data_streams.js → datastreams/checkpointer.js}

@@ -1,4 +1,4 @@
-const DataStreamsContext = require('./data_streams_context')
+const DataStreamsContext = require('./context')
 
 class DataStreamsCheckpointer {
   constructor (tracer) {

package/packages/dd-trace/src/{data_streams_context.js → datastreams/context.js}

@@ -1,5 +1,5 @@
-const { storage } = require('../../datadog-core')
-const log = require('./log')
+const { storage } = require('../../../datadog-core')
+const log = require('../log')
 
 function getDataStreamsContext () {
   const store = storage('legacy').getStore()

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

@@ -0,0 +1,104 @@
+'use strict'
+
+const {
+  getAmqpMessageSize,
+  getHeadersSize,
+  getMessageSize,
+  getSizeOrZero
+} = require('./size')
+
+// This is only needed because DSM code is spread across existing tracing
+// plugins instead of having dedicated DSM plugins that are themselves
+// lazy loaded.
+//
+// TODO: Remove this when DSM has been moved to dedicaed plugins.
+function lazyClass (classGetter, methods = [], staticMethods = []) {
+  let constructorArgs
+  let ActiveClass
+
+  const LazyClass = function (...args) {
+    constructorArgs = args
+  }
+
+  const activate = () => {
+    return (ActiveClass = ActiveClass || classGetter())
+  }
+
+  for (const method of methods) {
+    LazyClass.prototype[method] = function (...args) {
+      const instance = activate() && new ActiveClass(...constructorArgs)
+
+      // Replace the whole prototype instead of only the method itself whenever
+      // any individual method is called to avoid running through this code
+      // again every time another method is called. This is not only more
+      // efficient but it also means that the class instance does not need to be
+      // stored for future calls to other methods.
+      Object.setPrototypeOf(this, instance)
+
+      return this[method](...args)
+    }
+  }
+
+  for (const method of staticMethods) {
+    LazyClass[method] = function (...args) {
+      LazyClass[method] = activate() && ActiveClass[method]
+
+      return LazyClass[method](...args)
+    }
+  }
+
+  return LazyClass
+}
+
+const DsmPathwayCodec = lazyClass(() => require('./pathway').DsmPathwayCodec, [], [
+  'encode',
+  'decode'
+])
+
+const DataStreamsCheckpointer = lazyClass(() => require('./checkpointer').DataStreamsCheckpointer, [
+  'setProduceCheckpoint',
+  'setConsumeCheckpoint'
+])
+
+const DataStreamsManager = lazyClass(() => require('./manager').DataStreamsManager, [
+  'setCheckpoint',
+  'decodeDataStreamsContext'
+])
+
+// TODO: Are all those methods actually public?
+const DataStreamsProcessor = lazyClass(() => require('./processor').DataStreamsProcessor, [
+  'onInterval',
+  'bucketFromTimestamp',
+  'recordCheckpoint',
+  'setCheckpoint',
+  'recordOffset',
+  'setOffset',
+  'setUrl',
+  'trySampleSchema',
+  'canSampleSchema',
+  'getSchema'
+])
+
+const SchemaBuilder = lazyClass(() => require('./schemas/schema_builder').SchemaBuilder, [
+  'build',
+  'addProperty',
+  'shouldExtractSchema'
+], [
+  'getCache',
+  'getSchemaDefinition',
+  'getSchema'
+])
+
+module.exports = {
+  DsmPathwayCodec,
+  DataStreamsCheckpointer,
+  DataStreamsManager,
+  DataStreamsProcessor,
+  SchemaBuilder,
+
+  // These are small functions so they are exposed directly and not lazy loaded.
+  getAmqpMessageSize,
+  getHeadersSize,
+  getMessageSize,
+  getSizeOrZero
+}

package/packages/dd-trace/src/datastreams/manager.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { DsmPathwayCodec } = require('./pathway')
+const DataStreamsContext = require('./context')
+
+class DataStreamsManager {
+  constructor (processor) {
+    this._dataStreamsProcessor = processor
+  }
+
+  setCheckpoint (edgeTags, span, payloadSize = 0) {
+    const ctx = this._dataStreamsProcessor.setCheckpoint(
+      edgeTags, span, DataStreamsContext.getDataStreamsContext(), payloadSize
+    )
+    DataStreamsContext.setDataStreamsContext(ctx)
+    return ctx
+  }
+
+  decodeDataStreamsContext (carrier) {
+    const ctx = DsmPathwayCodec.decode(carrier)
+    // we erase the previous context everytime we decode a new one
+    DataStreamsContext.setDataStreamsContext(ctx)
+    return ctx
+  }
+}
+
+module.exports = { DataStreamsManager }