newrelic 8.10.0 → 8.11.2

package/lib/collector/serverless.js

@@ -22,10 +22,10 @@ class ServerlessCollector {
   /**
    * Constructs a new serverless collector instance with the give agent.
    *
-   * @constructor
+   * @class
+   * @param pipePath
    * @classdesc
    *  A helper class for wrapping modules with segments
-   *
    * @param {Agent} agent - The agent this collector will use
    */
   constructor(agent, pipePath) {
@@ -44,6 +44,8 @@ class ServerlessCollector {
 
   /**
    * Sets the ARN to be sent up in the metadata.
+   *
+   * @param arn
    */
   setLambdaArn(arn) {
     this.metadata.arn = arn
@@ -51,6 +53,8 @@ class ServerlessCollector {
 
   /**
    * Sets the function_version to be sent up in the metadata.
+   *
+   * @param function_version
    */
   setLambdaFunctionVersion(function_version) {
     this.metadata.function_version = function_version
@@ -79,6 +83,8 @@ class ServerlessCollector {
 
   /**
    * There is nothing to actually restart for serverless, so we do nothing.
+   *
+   * @param cb
    */
   restart(cb) {
     setImmediate(cb, null, CollectorResponse.success(null))
@@ -193,6 +199,19 @@ class ServerlessCollector {
     cb(null, { retainData: false })
   }
 
+  /**
+   * Records log event data to be serialized.
+   *
+   * @param {Array} payload The log event data payload to serialize.
+   * @param {Function} cb The callback to invoke when finished.
+   */
+  log_event_data(payload, cb) {
+    if (this.enabled) {
+      this.payload.log_event_data = payload
+    }
+    cb(null, { retainData: false })
+  }
+
   /**
    * Constructs, serializes, and prints the final consolidated payload to stdout.
    *
@@ -250,6 +269,8 @@ class ServerlessCollector {
 
   /**
    * Writes payload to pipe
+   *
+   * @param payload
    */
   flushToPipeSync(payload) {
     try {
@@ -279,7 +300,6 @@ class ServerlessCollector {
    * Internal method to handle flushing to stdout.
    *
    * @private
-   *
    * @param {string} payload The payload to flush.
    * @param {boolean} sync Whether to write to stdout synchronously.
    */

package/lib/config/default.js

@@ -305,7 +305,6 @@ exports.config = () => ({
      * grows too large the New Relic servers may reject it.
      *
      * @env NEW_RELIC_ERROR_COLLECTOR_MAX_EVENT_SAMPLES_STORED
-     *
      */
     max_event_samples_stored: 100,
 
@@ -689,7 +688,6 @@ exports.config = () => ({
      * grows too large the New Relic servers may reject it.
      *
      * @env NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED
-     *
      */
     max_samples_stored: 1000
   },
@@ -720,9 +718,9 @@ exports.config = () => ({
    * disabled.
    *
    * Attributes of high security mode (when enabled):
-   *  * requires SSL
-   *  * does not allow capturing of http params
-   *  * does not allow custom params
+   *  requires SSL
+   *  does not allow capturing of http params
+   *  does not allow custom params
    *
    * To read more see: https://docs.newrelic.com/docs/subscriptions/high-security
    */
@@ -761,11 +759,10 @@ exports.config = () => ({
   /**
    * Controls behavior of datastore instance metrics.
    *
-   * @property {Boolean} [instance_reporting.enabled=true]
+   * @property {boolean} [instance_reporting.enabled=true]
    *  Enables reporting the host and port/path/id of database servers. Default
    *  is `true`.
-   *
-   * @property {Boolean} [database_name_reporting.enabled=true]
+   * @property {boolean} [database_name_reporting.enabled=true]
    *  Enables reporting of database/schema names. Default is `true`.
    */
   datastore_tracer: {
@@ -873,7 +870,7 @@ exports.config = () => ({
   /**
    * Controls the use of cross-application tracing.
    *
-   * @property {Boolean} [enabled=false]
+   * @property {boolean} [enabled=false]
    * Enables tracing transactions across multiple applications. Default is `false`.
    * This feature has been deprecated in favor of Distributed Tracing (DT).
    * To fully enable this feature, you must also disable DT in your configuration.
@@ -883,7 +880,7 @@ exports.config = () => ({
   /**
    * Controls behavior of message broker tracing.
    *
-   * @property {Boolean} [segment_parameters.enabled=true]
+   * @property {boolean} [segment_parameters.enabled=true]
    *  Enables reporting parameters on message broker segments.
    */
   message_tracer: {
@@ -934,5 +931,48 @@ exports.config = () => ({
      * loop data.
      */
     native_metrics: { enabled: true }
+  },
+
+  /**
+   *
+   * Controls the behavior of Logs in Context within agent
+   */
+  application_logging: {
+    /**
+     * Toggles the ability for all application logging features to be enabled.
+     *
+     * @env NEW_RELIC_APPLICATION_LOGGING_ENABLED
+     */
+    enabled: true,
+    forwarding: {
+      /**
+       * Toggles whether the agent gathers log records for sending to New Relic.
+       *
+       * @env NEW_RELIC_APPLICATION_LOGGING_FORWARDING_ENABLED
+       */
+      enabled: false,
+      /**
+       * Number of log records to send per minute to New Relic.
+       *
+       * @env NEW_RELIC_APPLICATION_LOGGING_FORWARDING_MAX_SAMPLES_STORED
+       */
+      max_samples_stored: 10000
+    },
+    metrics: {
+      /**
+       * Toggles whether the agent gathers logging metrics.
+       *
+       * @env NEW_RELIC_APPLICATION_LOGGING_METRICS_ENABLED
+       */
+      enabled: true
+    },
+    local_decorating: {
+      /**
+       * Toggles whether the agent performs log decoration on standard log output.
+       *
+       * @env NEW_RELIC_APPLICATION_LOGGING_LOCAL_DECORATING_ENABLED
+       */
+      enabled: false
+    }
   }
 })

package/lib/config/env.js

@@ -167,6 +167,19 @@ const ENV_MAPPING = {
     span_events: {
       queue_size: 'NEW_RELIC_INFINITE_TRACING_SPAN_EVENTS_QUEUE_SIZE'
     }
+  },
+  application_logging: {
+    enabled: 'NEW_RELIC_APPLICATION_LOGGING_ENABLED',
+    forwarding: {
+      enabled: 'NEW_RELIC_APPLICATION_LOGGING_FORWARDING_ENABLED',
+      max_samples_stored: 'NEW_RELIC_APPLICATION_LOGGING_FORWARDING_MAX_SAMPLES_STORED'
+    },
+    metrics: {
+      enabled: 'NEW_RELIC_APPLICATION_LOGGING_METRICS_ENABLED'
+    },
+    local_decorating: {
+      enabled: 'NEW_RELIC_APPLICATION_LOGGING_LOCAL_DECORATING_ENABLED'
+    }
   }
 }
 
@@ -242,7 +255,11 @@ const BOOLEAN_VARS = new Set([
   'NEW_RELIC_UTILIZATION_DETECT_GCP',
   'NEW_RELIC_UTILIZATION_DETECT_KUBERNETES',
   'NEW_RELIC_SERVERLESS_MODE_ENABLED',
-  'NEW_RELIC_NATIVE_METRICS_ENABLED'
+  'NEW_RELIC_NATIVE_METRICS_ENABLED',
+  'NEW_RELIC_APPLICATION_LOGGING_ENABLED',
+  'NEW_RELIC_APPLICATION_LOGGING_FORWARDING_ENABLED',
+  'NEW_RELIC_APPLICATION_LOGGING_METRICS_ENABLED',
+  'NEW_RELIC_APPLICATION_LOGGING_LOCAL_DECORATING_ENABLED'
 ])
 
 const FLOAT_VARS = new Set(['NEW_RELIC_APDEX_T', 'NEW_RELIC_TRACER_THRESHOLD'])
@@ -254,7 +271,8 @@ const INT_VARS = new Set([
   'NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED',
   'NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED',
   'NEW_RELIC_TRANSACTION_EVENTS_MAX_SAMPLES_STORED',
-  'NEW_RELIC_ERROR_COLLECTOR_MAX_EVENT_SAMPLES_STORED'
+  'NEW_RELIC_ERROR_COLLECTOR_MAX_EVENT_SAMPLES_STORED',
+  'NEW_RELIC_APPLICATION_LOGGING_FORWARDING_MAX_SAMPLES_STORED'
 ])
 
 exports.ENV_MAPPING = ENV_MAPPING

package/lib/config/hsm.js

@@ -50,6 +50,11 @@ const HIGH_SECURITY_SETTINGS = {
   },
   slow_sql: {
     enabled: false
+  },
+  application_logging: {
+    forwarding: {
+      enabled: false
+    }
   }
 }
 

package/lib/config/index.js

@@ -182,7 +182,8 @@ function Config(config) {
         analytic_event_data: this.transaction_events.max_samples_stored,
         custom_event_data: this.custom_insights_events.max_samples_stored,
         error_event_data: this.error_collector.max_event_samples_stored,
-        span_event_data: this.span_events.max_samples_stored
+        span_event_data: this.span_events.max_samples_stored,
+        log_event_data: this.application_logging.forwarding.max_samples_stored
       }
     }
   }

package/lib/instrumentation/@node-redis/client.js

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2021 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+const CLIENT_COMMANDS = ['select', 'quit', 'SELECT', 'QUIT']
+
+module.exports = function initialize(agent, redis, moduleName, shim) {
+  shim.setDatastore(shim.REDIS)
+  const COMMANDS = Object.keys(shim.require('dist/lib/client/commands.js').default)
+  const CMDS_TO_INSTRUMENT = [...COMMANDS, ...CLIENT_COMMANDS]
+  shim.wrap(redis, 'createClient', function wrapCreateClient(shim, original) {
+    return function wrappedCreateClient() {
+      const client = original.apply(this, arguments)
+      const clientOptions = getRedisParams(client.options)
+      CMDS_TO_INSTRUMENT.forEach((cmd) => {
+        shim.recordOperation(client, cmd, function wrapCommand(shim, fn, fnName, args) {
+          const [key, value] = args
+          const parameters = Object.assign({}, clientOptions)
+          // If selecting a database, subsequent commands
+          // will be using said database, update the clientOptions
+          // but not the current parameters(feature parity with v3)
+          if (cmd.toLowerCase() === 'select') {
+            clientOptions.database_name = key
+          }
+          if (agent.config.attributes.enabled) {
+            if (key) {
+              parameters.key = JSON.stringify(key)
+            }
+            if (value) {
+              parameters.value = JSON.stringify(value)
+            }
+          }
+
+          return {
+            name: (cmd && cmd.toLowerCase()) || 'other',
+            parameters,
+            promise: true
+          }
+        })
+      })
+
+      return client
+    }
+  })
+
+  /**
+   * Extracts the datastore parameters from the client options
+   *
+   * @param {object} opts client.options
+   * @returns {object} params
+   */
+  function getRedisParams(opts) {
+    return {
+      host: (opts.socket && opts.socket.host) || 'localhost',
+      port_path_or_id: (opts.socket && opts.socket.path) || opts.socket.port || '6379',
+      database_name: opts.database || 0
+    }
+  }
+}

package/lib/instrumentation/@redis/client.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+module.exports = require('../@node-redis/client')

package/lib/instrumentation/core/child_process.js

@@ -9,7 +9,7 @@ module.exports = initialize
 
 function initialize(agent, childProcess, moduleName, shim) {
   if (!childProcess) {
-    shim.log.debug('Could not find child_process, not instrumenting')
+    shim.logger.debug('Could not find child_process, not instrumenting')
     return false
   }
 

package/lib/instrumentation/winston.js

@@ -0,0 +1,187 @@
+/*
+ * Copyright 2022 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+'use strict'
+
+const Stream = require('stream')
+const {
+  isApplicationLoggingEnabled,
+  isLogForwardingEnabled,
+  isLocalDecoratingEnabled,
+  isMetricsEnabled,
+  createModuleUsageMetric,
+  incrementLoggingLinesMetrics,
+  truncate
+} = require('../util/application-logging')
+const logger = require('../logger').child({ component: 'winston' })
+
+module.exports = function instrument(agent, winston, _, shim) {
+  const config = agent.config
+
+  if (!isApplicationLoggingEnabled(config)) {
+    logger.debug('Application logging not enabled. Not instrumenting winston.')
+    return
+  }
+
+  shim.wrap(winston, 'createLogger', function wrapCreate(shim, createLogger) {
+    return function createWrappedLogger() {
+      const args = shim.argsToArray.apply(shim, arguments)
+      const opts = args[0]
+      if (!shim.isObject(opts) || isStream(opts)) {
+        return createLogger.apply(this, args)
+      }
+
+      registerFormatter({ opts, config, agent, winston })
+
+      return createLogger.apply(this, args)
+    }
+  })
+}
+
+/**
+ * There is no right way to do this.  But since we are automagical
+ * it is hard to predict how a customer uses winston.  We will iterate over the formatters specified on the logger and add last if forwarder or first if local decorating.
+ * This is because we want all the customizations of previous formatters before adding log log to log aggregator.  But in the case of local decorating we want to do this first so any formatter that is transforming data will have the changes.
+ *
+ * Note: The logic explained above does not apply if a customer specifies multiple formats for a given transport.
+ * We cannot instrument the formats on the transport because if a customer has multiple transports we would be duplicating logs when forwaring.
+ *
+ * @param {object} params object passed to function
+ * @param {object} params.opts options from winston.createLogger
+ * @param {object} params.config agent config
+ * @param {object} params.agent NR agent
+ * @param {object} params.winston exported winston package
+ */
+function registerFormatter({ opts, config, agent, winston }) {
+  const instrumentedFormatter = nrWinstonFormatter(agent, winston)
+
+  if ('format' in opts) {
+    const formatters = [opts.format]
+
+    if (isLogForwardingEnabled(config, agent)) {
+      formatters.push(instrumentedFormatter())
+    } else {
+      formatters.unshift(instrumentedFormatter())
+    }
+
+    opts.format = winston.format.combine(...formatters)
+  } else {
+    opts.format = instrumentedFormatter()
+  }
+}
+
+/**
+ * This formatter is being used to facilitate
+ * the application logging use cases.
+ * It is worth noting that the features below are mutually
+ * exclusive.
+ *
+ * The application logging use cases are local log decorating
+ * and log forwarding.
+ *
+ * Local log decorating appends `NR-LINKING` piped metadata to
+ * the message key in log line. You must configure a log forwarder to get
+ * this data to NR1.
+ *
+ * Log forwarding includes the linking metadata as keys on logging
+ * object as well as adds the log line to the agent log aggregator.
+ *
+ * @param {object} agent NR agent
+ * @param {object} winston exported winston package
+ * @returns {object} log line with NR context or NR-LINKING metadata on message
+ */
+function nrWinstonFormatter(agent, winston) {
+  const config = agent.config
+  const metrics = agent.metrics
+  createModuleUsageMetric('winston', metrics)
+
+  return winston.format((logLine) => {
+    if (isMetricsEnabled(config)) {
+      incrementLoggingLinesMetrics(logLine.level, metrics)
+    }
+
+    if (isLogForwardingEnabled(config, agent)) {
+      const metadata = agent.getLinkingMetadata()
+      reformatLogLine(logLine, metadata, agent)
+      agent.logs.add(logLine)
+    } else if (isLocalDecoratingEnabled(config)) {
+      logLine.message += agent.getNRLinkingMetadata()
+    }
+
+    return logLine
+  })
+}
+
+/**
+ * Reformats a log line by reformatting errors, timestamp and adding
+ * new relic linking metadata(context)
+ *
+ * @param {object} logLine log line
+ * @param {object} metadata linking metadata
+ * @param {object} agent NR agent
+ */
+function reformatLogLine(logLine, metadata, agent) {
+  if (logLine.exception === true) {
+    reformatError(logLine)
+  }
+
+  reformatTimestamp(logLine, agent)
+
+  // Add the metadata to the logLine object being logged
+  Object.assign(logLine, metadata)
+}
+
+/**
+ * Decorates the log line with  truncated error.message, error.class, and error.stack and removes
+ * trace and stack
+ *
+ * @param {object} logLine a log line
+ */
+function reformatError(logLine) {
+  // Due to Winston internals sometimes the error on the logLine object is a string or an
+  // empty object, and so the message property is all we have
+  const errorMessage = logLine.error.message || logLine.message || ''
+
+  logLine['error.message'] = truncate(errorMessage)
+  logLine['error.class'] =
+    logLine.error.name === 'Error' ? logLine.error.constructor.name : logLine.error.name
+  logLine['error.stack'] = truncate(logLine.error.stack)
+  logLine.message = truncate(logLine.message)
+
+  // Removes additional capture of stack to reduce overall payload/log-line size.
+  // The server has a maximum of ~4k characters per line allowed.
+  delete logLine.trace
+  delete logLine.stack
+}
+
+/**
+ * Turns timestamp into unix timestamp. If timestamp existed it will move original
+ * to `original_timestamp` key
+ *
+ * @param {object} logLine a log line
+ */
+function reformatTimestamp(logLine) {
+  if (logLine.timestamp) {
+    logger.traceOnce(
+      'Overwriting `timestamp` key; assigning original value to `original_timestamp`.'
+    )
+    logLine.original_timestamp = logLine.timestamp
+  }
+  logLine.timestamp = Date.now()
+}
+
+/**
+ * winston allows you to compose a logger
+ * from an instantiated logger.  Through a series
+ * of inherited classes, this logger instance is a Stream.
+ * Check what gets passed into `winston.createLogger` to avoid
+ * instrumenting an already instrumented instance of a logger.
+ *
+ * @param {*} obj obj to check if a stream
+ * @returns {boolean} is object is a stream or not
+ */
+function isStream(obj) {
+  return obj instanceof Stream
+}

package/lib/instrumentations.js

@@ -29,11 +29,14 @@ module.exports = function instrumentations() {
     'pg': { type: MODULE_TYPE.DATASTORE },
     'q': { type: null },
     'redis': { type: MODULE_TYPE.DATASTORE },
+    '@node-redis/client': { type: MODULE_TYPE.DATASTORE },
+    '@redis/client': { type: MODULE_TYPE.DATASTORE },
     'restify': { type: MODULE_TYPE.WEB_FRAMEWORK },
     'superagent': { module: '@newrelic/superagent' },
     'undici': { type: MODULE_TYPE.TRANSACTION },
     'oracle': { type: null },
     'vision': { type: MODULE_TYPE.WEB_FRAMEWORK },
-    'when': { type: null }
+    'when': { type: null },
+    'winston': { type: MODULE_TYPE.GENERIC }
   }
 }

package/lib/metrics/names.js

@@ -19,11 +19,13 @@ const SUPPORTABILITY = {
   TRANSACTION_API: 'Supportability/API/Transaction',
   UTILIZATION: 'Supportability/utilization',
   DEPENDENCIES: 'Supportability/InstalledDependencies',
+  NODEJS_DEPENDENCIES: 'Supportability/InstalledDependencies/Nodejs',
   NODEJS: 'Supportability/Nodejs',
   REGISTRATION: 'Supportability/Registration',
   EVENT_HARVEST: 'Supportability/EventHarvest',
   INFINITE_TRACING: 'Supportability/InfiniteTracing',
-  FEATURES: 'Supportability/Features'
+  FEATURES: 'Supportability/Features',
+  LOGGING: 'Supportability/Logging'
 }
 
 const ERRORS = {
@@ -197,7 +199,8 @@ const EVENT_HARVEST = {
     ANALYTIC: SUPPORTABILITY.EVENT_HARVEST + '/AnalyticEventData/HarvestLimit',
     CUSTOM: SUPPORTABILITY.EVENT_HARVEST + '/CustomEventData/HarvestLimit',
     ERROR: SUPPORTABILITY.EVENT_HARVEST + '/ErrorEventData/HarvestLimit',
-    SPAN: SUPPORTABILITY.EVENT_HARVEST + '/SpanEventData/HarvestLimit'
+    SPAN: SUPPORTABILITY.EVENT_HARVEST + '/SpanEventData/HarvestLimit',
+    LOG: SUPPORTABILITY.EVENT_HARVEST + '/LogEventData/HarvestLimit'
   }
 }
 
@@ -259,6 +262,29 @@ const FEATURES = {
   }
 }
 
+const LOGGING_LINES_PREFIX = 'Logging/lines'
+const LOGGING_FORWARDING_PREFIX = `${SUPPORTABILITY.LOGGING}/Forwarding`
+const LOGGING = {
+  LINES: LOGGING_LINES_PREFIX,
+  LEVELS: {
+    INFO: `${LOGGING_LINES_PREFIX}/INFO`,
+    WARN: `${LOGGING_LINES_PREFIX}/WARN`,
+    ERROR: `${LOGGING_LINES_PREFIX}/ERROR`,
+    DEBUG: `${LOGGING_LINES_PREFIX}/DEBUG`,
+    TRACE: `${LOGGING_LINES_PREFIX}/TRACE`
+  },
+  LIBS: {
+    PINO: `${SUPPORTABILITY.LOGGING}/${NODEJS.PREFIX}pino/enabled`,
+    WINSTON: `${SUPPORTABILITY.LOGGING}/${NODEJS.PREFIX}winston/enabled`
+  },
+  DROPPED: `Logging/Forwarding/Dropped`,
+  SEEN: `${LOGGING_FORWARDING_PREFIX}/Seen`,
+  SENT: `${LOGGING_FORWARDING_PREFIX}/Sent`,
+  FORWARDING: `${LOGGING_FORWARDING_PREFIX}/${NODEJS.PREFIX}`,
+  METRICS: `${SUPPORTABILITY.LOGGING}/Metrics/${NODEJS.PREFIX}`,
+  LOCAL_DECORATING: `${SUPPORTABILITY.LOGGING}/LocalDecorating/${NODEJS.PREFIX}`
+}
+
 module.exports = {
   ACTION_DELIMITER: '/',
   ALL: ALL,
@@ -284,6 +310,7 @@ module.exports = {
   HTTP: 'HttpDispatcher',
   INFINITE_TRACING: INFINITE_TRACING,
   LOOP: LOOP,
+  LOGGING,
   MEMCACHE: MEMCACHE,
   MEMORY: MEMORY,
   MESSAGE_TRANSACTION: MESSAGE_TRANSACTION,