dd-trace 5.67.0 → 5.69.0

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

@@ -13,6 +13,7 @@ class NativeSpaceProfiler {
   _started = false
 
   constructor (options = {}) {
+    // TODO: Remove default value. It is only used in testing.
     this._samplingInterval = options.heapSamplingInterval || 512 * 1024
     this._stackDepth = options.stackDepth || 64
     this._oomMonitoring = options.oomMonitoring || {}

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

@@ -17,7 +17,7 @@ const TRACE_ENDPOINT_LABEL = 'trace endpoint'
 
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('../webspan-utils')
 
-const beforeCh = dc.channel('dd-trace:storage:before')
+let beforeCh
 const enterCh = dc.channel('dd-trace:storage:enter')
 const spanFinishCh = dc.channel('dd-trace:span:finish')
 const profilerTelemetryMetrics = telemetryMetrics.manager.namespace('profilers')
@@ -25,21 +25,53 @@ const profilerTelemetryMetrics = telemetryMetrics.manager.namespace('profilers')
 const ProfilingContext = Symbol('NativeWallProfiler.ProfilingContext')
 
 let kSampleCount
+let kCPEDContextCount
 
 function getActiveSpan () {
   const store = storage('legacy').getStore()
   return store && store.span
 }
 
+function toBigInt (spanId) {
+  return spanId !== null && typeof spanId === 'object' ? spanId.toBigInt() : spanId
+}
+
+function updateContext (context) {
+  // Converting spanIDs to bigints is not necessary as generateLabels will do it
+  // too. When we don't use async context frame, we can convert them when the
+  // sample is taken though so we amortize the latency of operations. It is an
+  // optimization.
+  if (context.spanId !== undefined) {
+    context.spanId = toBigInt(context.spanId)
+  }
+  if (context.rootSpanId !== undefined) {
+    context.rootSpanId = toBigInt(context.rootSpanId)
+  }
+  if (context.webTags !== undefined && context.endpoint === undefined) {
+    // endpoint may not be determined yet, but keep it as fallback
+    // if tags are not available anymore during serialization
+    context.endpoint = endpointNameFromTags(context.webTags)
+  }
+}
+
 let channelsActivated = false
-function ensureChannelsActivated () {
+function ensureChannelsActivated (asyncContextFrameEnabled) {
   if (channelsActivated) return
 
-  const { AsyncLocalStorage, createHook } = require('async_hooks')
   const shimmer = require('../../../../datadog-shimmer')
+  const asyncHooks = require('async_hooks')
+
+  // When using AsyncContextFrame to store sample context, we do not need to use
+  // async_hooks.createHook to create a "before" callback anymore.
+  if (!asyncContextFrameEnabled) {
+    const { createHook } = asyncHooks
+    beforeCh = dc.channel('dd-trace:storage:before')
+    createHook({ before: () => beforeCh.publish() }).enable()
+  }
 
-  createHook({ before: () => beforeCh.publish() }).enable()
+  const { AsyncLocalStorage } = asyncHooks
 
+  // We need to instrument AsyncLocalStorage.enterWith() both with and without AsyncContextFrame.
   let inRun = false
   shimmer.wrap(AsyncLocalStorage.prototype, 'enterWith', function (original) {
     return function (...args) {
@@ -49,73 +81,93 @@ function ensureChannelsActivated () {
     }
   })
 
-  shimmer.wrap(AsyncLocalStorage.prototype, 'run', function (original) {
-    return function (store, callback, ...args) {
-      const wrappedCb = shimmer.wrapFunction(callback, cb => function (...args) {
-        inRun = false
-        enterCh.publish()
-        const retVal = cb.apply(this, args)
+  // We only need to instrument AsyncLocalStorage.run() when not using AsyncContextFrame.
+  // AsyncContextFrame-based implementation of AsyncLocalStorage.run() delegates
+  // to AsyncLocalStorage.enterWith() so it doesn't need to be separately instrumented.
+  if (!asyncContextFrameEnabled) {
+    shimmer.wrap(AsyncLocalStorage.prototype, 'run', function (original) {
+      return function (store, callback, ...args) {
+        const wrappedCb = shimmer.wrapFunction(callback, cb => function (...args) {
+          inRun = false
+          enterCh.publish()
+          const retVal = cb.apply(this, args)
+          inRun = true
+          return retVal
+        })
         inRun = true
+        const retVal = original.call(this, store, wrappedCb, ...args)
+        enterCh.publish()
+        inRun = false
         return retVal
-      })
-      inRun = true
-      const retVal = original.call(this, store, wrappedCb, ...args)
-      enterCh.publish()
-      inRun = false
-      return retVal
-    }
-  })
+      }
+    })
+  }
 
   channelsActivated = true
 }
 
 class NativeWallProfiler {
-  type = 'wall'
-  _mapper
-  _pprof
-  _started = false
+  #asyncContextFrameEnabled = false
+  #captureSpanData = false
+  #codeHotspotsEnabled = false
+  #cpuProfilingEnabled = false
+  #endpointCollectionEnabled = false
+  #flushIntervalMillis = 0
+  #logger
+  #mapper
+  #pprof
+  #samplingIntervalMicros = 0
+  #started = false
+  #telemetryHeartbeatIntervalMillis = 0
+  #timelineEnabled = false
+  #v8ProfilerBugWorkaroundEnabled = false
+  #withContexts = false
+
+  // Bind these to this so they can be used as callbacks
+  #boundEnter = this.#enter.bind(this)
+  #boundSpanFinished = this.#spanFinished.bind(this)
+  #boundGenerateLabels = this._generateLabels.bind(this)
+
+  get type () { return 'wall' }
 
   constructor (options = {}) {
-    this._samplingIntervalMicros = (options.samplingInterval || 1e3 / 99) * 1000 // 99hz
-    this._flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
-    this._codeHotspotsEnabled = !!options.codeHotspotsEnabled
-    this._endpointCollectionEnabled = !!options.endpointCollectionEnabled
-    this._timelineEnabled = !!options.timelineEnabled
-    this._cpuProfilingEnabled = !!options.cpuProfilingEnabled
+    this.#asyncContextFrameEnabled = !!options.asyncContextFrameEnabled
+    this.#codeHotspotsEnabled = !!options.codeHotspotsEnabled
+    this.#cpuProfilingEnabled = !!options.cpuProfilingEnabled
+    this.#endpointCollectionEnabled = !!options.endpointCollectionEnabled
+    this.#flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
+    this.#logger = options.logger
+    // TODO: Remove default value. It is only used in testing.
+    this.#samplingIntervalMicros = (options.samplingInterval || 1e3 / 99) * 1000
+    this.#telemetryHeartbeatIntervalMillis = options.heartbeatInterval || 60 * 1e3 // 60 seconds
+    this.#timelineEnabled = !!options.timelineEnabled
+    this.#v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
+
     // We need to capture span data into the sample context for either code hotspots
     // or endpoint collection.
-    this._captureSpanData = this._codeHotspotsEnabled || this._endpointCollectionEnabled
+    this.#captureSpanData = this.#codeHotspotsEnabled || this.#endpointCollectionEnabled
     // We need to run the pprof wall profiler with sample contexts if we're either
     // capturing span data or timeline is enabled (so we need sample timestamps, and for now
     // timestamps require the sample contexts feature in the pprof wall profiler), or
     // cpu profiling is enabled.
-    this._withContexts = this._captureSpanData || this._timelineEnabled || this._cpuProfilingEnabled
-    this._v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
-
-    // Bind these to this so they can be used as callbacks
-    if (this._withContexts && this._captureSpanData) {
-      this._enter = this._enter.bind(this)
-      this._spanFinished = this._spanFinished.bind(this)
-    }
-    this._generateLabels = this._generateLabels.bind(this)
-
-    this._logger = options.logger
+    this.#withContexts = this.#captureSpanData || this.#timelineEnabled || this.#cpuProfilingEnabled
   }
 
   codeHotspotsEnabled () {
-    return this._codeHotspotsEnabled
+    return this.#codeHotspotsEnabled
   }
 
   endpointCollectionEnabled () {
-    return this._endpointCollectionEnabled
+    return this.#endpointCollectionEnabled
   }
 
   start ({ mapper } = {}) {
-    if (this._started) return
+    if (this.#started) return
 
-    this._mapper = mapper
-    this._pprof = require('@datadog/pprof')
-    kSampleCount = this._pprof.time.constants.kSampleCount
+    this.#mapper = mapper
+    this.#pprof = require('@datadog/pprof')
+    kSampleCount = this.#pprof.time.constants.kSampleCount
+    kCPEDContextCount = this.#pprof.time.constants.kCPEDContextCount
 
     // pprof otherwise crashes in worker threads
     if (!process._startProfilerIdleNotifier) {
@@ -125,51 +177,88 @@ class NativeWallProfiler {
       process._stopProfilerIdleNotifier = () => {}
     }
 
-    this._pprof.time.start({
-      intervalMicros: this._samplingIntervalMicros,
-      durationMillis: this._flushIntervalMillis,
-      sourceMapper: this._mapper,
-      withContexts: this._withContexts,
+    this.#pprof.time.start({
+      collectCpuTime: this.#cpuProfilingEnabled,
+      durationMillis: this.#flushIntervalMillis,
+      intervalMicros: this.#samplingIntervalMicros,
       lineNumbers: false,
-      workaroundV8Bug: this._v8ProfilerBugWorkaroundEnabled,
-      collectCpuTime: this._cpuProfilingEnabled
+      sourceMapper: this.#mapper,
+      useCPED: this.#asyncContextFrameEnabled,
+      withContexts: this.#withContexts,
+      workaroundV8Bug: this.#v8ProfilerBugWorkaroundEnabled
     })
 
-    if (this._withContexts) {
-      this._setNewContext()
+    if (this.#withContexts) {
+      if (!this.#asyncContextFrameEnabled) {
+        this.#setNewContext()
+      }
 
-      if (this._captureSpanData) {
-        this._profilerState = this._pprof.time.getState()
+      if (this.#captureSpanData) {
+        this._profilerState = this.#pprof.time.getState()
         this._lastSampleCount = 0
 
-        ensureChannelsActivated()
+        ensureChannelsActivated(this.#asyncContextFrameEnabled)
 
-        beforeCh.subscribe(this._enter)
-        enterCh.subscribe(this._enter)
-        spanFinishCh.subscribe(this._spanFinished)
+        if (this.#asyncContextFrameEnabled) {
+          this.#setupTelemetryMetrics()
+        } else {
+          beforeCh.subscribe(this.#boundEnter)
+        }
+        enterCh.subscribe(this.#boundEnter)
+        spanFinishCh.subscribe(this.#boundSpanFinished)
       }
     }
 
-    this._started = true
+    this.#started = true
   }
 
-  _enter () {
-    if (!this._started) return
+  #setupTelemetryMetrics () {
+    const contextCountGauge = profilerTelemetryMetrics.gauge('wall.sample_contexts')
 
-    const sampleCount = this._profilerState[kSampleCount]
-    if (sampleCount !== this._lastSampleCount) {
-      this._lastSampleCount = sampleCount
-      const context = this._currentContext.ref
-      this._setNewContext()
+    const that = this
+    this._contextCountGaugeUpdater = setInterval(() => {
+      contextCountGauge.mark(that._profilerState[kCPEDContextCount])
+    }, that.#telemetryHeartbeatIntervalMillis)
+    this._contextCountGaugeUpdater.unref()
+  }
 
-      this._updateContext(context)
-    }
+  #enter () {
+    if (!this.#started) return
 
     const span = getActiveSpan()
-    this._currentContext.ref = span ? this._getProfilingContext(span) : {}
+    const sampleContext = span ? this.#getProfilingContext(span) : {}
+
+    // Note that we store the sample context differently with and without the
+    // async context frame. With the async context frame, we tell the profiler
+    // to store the sample context directly in the frame on each enterWith.
+    // Without the async context frame, we store one holder object as the
+    // profiler's single sample context, and reassign its "ref" property on
+    // every async context change. Then when we detect that the profiler took a
+    // sample (and thus bound the holder as that sample's context), we create a
+    // new holder object so that we no longer mutate the old one. This is really
+    // an optimization to avoid going to profiler's native SetContext every
+    // time. With async context frame however, we can't have that optimization,
+    // as we can't tell from which async context frame was the sampling context
+    // taken. For the same reason we can't call updateContext() on the old
+    // context -- we simply can't tell which one it might've been across all
+    // possible async context frames.
+    if (this.#asyncContextFrameEnabled) {
+      this.#pprof.time.setContext(sampleContext)
+    } else {
+      const sampleCount = this._profilerState[kSampleCount]
+      if (sampleCount !== this._lastSampleCount) {
+        this._lastSampleCount = sampleCount
+        const context = this._currentContext.ref
+        this.#setNewContext()
+
+        updateContext(context)
+      }
+
+      this._currentContext.ref = sampleContext
+    }
   }
 
-  _getProfilingContext (span) {
+  #getProfilingContext (span) {
     let profilingContext = span[ProfilingContext]
     if (profilingContext === undefined) {
       const context = span.context()
@@ -177,13 +266,13 @@ class NativeWallProfiler {
 
       let spanId
       let rootSpanId
-      if (this._codeHotspotsEnabled) {
+      if (this.#codeHotspotsEnabled) {
         spanId = context._spanId
         rootSpanId = startedSpans.length ? startedSpans[0].context()._spanId : context._spanId
       }
 
       let webTags
-      if (this._endpointCollectionEnabled) {
+      if (this.#endpointCollectionEnabled) {
         const tags = context._tags
         if (isWebServerSpan(tags)) {
           webTags = tags
@@ -193,7 +282,7 @@ class NativeWallProfiler {
           for (let i = startedSpans.length; --i >= 0;) {
             const ispan = startedSpans[i]
             if (ispan.context()._spanId === parentId) {
-              webTags = this._getProfilingContext(ispan).webTags
+              webTags = this.#getProfilingContext(ispan).webTags
               break
             }
           }
@@ -206,50 +295,36 @@ class NativeWallProfiler {
     return profilingContext
   }
 
-  _setNewContext () {
-    this._pprof.time.setContext(
+  #setNewContext () {
+    this.#pprof.time.setContext(
       this._currentContext = {
         ref: {}
       }
     )
   }
 
-  _updateContext (context) {
-    if (context.spanId !== null && typeof context.spanId === 'object') {
-      context.spanId = context.spanId.toBigInt()
-    }
-    if (context.rootSpanId !== null && typeof context.rootSpanId === 'object') {
-      context.rootSpanId = context.rootSpanId.toBigInt()
-    }
-    if (context.webTags !== undefined && context.endpoint === undefined) {
-      // endpoint may not be determined yet, but keep it as fallback
-      // if tags are not available anymore during serialization
-      context.endpoint = endpointNameFromTags(context.webTags)
-    }
-  }
-
-  _spanFinished (span) {
+  #spanFinished (span) {
     if (span[ProfilingContext] !== undefined) {
       span[ProfilingContext] = undefined
     }
   }
 
-  _reportV8bug (maybeBug) {
-    const tag = `v8_profiler_bug_workaround_enabled:${this._v8ProfilerBugWorkaroundEnabled}`
+  #reportV8bug (maybeBug) {
+    const tag = `v8_profiler_bug_workaround_enabled:${this.#v8ProfilerBugWorkaroundEnabled}`
     const metric = `v8_cpu_profiler${maybeBug ? '_maybe' : ''}_stuck_event_loop`
-    this._logger?.warn(`Wall profiler: ${maybeBug ? 'possible ' : ''}v8 profiler stuck event loop detected.`)
+    this.#logger?.warn(`Wall profiler: ${maybeBug ? 'possible ' : ''}v8 profiler stuck event loop detected.`)
     // report as runtime metric (can be removed in the future when telemetry is mature)
     runtimeMetrics.increment(`runtime.node.profiler.${metric}`, tag, true)
     // report as telemetry metric
     profilerTelemetryMetrics.count(metric, [tag]).inc()
   }
 
-  _stop (restart) {
-    if (!this._started) return
+  #stop (restart) {
+    if (!this.#started) return
 
-    if (this._captureSpanData) {
+    if (this.#captureSpanData && !this.#asyncContextFrameEnabled) {
       // update last sample context if needed
-      this._enter()
+      this.#enter()
       this._lastSampleCount = 0
     }
 
@@ -257,21 +332,24 @@ class NativeWallProfiler {
     const lowCardinalityLabels = Object.keys(getThreadLabels())
     lowCardinalityLabels.push(TRACE_ENDPOINT_LABEL)
 
-    const profile = this._pprof.time.stop(restart, this._generateLabels, lowCardinalityLabels)
+    const profile = this.#pprof.time.stop(restart, this.#boundGenerateLabels, lowCardinalityLabels)
 
     if (restart) {
-      const v8BugDetected = this._pprof.time.v8ProfilerStuckEventLoopDetected()
+      const v8BugDetected = this.#pprof.time.v8ProfilerStuckEventLoopDetected()
       if (v8BugDetected !== 0) {
-        this._reportV8bug(v8BugDetected === 1)
+        this.#reportV8bug(v8BugDetected === 1)
       }
     } else {
-      if (this._captureSpanData) {
-        beforeCh.unsubscribe(this._enter)
-        enterCh.unsubscribe(this._enter)
-        spanFinishCh.unsubscribe(this._spanFinished)
+      clearInterval(this._contextCountGaugeUpdater)
+      if (this.#captureSpanData) {
+        if (!this.#asyncContextFrameEnabled) {
+          beforeCh.unsubscribe(this.#boundEnter)
+        }
+        enterCh.unsubscribe(this.#boundEnter)
+        spanFinishCh.unsubscribe(this.#boundSpanFinished)
         this._profilerState = undefined
       }
-      this._started = false
+      this.#started = false
     }
 
     return profile
@@ -280,7 +358,7 @@ class NativeWallProfiler {
   _generateLabels ({ node, context }) {
     // check for special node that represents CPU time all non-JS threads.
     // In that case only return a special thread name label since we cannot associate any timestamp/span/endpoint to it.
-    if (node.name === this._pprof.time.constants.NON_JS_THREADS_FUNCTION_NAME) {
+    if (node.name === this.#pprof.time.constants.NON_JS_THREADS_FUNCTION_NAME) {
       return getNonJSThreadsLabels()
     }
 
@@ -292,7 +370,7 @@ class NativeWallProfiler {
 
     const labels = { ...getThreadLabels() }
 
-    if (this._timelineEnabled) {
+    if (this.#timelineEnabled) {
       // Incoming timestamps are in microseconds, we emit nanos.
       labels[END_TIMESTAMP_LABEL] = context.timestamp * 1000n
     }
@@ -303,8 +381,9 @@ class NativeWallProfiler {
     }
 
     // Native profiler doesn't set context.context for some samples, such as idle samples or when
-    // the context was otherwise unavailable when the sample was taken.
-    const ref = context.context?.ref
+    // the context was otherwise unavailable when the sample was taken. Note that with async context
+    // frame, we don't use the "ref" indirection.
+    const ref = this.#asyncContextFrameEnabled ? context.context : context.context?.ref
     if (typeof ref !== 'object') {
       return labels
     }
@@ -312,10 +391,10 @@ class NativeWallProfiler {
     const { spanId, rootSpanId, webTags, endpoint } = ref
 
     if (spanId !== undefined) {
-      labels[SPAN_ID_LABEL] = spanId
+      labels[SPAN_ID_LABEL] = toBigInt(spanId)
     }
     if (rootSpanId !== undefined) {
-      labels[LOCAL_ROOT_SPAN_ID_LABEL] = rootSpanId
+      labels[LOCAL_ROOT_SPAN_ID_LABEL] = toBigInt(rootSpanId)
     }
     if (webTags !== undefined && Object.keys(webTags).length !== 0) {
       labels[TRACE_ENDPOINT_LABEL] = endpointNameFromTags(webTags)
@@ -328,7 +407,7 @@ class NativeWallProfiler {
   }
 
   profile (restart) {
-    return this._stop(restart)
+    return this.#stop(restart)
   }
 
   encode (profile) {
@@ -336,11 +415,11 @@ class NativeWallProfiler {
   }
 
   stop () {
-    this._stop(false)
+    this.#stop(false)
   }
 
   isStarted () {
-    return this._started
+    return this.#started
   }
 }
 

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

@@ -88,6 +88,9 @@ class Tracer extends NoopProxy {
     }
   }
 
+  /**
+   * @override
+   */
   init (options) {
     if (this._initialized) return this
 
@@ -241,6 +244,9 @@ class Tracer extends NoopProxy {
         this.dataStreamsCheckpointer = this._tracer.dataStreamsCheckpointer
         lazyProxy(this, 'appsec', config, () => require('./appsec/sdk'), this._tracer, config)
         lazyProxy(this, 'llmobs', config, () => require('./llmobs/sdk'), this._tracer, this._modules.llmobs, config)
+        if (config.experimental?.aiguard?.enabled) {
+          lazyProxy(this, 'aiguard', config, () => require('./aiguard/sdk'), this._tracer, config)
+        }
         this._tracingInitialized = true
       }
       if (config.iast.enabled) {
@@ -261,6 +267,9 @@ class Tracer extends NoopProxy {
     }
   }
 
+  /**
+   * @override
+   */
   profilerStarted () {
     if (!this._profilerStarted) {
       // injection hardening: this is only ever invoked from tests.
@@ -269,11 +278,17 @@ class Tracer extends NoopProxy {
     return this._profilerStarted
   }
 
+  /**
+   * @override
+   */
   use () {
     this._pluginManager.configurePlugin(...arguments)
     return this
   }
 
+  /**
+   * @override
+   */
   get TracerProvider () {
     return require('./opentelemetry/tracer_provider')
   }

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

@@ -3,14 +3,25 @@
 const limiter = require('limiter')
 
 class RateLimiter {
+  /**
+   * @param {number} rateLimit - Allowed units per interval. Negative means unlimited, 0 disables.
+   * @param {'second'|'minute'|'hour'|'day'} [interval='second'] - Time window for the limiter.
+   */
   constructor (rateLimit, interval = 'second') {
-    this._rateLimit = Number.parseInt(rateLimit)
+    this._rateLimit = Number.parseInt(String(rateLimit))
+    // The limiter constructor accepts a token count number and an interval string
     this._limiter = new limiter.RateLimiter(this._rateLimit, interval)
     this._tokensRequested = 0
     this._prevIntervalTokens = 0
     this._prevTokensRequested = 0
   }
 
+  /**
+   * Attempts to consume a token and reports whether it was allowed.
+   * Updates internal counters used for effective rate computation.
+   *
+   * @returns {boolean}
+   */
   isAllowed () {
     const curIntervalStart = this._limiter.curIntervalStart
     const curIntervalTokens = this._limiter.tokensThisInterval
@@ -27,6 +38,12 @@ class RateLimiter {
     return allowed
   }
 
+  /**
+   * Returns the fraction of allowed requests over requested ones in the
+   * current and previous intervals combined.
+   *
+   * @returns {number}
+   */
   effectiveRate () {
     if (this._rateLimit < 0) return 1
     if (this._rateLimit === 0) return 0
@@ -38,6 +55,10 @@ class RateLimiter {
     return allowed / requested
   }
 
+  /**
+   * Internal token consumption without counter side-effects.
+   * @returns {boolean}
+   */
   _isAllowed () {
     if (this._rateLimit < 0) return true
     if (this._rateLimit === 0) return false
@@ -45,6 +66,10 @@ class RateLimiter {
     return this._limiter.tryRemoveTokens(1)
   }
 
+  /**
+   * Effective rate within the current interval only.
+   * @returns {number}
+   */
   _currentWindowRate () {
     if (this._rateLimit < 0) return 1
     if (this._rateLimit === 0) return 0

package/packages/dd-trace/src/remote_config/capabilities.js

@@ -31,4 +31,9 @@ module.exports = {
   ASM_RASP_CMDI: 1n << 37n,
   ASM_DD_MULTICONFIG: 1n << 42n,
   ASM_TRACE_TAGGING_RULES: 1n << 43n,
+  /*
+    DO NOT ADD ARBITRARY CAPABILITIES IN YOUR CODE
+    UNLESS THEY ARE ALREADY DEFINED IN THE BACKEND SOURCE OF TRUTH
+    DOING SO TRIGGERS BACKEND ALERTS
+  */
 }

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

@@ -11,6 +11,7 @@ const { UNACKNOWLEDGED, ACKNOWLEDGED, ERROR } = require('./apply_states')
 const Scheduler = require('./scheduler')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const tagger = require('../tagger')
+const defaults = require('../config_defaults')
 
 const clientId = uuid()
 
@@ -31,7 +32,7 @@ class RemoteConfigManager extends EventEmitter {
 
     this.url = config.url || new URL(format({
       protocol: 'http:',
-      hostname: config.hostname || 'localhost',
+      hostname: config.hostname || defaults.hostname,
       port: config.port
     }))
 
@@ -153,7 +154,7 @@ class RemoteConfigManager extends EventEmitter {
       if (statusCode === 404) return cb()
 
       if (err) {
-        log.error('[RC] Error in request', err)
+        log.errorWithoutTelemetry('[RC] Error in request', err)
         return cb()
       }