newrelic 6.4.0 → 6.6.0

package/lib/instrumentation/core/http.js

@@ -12,6 +12,7 @@ const urltils = require('../../util/urltils')
 const properties = require('../../util/properties')
 const psemver = require('../../util/process-version')
 const headerAttributes = require('../../header-attributes')
+const headerProcessing = require('../../header-processing')
 
 const NAMES = require('../../metrics/names')
 const DESTS = require('../../config/attribute-filter').DESTINATIONS
@@ -22,14 +23,12 @@ const DESTS = require('../../config/attribute-filter').DESTINATIONS
  *
  */
 const SHOULD_WRAP_HTTPS = psemver.satisfies('>=9.0.0 || 8.9.0')
+const SHOULD_FORMAT_ARGS = psemver.satisfies('>=10.0.0')
 const NR_CONNECTION_PROP = '__NR__connection'
-const REQUEST_HEADER = 'x-request-start'
-const QUEUE_HEADER = 'x-queue-start'
 const NEWRELIC_ID_HEADER = 'x-newrelic-id'
 const NEWRELIC_APP_DATA_HEADER = 'x-newrelic-app-data'
 const NEWRELIC_TRANSACTION_HEADER = 'x-newrelic-transaction'
 const NEWRELIC_SYNTHETICS_HEADER = 'x-newrelic-synthetics'
-const CONTENT_LENGTH_REGEX = /^Content-Length$/i
 const TRANSACTION_INFO_KEY = '__NR_transactionInfo'
 
 
@@ -113,36 +112,11 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
       'Applying user naming rules for RUM.')
     transaction.applyUserNamingRules(request.url)
 
