dd-trace 4.17.0 → 4.18.0

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

@@ -10,7 +10,7 @@ const coalesce = require('koalas')
 const tagger = require('./tagger')
 const { isTrue, isFalse } = require('./util')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('./plugins/util/tags')
-const { getGitMetadataFromGitProperties } = require('./git_properties')
+const { getGitMetadataFromGitProperties, removeUserSensitiveInfo } = require('./git_properties')
 const { updateConfig } = require('./telemetry')
 const { getIsGCPFunction, getIsAzureFunctionConsumptionPlan } = require('./serverless')
 
@@ -251,7 +251,7 @@ class Config {
     )
     const DD_TELEMETRY_METRICS_ENABLED = coalesce(
       process.env.DD_TELEMETRY_METRICS_ENABLED,
-      false
+      true
     )
     const DD_TRACE_AGENT_PROTOCOL_VERSION = coalesce(
       options.protocolVersion,
@@ -447,7 +447,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       5 // seconds
     )
 
-    const iastOptions = options.experimental && options.experimental.iast
+    const iastOptions = options?.experimental?.iast
     const DD_IAST_ENABLED = coalesce(
       iastOptions &&
       (iastOptions === true || iastOptions.enabled === true),
@@ -461,7 +461,7 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
 
     const defaultIastRequestSampling = 30
     const iastRequestSampling = coalesce(
-      parseInt(iastOptions && iastOptions.requestSampling),
+      parseInt(iastOptions?.requestSampling),
       parseInt(process.env.DD_IAST_REQUEST_SAMPLING),
       defaultIastRequestSampling
     )
@@ -469,31 +469,43 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       iastRequestSampling > 100 ? defaultIastRequestSampling : iastRequestSampling
 
     const DD_IAST_MAX_CONCURRENT_REQUESTS = coalesce(
-      parseInt(iastOptions && iastOptions.maxConcurrentRequests),
+      parseInt(iastOptions?.maxConcurrentRequests),
       parseInt(process.env.DD_IAST_MAX_CONCURRENT_REQUESTS),
       2
     )
 
     const DD_IAST_MAX_CONTEXT_OPERATIONS = coalesce(
-      parseInt(iastOptions && iastOptions.maxContextOperations),
+      parseInt(iastOptions?.maxContextOperations),
       parseInt(process.env.DD_IAST_MAX_CONTEXT_OPERATIONS),
       2
     )
 
     const DD_IAST_DEDUPLICATION_ENABLED = coalesce(
-      iastOptions && iastOptions.deduplicationEnabled,
+      iastOptions?.deduplicationEnabled,
       process.env.DD_IAST_DEDUPLICATION_ENABLED && isTrue(process.env.DD_IAST_DEDUPLICATION_ENABLED),
       true
     )
 
     const DD_IAST_REDACTION_ENABLED = coalesce(
-      iastOptions && iastOptions.redactionEnabled,
+      iastOptions?.redactionEnabled,
       !isFalse(process.env.DD_IAST_REDACTION_ENABLED),
       true
     )
 
+    const DD_IAST_REDACTION_NAME_PATTERN = coalesce(
+      iastOptions?.redactionNamePattern,
+      process.env.DD_IAST_REDACTION_NAME_PATTERN,
+      null
+    )
+
+    const DD_IAST_REDACTION_VALUE_PATTERN = coalesce(
+      iastOptions?.redactionValuePattern,
+      process.env.DD_IAST_REDACTION_VALUE_PATTERN,
+      null
+    )
+
     const DD_IAST_TELEMETRY_VERBOSITY = coalesce(
-      iastOptions && iastOptions.telemetryVerbosity,
+      iastOptions?.telemetryVerbosity,
       process.env.DD_IAST_TELEMETRY_VERBOSITY,
       'INFORMATION'
     )
@@ -588,8 +600,8 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.telemetry = {
       enabled: DD_TRACE_EXPORTER !== 'datadog' && isTrue(DD_TRACE_TELEMETRY_ENABLED),
       heartbeatInterval: DD_TELEMETRY_HEARTBEAT_INTERVAL,
-      logCollection: isTrue(DD_TELEMETRY_LOG_COLLECTION_ENABLED),
       debug: isTrue(DD_TELEMETRY_DEBUG),
+      logCollection: isTrue(DD_TELEMETRY_LOG_COLLECTION_ENABLED),
       metrics: isTrue(DD_TELEMETRY_METRICS_ENABLED)
     }
     this.protocolVersion = DD_TRACE_AGENT_PROTOCOL_VERSION
@@ -620,6 +632,8 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       maxContextOperations: DD_IAST_MAX_CONTEXT_OPERATIONS,
       deduplicationEnabled: DD_IAST_DEDUPLICATION_ENABLED,
       redactionEnabled: DD_IAST_REDACTION_ENABLED,
+      redactionNamePattern: DD_IAST_REDACTION_NAME_PATTERN,
+      redactionValuePattern: DD_IAST_REDACTION_VALUE_PATTERN,
       telemetryVerbosity: DD_IAST_TELEMETRY_VERBOSITY
     }
 
