newrelic 7.5.2 → 8.3.0

package/lib/spans/create-span-event-aggregator.js

@@ -5,38 +5,35 @@
 
 'use strict'
 
-const psemver = require('../util/process-version')
 const logger = require('../logger')
 const SpanEventAggregator = require('./span-event-aggregator')
 const StreamingSpanEventAggregator = require('./streaming-span-event-aggregator')
 
 function createSpanEventAggregator(config, collector, metrics) {
-  const trace_observer = config.infinite_tracing.trace_observer
+  const traceObserver = config.infinite_tracing.trace_observer
 
-  let shouldCreateStreaming = false
-  if (trace_observer.host) {
-    // TODO: ideally this validation and configuration clearing would happen
-    // in the config. Since we don't currently have a way to generate
-    // support metrics in the config, keeping this related logic together here.
-    // If logic happened prior, could merely check for existence of trace_observer.host.
-    shouldCreateStreaming = validateInfiniteTracing()
+  if (traceObserver.host) {
+    traceObserver.host = traceObserver.host.trim()
 
-    if (!shouldCreateStreaming) {
-      // Explicitly disable for any downstream consumers
-      trace_observer.host = ''
-      trace_observer.port = ''
+    if (typeof traceObserver.port !== 'string') {
+      traceObserver.port = String(traceObserver.port)
     }
-  }
-
-  if (shouldCreateStreaming) {
-    trace_observer.host = trace_observer.host.trim()
-
-    if (typeof trace_observer.port !== 'string') {
-      trace_observer.port = String(trace_observer.port)
+    traceObserver.port = traceObserver.port.trim()
+
+    try {
+      return createStreamingAggregator(config, collector, metrics)
+    } catch (err) {
+      logger.warn(
+        err,
+        'Failed to create streaming span event aggregator for infinite tracing. ' +
+          'Reverting to standard span event aggregator and disabling infinite tracing'
+      )
+      config.infinite_tracing.trace_observer = {
+        host: '',
+        port: ''
+      }
+      return createStandardAggregator(config, collector, metrics)
     }
-    trace_observer.port = trace_observer.port.trim()
-
-    return createStreamingAggregator(config, collector, metrics)
   }
 
   return createStandardAggregator(config, collector, metrics)
@@ -44,12 +41,10 @@ function createSpanEventAggregator(config, collector, metrics) {
 
 function createStreamingAggregator(config, collector, metrics) {
   logger.trace('Creating streaming span event aggregator for infinite tracing.')
-
-  // loading the class here to ensure its behind a feature flag
-  // and won't trigger a grpc load in node 8
   const GrpcConnection = require('../grpc/connection')
-  const connection = new GrpcConnection(config.infinite_tracing.trace_observer, metrics)
   const SpanStreamer = require('./span-streamer')
+
+  const connection = new GrpcConnection(config.infinite_tracing.trace_observer, metrics)
   const spanStreamer = new SpanStreamer(
     config.license_key,
     connection,
@@ -63,9 +58,7 @@ function createStreamingAggregator(config, collector, metrics) {
     span_streamer: spanStreamer
   }
 
-  const aggregator = new StreamingSpanEventAggregator(opts, collector, metrics)
-
-  return aggregator
+  return new StreamingSpanEventAggregator(opts, collector, metrics)
 }
 
 function createStandardAggregator(config, collector, metrics) {
@@ -76,20 +69,7 @@ function createStandardAggregator(config, collector, metrics) {
     limit: config.event_harvest_config.harvest_limits.span_event_data
   }
 
-  const aggregator = new SpanEventAggregator(opts, collector, metrics)
-  return aggregator
-}
-
-function validateInfiniteTracing() {
-  // TODO: Remove semver check when Node 10 support dropped.
-  if (!psemver.satisfies('>=10.10.0')) {
-    logger.warn(
-      'Infinite tracing disabled: this version of Node is not supported (must be >=10.10.0)'
-    )
-    return false
-  }
-
-  return true
+  return new SpanEventAggregator(opts, collector, metrics)
 }
 
 module.exports = createSpanEventAggregator

package/lib/spans/span-context.js

@@ -5,9 +5,9 @@
 
 'use strict'
 
-const {MAXIMUM_CUSTOM_ATTRIBUTES} = require('../attributes')
-const {PrioritizedAttributes, ATTRIBUTE_PRIORITY} = require('../prioritized-attributes')
-const {DESTINATIONS} = require('../config/attribute-filter')
+const { MAXIMUM_CUSTOM_ATTRIBUTES } = require('../attributes')
+const { PrioritizedAttributes, ATTRIBUTE_PRIORITY } = require('../prioritized-attributes')
+const { DESTINATIONS } = require('../config/attribute-filter')
 
 // Scoping impacts memoization. We could decide to add a scope instead of including
 // spans in segment scope in the future.
@@ -31,13 +31,7 @@ class SpanContext {
   }
 
   addCustomAttribute(key, value, priority) {
-    this.customAttributes.addAttribute(
-      DESTINATIONS.SPAN_EVENT,
-      key,
-      value,
-      false,
-      priority
-    )
+    this.customAttributes.addAttribute(DESTINATIONS.SPAN_EVENT, key, value, false, priority)
   }
 
   /**

package/lib/spans/span-event-aggregator.js

@@ -5,12 +5,14 @@
 
 'use strict'
 
-const logger = require('../logger')
-let spanLogger = null
+const logger = require('../logger').child({ component: 'span_aggregator' })
 const EventAggregator = require('../aggregators/event-aggregator')
 const SpanEvent = require('./span-event')
 const NAMES = require('../metrics/names')
-const LIMIT = 1000
+
+const DEFAULT_SPAN_EVENT_LIMIT = 2000
+// Used only when server value missing
+const SPAN_EVENT_FALLBACK_MAX_LIMIT = 10000
 
 class SpanEventAggregator extends EventAggregator {
   constructor(opts, collector, metrics) {
@@ -18,8 +20,6 @@ class SpanEventAggregator extends EventAggregator {
     opts.method = opts.method || 'span_event_data'
     opts.metricNames = opts.metricNames || NAMES.SPAN_EVENTS
 
-    spanLogger = logger.child({component: 'span_aggregator'})
-
     super(opts, collector, metrics)
   }
 
@@ -27,7 +27,7 @@ class SpanEventAggregator extends EventAggregator {
     const events = this.events
 
     if (events.length === 0) {
-      spanLogger.debug('No span events to send.')
+      logger.debug('No span events to send.')
       return
     }
 
@@ -46,11 +46,14 @@ class SpanEventAggregator extends EventAggregator {
   }
 
   send() {
-    if (spanLogger.traceEnabled()) {
-      spanLogger.trace({
-        spansCollected: this.length,
-        spansSeen: this.seen
-      }, 'Entity stats on span harvest')
+    if (logger.traceEnabled()) {
+      logger.trace(
+        {
+          spansCollected: this.length,
+          spansSeen: this.seen
+        },
+        'Entity stats on span harvest'
+      )
     }
     super.send()
   }
@@ -61,7 +64,7 @@ class SpanEventAggregator extends EventAggregator {
    * @param {TraceSegment}  segment         - The segment to add.
    * @param {string}        [parentId=null] - The GUID of the parent span.
    *
-   * @return {bool} True if the segment was added, or false if it was discarded.
+   * @return {boolean} True if the segment was added, or false if it was discarded.
    */
   addSegment(segment, parentId, isRoot) {
     // Check if the priority would be accepted before creating the event object.
@@ -76,7 +79,59 @@ class SpanEventAggregator extends EventAggregator {
     const span = SpanEvent.fromSegment(segment, parentId || null, isRoot)
     return this.add(span, tx.priority)
   }
+
+  /**
+   * Reconfigure the `SpanEventAggregator` based on values from server
+   *
+   * @param {Config} config
+   */
+  reconfigure(config) {
+    super.reconfigure(config)
+
+    const { periodMs, limit } = this._getValidSpanConfiguration(config)
+
+    this.periodMs = periodMs
+    this.limit = limit
+    this._metrics.getOrCreateMetric(this._metricNames.LIMIT).recordValue(this.limit)
+    this._items.setLimit(this.limit)
+  }
+
+  /**
+   * Retrieves report period and harvest limits defined in `span_event_harvest_config`.
+   * When no `span_event_harvest_config` has been received from the server, applies an
+   * agent-defined fallback maximum to protect against collecting and sending too many spans.
+   *
+   * @param {Config} config
+   */
+  _getValidSpanConfiguration(config) {
+    const spanHarvestConfig = config.span_event_harvest_config
+    if (spanHarvestConfig) {
+      logger.trace('Using span_event_harvest_config values.')
+
+      return {
+        periodMs: spanHarvestConfig.report_period_ms,
+        limit: spanHarvestConfig.harvest_limit
+      }
+    }
+
+    const configuredLimit = config.span_events.max_samples_stored || DEFAULT_SPAN_EVENT_LIMIT
+
+    return {
+      periodMs: this.defaultPeriod,
+      limit: _enforceMaxLimit(configuredLimit, SPAN_EVENT_FALLBACK_MAX_LIMIT)
+    }
+  }
+}
+
+function _enforceMaxLimit(currentLimit, maxLimit) {
+  let spanLimit = currentLimit
+  if (spanLimit > maxLimit) {
+    spanLimit = maxLimit
+
+    logger.debug('Using maximum allowed span event limit of %s', maxLimit)
+  }
+
+  return spanLimit
 }
 
 module.exports = SpanEventAggregator
-module.exports.LIMIT = LIMIT

package/lib/spans/span-event.js

@@ -6,9 +6,9 @@
 'use strict'
 
 const Config = require('../config')
-const {truncate} = require('../util/byte-limit')
+const { truncate } = require('../util/byte-limit')
 
-const {DESTINATIONS} = require('../config/attribute-filter')
+const { DESTINATIONS } = require('../config/attribute-filter')
 
 const HTTP_LIBRARY = 'http'
 const CLIENT_KIND = 'client'
@@ -149,15 +149,13 @@ class SpanEvent {
   toJSON() {
     return [
       _filterNulls(this.intrinsics),
-      this.customAttributes ?
-        _filterNulls(this.customAttributes) :
-        EMPTY_USER_ATTRS,
+      this.customAttributes ? _filterNulls(this.customAttributes) : EMPTY_USER_ATTRS,
       _filterNulls(this.attributes)
     ]
   }
 
   addCustomAttribute(key, value, truncateExempt = false) {
-    const {attributeFilter} = Config.getInstance()
+    const { attributeFilter } = Config.getInstance()
     const dest = attributeFilter.filterSegment(DESTINATIONS.SPAN_EVENT, key)
     if (dest & DESTINATIONS.SPAN_EVENT) {
       this.customAttributes[key] = truncateExempt ? value : _truncate(value)
@@ -165,7 +163,7 @@ class SpanEvent {
   }
 
   addAttribute(key, value, truncateExempt = false) {
-    const {attributeFilter} = Config.getInstance()
+    const { attributeFilter } = Config.getInstance()
     const dest = attributeFilter.filterSegment(DESTINATIONS.SPAN_EVENT, key)
     if (dest & DESTINATIONS.SPAN_EVENT) {
       this.attributes[key] = truncateExempt ? value : _truncate(value)

package/lib/spans/span-streamer.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-const logger = require('../logger').child({component: 'span-streamer'})
+const logger = require('../logger').child({ component: 'span-streamer' })
 const NAMES = require('../metrics/names').INFINITE_TRACING
 
 const SPAN_DROP_MSG_INTERVAL_MS = 30000
@@ -14,25 +14,25 @@ const SPAN_DROP_MSG =
   `Will not warn again for ${SPAN_DROP_MSG_INTERVAL_MS / 1000} seconds.`
 
 class SpanStreamer {
-  constructor(license_key, connection, metrics, queue_size) {
+  constructor(licenseKey, connection, metrics, queueSize) {
     this.stream = null
-    this.license_key = license_key
+    this.license_key = licenseKey
     this.connection = connection
-    this.queue_size = queue_size
+    this.queue_size = queueSize
     this.spans = []
     this._metrics = metrics
     this._writable = false
 
     // 'connected' indicates a safely writeable stream.
     // May still be mid-connect to gRPC server.
-    this.connection.on('connected', (stream) =>{
+    this.connection.on('connected', (stream) => {
       logger.info('Span streamer connected')
       this.stream = stream
       this._writable = true
       this.sendQueue()
     })
 
-    this.connection.on('disconnected', () =>{
+    this.connection.on('disconnected', () => {
       logger.info('Span streamer disconnected')
       this.stream = null
       this._writable = false
@@ -110,8 +110,7 @@ class SpanStreamer {
     // average time to drain from when we first notice.
     const drainCompleted = Date.now()
     const drainDurationMs = drainCompleted - waitDrainStart
-    this._metrics.getOrCreateMetric(NAMES.DRAIN_DURATION)
-      .recordValue(drainDurationMs / 1000)
+    this._metrics.getOrCreateMetric(NAMES.DRAIN_DURATION).recordValue(drainDurationMs / 1000)
 
     // Once the 'drain' event fires we can begin writing to the stream again
     this._writable = true
@@ -131,18 +130,11 @@ class SpanStreamer {
       this.send(nextObject.toStreamingFormat())
     }
 
-    logger.trace(
-      'Finished sending spans from queue. Items left in queue: %s',
-      this.spans.length
-    )
+    logger.trace('Finished sending spans from queue. Items left in queue: %s', this.spans.length)
   }
 
-  connect(agent_run_id, requestHeadersMap) {
-    this.connection.setConnectionDetails(
-      this.license_key,
-      agent_run_id,
-      requestHeadersMap
-    )
+  connect(agentRunId, requestHeadersMap) {
+    this.connection.setConnectionDetails(this.license_key, agentRunId, requestHeadersMap)
 
     this.connection.connectSpans()
   }

package/lib/spans/streaming-span-event-aggregator.js

@@ -7,7 +7,7 @@
 
 const Aggregator = require('../aggregators/base-aggregator')
 const StreamingSpanEvent = require('./streaming-span-event')
-const logger = require('../logger').child({component: 'streaming-span-event-aggregator'})
+const logger = require('../logger').child({ component: 'streaming-span-event-aggregator' })
 
 const SEND_WARNING =
   'send() is not currently supported on streaming span event aggregator. ' +

package/lib/spans/streaming-span-event.js

@@ -6,10 +6,10 @@
 'use strict'
 
 const StreamingSpanAttributes = require('./streaming-span-attributes')
-const {truncate} = require('../util/byte-limit')
+const { truncate } = require('../util/byte-limit')
 const Config = require('../config')
 
-const {DESTINATIONS} = require('../config/attribute-filter')
+const { DESTINATIONS } = require('../config/attribute-filter')
 
 const HTTP_LIBRARY = 'http'
 const CLIENT_KIND = 'client'
@@ -88,7 +88,7 @@ class StreamingSpanEvent {
   }
 
   _checkFilter(key) {
-    const {attributeFilter} = Config.getInstance()
+    const { attributeFilter } = Config.getInstance()
     const dest = attributeFilter.filterSegment(DESTINATIONS.SPAN_EVENT, key)
     return dest & DESTINATIONS.SPAN_EVENT
   }
@@ -128,7 +128,7 @@ class StreamingSpanEvent {
     let span = null
     if (StreamingHttpSpanEvent.isHttpSegment(segment)) {
       span = new StreamingHttpSpanEvent(traceId, agentAttributes, customAttributes)
-    }  else if (StreamingDatastoreSpanEvent.isDatastoreSegment(segment)) {
+    } else if (StreamingDatastoreSpanEvent.isDatastoreSegment(segment)) {
       span = new StreamingDatastoreSpanEvent(traceId, agentAttributes, customAttributes)
     } else {
       span = new StreamingSpanEvent(traceId, agentAttributes, customAttributes)

package/lib/stats/apdex.js

@@ -12,7 +12,6 @@
  */
 var FROM_MILLIS = 1e-3
 
-
 function ApdexStats(apdexT) {
   if (!apdexT && apdexT !== 0) {
     throw new Error('Apdex summary must be created with apdexT.')
@@ -35,8 +34,10 @@ ApdexStats.prototype.recordValue = function recordValue(time, overrideApdex) {
   }
 }
 
-ApdexStats.prototype.recordValueInMillis =
-function recordValueInMillis(timeInMillis, overrideApdex) {
+ApdexStats.prototype.recordValueInMillis = function recordValueInMillis(
+  timeInMillis,
+  overrideApdex
+) {
   this.recordValue(timeInMillis * FROM_MILLIS, overrideApdex * FROM_MILLIS)
 }
 
@@ -71,14 +72,7 @@ ApdexStats.prototype.merge = function merge(other) {
  *                  load times, respectively.
  */
 ApdexStats.prototype.toJSON = function toJSON() {
-  return [
-    this.satisfying,
-    this.tolerating,
-    this.frustrating,
-    this.apdexT,
-    this.apdexT,
-    0
-  ]
+  return [this.satisfying, this.tolerating, this.frustrating, this.apdexT, this.apdexT, 0]
 }
 
 module.exports = ApdexStats

package/lib/stats/index.js

@@ -13,7 +13,6 @@
 var BYTES_PER_MB = 1024 * 1024
 var FROM_MILLIS = 1e-3
 
-
 /**
  * Simple container for tracking running statistics for a metric.
  */
@@ -35,8 +34,12 @@ function Stats() {
  */
 Stats.prototype.recordValue = function recordValue(totalTime, exclusiveTime) {
   // even if a caller messes up, don't break everything else
-  if (totalTime !== 0 && !totalTime) totalTime = 0
-  if (exclusiveTime !== 0 && !exclusiveTime) exclusiveTime = totalTime
+  if (totalTime !== 0 && !totalTime) {
+    totalTime = 0
+  }
+  if (exclusiveTime !== 0 && !exclusiveTime) {
+    exclusiveTime = totalTime
+  }
 
   if (this.callCount > 0) {
     this.min = Math.min(totalTime, this.min)
@@ -45,7 +48,7 @@ Stats.prototype.recordValue = function recordValue(totalTime, exclusiveTime) {
   }
   this.max = Math.max(totalTime, this.max)
 
-  this.sumOfSquares += (totalTime * totalTime)
+  this.sumOfSquares += totalTime * totalTime
   ++this.callCount
   this.total += totalTime
   this.totalExclusive += exclusiveTime
@@ -57,10 +60,7 @@ Stats.prototype.recordValue = function recordValue(totalTime, exclusiveTime) {
  */
 Stats.prototype.recordValueInMillis = recordValueInMillis
 function recordValueInMillis(totalTime, exclusiveTime) {
-  this.recordValue(
-    totalTime * FROM_MILLIS,
-    exclusiveTime >= 0 ? exclusiveTime * FROM_MILLIS : null
-  )
+  this.recordValue(totalTime * FROM_MILLIS, exclusiveTime >= 0 ? exclusiveTime * FROM_MILLIS : null)
 }
 
 Stats.prototype.recordValueInBytes = function recordValueInBytes(bytes, exclusiveBytes) {
@@ -69,7 +69,9 @@ Stats.prototype.recordValueInBytes = function recordValueInBytes(bytes, exclusiv
 }
 
 Stats.prototype.incrementCallCount = function incrementCallCount(count) {
-  if (typeof count === 'undefined') count = 1
+  if (typeof count === 'undefined') {
+    count = 1
+  }
   this.callCount += count
 }
 
@@ -113,14 +115,7 @@ Stats.prototype.merge = function merge(other) {
  *                  running sum of squares.
  */
 Stats.prototype.toJSON = function toJSON() {
-  return [
-    this.callCount,
-    this.total,
-    this.totalExclusive,
-    this.min,
-    this.max,
-    this.sumOfSquares
-  ]
+  return [this.callCount, this.total, this.totalExclusive, this.min, this.max, this.sumOfSquares]
 }
 
 module.exports = Stats

package/lib/system-info.js

@@ -9,7 +9,7 @@ var exec = require('child_process').exec
 var readProc = require('./utilization/common').readProc
 var getBootId = require('./utilization/docker-info').getBootId
 var utilization = require('./utilization')
-var logger = require('./logger.js').child({component: 'system-info'})
+var logger = require('./logger.js').child({ component: 'system-info' })
 var os = require('os')
 var parseCpuInfo = require('./parse-proc-cpuinfo')
 var parseMemInfo = require('./parse-proc-meminfo')
@@ -193,14 +193,18 @@ function getKernelVersion(callback) {
 }
 
 function getSysctlValue(names, callback) {
-  if (!names) return callback(null)
+  if (!names) {
+    return callback(null)
+  }
   var returned = false
   var ran = 0
   names.forEach(function sysctlName(name) {
     exec('sysctl -n ' + name, respond)
 
     function respond(err, stdout, stderr) {
-      if (returned) return
+      if (returned) {
+        return
+      }
       if (err) {
         logger.debug('Error when trying to run: sysctl -n %s: %s', name, err.message)
         callback(null)

package/lib/timer.js

@@ -20,10 +20,9 @@ var PENDING = 1
 var RUNNING = 2
 var STOPPED = 3
 
-
 function hrToMillis(hr) {
   // process.hrTime gives you [second, nanosecond] duration pairs
-  return (hr[0] * 1e3) + (hr[1] / 1e6)
+  return hr[0] * 1e3 + hr[1] / 1e6
 }
 
 /**
@@ -45,7 +44,9 @@ function Timer() {
  * Uses process.hrtime if available, Date.now() otherwise.
  */
 Timer.prototype.begin = function begin() {
-  if (this.state > PENDING) return
+  if (this.state > PENDING) {
+    return
+  }
 
   this.start = Date.now()
   this.hrstart = process.hrtime()
@@ -56,8 +57,12 @@ Timer.prototype.begin = function begin() {
  * End measurement.
  */
 Timer.prototype.end = function end() {
-  if (this.state > RUNNING) return
-  if (this.state === PENDING) this.begin()
+  if (this.state > RUNNING) {
+    return
+  }
+  if (this.state === PENDING) {
+    this.begin()
+  }
   this.hrDuration = process.hrtime(this.hrstart)
   this.touched = true
   this.state = STOPPED
@@ -68,8 +73,12 @@ Timer.prototype.end = function end() {
  */
 Timer.prototype.touch = function touch() {
   this.touched = true
-  if (this.state > RUNNING) return
-  if (this.state === PENDING) this.begin()
+  if (this.state > RUNNING) {
+    return
+  }
+  if (this.state === PENDING) {
+    this.begin()
+  }
 
   this.hrDuration = process.hrtime(this.hrstart)
 }
@@ -79,12 +88,18 @@ Timer.prototype.touch = function touch() {
  * "now". Returns a boolean indicating whether the end time changed.
  */
 Timer.prototype.softEnd = function softEnd() {
-  if (this.state > RUNNING) return false
-  if (this.state === PENDING) this.begin()
+  if (this.state > RUNNING) {
+    return false
+  }
+  if (this.state === PENDING) {
+    this.begin()
+  }
 
   this.state = STOPPED
 
-  if (this.touched) return false
+  if (this.touched) {
+    return false
+  }
   this.hrDuration = process.hrtime(this.hrstart)
   this.touched = true
   return true
@@ -146,7 +161,7 @@ Timer.prototype.setDurationInMillis = function setDurationInMillis(duration, sta
   // is the assumption being made here.  since hrstart isn't used
   // anywhere except to calculate duration, and we are setting duration
   // this is fine.
-  this.hrstart = [Math.floor(start / 1e3), start % 1e3 * 1e6]
+  this.hrstart = [Math.floor(start / 1e3), (start % 1e3) * 1e6]
   if (start != null) {
     this.start = start
   }
@@ -157,7 +172,9 @@ Timer.prototype.setDurationInMillis = function setDurationInMillis(duration, sta
  * how long it ran (if it's been ended or touched).
  */
 Timer.prototype.getDurationInMillis = function getDurationInMillis() {
-  if (this.state === PENDING) return 0
+  if (this.state === PENDING) {
+    return 0
+  }
 
   // only set by setDurationInMillis
   if (this.durationInMillis !== null && this.durationInMillis >= 0) {
@@ -195,7 +212,6 @@ Timer.prototype.startedRelativeTo = function startedRelativeTo(other) {
     var s = this.hrstart[0] - other.hrstart[0]
     var ns = this.hrstart[1] - other.hrstart[1]
 
-
     return hrToMillis([s, ns])
   }
 
@@ -206,9 +222,7 @@ Timer.prototype.startedRelativeTo = function startedRelativeTo(other) {
  * Returns true if this timer ends after the other.
  */
 Timer.prototype.endsAfter = function compare(other) {
-  return (this.getDurationInMillis() + this.start) >
-    (other.getDurationInMillis() + other.start)
+  return this.getDurationInMillis() + this.start > other.getDurationInMillis() + other.start
 }
 
-
 module.exports = Timer

package/lib/transaction/dt-payload.js

@@ -5,7 +5,7 @@
 
 'use strict'
 
-var logger = require('../logger').child({component: 'distributedTracePayload'})
+var logger = require('../logger').child({ component: 'distributedTracePayload' })
 
 const DT_VERSION_MAJOR = 0
 const DT_VERSION_MINOR = 1