dd-trace 4.16.0 → 4.18.0

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

@@ -602,6 +602,23 @@ module.exports = {
       tags[refKey] = ref
     }
 
+    if (env.CODEBUILD_INITIATOR?.startsWith('codepipeline/')) {
+      const {
+        CODEBUILD_BUILD_ARN,
+        DD_ACTION_EXECUTION_ID,
+        DD_PIPELINE_EXECUTION_ID
+      } = env
+      tags = {
+        [CI_PROVIDER_NAME]: 'awscodepipeline',
+        [CI_PIPELINE_ID]: DD_PIPELINE_EXECUTION_ID,
+        [CI_ENV_VARS]: JSON.stringify({
+          CODEBUILD_BUILD_ARN,
+          DD_PIPELINE_EXECUTION_ID,
+          DD_ACTION_EXECUTION_ID
+        })
+      }
+    }
+
     normalizeTag(tags, CI_WORKSPACE_PATH, resolveTilde)
     normalizeTag(tags, GIT_REPOSITORY_URL, filterSensitiveInfoFromRepository)
     normalizeTag(tags, GIT_BRANCH, normalizeRef)

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

@@ -61,15 +61,37 @@ function unshallowRepository () {
   }
   const defaultRemoteName = sanitizedExec('git', ['config', '--default', 'origin', '--get', 'clone.defaultRemoteName'])
   const revParseHead = sanitizedExec('git', ['rev-parse', 'HEAD'])