@@ -638,9 +652,11 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
     this.memcachedCommandEnabled = isTrue(DD_TRACE_MEMCACHED_COMMAND_ENABLED)
 
     if (this.gitMetadataEnabled) {
-      this.repositoryUrl = coalesce(
-        process.env.DD_GIT_REPOSITORY_URL,
-        this.tags[GIT_REPOSITORY_URL]
+      this.repositoryUrl = removeUserSensitiveInfo(
+        coalesce(
+          process.env.DD_GIT_REPOSITORY_URL,
+          this.tags[GIT_REPOSITORY_URL]
+        )
       )
       this.commitSHA = coalesce(
         process.env.DD_GIT_COMMIT_SHA,

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

@@ -1,6 +1,20 @@
 const commitSHARegex = /git\.commit\.sha=([a-f\d]{40})/
 const repositoryUrlRegex = /git\.repository_url=([\w\d:@/.-]+)/
 
+function removeUserSensitiveInfo (repositoryUrl) {
+  try {
+    // repository URLs can contain username and password, so we want to filter those out
+    const parsedUrl = new URL(repositoryUrl)
+    if (parsedUrl.username || parsedUrl.password) {
+      return `${parsedUrl.origin}${parsedUrl.pathname}`
+    }
+    return repositoryUrl
+  } catch (e) {
+    // if protocol isn't https, no password will be used
+    return repositoryUrl
+  }
+}
+
 function getGitMetadataFromGitProperties (gitPropertiesString) {
   if (!gitPropertiesString) {
     return {}
@@ -9,24 +23,11 @@ function getGitMetadataFromGitProperties (gitPropertiesString) {
   const repositoryUrlMatch = gitPropertiesString.match(repositoryUrlRegex)
 
   const repositoryUrl = repositoryUrlMatch ? repositoryUrlMatch[1] : undefined
-  let parsedUrl = repositoryUrl
-
-  if (repositoryUrl) {
-    try {
-      // repository URLs can contain username and password, so we want to filter those out
-      parsedUrl = new URL(repositoryUrl)
-      if (parsedUrl.password) {
-        parsedUrl = `${parsedUrl.origin}${parsedUrl.pathname}`
-      }
-    } catch (e) {
-      // if protocol isn't https, no password will be used
-    }
-  }
 
   return {
     commitSHA: commitSHAMatch ? commitSHAMatch[1] : undefined,
-    repositoryUrl: parsedUrl
+    repositoryUrl: removeUserSensitiveInfo(repositoryUrl)
   }
 }
 
-module.exports = { getGitMetadataFromGitProperties }
+module.exports = { getGitMetadataFromGitProperties, removeUserSensitiveInfo }

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

@@ -118,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
@@ -492,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

@@ -128,24 +128,10 @@ class Config {
       ? options.profilers
       : getProfilers({ DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS })
 
-    function getCodeHotspotsOptionsOr (defvalue) {
-      return coalesce(options.codeHotspotsEnabled,
-        DD_PROFILING_CODEHOTSPOTS_ENABLED,
-        DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED, defvalue)
-    }
-    this.codeHotspotsEnabled = isTrue(getCodeHotspotsOptionsOr(false))
+    this.codeHotspotsEnabled = isTrue(coalesce(options.codeHotspotsEnabled,
+      DD_PROFILING_CODEHOTSPOTS_ENABLED,
+      DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED, false))
     logExperimentalVarDeprecation('CODEHOTSPOTS_ENABLED')
-    if (this.endpointCollectionEnabled && !this.codeHotspotsEnabled) {
-      if (getCodeHotspotsOptionsOr(undefined) !== undefined) {
-        this.logger.warn(
-          'Endpoint collection is enabled, but Code Hotspots are disabled. ' +
-          'Enable Code Hotspots too for endpoint collection to work.')
-        this.endpointCollectionEnabled = false
-      } else {
-        this.logger.info('Code Hotspots are implicitly enabled by endpoint collection.')
-        this.codeHotspotsEnabled = true
-      }
-    }
 
     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 () {
@@ -24,7 +30,7 @@ function getStartedSpans (context) {
 }
 
 function generateLabels ({ context: { spanId, rootSpanId, webTags, endpoint }, timestamp }) {
-  const labels = {}
+  const labels = { 'thread name': threadName }
   if (spanId) {
     labels['span id'] = spanId
   }
@@ -58,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'
@@ -88,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
@@ -109,12 +93,6 @@ class NativeWallProfiler {
   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
@@ -131,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)
@@ -161,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()
@@ -176,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`
@@ -188,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) {
@@ -215,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/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/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 }