-    /**
-     * Calculate Queue Time
-     *
-     * Queue time is provided by certain providers by stamping the request
-     * header with the time the request arrived at the router.
-     *
-     * Units for queue time are
-     */
-    var qtime = request.headers[REQUEST_HEADER] || request.headers[QUEUE_HEADER]
-    if (qtime) {
-      var split = qtime.split('=')
-      if (split.length > 1) {
-        qtime = split[1]
-      }
-
-      var start = parseFloat(qtime)
-
-      if (isNaN(start)) {
-        logger.warn('Queue time header parsed as NaN (%s)', qtime)
-      } else {
-        // nano seconds
-        if (start > 1e18) start = start / 1e6
-        // micro seconds
-        else if (start > 1e15) start = start / 1e3
-        // seconds
-        else if (start < 1e12) start = start * 1e3
-
-        transaction.queueTime = Date.now() - start
-      }
+    const queueTimeStamp = headerProcessing.getQueueTime(logger, request.headers)
+    if (queueTimeStamp) {
+      transaction.queueTime = Date.now() - queueTimeStamp
     }
+
     if (agent.config.distributed_tracing.enabled) {
       // Node http headers are automatically lowercase
       transaction.acceptDistributedTraceHeaders(transport, request.headers)
@@ -179,6 +153,10 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
 
       if (response) {
         if (response.statusCode != null) {
+          /*
+          TODO: remove with next major release
+          httpResponseCode attribute is deprecated
+          */
           var responseCode = String(response.statusCode)
           transaction.trace.attributes.addAttribute(
             DESTS.TRANS_COMMON,
@@ -187,6 +165,16 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
           )
 
           if (/^\d+$/.test(responseCode)) {
+            transaction.trace.attributes.addAttribute(
+              DESTS.TRANS_COMMON,
+              'http.statusCode',
+              responseCode
+            )
+
+            /*
+            TODO: remove with next major release
+            response.status attribute is deprecated
+            */
             transaction.trace.attributes.addAttribute(
               DESTS.TRANS_COMMON,
               'response.status',
@@ -194,7 +182,18 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
             )
           }
         }
+
         if (response.statusMessage !== undefined) {
+          transaction.trace.attributes.addAttribute(
+            DESTS.TRANS_COMMON,
+            'http.statusText',
+            response.statusMessage
+          )
+
+          /*
+            TODO: remove with next major release
+            httpResponseMessage attribute is deprecated
+          */
           transaction.trace.attributes.addAttribute(
             DESTS.TRANS_COMMON,
             'httpResponseMessage',
@@ -202,8 +201,7 @@ function wrapEmitWithTransaction(agent, emit, isHTTPS) {
           )
         }
 
-        // TODO: Just use `getHeaders()` after deprecating Node <7.7.
-        var headers = (response.getHeaders && response.getHeaders()) || response._headers
+        var headers = response.getHeaders()
         if (headers) {
           headerAttributes.collectResponseHeaders(headers, transaction)
         }
@@ -356,25 +354,12 @@ function wrapWriteHead(agent, writeHead) {
     var new_headers = arguments[arguments.length - 1]
 
     if (typeof new_headers === 'object') {
-      for (var header in new_headers) {  // jshint ignore: line
-        if (CONTENT_LENGTH_REGEX.test(header)) {
-          contentLength = new_headers[header]
-          break
-        }
-      }
+      contentLength = headerProcessing.getContentLengthFromHeaders(new_headers)
     }
 
-    if (contentLength === -1 && this._headers) {
-      // JSHint complains about ownProperty stuff, but since we are looking
-      // for a specific name that doesn't matter so I'm disabling it.
-      // Outbound headers can be capitalized in any way, use regex instead
-      // of direct lookup.
-      for (var userHeader in this._headers) {  // jshint ignore: line
-        if (CONTENT_LENGTH_REGEX.test(userHeader)) {
-          contentLength = this._headers[userHeader]
-          break
-        }
-      }
+    const currentHeaders = this.getHeaders()
+    if (contentLength === -1 && currentHeaders) {
+      contentLength = headerProcessing.getContentLengthFromHeaders(currentHeaders)
     }
     // Stored on the tx so we can push a metric with this time instead of
     // actual duration.
@@ -411,8 +396,60 @@ function wrapWriteHead(agent, writeHead) {
   }
 }
 
+// Taken from the Node code base, internal/url.js
+function urlToOptions(_url) {
+  const options = {
+    protocol: _url.protocol,
+    hostname: typeof _url.hostname === 'string' && _url.hostname.startsWith('[') ?
+      _url.hostname.slice(1, -1) :
+      _url.hostname,
+    hash: _url.hash,
+    search: _url.search,
+    pathname: _url.pathname,
+    path: `${_url.pathname || ''}${_url.search || ''}`,
+    href: _url.href
+  }
+  if (_url.port !== '') {
+    options.port = Number(_url.port)
+  }
+  if (_url.username || _url.password) {
+    options.auth = `${_url.username}:${_url.password}`
+  }
+  return options
+}
+
 function wrapRequest(agent, request) {
-  return function wrappedRequest(options) {
+  // URL as a global was not added until Node v10
+  const URLClass = global.URL ? global.URL : url.URL
+  return function wrappedRequest(input, options, cb) {
+    let reqArgs = arguments
+    if (SHOULD_FORMAT_ARGS) {
+      // Support new function signatures in Node v10+. If the first argument is a URL,
+      // merge it into the options object. This code is copied from Node internals.
+      if (typeof input === 'string') {
+        const urlStr = input
+        input = urlToOptions(new URLClass(urlStr))
+      } else if (input.constructor && input.constructor.name === 'URL') {
+        input = urlToOptions(input)
+      } else {
+        cb = options
+        options = input
+        input = null
+      }
+
+      if (typeof options === 'function') {
+        cb = options
+        options = input || {}
+      } else {
+        options = Object.assign(input || {}, options)
+      }
+
+      reqArgs = [options, cb]
+    } else {
+      // Node v8 function signature had options as the first argument
+      options = input
+    }
+
     // Don't pollute metrics and calls with NR connections
     const internalOnly = options && options[NR_CONNECTION_PROP]
     if (internalOnly) {
@@ -430,13 +467,12 @@ function wrapRequest(agent, request) {
           logOpts.port
         )
       }
-      return request.apply(this, arguments)
+      return request.apply(this, reqArgs)
     }
 
-    const args = agent.tracer.slice(arguments)
+    const args = agent.tracer.slice(reqArgs)
     const context = this
 
-    // hostname & port logic pulled directly from node's 0.10 lib/http.js
     return instrumentOutbound(agent, options, function makeRequest(opts) {
       args[0] = opts
       return request.apply(context, args)
@@ -444,28 +480,6 @@ function wrapRequest(agent, request) {
   }
 }
 
-function wrapLegacyRequest(agent, request) {
-  return function wrappedLegacyRequest(method, path, headers) {
-    var makeRequest = request.bind(this, method, path, headers)
-
-    if (agent.tracer.getTransaction()) {
-      return instrumentOutbound(agent, this, makeRequest)
-    }
-
-    logger.trace('No transaction, not recording external to %s:%s', this.host, this.port)
-    return makeRequest()
-  }
-}
-
-function wrapLegacyClient(agent, proto) {
-  shimmer.wrapMethod(
-    proto,
-    'http.Client.prototype',
-    'request',
-    wrapLegacyRequest.bind(null, agent)
-  )
-}
-
 module.exports = function initialize(agent, http, moduleName) {
   if (!http) {
     logger.debug('Did not get http module, not instrumenting!')
@@ -522,7 +536,7 @@ module.exports = function initialize(agent, http, moduleName) {
   // change originally also appeared in 8.9.0 but was reverted in 8.9.1.
   //
   // TODO: Remove `SHOULD_WRAP_HTTPS` after deprecating Node <9.
-  if (SHOULD_WRAP_HTTPS || !IS_HTTPS) {
+  if (SHOULD_WRAP_HTTPS || !IS_HTTPS) {
     shimmer.wrapMethod(
       http,
       'http',
@@ -530,21 +544,12 @@ module.exports = function initialize(agent, http, moduleName) {
       wrapRequest.bind(null, agent)
     )
 
-    // Upon updating to https-proxy-agent v2, we are now using
-    // agent-base v4, which patches https.get to use https.request.
-    //
-    // https://github.com/TooTallNate/node-agent-base/commit/7de92df780e147d4618
-    //
-    // This means we need to skip instrumenting to avoid double
-    // instrumenting external requests.
-    if (!IS_HTTPS && psemver.satisfies('>=8')) {
-      shimmer.wrapMethod(
-        http,
-        'http',
-        'get',
-        wrapRequest.bind(null, agent)
-      )
-    }
+    shimmer.wrapMethod(
+      http,
+      'http',
+      'get',
+      wrapRequest.bind(null, agent)
+    )
   }
 
   shimmer.wrapMethod(
@@ -569,58 +574,6 @@ module.exports = function initialize(agent, http, moduleName) {
       }
     }
   )
-
-  // http.Client is deprecated, but still in use
-  // TODO: Remove this once Node <7 is deprecated.
-  var DeprecatedClient, deprecatedCreateClient
-  function clearGetters() {
-    if (DeprecatedClient) {
-      delete http.Client
-      http.Client = DeprecatedClient
-    }
-    if (deprecatedCreateClient) {
-      delete http.createClient
-      http.createClient = deprecatedCreateClient
-    }
-  }
-
-  // TODO: Remove this once Node <7 is deprecated.
-  DeprecatedClient = shimmer.wrapDeprecated(
-    http,
-    'http',
-    'Client',
-    {
-      get: function get() {
-        var example = new DeprecatedClient(80, 'localhost')
-        wrapLegacyClient(agent, example.constructor.prototype)
-        clearGetters()
-
-        return DeprecatedClient
-      },
-      set: function set(NewClient) {
-        DeprecatedClient = NewClient
-      }
-    }
-  )
-
-  // TODO: Remove this once Node <7 is deprecated.
-  deprecatedCreateClient = shimmer.wrapDeprecated(
-    http,
-    'http',
-    'createClient',
-    {
-      get: function get() {
-        var example = deprecatedCreateClient(80, 'localhost')
-        wrapLegacyClient(agent, example.constructor.prototype)
-        clearGetters()
-
-        return deprecatedCreateClient
-      },
-      set: function set(newCreateClient) {
-        deprecatedCreateClient = newCreateClient
-      }
-    }
-  )
 }
 
 /**

package/lib/instrumentation/hapi/hapi-17.js

@@ -1,6 +1,7 @@
 'use strict'
 
-var shared = require('./shared')
+const shared = require('./shared')
+const record = require('../../metrics/recorders/generic')
 
 // TODO: abstract and consolidate mostly-shared hapi functionality
 module.exports = function initialize(agent, hapi, moduleName, shim) {
@@ -154,14 +155,20 @@ function wrapPreHandlers(shim, container, path) {
     }
     return container
   } else if (shim.isFunction(container)) {
-    return wrapRouteHandler(shim, container, path)
+    return wrapPreHandler(shim, container, path)
   } else if (container.method && shim.isFunction(container.method)) {
     return shim.wrap(container, 'method', function wrapHandler(shim, handler) {
-      return wrapRouteHandler(shim, handler, path)
+      return wrapPreHandler(shim, handler, path)
     })
   }
 }
 
+function wrapPreHandler(shim, container, path) {
+  return shim.record(container, (shim) => {
+    return {name: [shim.HAPI, ' pre handler: ','(',path,')'].join(''), recorder: record}
+  })
+}
+
 function wrapRouteHandler(shim, handler, path) {
   return shim.recordMiddleware(handler, {
     route: path,

package/lib/metrics/names.js

@@ -16,7 +16,8 @@ const SUPPORTABILITY = {
   DEPENDENCIES: 'Supportability/InstalledDependencies',
   NODEJS: 'Supportability/Nodejs',
   REGISTRATION: 'Supportability/Registration',
-  EVENT_HARVEST: 'Supportability/EventHarvest'
+  EVENT_HARVEST: 'Supportability/EventHarvest',
+  INFINITE_TRACING: 'Supportability/InfiniteTracing'
 }
 
 const ERRORS = {
@@ -231,6 +232,15 @@ const SPAN_EVENTS = {
   DROPPED: SUPPORTABILITY.PREFIX + 'SpanEvent/Discarded'
 }
 
+const INFINITE_TRACING = {
+  SEEN: SUPPORTABILITY.INFINITE_TRACING + '/Span/Seen',
+  SENT: SUPPORTABILITY.INFINITE_TRACING + '/Span/Sent',
+  SPAN_RESPONSE_ERROR: SUPPORTABILITY.INFINITE_TRACING + '/Span/Response/Error',
+  SPAN_RESPONSE_GRPC_UNIMPLEMENTED: SUPPORTABILITY.INFINITE_TRACING + '/Span/gRPC/UNIMPLEMENTED',
+  SPAN_RESPONSE_GRPC_STATUS: SUPPORTABILITY.INFINITE_TRACING + '/Span/gRPC/%s',
+  DRAIN_DURATION: SUPPORTABILITY.INFINITE_TRACING + '/Drain/Duration'
+}
+
 module.exports = {
   ACTION_DELIMITER: '/',
   ALL: ALL,
@@ -253,6 +263,7 @@ module.exports = {
   GC: GC,
   HAPI: HAPI,
   HTTP: 'HttpDispatcher',
+  INFINITE_TRACING: INFINITE_TRACING,
   LOOP: LOOP,
   MEMCACHE: MEMCACHE,
   MEMORY: MEMORY,

package/lib/proxy/grpc.js

@@ -0,0 +1,15 @@
+'use strict'
+class ProxyGrpc {
+  constructor(grpcLibrary = '@grpc/grpc-js') {
+    this.library = require(grpcLibrary)
+
+    // add methods or objets from base grpc class that we need as needed
+    this.credentials = this.library.credentials
+    this.Metadata = this.library.Metadata
+    this.loadPackageDefinition = this.library.loadPackageDefinition
+    this.status = this.library.status
+    this.Server = this.library.Server
+    this.ServerCredentials = this.library.ServerCredentials
+  }
+}
+module.exports = (new ProxyGrpc)

package/lib/serverless/aws-lambda.js

@@ -174,6 +174,8 @@ class AwsLambda {
 
       shim.agent.setLambdaArn(context.invokedFunctionArn)
 
+      shim.agent.setLambdaFunctionVersion(context.functionVersion)
+
       segment.start()
 
       let res

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

@@ -0,0 +1,112 @@
+'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) {
+  let shouldCreateStreaming = false
+  if (config.infinite_tracing.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 existance of trace_observer.host.
+    shouldCreateStreaming = validateInfiniteTracing(config.infinite_tracing.trace_observer)
+
+    if (!shouldCreateStreaming) {
+      // Explicitly disable for any downstream consumers
+      config.infinite_tracing.trace_observer.host = ''
+      config.infinite_tracing.trace_observer.port = ''
+    }
+  }
+
+  if (shouldCreateStreaming) {
+    return createStreamingAggregator(config, collector, metrics)
+  }
+
+  return createStandardAggregator(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 spanStreamer = new SpanStreamer(
+    config.license_key,
+    connection,
+    metrics
+  )
+
+  const opts = {
+    periodMs: 1000,
+    limit: 50000,
+    span_streamer: spanStreamer
+  }
+
+  const aggregator = new StreamingSpanEventAggregator(opts, collector, metrics)
+
+  return aggregator
+}
+
+function createStandardAggregator(config, collector, metrics) {
+  logger.trace('Creating standard span event aggregator.')
+
+  const opts = {
+    periodMs: config.event_harvest_config.report_period_ms,
+    limit: config.event_harvest_config.harvest_limits.span_event_data
+  }
+
+  const aggregator = new SpanEventAggregator(opts, collector, metrics)
+  return aggregator
+}
+
+function validateInfiniteTracing(trace_observer) {
+  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
+  }
+
+  trace_observer.host = trace_observer.host.trim()
+
+  if (!validateHostName(trace_observer.host)) {
+    logger.warn('Infinite tracing disabled: invalid infinite_tracing.trace_observer.host value')
+
+    return false
+  }
+
+  if (typeof trace_observer.port !== 'string') {
+    trace_observer.port = String(trace_observer.port)
+  }
+
+  trace_observer.port = trace_observer.port.trim()
+
+  if (!validatePortValue(trace_observer.port)) {
+    logger.warn('Infinite tracing disabled: invalid infinite_tracing.trace_observer.port value')
+
+    return false
+  }
+
+  return true
+}
+
+function validateHostName(host) {
+  // Regular expression for validating a hostname
+  const hostReg = /(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{0,62}[a-zA-Z0-9]\.)+[a-zA-Z]{2,63}$)/
+
+  return hostReg.test(host)
+}
+
+function validatePortValue(port) {
+  if (port.length === 0) return false
+
+  return !isNaN(port)
+}
+
+module.exports = createSpanEventAggregator

package/lib/spans/map-to-streaming-type.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const STRING_TYPE = 'string_value'
+const BOOL_TYPE = 'bool_value'
+const INT_TYPE = 'int_value'
+const DOUBLE_TYPE = 'double_value'
+
+function mapToStreamingType(value) {
+  if (value === null || value === undefined) {
+    return
+  }
+
+  const valueType = typeof value
+
+  let protoTypeString = null
+  switch (valueType) {
+    case 'string': {
+      protoTypeString = STRING_TYPE
+      break
+    }
+    case 'boolean': {
+      protoTypeString = BOOL_TYPE
+      break
+    }
+    case 'number': {
+      const isInteger = Number.isInteger(value)
+      protoTypeString = isInteger ? INT_TYPE : DOUBLE_TYPE
+      break
+    }
+    default: {
+      protoTypeString = null
+    }
+  }
+
+  if (protoTypeString) {
+    return {
+      [protoTypeString]: value
+    }
+  }
+
+  return
+}
+
+module.exports = mapToStreamingType

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

@@ -35,6 +35,11 @@ class SpanEventAggregator extends EventAggregator {
     return [this.runId, metrics, eventData]
   }
 
+  start() {
+    logger.debug('starting SpanEventAggregator')
+    return super.start()
+  }
+
   send() {
     if (spanLogger.traceEnabled()) {
       spanLogger.trace({

package/lib/spans/span-event.js

@@ -12,6 +12,7 @@ const CATEGORIES = {
   DATASTORE: 'datastore',
   GENERIC: 'generic'
 }
+
 const EMPTY_USER_ATTRS = Object.freeze(Object.create(null))
 
 /**
@@ -48,7 +49,8 @@ class SpanIntrinsics {
  * @class
  */
 class SpanEvent {
-  constructor(attributes) {
+  constructor(attributes, customAttributes) {
+    this.customAttributes = customAttributes
     this.attributes = attributes
     this.intrinsics = new SpanIntrinsics()
   }
@@ -78,14 +80,15 @@ class SpanEvent {
    */
   static fromSegment(segment, parentId = null, isRoot = false) {
     const attributes = segment.attributes.get(DESTINATIONS.SPAN_EVENT)
+    const customAttributes = segment.customAttributes.get(DESTINATIONS.SPAN_EVENT)
 
     let span = null
     if (HttpSpanEvent.testSegment(segment)) {
-      span = new HttpSpanEvent(attributes)
+      span = new HttpSpanEvent(attributes, customAttributes)
     } else if (DatastoreSpanEvent.testSegment(segment)) {
-      span = new DatastoreSpanEvent(attributes)
+      span = new DatastoreSpanEvent(attributes, customAttributes)
     } else {
-      span = new SpanEvent(attributes)
+      span = new SpanEvent(attributes, customAttributes)
     }
 
     const tx = segment.transaction
@@ -120,11 +123,21 @@ class SpanEvent {
   toJSON() {
     return [
       _filterNulls(this.intrinsics),
-      EMPTY_USER_ATTRS,
+      this.customAttributes ?
+        _filterNulls(this.customAttributes) :
+        EMPTY_USER_ATTRS,
       _filterNulls(this.attributes)
     ]
   }
 
+  addCustomAttribute(key, value, truncateExempt = false) {
+    const {attributeFilter} = Config.getInstance()
+    const dest = attributeFilter.filterSegment(DESTINATIONS.SPAN_EVENT, key)
+    if (dest & DESTINATIONS.SPAN_EVENT) {
+      this.customAttributes[key] = truncateExempt ? value : _truncate(value)
+    }
+  }
+
   addAttribute(key, value, truncateExempt = false) {
     const {attributeFilter} = Config.getInstance()
     const dest = attributeFilter.filterSegment(DESTINATIONS.SPAN_EVENT, key)
@@ -141,8 +154,8 @@ class SpanEvent {
  * @class
  */
 class HttpSpanEvent extends SpanEvent {
-  constructor(attributes) {
-    super(attributes)
+  constructor(attributes, customAttributes) {
+    super(attributes, customAttributes)
 
     this.intrinsics.category = CATEGORIES.HTTP
     this.intrinsics.component = attributes.library || HTTP_LIBRARY
@@ -175,8 +188,8 @@ class HttpSpanEvent extends SpanEvent {
  * @class.
  */
 class DatastoreSpanEvent extends SpanEvent {
-  constructor(attributes) {
-    super(attributes)
+  constructor(attributes, customAttributes) {
+    super(attributes, customAttributes)
 
     this.intrinsics.category = CATEGORIES.DATASTORE
     this.intrinsics['span.kind'] = CLIENT_KIND