-  sanitizedExec('git', [
+
+  const baseGitOptions = [
     'fetch',
     '--shallow-since="1 month ago"',
     '--update-shallow',
     '--filter=blob:none',
     '--recurse-submodules=no',
-    defaultRemoteName,
-    revParseHead
-  ])
+    defaultRemoteName
+  ]
+
+  try {
+    execFileSync('git', [
+      ...baseGitOptions,
+      revParseHead
+    ], { stdio: 'pipe' })
+  } catch (e) {
+    // If the local HEAD is a commit that has not been pushed to the remote, the above command will fail.
+    log.error(e)
+    const upstreamRemote = sanitizedExec('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'])
+    try {
+      execFileSync('git', [
+        ...baseGitOptions,
+        upstreamRemote
+      ], { stdio: 'pipe' })
+    } catch (e) {
+      // If the CI is working on a detached HEAD or branch tracking hasn’t been set up, the above command will fail.
+      log.error(e)
+      // We use sanitizedExec here because if this last option fails, we'll give up.
+      sanitizedExec('git', baseGitOptions)
+    }
+  }
 }
 
 function getRepositoryUrl () {

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

@@ -58,6 +58,8 @@ const TEST_ITR_SKIPPING_ENABLED = 'test.itr.tests_skipping.enabled'
 const TEST_ITR_SKIPPING_TYPE = 'test.itr.tests_skipping.type'
 const TEST_ITR_SKIPPING_COUNT = 'test.itr.tests_skipping.count'
 const TEST_CODE_COVERAGE_ENABLED = 'test.code_coverage.enabled'
+const TEST_ITR_UNSKIPPABLE = 'test.itr.unskippable'
+const TEST_ITR_FORCED_RUN = 'test.itr.forced_run'
 
 const TEST_CODE_COVERAGE_LINES_PCT = 'test.code_coverage.lines_pct'
 
@@ -107,6 +109,8 @@ module.exports = {
   TEST_ITR_SKIPPING_COUNT,
   TEST_CODE_COVERAGE_ENABLED,
   TEST_CODE_COVERAGE_LINES_PCT,
+  TEST_ITR_UNSKIPPABLE,
+  TEST_ITR_FORCED_RUN,
   addIntelligentTestRunnerSpanTags,
   getCoveredFilenamesFromCoverage,
   resetCoverage,
@@ -114,7 +118,8 @@ module.exports = {
   fromCoverageMapToCoverage,
   getTestLineStart,
   getCallSites,
-  removeInvalidMetadata
+  removeInvalidMetadata,
+  parseAnnotations
 }
 
 // Returns pkg manager and its version, separated by '-', e.g. npm-8.15.0 or yarn-1.22.19
@@ -366,7 +371,9 @@ function addIntelligentTestRunnerSpanTags (
     isCodeCoverageEnabled,
     testCodeCoverageLinesTotal,
     skippingCount,
-    skippingType = 'suite'
+    skippingType = 'suite',
+    hasUnskippableSuites,
+    hasForcedToRunSuites
   }
 ) {
   testSessionSpan.setTag(TEST_ITR_TESTS_SKIPPED, isSuitesSkipped ? 'true' : 'false')
@@ -381,6 +388,15 @@ function addIntelligentTestRunnerSpanTags (
   testModuleSpan.setTag(TEST_ITR_SKIPPING_COUNT, skippingCount)
   testModuleSpan.setTag(TEST_CODE_COVERAGE_ENABLED, isCodeCoverageEnabled ? 'true' : 'false')
 
+  if (hasUnskippableSuites) {
+    testSessionSpan.setTag(TEST_ITR_UNSKIPPABLE, 'true')
+    testModuleSpan.setTag(TEST_ITR_UNSKIPPABLE, 'true')
+  }
+  if (hasForcedToRunSuites) {
+    testSessionSpan.setTag(TEST_ITR_FORCED_RUN, 'true')
+    testModuleSpan.setTag(TEST_ITR_FORCED_RUN, 'true')
+  }
+
   // If suites have been skipped we don't want to report the total coverage, as it will be wrong
   if (testCodeCoverageLinesTotal !== undefined && !isSuitesSkipped) {
     testSessionSpan.setTag(TEST_CODE_COVERAGE_LINES_PCT, testCodeCoverageLinesTotal)
@@ -477,3 +493,30 @@ function getCallSites () {
 
   return v8StackTrace
 }
+
+/**
+ * Gets an object of test tags from an Playwright annotations array.
+ * @param {Object[]} annotations - Annotations from a Playwright test.
+ * @param {string} annotations[].type - Type of annotation. A string of the shape DD_TAGS[$tag_name].
+ * @param {string} annotations[].description - Value of the tag.
+ */
+function parseAnnotations (annotations) {
+  return annotations.reduce((tags, annotation) => {
+    if (!annotation?.type) {
+      return tags
+    }
+    const { type, description } = annotation
+    if (type.startsWith('DD_TAGS')) {
+      const regex = /\[(.*?)\]/
+      const match = regex.exec(type)
+      let tagValue = ''
+      if (match) {
+        tagValue = match[1]
+      }
+      if (tagValue) {
+        tags[tagValue] = description
+      }
+    }
+    return tags
+  }, {})
+}

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

@@ -37,6 +37,8 @@ class Config {
       DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
       DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
       DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES,
+      DD_PROFILING_CODEHOTSPOTS_ENABLED,
+      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
       DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED
     } = process.env
@@ -53,8 +55,6 @@ class Config {
       Number(DD_PROFILING_UPLOAD_TIMEOUT), 60 * 1000)
     const sourceMap = coalesce(options.sourceMap,
       DD_PROFILING_SOURCE_MAP, true)
-    const endpointCollectionEnabled = coalesce(options.endpointCollection,
-      DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED, false)
     const pprofPrefix = coalesce(options.pprofPrefix,
       DD_PROFILING_PPROF_PREFIX, '')
 
@@ -71,11 +71,25 @@ class Config {
       tagger.parse({ env, host, service, version, functionname })
     )
     this.logger = ensureLogger(options.logger)
+    const logger = this.logger
+    function logExperimentalVarDeprecation (shortVarName) {
+      const deprecatedEnvVarName = `DD_PROFILING_EXPERIMENTAL_${shortVarName}`
+      const v = process.env[deprecatedEnvVarName]
+      // not null, undefined, or NaN -- same logic as koalas.hasValue
+      // eslint-disable-next-line no-self-compare
+      if (v != null && v === v) {
+        logger.warn(`${deprecatedEnvVarName} is deprecated. Use DD_PROFILING_${shortVarName} instead.`)
+      }
+    }
     this.flushInterval = flushInterval
     this.uploadTimeout = uploadTimeout
     this.sourceMap = sourceMap
     this.debugSourceMaps = isTrue(coalesce(options.debugSourceMaps, DD_PROFILING_DEBUG_SOURCE_MAPS, false))
-    this.endpointCollectionEnabled = endpointCollectionEnabled
+    this.endpointCollectionEnabled = isTrue(coalesce(options.endpointCollection,
+      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED, false))
+    logExperimentalVarDeprecation('ENDPOINT_COLLECTION_ENABLED')
+
     this.pprofPrefix = pprofPrefix
     this.v8ProfilerBugWorkaroundEnabled = isTrue(coalesce(options.v8ProfilerBugWorkaround,
       DD_PROFILING_V8_PROFILER_BUG_WORKAROUND, true))
@@ -113,8 +127,11 @@ class Config {
     const profilers = options.profilers
       ? options.profilers
       : getProfilers({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS })
+
     this.codeHotspotsEnabled = isTrue(coalesce(options.codeHotspotsEnabled,
+      DD_PROFILING_CODEHOTSPOTS_ENABLED,
       DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED, false))
+    logExperimentalVarDeprecation('CODEHOTSPOTS_ENABLED')
 
     this.profilers = ensureProfilers(profilers, this)
   }

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -12,6 +12,12 @@ const beforeCh = dc.channel('dd-trace:storage:before')
 const enterCh = dc.channel('dd-trace:storage:enter')
 const profilerTelemetryMetrics = telemetryMetrics.manager.namespace('profilers')
 
+const threadName = (function () {
+  const { isMainThread, threadId } = require('node:worker_threads')
+  const name = isMainThread ? 'Main' : `Worker #${threadId}`
+  return `${name} Event Loop`
+})()
+
 let kSampleCount
 
 function getActiveSpan () {
@@ -23,8 +29,8 @@ function getStartedSpans (context) {
   return context._trace.started
 }
 
-function generateLabels ({ spanId, rootSpanId, webTags, endpoint }) {
-  const labels = {}
+function generateLabels ({ context: { spanId, rootSpanId, webTags, endpoint }, timestamp }) {
+  const labels = { 'thread name': threadName }
   if (spanId) {
     labels['span id'] = spanId
   }
@@ -37,6 +43,8 @@ function generateLabels ({ spanId, rootSpanId, webTags, endpoint }) {
     // fallback to endpoint computed when sample was taken
     labels['trace endpoint'] = endpoint
   }
+  // Incoming timestamps are in microseconds, we emit nanos.
+  labels['end_timestamp_ns'] = timestamp * 1000n
 
   return labels
 }
@@ -56,29 +64,6 @@ function endpointNameFromTags (tags) {
   ].filter(v => v).join(' ')
 }
 
-function updateContext (context, span, startedSpans, endpointCollectionEnabled) {
-  context.spanId = span.context().toSpanId()
-  const rootSpan = startedSpans[0]
-  if (rootSpan) {
-    context.rootSpanId = rootSpan.context().toSpanId()
-    if (endpointCollectionEnabled) {
-      // Find the first webspan starting from the end:
-      // There might be several webspans, for example with next.js, http plugin creates a first span
-      // and then next.js plugin creates a child span, and this child span haves the correct endpoint information.
-      for (let i = startedSpans.length - 1; i >= 0; i--) {
-        const tags = getSpanContextTags(startedSpans[i])
-        if (isWebServerSpan(tags)) {
-          context.webTags = tags
-          // endpoint may not be determined yet, but keep it as fallback
-          // if tags are not available anymore during serialization
-          context.endpoint = endpointNameFromTags(tags)
-          break
-        }
-      }
-    }
-  }
-}
-
 class NativeWallProfiler {
   constructor (options = {}) {
     this.type = 'wall'
@@ -86,6 +71,7 @@ class NativeWallProfiler {
     this._flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
     this._codeHotspotsEnabled = !!options.codeHotspotsEnabled
     this._endpointCollectionEnabled = !!options.endpointCollectionEnabled
+    this._withContexts = this._codeHotspotsEnabled || this._endpointCollectionEnabled
     this._v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
     this._mapper = undefined
     this._pprof = undefined
@@ -100,15 +86,13 @@ class NativeWallProfiler {
     return this._codeHotspotsEnabled
   }
 
+  endpointCollectionEnabled () {
+    return this._endpointCollectionEnabled
+  }
+
   start ({ mapper } = {}) {
     if (this._started) return
 
-    if (this._codeHotspotsEnabled && !this._emittedFFMessage && this._logger) {
-      this._logger.debug(
-        `Wall profiler: Enable trace_show_breakdown_profiling_for_node feature flag to see code hotspots.`)
-      this._emittedFFMessage = true
-    }
-
     this._mapper = mapper
     this._pprof = require('@datadog/pprof')
     kSampleCount = this._pprof.time.constants.kSampleCount
@@ -125,12 +109,12 @@ class NativeWallProfiler {
       intervalMicros: this._samplingIntervalMicros,
       durationMillis: this._flushIntervalMillis,
       sourceMapper: this._mapper,
-      withContexts: this._codeHotspotsEnabled,
+      withContexts: this._withContexts,
       lineNumbers: false,
       workaroundV8Bug: this._v8ProfilerBugWorkaroundEnabled
     })
 
-    if (this._codeHotspotsEnabled) {
+    if (this._withContexts) {
       this._profilerState = this._pprof.time.getState()
       this._currentContext = {}
       this._pprof.time.setContext(this._currentContext)
@@ -155,9 +139,7 @@ class NativeWallProfiler {
       this._currentContext = {}
       this._pprof.time.setContext(this._currentContext)
 
-      if (this._lastSpan) {
-        updateContext(context, this._lastSpan, this._lastStartedSpans, this._endpointCollectionEnabled)
-      }
+      this._updateContext(context)
     }
 
     const span = getActiveSpan()
@@ -170,6 +152,35 @@ class NativeWallProfiler {
     }
   }
 
+  _updateContext (context) {
+    if (!this._lastSpan) {
+      return
+    }
+    if (this._codeHotspotsEnabled) {
+      context.spanId = this._lastSpan.context().toSpanId()
+      const rootSpan = this._lastStartedSpans[0]
+      if (rootSpan) {
+        context.rootSpanId = rootSpan.context().toSpanId()
+      }
+    }
+    if (this._endpointCollectionEnabled) {
+      const startedSpans = this._lastStartedSpans
+      // Find the first webspan starting from the end:
+      // There might be several webspans, for example with next.js, http plugin creates a first span
+      // and then next.js plugin creates a child span, and this child span haves the correct endpoint information.
+      for (let i = startedSpans.length - 1; i >= 0; i--) {
+        const tags = getSpanContextTags(startedSpans[i])
+        if (isWebServerSpan(tags)) {
+          context.webTags = tags
+          // endpoint may not be determined yet, but keep it as fallback
+          // if tags are not available anymore during serialization
+          context.endpoint = endpointNameFromTags(tags)
+          break
+        }
+      }
+    }
+  }
+
   _reportV8bug (maybeBug) {
     const tag = `v8_profiler_bug_workaround_enabled:${this._v8ProfilerBugWorkaroundEnabled}`
     const metric = `v8_cpu_profiler${maybeBug ? '_maybe' : ''}_stuck_event_loop`
@@ -182,12 +193,12 @@ class NativeWallProfiler {
 
   _stop (restart) {
     if (!this._started) return
-    if (this._codeHotspotsEnabled) {
+    if (this._withContexts) {
       // update last sample context if needed
       this._enter()
       this._lastSampleCount = 0
     }
-    const profile = this._pprof.time.stop(restart, this._codeHotspotsEnabled ? generateLabels : undefined)
+    const profile = this._pprof.time.stop(restart, this._withContexts ? generateLabels : undefined)
     if (restart) {
       const v8BugDetected = this._pprof.time.v8ProfilerStuckEventLoopDetected()
       if (v8BugDetected !== 0) {
@@ -209,9 +220,9 @@ class NativeWallProfiler {
     if (!this._started) return
 
     const profile = this._stop(false)
-    if (this._codeHotspotsEnabled) {
+    if (this._withContexts) {
       beforeCh.unsubscribe(this._enter)
-      enterCh.subscribe(this._enter)
+      enterCh.unsubscribe(this._enter)
       this._profilerState = undefined
     }
 

package/packages/dd-trace/src/service-naming/extra-services.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const maxExtraServices = 64
+const extraServices = new Set()
+
+function getExtraServices () {
+  return [...extraServices]
+}
+
+function registerExtraService (serviceName) {
+  if (serviceName && extraServices.size < maxExtraServices) {
+    extraServices.add(serviceName)
+  }
+}
+
+function clear () {
+  extraServices.clear()
+}
+
+module.exports = {
+  registerExtraService,
+  getExtraServices,
+  clear
+}

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

@@ -7,6 +7,7 @@ const dependencies = require('./dependencies')
 const { sendData } = require('./send-data')
 
 const { manager: metricsManager } = require('./metrics')
+const logs = require('./logs')
 
 const telemetryStartChannel = dc.channel('datadog:telemetry:start')
 const telemetryStopChannel = dc.channel('datadog:telemetry:stop')
@@ -139,10 +140,13 @@ function start (aConfig, thePluginManager) {
   heartbeatInterval = config.telemetry.heartbeatInterval
 
   dependencies.start(config, application, host)
+  logs.start(config)
+
   sendData(config, application, host, 'app-started', appStarted())
   heartbeat(config, application, host)
   interval = setInterval(() => {
     metricsManager.send(config, application, host)
+    logs.send(config, application, host)
   }, heartbeatInterval)
   interval.unref()
   process.on('beforeExit', onBeforeExit)

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

@@ -0,0 +1,65 @@
+'use strict'
+
+const dc = require('../../../../diagnostics_channel')
+const logCollector = require('./log-collector')
+const { sendData } = require('../send-data')
+
+const telemetryLog = dc.channel('datadog:telemetry:log')
+
+let enabled = false
+
+/**
+ * Telemetry logs api defines only ERROR, WARN and DEBUG levels:
+ * - WARN level is enabled by default
+ * - DEBUG level will be possible to activate with an env var or telemetry config property
+ */
+function isLevelEnabled (level) {
+  return isValidLevel(level)
+}
+
+function isValidLevel (level) {
+  switch (level) {
+    case 'ERROR':
+    case 'WARN':
+      return true
+    default:
+      return false
+  }
+}
+
+function onLog (log) {
+  if (isLevelEnabled(log?.level?.toUpperCase())) {
+    logCollector.add(log)
+  }
+}
+
+function start (config) {
+  if (!config.telemetry.logCollection || enabled) return
+
+  enabled = true
+
+  telemetryLog.subscribe(onLog)
+}
+
+function stop () {
+  enabled = false
+
+  if (telemetryLog.hasSubscribers) {
+    telemetryLog.unsubscribe(onLog)
+  }
+}
+
+function send (config, application, host) {
+  if (!enabled) return
+
+  const logs = logCollector.drain()
+  if (logs) {
+    sendData(config, application, host, 'logs', logs)
+  }
+}
+
+module.exports = {
+  start,
+  stop,
+  send
+}

package/packages/dd-trace/src/{appsec/iast/telemetry/log → telemetry/logs}/log-collector.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const log = require('../../../../log')
+const log = require('../../log')
 
 const logs = new Map()
 
@@ -18,37 +18,21 @@ function hashCode (hashSource) {
 }
 
 function createHash (logEntry) {
-  if (!logEntry) return 0
-
   const prime = 31
   let result = ((!logEntry.level) ? 0 : hashCode(logEntry.level))
   result = (((prime * result) | 0) + ((!logEntry.message) ? 0 : hashCode(logEntry.message))) | 0
-
-  // NOTE: tags are not used at the moment
-  // result = (((prime * result) | 0) + ((!logEntry.tags) ? 0 : hashCode(logEntry.tags))) | 0
   result = (((prime * result) | 0) + ((!logEntry.stack_trace) ? 0 : hashCode(logEntry.stack_trace))) | 0
   return result
 }
 
-function newLogEntry (message, level, tags) {
-  return {
-    message,
-    level,
-    tags
-  }
-}
-
 function isValid (logEntry) {
-  return logEntry && logEntry.level && logEntry.message
+  return logEntry?.level && logEntry.message
 }
 
 const logCollector = {
   add (logEntry) {
     try {
-      if (!isValid(logEntry)) {
-        log.info('IAST log collector discarding invalid log')
-        return
-      }
+      if (!isValid(logEntry)) return false
 
       // NOTE: should errors have higher priority? and discard log entries with lower priority?
       if (logs.size >= maxEntries) {
@@ -70,11 +54,13 @@ const logCollector = {
   drain () {
     if (logs.size === 0) return
 
-    const drained = []
-    drained.push(...logs.values())
+    const drained = [...logs.values()]
 
     if (overflowedCount > 0) {
-      drained.push(newLogEntry(`Omitted ${overflowedCount} entries due to overflowing`, 'ERROR'))
+      drained.push({
+        message: `Omitted ${overflowedCount} entries due to overflowing`,
+        level: 'ERROR'
+      })
     }
 
     this.reset()
@@ -85,6 +71,7 @@ const logCollector = {
   reset (max) {
     logs.clear()
     overflowedCount = 0
+
     if (max) {
       maxEntries = max
     }

package/packages/dd-trace/src/telemetry/metrics.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const { version } = require('../../../../package.json')
-
 const { sendData } = require('./send-data')
 
 function getId (type, namespace, name, tags) {
@@ -35,10 +33,7 @@ class Metric {
     this.metric = common ? metric : `nodejs.${metric}`
     this.tags = tagArray(tags)
     if (common) {
-      this.tags.push('lib_language:nodejs')
       this.tags.push(`version:${process.version}`)
-    } else {
-      this.tags.push(`lib_version:${version}`)
     }
     this.common = common
 

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

@@ -1,87 +0,0 @@
-'use strict'
-
-const dc = require('../../../../../../diagnostics_channel')
-const logCollector = require('./log-collector')
-const { sendData } = require('../../../../telemetry/send-data')
-const log = require('../../../../log')
-
-const telemetryStartChannel = dc.channel('datadog:telemetry:start')
-const telemetryStopChannel = dc.channel('datadog:telemetry:stop')
-
-let config, application, host, interval
-
-function publish (log) {
-  if (log && isLevelEnabled(log.level)) {
-    logCollector.add(log)
-  }
-}
-
-function sendLogs () {
-  try {
-    const logs = logCollector.drain()
-    if (logs) {
-      sendData(config, application, host, 'logs', logs)
-    }
-  } catch (e) {
-    log.error(e)
-  }
-}
-
-function isLevelEnabled (level) {
-  return isLogCollectionEnabled(config) && level !== 'DEBUG'
-}
-
-function isLogCollectionEnabled (config) {
-  return config && config.telemetry && config.telemetry.logCollection
-}
-
-function onTelemetryStart (msg) {
-  if (!msg || !isLogCollectionEnabled(msg.config)) {
-    log.info('IAST telemetry logs start event received but log collection is not enabled or configuration is incorrect')
-    return false
-  }
-
-  log.info('IAST telemetry logs starting')
-
-  config = msg.config
-  application = msg.application
-  host = msg.host
-
-  if (msg.heartbeatInterval) {
-    interval = setInterval(sendLogs, msg.heartbeatInterval)
-    interval.unref()
-  }
-
-  return true
-}
-
-function onTelemetryStop () {
-  stop()
-}
-
-function start () {
-  telemetryStartChannel.subscribe(onTelemetryStart)
-  telemetryStopChannel.subscribe(onTelemetryStop)
-}
-
-function stop () {
-  if (!isLogCollectionEnabled(config)) return
-
-  log.info('IAST telemetry logs stopping')
-
-  config = null
-  application = null
-  host = null
-
-  if (telemetryStartChannel.hasSubscribers) {
-    telemetryStartChannel.unsubscribe(onTelemetryStart)
-  }
-
-  if (telemetryStopChannel.hasSubscribers) {
-    telemetryStopChannel.unsubscribe(onTelemetryStop)
-  }
-
-  clearInterval(interval)
-}
-
-module.exports = { start, stop, publish, isLevelEnabled }