Repository  -  API  -  Source


July 29, 2019
  • Implements Expected and Ignored Errors functionality

  • Bumps jsdoc and lodash dev dependency to avoid upstream vulnerability warning.

  • Added support for scoped package name introduced in hapi v18 (@hapi/hapi).

    This will provide functionality at parity with instrumentation for hapi v17. Any new features may not yet be supported.

    Huge shoutout to Aori Nevo (@aorinevo) for this contribution.

  • Fixed bug where agent would count errors towards error metrics even if they were dropped due to the error collector being disabled.

  • The agent will now properly track cached paths to files in loaded modules on Node versions >10.

    As of Node v11, the path to a file in a module being loaded will only be resolved on the first load; subsequent resolution of that file will use a cached value. The agent records this resolved path and uses it for relative file look ups in order to deep link into modules using Shim#require. Since the agent couldn't reliably get at the path on the subsequent calls to require, it now replicates the caching logic and hold onto the resolved path for a given file.

  • Adds detailed logging through harvest/collector code to increase supportability.


June 11, 2019
  • The agent now allows installation on node v11 and v12.

    This change relaxes the engines restriction to include Node v11 and v12. This does not constitute official support for those versions, and users on those versions may run into subtle incompatibilities. For those users who are interested in experimenting with the agent on v11 and v12, we are tracking relevant issues here:

  • Lambda invocations ended with promises will now be recorded properly.

    Previously, the lambda instrumentation was not intercepting the promise resolution/rejection returned from a lambda handler. The instrumentation now properly observes the promise, and ends the transaction when the promise has finished.

  • Lambda invocations will only attempt to end the related transaction a single time.

    In the event of two lambda response events (e.g. callback called, and a promise returned), the agent would attempt to end the transaction twice, producing an extraneous empty payload. The agent now limits itself to a single end call for a given transaction.

  • The agent will now properly end transactions in the face of uncaught exceptions while in serverless mode.

  • Enables ability to migrate to Configurable Security Policies (CSP) on a per agent basis for accounts already using High Security Mode (HSM).

    When both HSM and CSP are enabled for an account, an agent (this version or later) can successfully connect with either high_security: true or the appropriate security_policies_token configured. high_security has been added as part of the preconnect payload.


May 28, 2019
  • moved third party notices to

  • Shim#require will now operate as expected.

    Previously, the module interception code made the faulty assumption that a module's filepath would be resolved before the module load call was invoked. This caused the wrap filepath to be attributed to the modules being instrumented. This meant that attempted relative require calls using Shim#require would resolved from the incorrect path. The logic has been changed to keep a stack of the resolved filepaths, resolving the issue.

  • Updates error message for license check to indicate all places that need to be updated.

  • Shim#wrapReturn now uses ES6 proxies to wrap its methods.

    This will accurately propagate look up and assignment onto the underlying wrapped function, while maintaining all previous functionality.

  • Updated versioned test configurations to reflect current engine support.


May 20, 2019
  • Removed older versions of Cassandra from versioned tests

  • For debug/test runs, shimmer will now cleanup the __NR_shim property on instrumented methods. This leftover property did not result in any negative behaviors but cleaning up for thoroughness and to prevent potential confusion.

  • serverless_mode feature flag is now enabled by default.

  • Fixes recordMiddleware promise parenting for certain cases where child segments are created within resolving middleware next() promises.

  • Added instrumentLoadedModule function to the API, allowing end-users to manually apply an instrumentation to a loaded module. Useful for cases where some module needs to be loaded before newrelic


May 6, 2019
  • Modifies MiddlewareSpec route property to allow functions. Defers route processing and segment naming until just before needed (each middleware invocation).

  • Fixed outdated license ref in package.json.

  • Middleware instrumentation now honors spec.appendPath for more cases and will not pop paths when it has not appended a path.


April 24, 2019
  • Added getStatusName to NameState.

    Now web transactions will be named after known status code messages (404, 405, and 501).

  • Broke apart integration script test globs.

  • Added appendPath option to MiddlewareSpec.


April 16, 2019
  • Refactored config to log warning and disable distributed tracing if enabled in serverless mode, but missing required config setting.

  • Serverless mode no longer sets different data collection limits.

  • The agent will no longer crash the process in the event of unexpected calls to the harvest callback.

  • Updated required config values when using distributed tracing in serverless_mode to only include account_id.


April 1, 2019


March 25, 2019
  • Agent now respects attribute type restrictions on trace/segment attributes, as well as error event/trace attributes.

  • Fixes potential for RangeError: Maximum call stack size exceeded error on Transaction/Trace end.

  • Custom events no longer accept attributes with invalid types.

    The only attribute types accepted by the backend are boolean, string, and number; any attribute assigned to a custom event outside these types would be dropped on ingest. The agent now filters these attributes out, and logs out a helpful message detailing the issue.


March 11, 2019
  • Updated log message for not adding attributes and change the log level to debug.

  • Fixed an issue where exclusive time would be improperly calculated in some cases.


March 4, 2019
  • Added product attribute to existing datastore instrumentations.

  • Added db.collection to datastore span event attributes.

  • trusted_account_key, account_id, and primary_application_id may now be configured via a configuration file while in serverless mode.

  • Fixed a bug where data belonging to distributed traces starting in the Node.js agent would be prioritized over data produced from traces starting in other language agents.

    Previously, the agent would use the same random number for both the transaction priority (used for data sampling) and the Distributed Tracing trace sampling decision (whether to create DT data for a given transaction). This random number reuse resulted in a bias that caused data from distributed traces started in the Node.js agent to be prioritized above data that belongs to distributed traces started in other language agents. The agent now makes individual rolls for each of these quantities (i.e. the transaction priority and trace sampling decision), eliminating the bias.

  • Optimized exclusive time duration calculator.

    Previously, the agent would spend a lot of time sorting redundant arrays while calculating the exclusive time for the segments of a trace. This has been refactored into a single postorder traversal over the tree which will calculate the exclusive time for all segments in the subtree rooted at a given segment.

  • Prevent a split on undefined location under certain conditions in Memcached.

    Special thanks to Ben Wolfe (@bwolfe) for this fix!


February 19, 2019
  • Fixed issue where shim.createSegment() could result in modifying the parent when opaque.

  • Fixed issue where http-outbound would modify parent segments when parent is opaque.

  • Moved processing of exclusive time attribute out of toJSON and into finalize to only be calculated once.

    Previously, serializing a segment would result in calculating and caching exclusive time which could result in issues if serialized prior to ending.

  • Added SNS to message shim library names.

  • Added check for collect_span_events in config sent from the server on connect.

    Collection of span events can be disabled from the server configuration, but not enabled.

  • Refactored Segment#toJSON to be more readable.

  • Added a try/catch to config initialization to safely handle invalid setting combinations.

    When an error is caught the agent is marked as disabled, which ultimately returns a stub API and keeps the process running.

  • String truncation is now done using a binary search over the byte length of the string.

    Previously this truncation was done using a linear search for the proper byte length.

  • Optimized segment and span attribute filtering.


February 12, 2019
  • Added span_events and transaction_segments attribute destinations.

    Span event and segment attributes can now be filtered using the same include/exclude config rules as other types. See agent attribute configuration for more details.

  • Added metadata field to connect payload, for collecting NEW_RELIC_METADATA_-prefixed environment variables.

  • Added DynamoDB to datastores.

  • Added opaque option to datastore operation spec.

  • Added Kubernetes utilization detection.

  • Upgraded concat-stream and readable-stream to next major version.

    These modules had previously been held back due to support for Node <6. Since v5.0.0 we dropped that support thus enabling these updates.

  • Added SQS as a supported messaging library name.

  • Fixed opaque segment functionality for message-shim.recordProduce.

  • Fixed opaque segment functionality for message-shim.recordConsume.

  • Enabled tracking of callback via message-shim.recordConsume when no messageHandler provided.

  • Replaced make rules with npm scripts.

  • The agent will now consistently harvest in all response cases when in serverless mode.

    Previously, the agent's harvest was in a race with process suspension in the event of an uncaught exception, or responding without calling a callback. A synchronous harvesting process is now used to circumvent this racing issue.

  • Fixed issue with socket connection errors causing the agent to stop attempting to connect at startup.


January 28, 2019
  • Fixed bug where agent would stop sending data to New Relic servers when a connectivity issue was encountered.

  • Removed installation of Oracle container test scripts.

  • Replaced explicit config.high_security === true checks with general truthiness checks.

    The agent will now treat any truthy value in the high_security config setting as if it is enabled.

  • Fixed unit test with incorrect usage of cross application tracing.


January 23, 2019
  • Upgraded to @newrelic/native-metrics v4.

  • Removed outdated config files.

  • Removed old, outdated examples.

  • Fixed an issue where old CAT headers would be injected while distributed tracing was enabled.

    This would happen if both cross_application_tracing.enabled and distributed_tracing.enabled were set to true and an instrumentation disabled tracing for an outbound request.

  • Fixed access to ConglomerateShim in shimmer.

  • Added Neptune to the known database names.

  • Updated log messages for missing configuration files to point at the base configuration.

    Previously the log messages pointed at an internal file defining default values for every configuration.


January 16, 2019
  • Added new shim type: ConglomerateShim

    This shim class is useful for instrumenting modules which implement several service interfaces of different types.

  • Disabled logging by default when serverless_mode is enabled. Please note serverless/lambda monitoring is not yet officially released.

  • null trace attribute values are no longer sent to New Relic.

    This change brings the Node agent in alignment with the behavior of other language agents.


January 8, 2019
  • Dropped support for Node versions less than 6.

  • Agent no longer creates transactions when in a stopped, stopping or errored state.

  • Removed public API methods that have been deprecated since Agent v2: createTracer, createWebTransaction, createBackgroundTransaction, and addCustomParameter/(s). See the Migration Guide for more information.

  • Flagged API#setIgnoreTransaction as deprecated; TransactionHandle#ignore should be used instead.

  • Released several feature flags. These flags are no longer used:

    • feature_flag.custom_instrumentation
    • feature_flag.custom_metrics
    • feature_flag.synthetics
    • feature_flag.native_metrics
  • Added plugins.native_metrics.enabled configuration value.

    This configuration value controls the use of the @newrelic/native-metrics module. When set to false the agent will not attempt to load that module.

  • Custom metrics recorded via recordMetric and incrementMetric API calls now automatically have the name prepended with 'Custom/'. Usages of these APIs that manually prepend with 'Custom/' will need to remove the manually specified one or will end up with metrics prepended with 'Custom/Custom/'.

  • Dropped support for node-cassandra-cql.

  • Removed from ignore_server_configuration config setting.

  • Removed deprecated configuration settings capture_params and ignored_params.

  • The agent will no longer cause a stack overflow when logging at trace level to stdout.

    Previously, the agent would inadvertently trigger a trace level log from its trace level log (through wrapping a nextTick call), causing a stack overflow. The agent now detects this case and aborts the nested call.


December 20, 2018
  • Fixed clearing of active harvest via _stopHarvester().

  • Fixed handling of harvest endpoints when not all fail.

  • Added agent state "connecting" to indicate when handshake with New Relic servers is starting. This can be triggered on startup and restarts.

  • Added --no-package-lock to unit and integration rules.

  • Released protocol_17 feature flag.

  • The agent now reacts to failed New Relic requests based on response code, as opposed to parsing an exception message in the response body.

  • Replaced nsp with npm audit in security checks.

  • Collector now specify application/json content-type when data is compressed instead of octet-stream.

  • Bumped ecmaVersion in test .eslintrc to 8


December 3, 2018
  • Converted error handling in CollectorAPI and RemoteMethod to callbacks.

    Previously many of the errors were thrown. For consistency with async errors, these are now handed to the callback instead of thrown. The old behavior could result in a crash under a few circumstances, such as when the agent exceeded a configured maximum payload size. These errors came from RemoteMethod._safeRequest. Since these errors are handed to the callback instead of thrown, this bug is no longer a potential.

  • Added IP address collection and forwarding of metadata headers for upcoming protocol 17.

    These features are currently behind the protocol_17 feature flag until all parts of protocol 17 are implemented.

  • Refactored harvest interactions in preparation for protocol 17 status codes.


November 15, 2018
  • Changed totalTime attribute to be in decimal seconds instead of milliseconds for transaction events.

  • Agent no longer produces spans on ignored transactions.

    Previously, the agent would produce distributed tracing span events regardless of the ignored status of the transaction the events originated from.

  • Extended Restify instrumentation to mark possible transaction names in order to account for async response methods.

  • Added protocol_17 feature flag.

    Flag will be removed and protocol will be hard-coded to 17 once functionality is released on New Relic backend.

  • Added switch statement indenting standard to eslintrc

  • This release also includes changes to the agent to enable monitoring of Lambda functions. If you are interested in learning more or previewing New Relic Lambda monitoring please email

  • Introduced "warn" level 2 space rule to eslintrc

  • Updated hapi@16 versioned tests to only run on Node 6 and above.

  • Upgraded @newrelic/test-utilities to v2.

  • Pinned mysql2 to <1.6.2 in versioned tests.

  • Added waitForIdle option to API#shutdown.

    This new option will make the agent wait for all active transactions to finish before actually shutting down. This does not pre-empt creation of new transactions, so care must be taken to ensure the active transaction pool drains or the agent will never shut down.


November 1, 2018
  • Added DatastoreShim#getDatabaseNameFromUseQuery

    This new method can be used to extract the database name from USE SQL queries.

  • Added link to file in

    Thanks to Yuri Tkachenko (@tamtamchik) for the contribution.

  • Added VS Code settings to git ignore.

  • Fixed bug preventing Distributed Tracing (DT) from fully functioning when Cross Application Tracing (CAT) was disabled.

  • The agent will no longer break express routers in the case of using regex paths in a list.

    Previously, the agent would overwrite the regex with the source of the regex. The agent now makes a copy of the route array and mutates that instead.

  • Attributes will now be properly propagated to PageView events.

    The agent may now be configured to pass attributes along to the browser agent. The attributes that match the include/exclude rules in the browser_monitor.attributes section will now be placed on PageView events.

  • Renames better-cat integration test organization to be distributed-tracing and updated some test verbiage to use DT or distributed tracing instead of CAT or cross application tracing.


October 1, 2018
  • Updated DT payload creation to use primary_application_id from connect response.

  • Added protection against functions with modified prototypes in shim.applySegment.

  • Replaced SQL ID hash generation algorithm with SHA1 instead of MD5 to allow usage in FIPS compliant environments.

  • Leveraged 16 hex digits for creation of SQL ID.

  • Fixed codec.decode() callback bug that would re-call a callback with an error thrown within the callback.

  • Added superagent as built-in instrumentation.

    This instrumentation just maintains transaction state when using the superagent module to make HTTP requests with either callbacks or promises.

  • Updated noticeError API method to be partially functional in High Security Mode.

    In HSM, any custom attributes will be ignored, but the error will still be tracked. This brings the Node agent in line with the behavior of other language agents.

  • Upgraded ejs module to get rid of Github security warnings. The ejs module was only used for tests and not in main agent code.

  • Fixed bug requiring Cross Application Tracing (CAT) to be enabled for Distributed Tracing (DT) createDistributedTracePayload and acceptDistributedTracePayload APIs to function. DT configuration will no longer consider CAT configuration.

  • Changes DT payload configuration log messages to debug level as it is not uncommon for calls to occur before server configuration has been retrieved.

  • Converted net instrumentation to use shim api.

  • Converted child_process instrumentation to newer shim style.

  • Converted Timers instrumentation to newer shim style.

  • Fixed bug in wrap() that would fail to wrap callbacks if the callback index was 0.

  • Added PromiseShim class for instrumenting promise libraries.

  • Support for setting transaction_tracer.transaction_threshold to 0 has been added.

  • The agent now respects NEW_RELIC_TRACER_THRESHOLD.

    Previously, this environment variable was stored as a string. The environment variable is now stored as a float.

  • Converted zlib instrumentation to use shim API.


August 27, 2018
  • Converted File System instrumentation to use newer shim style.

  • Agent instrumentation will no longer interfere with promisification of core methods.

    Some core methods expose pre-promisified versions of the methods as a reference on the method itself. When instrumenting these methods, it neglected to forward these references onto the wrapper function. Now the instrumentation will properly forward property look ups to the original method.

  • Converted DNS instrumentation to newer shim style.

  • Added tracking of callbacks to DNS instrumentation.

  • Converted crypto instrumentation to newer shim style.

  • Updated domains instrumentation to use an instrumentation shim.

  • Refactored the global instrumentation to use the shim API.

  • Ported inspector instrumentation to use an instrumentation shim.

  • Ported async_hooks based promise instrumentation over to using shims.

  • Added shim types for core instrumentations.

  • Fixed outbound https call to use to resolve integration test issue.

  • Fixed tests for ioredis 4.0.0 and above.

  • Improved benchmark comparison output.

  • Added http benchmark tests.


August 13, 2018
  • Added JSON-formatted output to benchmarks to enable automated benchmark comparison.

  • Updated the benchmark runner to measure specifically userland CPU overhead.

  • Added DatastoreShim benchmarks.

  • Fixed MongoDB instrumentation for driver versions greater than 3.0.6.

    Mongo 3.0.6 removed metadata the Agent relied upon to instrument the driver. This fixes that by going back to the old method of manually listing all objects and methods to instrument.

  • Implemented enforcement of max_payload_size_in_bytes config value.

    Any payload during the harvest sequence that exceeds the configured limit will be discarded.

  • Updated MySQL versioned tests to run against the latest release.


July 31, 2018
  • Added support for distributed tracing.

    Distributed tracing lets you see the path that a request takes as it travels through your distributed system. By showing the distributed activity through a unified view, you can troubleshoot and understand a complex system better than ever before.

    Distributed tracing is available with an APM Pro or equivalent subscription. To see a complete distributed trace, you need to enable the feature on a set of neighboring services. Enabling distributed tracing changes the behavior of some New Relic features, so carefully consult the transition guide before you enable this feature.

    To enable distributed tracing, set distributed_tracing.enabled to true in your newrelic.js file, or set NEW_RELIC_DISTRIBUTED_TRACING_ENABLED in your environment.

  • Added a warning for too-new versions of Node.js during agent startup.

  • Appropriately obfuscated SQL statements will now be included in all transaction traces.

    Previously, the agent would only include the SQL statements if the corresponding query was sufficiently slow.

  • Added ability to execute instrumentation functions in the context of the segment the segment descriptor is describing.

    All record* methods supplied by all instrumentation shim classes now allow for a function to be executed under the context of the segment the record call will produce. This may be done by supplying a function in the inContext key for the segment descriptor passed to the record method.

  • Reservoirs will now respect setting their size to 0.


July 24, 2018
  • Added full support for Node v10.

  • Added instrumentation for crypto.scrypt.

  • Added instrumentation for fs.realpath.native.

  • Added instrumentation for process.setUncaughtExceptionCaptureCallback.

  • Updated tests to use asyncResource.runInAsyncScope instead of emitBefore and emitAfter

  • Pulled distributed_tracing config value from behind feature_flag.


July 18, 2018
  • The agent will now properly remerge event data on collection failure.

    Previously, the agent wouldn't observe the correct format for remerging, causing undefined events to be pushed into the reservoir.


July 16, 2018
  • Feature flags may now be set from environment variables.

    Using the naming convention NEW_RELIC_FEATURE_FLAG_<feature flag name in upper case>.

  • Transaction events may be harvested in two payloads now.

    This change reduces the occurrence of harvests being rejected due to large payloads. Payloads will only be split when they are large (greater than 1/3 the maximum).

  • Updated Hapi v17 instrumentation to wrap server export, in addition to Server.

  • ROOT segment no longer turns into a span event.

  • Fixed span collection when transactions are sampled=false.

  • Removed grandparentId from spans.


July 12, 2018
  • Added config utilization env vars to the BOOLEAN_VARS set.

    This ensures that if these boolean config values are set outside of a config file, their values are respected, particularly when they are disabled.

  • Replaced trusted_account_ids array with trusted_account_key.

  • Added node v10 to the test matrix.

  • Converted distributed trace x-newrelic-trace header name to newrelic.

  • Added support for different transport types in distributed tracing.

  • Added more tests around priority/sampled attributes on traces and events.

  • Lazily calculate transaction priority only when needed.

  • Transaction priority is now truncated to 6 decimal places on generation.

  • Adaptive sampling now uses the sampling_target and sampling_target_period_in_seconds configuration values.

    With these configurations, the adaptive sampling window is separated from the harvest window.

  • Removed nr.tripId attribute from distributed trace intrinsics.

  • Default span events to enabled.

    These are still protected behind feature_flag.distributed_tracing which defaults to false.


July 9, 2018
  • Added nonce option for newrelic.getBrowserTimingHeader()

    This allows people to pass in a string to be injected as the nonce property of the generated script tag. Special thanks to João Vieira (@joaovieira) for contributing this feature!

  • Added check to mark Hapi 'onPreResponse' extensions as error handlers.

    Previously, the agent was unable to mark any Hapi errors as handled, even if they were, resulting in inaccurate reporting. This change assumes that 'onPreResponse' extensions act as error handlers, so errors are only reported if they persist to the final response.

  • Expose the External segment on the http request instance for outbound calls.


July 2, 2018
  • Fixed issue with tracking external requests to default ports.

    Special thanks to Ryan King for pinpointing the cause of this issue.

  • Added extra check for handling arrays of functions when wrapping middleware mounters.

    This fixes a bug with the agent incorrectly assuming that arrays passed as the first argument in middleware would only contain route paths, causing a fatal error.

  • The agent now reports the total time of the transaction on transaction events.

  • Added more tests for transaction naming with Restify.


June 19, 2018
  • Refactored harvest cycle into separate class.

    This refactoring eases managing harvested data and re-merging unharvested values on failure.

  • Added seen/sent/dropped supportability metrics for all event collections.

  • Updated WebFrameworkShim to handle arrays of routes when wrapping middleware mounters.

    Previously, a transaction that hit a shared middleware (eg, app.use(['/one', '/two'], ...)) would always be tagged with <unknown> in its name, due to the agent not interpreting arrays of paths. Now transaction names will include all paths for a shared middleware, comma-delimited, followed by the current route ('WebTransaction/Expressjs/GET//one,/two/one').

  • Added an option for using the finally method on promises for instrumentation.

    The promise instrumentation would use Promise#finally if available. This change is in response to Node v10 promises calling then inside their finally method, which caused infinite recursion in the agent's promise instrumentation.

  • No longer download gcc on test suites that do not require it.

  • Added url parameter to http external segments.

  • Renamed request parameters on external segments.

    Previously these were named just the parameter name (e.g. /foo?bar=baz would become the parameter "bar": "baz"). Now they are prefixed with request.parameter. (e.g. "": "baz").

  • Added EventAggregator base class.

    The ErrorAggregator class was refactored and most generic event aggregation logic was moved to the new EventAggregator class.

  • Added SpanEvent and SpanAggregator classes.

  • Added Span event generation to the trace end method.

  • Added Span events to harvest cycle steps.


June 11, 2018
  • Make require() statements explicitly reference package.json as a .json file.

    This solves a problem when requiring/importing newrelic from a Typescript file. Thanks @guyellis for the submission!

  • Check if process.mainModule.filename exists before using in missing config file check.

    When the agent is preloaded with Node's --require flag, mainModule is not yet defined when the agent checks for a config file, resulting in a TypeError in the event that no config file exists. Defaulting to the file path being executed in process.argv ensures that the app will not crash when preloaded without a config file.

  • Updated dev dependency tap to v12.0.1.

  • Fixed identification of errors with express.

    Previously the call next('router') was considered an error. This is actually valid usage of express and will no longer generate an error.

  • Removed debug.internal_metrics configuration.

    This legacy debug configuration was never used since trace-level logging provides everything this did and more.

  • Upgraded optional dependency @newrelic/native-metrics to v3.

    With this update comes pre-built binaries for Node 5 and 7. GC metrics are also now aggregated in C++ until the agent is ready to harvest them instead of hopping into JS for each event.

  • Added additional checks to uninstrumented ensuring that files with names matching instrumented modules do not result in a false uninstrumented status.

    For example, some users load config/env info before the agent. In that case, a file responsible for exporting DB config information (config/redis.js), may result in a false uninstrumented status, because the agent would interpret redis.js as the module itself.

  • Moved computeSampled call to Transaction constructor.

    Previously it was only called in createDistributedTracePayload, but this gives all transactions a sampled value, and potentially a boosted priority.


June 4, 2018
  • Transaction stubs are now created properly in api#getTransaction

    During a refactor to use classes for the TransactionHandle class, the TransactionHandleStub was converted into a class. This change in interface wasn't reflected in the use around the agent and would pass back the class instead of an instance.

    Big shoutout to Roy Miloh (@roymiloh) for submitting the fix to this!

  • Upgraded dev dependency chai to version 4.


May 29, 2018
  • Fixed metric merging when using debug.internal_metrics.

    The debug metrics cache would cause timestamps for harvested metrics to get stuck at agent startup. This will no longer happen, and the debug cache is reset each harvest.

  • Modularlized configuration constants to improve readability.

  • Added distributed_tracing feature flag.

  • Added acceptDistributedTracePayload method to Transaction.

  • Added createDistributedTracePayload method to Transaction.

  • Updated Agent#recordSupportability to not include Nodejs/ in the default metric name.

  • Added distributed tracing methods to TransactionHandle.

  • Added distributed tracing cases for http and other metric recorders.

  • Implemented _addDistributedTraceInstrinsics on Transaction.

    If the distributed_tracing feature flag is enabled, the agent will ignore old CAT attributes in favor of distributed trace–related ones.

  • Added integration tests around better CAT functionality.


May 22, 2018
  • Fixed access to properties on promisified methods.

    Thanks to John Morrison (@jrgm) for pointing this out and providing a reproduction.

  • Updated use of fs.unlink without a callback to fs.unlinkSync.

    As of Node v10, the callback is no longer optional, which was causing a false test failure.


May 14, 2018
  • Logger no longer tries to create very large log messages.

    When a message is created that would be too large to log, a process warning is emitted.

  • Optimized unhandledRejection reporting when using async_hooks.

  • The agent no longer resizes the metric timeslice start time to be the earliest start time of the transactions that finish during the timeslice.

  • Replaced all uses of util._extend with Object.assign.

  • Background transactions created may now be named through API#setTransactionName.

    Previously, the agent didn't respect the transaction naming precedence for background transactions. Background transaction naming behavior is now in line with web transaction behavior.

  • Completed TODOs regarding the Node 0.10 and 0.12 deprecation.

  • Added PriorityQueue serialization benchmarks.

  • Added check for a route prefix when wrapping Hapi route handlers.

    Previously, route prefixes specified via plugin options weren't being included in transaction names. Now, if the agent finds a route prefix associated with a given realm, it is prepended to the route path in the transaction name.

  • The agent will now respect event count limits when merging data from a failed send.

    Previously, when merging data into an event pool the agent wouldn't maintain the size limit of the reservoir.


April 23, 2018
  • Updated logic around wrapping route handlers when config object is present.

    Before, the agent would only attempt to wrap config.handler when any config object was present, without defaulting to the root handler if it didn't exist.

  • Added PriorityQueue class for collecting events.

    This replaces the Reservoir class for event sampling. Using priority sampling allows the agent to maintain randomness across a given time period while improving the chances that events will be coordinated across Transaction, Error, and Custom event pools.

  • The agent will now allow external instrumentation modules to fail in a safe way.

    Previously, the agent would stop running if an externally loaded instrumentation failed for any reason. Due to the way external instrumentations can be updated independently, the agent should allow them to fail and carry on after logging a warning.

  • Added the strip_exception_messages.enabled config option.

    The agent can now be configured to redact error messages on collected errors.

  • Added the attributes.include_enabled config option.

    The agent can now be configured to disallow attribute include patterns to be specified.


April 12, 2018
  • BREAKING: Updated the version of https-proxy-agent to v2.x - Dropped support for v0.10 and v0.12 of node.

    The version of https-proxy-agent used in the agent has a known security issue you can read about here: In order to resolve this issue, the dependency had to be updated to at least v2.2.0, which only supported node versions >=4. The update to this dependency forces the incompatibility of the agent with versions 0.10 and 0.12 of Node.

    In order to use use the Node.js agent, please upgrade node to version >=4, or you can continue to use the agent on Node versions 0.10 and 0.12 by pinning the agent to v3.

    You can read more about the issue here:


April 10, 2018
  • Added a type check to attribute validation, restricting values to primitive types (but not undefined).

    Previously the agent was only enforcing byte limits on string values, resulting in overly large arrays being collected. This brings the agent in line with other language agents.

  • The DatastoreShim will now respect specified after handlers.

    Previously on methods like DatastoreShim#recordQuery the after handler would be dropped. The property is now correctly propagated to the underlying Shim#record call.

  • The agent will now check that a specified parent segment is part of an active segment before running a method under instrumentation.

    Previously the agent would unconditionally run a method under a specified parent. The shim expects the parent to exist and be active, and will throw errors in the case where the parent belongs to an inactive transaction.


March 27, 2018
  • Added newrelic.startSegment() which replaces newrelic.createTracer().

    This new API method allows you to create custom segments using either callbacks or promises.

  • Fixed bug in pre route config option in Hapi instrumentation.

    Only applies to Hapi v16 and below. The pre handler wrapping was not properly returning in cases when the element was a string referring to a registered server method, and as a result these elements would be replaced with undefined.


March 14, 2018
  • Added @newrelic/koa as a dependency.

    This introduces instrumentation for Koa v2.0.0 or higher. It will be treated as first-party instrumentation within the agent, but publishing it as a separate module allows it to be installed independently according to users' needs.

  • Refactored instrumentation hooks to work with modules.

    With this change it is now possible to link against external instrumentation modules.


March 13, 2018
  • Promise based web framework middleware instrumentation now supports callback based sequencing.

    Previously, a promise based middleware was assumed to continue to the next middleware once the promise it returned resolved. This assumption has been relaxed to allow for a callback to be supplied to the middleware to invoke the next middleware.


March 6, 2018
  • Removed the ssl configuration option.

    TLS is now always used in communication with New Relic Servers. The ssl configuration value and NEW_RELIC_USE_SSL environment value are no longer used. Setting either value to anything other than true will result in a warning.

  • Security bulletin NR18-05:

    Fixes issue introduced in 2.8.0 where the agent may have captured all transaction attributes, even with High Security Mode enabled on the account. This may have included sensitive data attached to transactions.

  • All request parameters now prefixed with request.parameters..

    Previously request parameters such as route and query parameters were added as attributes without any name changes. For example /foo?bar=value would add the attribute bar to the transaction. Now this attribute would be named

    Any Insights dashboards, alerts, or other NRQL queries using these attributes must be updated to use the new attribute names.


March 5, 2018
  • Security bulletin NR18-05:

    Fixes issue introduced in 2.8.0 where the agent may have captured all transaction attributes, even with High Security Mode enabled on the account. This may have included sensitive data attached to transactions.

  • Removed support for agent attributes include/exclude rules.

    These will be coming back in Node Agent v3.0.0. The fix for the above security bulletin required a backwards incompatible change to our attributes.

  • Fixed bug in Bluebird instrumentation.

    Some methods were not instrumented correctly. This would cause a problem if a function was passed to these methods.

    Special thanks to Andreas Lind (@papandreou) for helping us find this bug.


February 27, 2018
  • Added the WebFrameworkShim#savePossibleTransactionName method.

    This method may be used to mark the current running middleware as a potential responder. savePossibleTransactionName should be used if a middleware can't be determined to be a terminal middleware while it executes, but may be responsible for responding after execution has finished.

  • Fixed dns.resolve results assertion.

  • Added check for parentSegment in async_hooks instrumentation, to help ensure that transaction context is maintained.

  • Expanded async_hooks tests around maintain transaction context.

  • Added Koa to metric naming objects.

  • Added callback prop to middlewareWithPromiseRecorder return spec.

    While we aren't actually wrapping any callback, this is a workaround that gives us access to the active segment. This ensures that all segments inside Koa transaction traces are named correctly, particularly in cases when transaction context may be lost.

  • Updated after prop in middlewareWithPromiseRecorder return spec to set txInfo.errorHandled = true in cases when there is no error.

    Because Koa has no concept of errorware in the same sense as Express or Connect ((err, req, res, next)), the agent now assumes if a middleware resolves, any error that may have occurred can be marked as handled.

  • Upgraded tap dev dependency to v10.

  • Added a check for the function's prototype in shim#wrapReturn.

    The agent used to throw if a function with no prototype was passed into wrapReturn, then bind was called on the wrapper.


February 21, 2018
  • Added instrumentation support for MongoDB version 3.

    Version 3 of mongodb is now supported. Previously datastore host information (instance metrics) was incorrectly captured by the agent with mongodb v3. This has been fixed and all features should be functional now.

  • Enable certain agent attributes when high security mode is enabled.

    During the switch from the old capture_params/ignored_params to the new attribute include/exclude rules, high security mode was over-zealous in what attributes it disallowed. This has been trimmed back to be in line with other agents.

  • Updated documentation for apdex_t setting and removed environment variable.

    This was never configurable on client side and the documentation was misleading.

  • Documented environment variables for slow_sql configurations.

    Thanks to Olivier Tassinari (@oliviertassinari) for the update!

  • Updated hapi/hapi-pre-17/package.json to run errors.tap.js in more versions.

  • Added internal cache to unwrapped core modules for agent use.

  • Improved logging around environment facts gathering.


February 8, 2018
  • Change attributes.enabled to true by default.

    In the previous version we defaulted this to false to maintain parity with capture_params which defaulted to false. However, this is a invalid parity because attribute.enabled controls more attributes than capture_params.

  • The agent will no longer generate browser data for ignored transactions.

  • Removed unnecessary checks around Timer.unref() calls.

    unref has been supported since Node v0.9, meaning it will always be present in timers set by the agent (with 0.10 being the earliest supported version).

  • Expanded Hapi instrumentation to support route pre handlers.

    This is a Hapi route config option that was previously uninstrumented, causing transaction names to become invalid. This expanded instrumentation ensures that all additional handlers are wrapped and associated with the main route.

  • Added a split in the node versions for the mysql2 and cassandra versioned tests.

    As of mysql2 v1.3.1 and cassandra v3.4.0 the minimum supported version of Node is 4.

  • Replaced as many instances of {} as possible with Object.create(null).

  • Removed extraneous logger arg in addCustomAttribute call.


February 1, 2018
  • Added agent attribute filtering via include and exclude rules.

    Agent attributes can now be controlled using fine grained include and exclude rules. These rules, described below, replace capture_params and ignored_params. Any attributes listed in ignored_params will be migrated to attributes.exclude internally, unless attributes.exclude is explicitly set.

    There are three new configuration properties added to the root config and each destination (more on destinations later). These new configurations are:

    • attributes.enabled - Enables collection of attributes for the destination.
    • attributes.include - A list of attributes or wildcard rules to include.
    • attributes.exclude - A list of attributes or wildcard rules to exclude.

    The include and exclude rules can be exact rules (for example request.headers.contentLength), or wildcard rules which match just the beginning of attribute keys (for example request.headers.* would match any request header).

    These rules can be specified globally at the root of the configuration, or for specific destinations. These destinations are:

    • transaction_tracer - Controls transaction trace attributes.
    • transaction_events - Controls transaction event attributes.
    • error_collector - Controls error event attributes.
    • browser_monitoring - Controls browser/RUM transaction attributes.
  • Renamed addCustomParameter to addCustomAttribute.

    The addCustomParameter method is now deprecated and will be removed in a future release of the agent. The addCustomAttribute method is a drop-in replacement for it.

  • Added cache to agent attribute filtering.

    To minimize the overhead of applying attribute rules, the agent caches results of filtering specific attribute keys and destinations. The cache is limited to 1000 destination-key pairs by default but can be configured with attributes.filter_cache_limit. This cache offers a 10x improvement for applying filter rules for cache-hits.

  • Added limits for agent attributes to keep monitoring overhead down.

    Attribute keys and values are limited to 255 bytes each. Keys which are larger than 255 bytes are dropped, and a warning message is logged. Values larger than 255 bytes are truncated to 255 bytes, respecting multi-byte UTF-8 encoding. Custom attributes are limited to 64 per transaction. Attributes beyond the 64th are silently ignored.

  • Added allow_all_headers to config options and updated http instrumentation.

    When set to true, the agent will collect all request headers. This collection respects the agent attribute include and exclude rules. A default set of exclusion rules are provided in newrelic.js. These rules exclude all cookies and authentication headers.

  • The agent will no longer crash when crypto.DEFAULT_ENCODING has been changed.

    Previously, the agent would assume the result of hash.digest() was an instance of a Buffer. If crypto.DEFAULT_ENCODING is changed, hash.digest() will return a string and the agent would crash. The agent now ensures that the value is a Buffer instance before moving on.

  • Renamed request_uri attribute to request.uri.

    This brings the attribute name in line with all other request attributes.

  • Updated https-proxy-agent dependency from ^0.3.5 to ^0.3.6.

  • Updated versioned tests where applicable to ensure most minor versions of instrumented modules work as expected.

  • Fixed stalling test for v1 line of Mongo driver.

  • Added tests verifying Hapi 404 transactions result in correctly named metrics.

    The Hapi instrumentation was doing the correct thing, but we did not have tests for this specific case.

  • Fixed error if process.config.variables.node_prefix missing.

    If process.config.variables.node_prefix is falsey (which can happen if using electron, leading to this issue the getGlobalPackages function in lib/environment.js will give an err when it shouldn't.

    Thanks to Jarred Filmer (@BrighTide) for the fix!

  • Segments may now be flagged as opaque, causing internal segments to be omitted from the transaction trace.

  • Added error to collector connection failure log message.


January 18, 2018
  • Fixed naming bug in Restify instrumentation regarding parameters to next.

    The instrumentation previously considered any truthy value passed to next to be an error. It is possible to pass a string or boolean to next in Restify to control further routing of the request. This would cause the middleware's mounting path to be erroneously appended to the transaction name.

  • Fixed access to bluebird.coroutine.addYieldHandler.

    This was accidentally not copied by our instrumentation making access to the function fail. This has been resolved and tests expanded to ensure no other properties were missed.

  • Added regression test for promise instrumentation and stack overflows.


January 9, 2018
  • Fixed a crashing error in the hapi instrumentation.

    When recording the execution of an extension listening to a server event (e.g. 'onPreStart') the agent would crash due to the lack of a raw property on the first argument passed to the extension handler. The agent now checks the event before wrapping the extension handler, and checks for the existence of the raw property before attempting to dereference off it.

  • Fixed an incompatibility with the npm module mimic-response.

    The agent's HTTP instrumentation previously did not play well with the way mimic-response copied properties from an http.IncomingMessage. This caused modules that relied on that, such as got, to hang.

  • Refactored promise instrumentation.

    This new instrumentation is far more performant than the previous and maintains a more sensible trace structure under a wider range of sequences.

  • Added transaction_tracer.hide_internals configuration.

    This configuration controls the enumerability of the internal properties the agent. Making these properties non-enumerable can have an impact on the performance of the agent. Disabling this option may decrease agent overhead.

  • Added concurrent environment scanning, limited to 2 reads at a time.

    This improves the performance of dependency scanning at agent startup, allowing the agent to connect to our services more quickly.

  • Refactored instrumentation tests to run against wide range of module versions.

    Instrumentation tests will be run against all supported major versions of every instrumented module. For releases, we will test against every supported minor version of the modules. This vastly improves our test coverage and should reduce the instances of regressions for specific versions of modules.

  • Added tests for all of bluebird's promise methods.

    These tests ensure that we 100% instrument bluebird. Some gaps in instrumentation were found and fixed. Anyone using bluebird should upgrade.

  • Fixed naming rule testing tool to use same url scrubbing as the agent itself.


  • Incorporated fixes and features from 1.38.0, 1.38.1, and 1.38.2.

  • Fixed the beta sign up link in the readme.

  • Improved API for writing web framework instrumentation.

    Introduced a new WebFrameworkShim class for writing instrumentation. This shim can be accessed using the newrelic.instrumentWebframework API method.

  • Rewrote instrumentation for Connect, Director, Express, Hapi, and Restify.

    These instrumentations were rewritten using the new WebFrameworkShim. As a consequence of this rewrite, all our instrumentations now have feature parity, meaning every instrumentation will create Middleware metrics for your server.

    Tutorials on using the new instrumentation shim can be found on our API docs:

  • Removed express_segments feature flag.

    This configuration previously controlled the creation of middleware metrics in our Express instrumentation. With the move to the WebFrameworkShim this was dropped.

  • Only one transaction is created for each request emitted by a server.

    Previously we created a transaction for each listener on the request event.

  • Dropped support for Express <4.6.


  • Incorporated fixes and features from 1.36.2, 1.37.0, and 1.37.1.

  • Domains are no longer preemptively instrumented, thus applications that do not use domains will not load the domain module.

    Including the domain module causes a small amount of extra overhead in other core libraries that must keep the domain state set correctly.

  • Added support for recording interfaces that return promises instead of taking callbacks. See RecorderSpec.promise for more details.

    Thanks to Gert Sallaerts (@Gertt) for this contribution.


January 3, 2018
  • Added hapi v17 instrumentation

    Hapi v17 added support for promise-based middleware which broke transaction tracking in the agent. This caused issues in naming, as the agent will name the transaction after the path to the middleware that responded to a request.

  • Added instrumentation for vision@5

    Due to the way vision is mounted to the hapi server when using hapi v17.x, the agent's instrumentation would not pick up on the middleware being mounted. This new instrumentation now correctly times rendering done in the vision middleware.

  • Added unwrapOnce method to shim object

    This new method can be used to unwrap a single layer of instrumentation. unwrapOnce is useful in cases where multiple instrumentations wrap the same method and unwrapping of the top level is required.

  • Added isErrorWare checks around nameState.appendPath/nameState.popPath calls to avoid doubling up paths in transaction names

    Previously, the agent would append its transaction name with the path fragment where an error handler middleware was mounted. The extraneous path fragment will now be omitted, and the transaction will be named properly after the middleware that threw the error.

  • Added parent property to webframework-shim segment description

  • Added support for pg-latest on Node 5 or higher

  • Fixed creating supportability metric when mysql2 goes uninstrumented.

  • Added a segmentStack.popto the middleware after in cases when an error is caught and there is no next handler

  • Fixed determining parents for middleware segments when transaction state is lost and reinstated

  • Refactored existing hapi instrumentation for different server.ext() invocations

  • Refactored webframework-shim _recordMiddleware to construct different segment descriptions for callback- or promise-based middleware

  • Added check to _recordMiddleware to avoid prepending a slash if original route is an array

  • Changed logic in http instrumentation to attach response.status to the transaction as a string

  • Updated startWebTransaction and startBackgroundTransaction to add nested transactions as segments to parent transactions

  • Updated node-postgres@^6 versioned tests to avoid deprecation warning on direct module connect and end calls

  • Fixed running domain tests on Node 9.3.0.

  • Improved logging for CAT headers and transaction name-state management.

  • All json-safe-stringify calls now wrapped in try/catch

  • Removed lib/util/safe-json


December 12, 2017
  • Added Peter Svetlichny to the contributors list!

  • Optimized NameState#getPath.

  • Optimized shim.record.

  • Optimized shim.recordMiddleware.

  • Upgraded eslint to v4.

  • Fixed parsing SQL for queries containing newlines.


November 28, 2017
  • Added promise benchmarks to test non-async_hooks instrumentation.

  • Added logging for external calls made outside of a transaction.

  • Added logging for when unhandledRejection is noticed.

  • Improved performance of creating and merging metrics.

  • Improved performance of tracer.bindFunction.

  • Moved require calls for vendor metadata to module-level.

  • Removed try-catch around internal property setting on older versions of Node.


  • Rewrote the cassandra-cql and memcached instrumentations using the DatastoreShim.

  • Improved instrumentation matching.

    Previously, the agent would determine which instrumentation would run for a given module being loaded using the basename of the file path. This lead to false positives (e.g. myapp/lib/express.js would trigger the express instrumentation) which we previously just ignored. Matches are now determined using the string passed to require. This means you can now match local relative paths (./lib/something) as well as package-relative paths (amqplib/callback_api).


November 15, 2017
  • Instrumentation will now only modify the arity of wrapped functions when needed.

    This can be controlled with the matchArity property on a WrapSpec. Disabling arity matching has a significant, positive impact on the performance of instrumentation.

  • Added benchmarks for shimmer methods.

  • Pinned hapi tests at v16 due to incompatibility in hapi v17 with Node.js versions <8.

  • The agent's parsed queries will now only hold onto the stack that the query was made at, instead of an error object instance.

    Previously, the parsed query objects would hold onto an error instance, which would in turn hold onto references to all the functions in the stack when the error was created. This could cause memory issues if the functions were holding onto references to other pieces of data.

  • Revert wrapping of https for Node ^8.9.1.

    The original cause for this problem was reverted by Node.


November 2, 2017
  • Fixed a bug with Node >=8.9 that prevented https externals from being recorded.

  • Added Node 9 to test suite.

  • Removed problematic tests for ancient version of Hapi (7.1).

  • Document purpose of throw in tracer to prevent developer confusion.

  • Added script for running agent micro benchmarks.

  • Added benchmarks for all the Shim and Tracer methods.


  • Incorporated fixes from 1.36.1


October 24, 2017
  • Agent will attempt to reconnect to the collector forever after backing off to 5 minute delays.

  • Refactored environment scan to improve startup time and fix cyclical symlink resolving.


October 16, 2017
  • The agent will now support the await keyword by default.

  • Added cases for omitting the agent with and without async hooks to the async hooks microbenchmark.

  • Pinned version of Mocha to 3.x due to the incompatibility of Mocha v4 and Node v0.10 and v0.12.

  • Added benchmark for performance of function wrapping.

  • Added GC information to async_hooks benchmark.

  • Improved trace-level logging for capturing queries.


  • Incorporated new features and fixes from 1.34.0, 1.35.1, and 1.36.0

  • The @newrelic/native-metrics module is now an optional dependency of the agent.

    Now npm will attempt to install the module when the agent is installed. If it fails for whatever reason, the agent itself will still be installed correctly and the rest of the npm install will finish normally.


September 26, 2017
  • Hapi handlers will now preserve the defaults associated with them.

    Previously when wrapping handlers, the agent would drop the associated defaults on the ground, these are now properly forwarded to the wrapper. Big thanks to Sean Parmelee (@seanparmelee) for finding the root cause of this bug and reporting it!

  • Pinned request version for testing old versions of Node.

  • Added tests for feature flags created at agent initialization.

  • Fixed starting the agent with an invalid process version.


September 11, 2017
  • Added metrics for enabled/disabled feature flags.

  • Fixed transaction naming for Hapi plugins.

    Thanks Marc Höffl (@KeKs0r) for providing a reproduction!


  • Incorporated new features and fixes from v1.30.4, v1.30.5, v1.31.0, v1.32.0, and v1.33.0.


August 22, 2017
  • Added support for ignoring ranges of status codes.

    The configuration error_collector.ignore_status_codes can now take ranges of numbers. For example, ignore_status_codes: ['400-404'] would ignore 400, 401, 402, 403, and 404.

  • Fixed a bug when a custom collector port was provided in the configuration that prevented redirected connections from working.

  • Fixed a bug in Shim#record that could cause an exception when trying to create a new segment as part of an ended/inactive transaction.

  • Fixed issue with custom Hapi handlers causing an error.

    Previously custom Hapi handlers defined using the server.handler() method were causing the Hapi server to return a 500 error. Now they are correctly handled and recorded as middleware functions.

  • Transaction state is now maintained in ChildProcess event listeners.

  • Updated examples and documentation regarding custom transaction creation.

    All examples and documentation now point at the newrelic.start*Transaction methods.

  • Reducing logging verbosity in the SQL query obfuscator.

  • Experimental instrumentation for async/await

    This is experimental instrumentation and has not yet been tested in a wide array of production environments. The feature is currently off by default behind a feature flag. To enable this experimental instrumentation, add await_support: true to the feature_flag setting in your agent config file.


  • Incorporated fixes from v1.30.1, v1.30.2, and v1.30.3.


August 8, 2017
  • Improved metadata collection for AWS, Azure, GCE, and Pivotal Cloud Foundry.

  • Fixed a bug in PG query obfuscation for $ placeholders.

    The agent used to mis-detect $1 value placeholders as unmatched dollar-quoted strings causing the whole query to be obfuscated to just ?. These placeholders are now correctly detected and obfuscated.


  • Incorporated fixes from v1.30.0

  • Added rowCallback property to datastore segment descriptors.

    With this parameter the shim will record the given function/parameter as a per-row callback which may be called multiple times. These calls will be counted up for traces.

  • Rewrote PostgreSQL instrumentation using new DatastoreShim class.

  • Reversed reverse_naming_rules default.

    Naming rules now default to evaluating in forward order.


August 1, 2017
  • Improved documentation for newrelic.start*Transaction and TransactionHandle.

    Formatting for the startWebTransaction and startBackgroundTransaction methods was fixed and documentation for the TransactionHandle class which getTransaction returns was added.

  • Fixed parsing the table name from SQL queries.

    Quotes around the table name are now stripped after parsing the query and before constructing the metrics.

  • Fixed unhandled rejection error caused by ioredis instrumentation.


July 25, 2017
  • Fixed issue with transaction events not including correct duration values.

    This issue was introduced in v2.0.0, and it has affected web transactions histogram and percentile charts.

  • Fixed issue with Redis instrumentation causing the agent to crash in some cases.

    Previously, the Redis instrumentation would crash the agent when Redis commands were called without a callback and after the transaction has ended.

  • Fixed issue with the agent crashing on Node v4.0-4.4 and v5.0-5.9.

    This issue was caused by incorrect shim for Buffer.from(), and it affected older minor versions of Node v4 and v5.


  • Dropped support for Nodejs < 0.10.

    Starting with agent 2.0.0 we are no longer testing or supporting the agent on Node.js prior to 0.10. Customers are strongly encouraged to follow best practices and run supported versions of the Node.js runtime so that you can get the latest and greatest New Relic features. For legacy Node support, agent versions 1.x will continue to work, but we have no plans to backport any future features or fixes.

  • Dropped support for node-mysql < 1.0.0.

    Support for versions of the MySQL driver <1.0.0 has been removed. They will not work with the agent versions >=2.0.0.

  • Improved API for writing instrumentation.

    Introduced new classes for writing instrumentation, Shim and DatastoreShim. These classes along with the new newrelic.instrument and newrelic.instrumentDatastore methods make writing 3rd party instrumentation much easier.

  • Rewrote instrumentation for Cassandra, Redis, ioredis, MySQL, and MongoDB.

    These instrumentations were rewritten using the new DatastoreShim interface. Their functionality is largely unchanged but the new code should be easier to maintain and extend.

  • Added public API documentation.

    Documentation for the New Relic agent API has been generated using JSDoc and is now hosted on GitHub at There you can find documentation on the new classes as well as the pre-existing API methods.


July 17, 2017
  • The New Relic Node Agent v2 is here!

    This release contains major changes to the agent instrumentation API, making it easier to create and distribute your own instrumentation for third party modules. Check out Upgrade the Node agent or the Migration Guide for more information on upgrading your application to this version.

  • BREAKING: Reversed naming and ignore rules.

    Naming rules are now applied in the order they are defined.

  • BREAKING: De-duplicated HTTP request transactions.

    Only one transaction is created per request event emitted by an HTTP server. Previously this was one transaction per listener per event emitted.

  • BREAKING: Stopped swallowing outbound request errors.

    Errors emitted by outbound HTTP requests will no longer be swallowed by the agent.

  • BREAKING: Node v0.8 is no longer supported. Minimum version is now v0.10.

    The v1 agent will continue to support Node 0.8 but will no longer receive updates.

  • BREAKING: npm v1 is no longer supported. Minimum version is now v2.0.0.

  • Added API for writing messaging framework instrumentation.

    Introduced new MessageShim class for writing instrumentation. This shim can be accessed using the newrelic.instrumentMessages() API method.

  • Added amqplib instrumentation.

    Applications driven by amqplib consumers will now have transactions automatically created for consumed messages. See Troubleshoot message consumers for more information on this instrumentation and its limitations.

  • Advanced instrumentation API is now generally available.

    New methods for instrumenting common modules were introduced during the Agent v2 beta. These APIs are now available to everyone:

    • newrelic.instrument()/Shim: This method can be used to instrument generic modules, such as connection pooling libraries, task schedulers, or anything else not covered by a specialized class.

    • newrelic.instrumentDatastore()/DatastoreShim: This method is good for instrumenting datastore modules such as mongodb, mysql, or pg.

    • newrelic.instrumentWebframework()/WebFrameworkShim: This method is used for instrumenting web frameworks like restify or express.

    Documentation and tutorials for the new API can be found on our GitHub documentation page:

  • Rewrote built-in instrumentation using the new Shim classes.

    The following instrumentations have been rewritten:

    • Datastores
      • cassandra-driver
      • ioredis
      • memcached
      • mongodb
      • mysql
      • node-cassandra-cql
      • pg
      • redis
    • Web frameworks
      • director
      • express
      • hapi
      • restify
  • The @newrelic/native-metrics module is now included as an optional dependency.

    This module will be installed automatically with Agent v2. If it fails to install the agent will still function.


June 7, 2017
  • Node v8 is officially supported with exception of async/await.

    Support for the new [async/await][mdn-async-function] keywords is coming in a future release. Until this support is added, using the agent with applications that utilize async/await is unsupported and highly discouraged as it could result in transaction state loss and data being mixed between transactions.

    Fixed issues related to changes in the core networking modules that resulted in transaction state loss. Also instrumented new asynchronous API methods in crypto and inspector.


May 11, 2017
  • Fixed a transaction state loss introduced in Node 7.10.0 when using net.createConnection.

    Added a new segment for net.connect, net.createConnection, and http.Agent#createConnection. Sockets created within a transaction also have their emit bound to the segment.

  • Fixed a typo about the name of the default configuration file. Thanks Jacob LeGrone (@jlegrone)!


May 1, 2017
  • Updated the default value for transaction_tracer.record_sql to obfuscated.

    This value was previously off by default. This change brings the New Relic Node Agent defaults in line with other New Relic Agents.

  • Our when instrumentation better detects when a module is actually when.

    Thanks to Pasi Eronen (@pasieronen) for the contribution!

  • Quiet a warning in our native promise instrumentation on Node 0.10.

  • Error messages are redacted in High Security Mode now.

  • New configurations were added for disabling some New Relic API methods. These default to enabled and are all disabled in High Security Mode.

    • api.custom_parameters_enabled controls newrelic.addCustomParameters()
    • api.custom_events_enabled controls newrelic.recordCustomEvent()
    • api.notice_error_enabled controls newrelic.noticeError()
  • Fixed a bug in the generic pool instrumentation affecting version 3.


March 29, 2017
  • When.js hooks similar to Promise.onPotentiallyUnhandledRejection now function as intended.

    Previously, hooks like Promise.onPotentiallyUnhandledRejection would not work due to the way the agent wraps the promise constructor. When.js expects these handles to be assigned directly onto the promise constructor, and our wrapper was intercepting the assignment. The wrapper will now properly proxy these values and assign them onto the original constructor, restoring the proper behavior.

  • Express route parameters will now be properly attached to the corresponding transaction.

    Previously, our express instrumentation would read the route parameters and place them on the segment responsible for matching the parameters. This behavior did not place the parameters on the transaction that the segments belonged to, causing the parameters to not show up properly on transaction traces and transaction events.


March 17, 2017
  • Fixed issue with when.js instrumentation not preserving all properties on wrapped Promise constructor.

    Previously, the when.js instrumentation would cause an unhandled exception when private methods on the Promise constructor were called (e.g. when adapting functions that do not use promises).


March 16, 2017
  • We're excited to announce the addition of a new Node VMs page to the UI that provides a curated view of the cpu, memory, garbage collection, and event loop metrics that we have added over the past several releases of the node agent and native-metrics module.

    For more information, see our documentation.

  • Added instrumentation of When.js promise library.

    Previously, the transaction state could get lost when multiple promises resolved close to each other.

  • Fixed name of environment variable in error message when configuration file cannot be found. Thanks to @Maubic for the contribution!

  • Updated tests to work with the latest version of Node 7.


February 16, 2017
  • Agent now wraps emit on http request/response objects instead of relying on listeners.

  • Fixed a bug in normalization rules when replacements do not maintain initial /.

  • Removed unused yakaa dependency.

  • Better de-duplication of errors when the same error instance is used multiple times.

  • Server-side naming rules are now applied even when user defined ones have matched.

  • Improved documentation for newrelic.noticeError() and ignore_status_codes configuration.

    The documentation now makes it clear that errors recorded using noticeError() do not obey the ignore_status_codes configuration value.

  • Errors reported outside of a transaction now include their stack trace on the error analytics page.

  • A potential stack overflow in trace serialization has been removed.

  • Fixed an issue with our Express and domain instrumentation related to a loss of transaction state that could result in incorrect transaction names, traces, and events.

  • Nested background transactions now report the correct number of metrics.


February 8, 2017
  • The agent now reports event loop metrics on supported platforms.

    On node versions 0.12, 4, 6, and 7 the agent will now record the number of event loop ticks per minute, and CPU time spent in each tick. You can read more about it on our docs site!

  • The agent no longer creates a segment for each row returned from a PG query when the pg-query-stream module is used.

  • Removed io.js from our test suite, since it has not been supported for some time.

  • Internal properties used in our promise instrumentation are now non-enumerable to prevent unexpected keys showing up for clients.

  • Agent now uses safe stringification when encoding payloads in order to prevent an issue with circular references.

  • Fixed issue with the agent holding the process open when retrying to connect to the collector.

  • Quieted a log message warning users about their own settings.

  • Fixed typo in a log message. Thanks to Dave Bobak (@davebobak) for the contribution.


January 26, 2017
  • Fixed issue with timing Redis operations when called without a callback.

    Previously these operations would continue to be timed until the transaction ended, and as a result reported incorrect times.

  • Transactions that result in a 404 HTTP error are now named "(not found)".

    Previously these transactions were reported with no name (e.g. get /).

  • When the newrelic.js configuration file is not present, the agent now logs a message to the console and no longer prevents the app from starting up.


January 12, 2017
  • Stop collecting URL parameters from the HTTP referer header

    The Node agent collects the request headers during an error trace to help determine the root cause of problems. The referer header is the URI that identifies the address of the webpage that linked to the resource being requested. It is possible that the referer URI may contain sensitive information in the request query parameters. New Relic has found that the query parameters are not properly stripped during the error trace. This update fixes this by stripping the query parameters from the referer in the request header before sending this data to New Relic.

    This release fixes New Relic Security Bulletin NR17-01.

  • Improved logging of modules that did not get instrumented.


December 21, 2016
  • Added CPU metric gathering to Node.js versions <6.1

    As of this release the agent will attempt to gather CPU usage metrics via the optional @newrelic/native-metrics module.

  • Added additional memory usage classification metrics.

    The agent will now report memory metrics that break down memory by its current use.

    For more information on these features, see our documentation.


December 13, 2016
  • Removed automatic installation of @newrelic/native-metrics.

    Due to the way npm v3+ flatten dependencies, a bug in the version of npm packaged with Node v5, and npm v1's ungraceful handling of scoped packages we have opted to not automatically install this module.

    If you would like to see native metrics for your application, you can add the @newrelic/native-metrics module to your package.json and the Node Agent will automatically pick it up.

  • Corrected attribution of the Bluebird patch in the last release's notes.

    Thanks to Matt Lavin (@mdlavin) for this correction!


December 12, 2016
  • The agent will now report garbage collection statistics on supported platforms.

    On node versions 0.10, 0.12, 4, 6, and 7 the agent will now record the time spent in, the number of, and type of garbage collection cycles. You can read more about it on our docs site!

  • The agent no longer double counts MySQL query times when using a connection pool.

    Previously, when using a pool of connections a query done through the pool would be recorded as the time it took on the pool, as well as the connection, effectively counting the time twice. This is no longer the case.

  • The agent will no longer lose transaction state across Bluebird's promise.nodify.

    Thanks to Matt Lavin (@mdlavin) for this contribution!


November 10, 2016
  • The agent now collects CPU metrics when running under Node 6.1.0 and higher.

    Node 6.1.0 introduced an API to get CPU time usage of the running Node process. We are now collecting this data as new metrics.

  • The agent now has a separate configuration for audit logging.

    Previously the data that the agent sends to the collector was logged only in trace logging mode, making the logs unnecessarily large and noisy. The agent can now include this data independent of the logging level using separate configuration settings.

  • A new API method addCustomParameters() has been added to allow adding multiple custom parameters at once. Thanks to Austin Peterson (@AKPWebDesign) for this contribution!

  • The shutdown() API now waits for connection to collect pending data.

    When a flag to collect pending data is provided to the shutdown() method, the agent now ensures a connection to the collector has been established. This is useful when the Node process is short-lived, such as in AWS Lambda.

  • Updated tests to run on Node 7.

    Node 7 is officially supported as of the previous release, v1.33.0.

  • The setIgnoreTransaction() API now works for background transactions.

  • Fixed issue with Synthetics result not displaying a link to the corresponding transaction trace.

  • Added running the nsp (Node Security Platform) tool to the test suite to help with detecting security-related vulnerabilities.


October 31, 2016
  • The agent now collects database instance information for Memcached operations. This information (database server and database name) is displayed in transaction traces and slow query traces.

  • long-polling requests are now ignored by default.

    Collecting metrics for these requests is typically not desirable since they are frequent and do not represent business transactions. Previously we recommended adding an ignore rule manually. Now it is included by default.

  • Improved test coverage for Postgres and MongoDB instrumentations.


October 20, 2016
  • The agent now collects database instance information for MySQL and MongoDB operations. This information (database server and database name) is displayed in transaction traces and slow query traces.

  • Datastore instance configuration can now be done through environment variables. These can be set through NEW_RELIC_DATASTORE_INSTANCE_REPORTING_ENABLED and NEW_RELIC_DATASTORE_DATABASE_NAME_REPORTING_ENABLED

  • The agent will no longer crash the process when an express param handler is executed when a transaction is not active.


October 12, 2016
  • The agent now collects database instance information for PostgreSQL and Redis operations. This information (database server and database name) is displayed in transaction traces and slow query traces.


October 4, 2016
  • Fixed issue with aborted requests causing the agent to crash in some cases.

    Previously the agent would crash when the client request aborted before Express server sent a response and encountered an error.

  • Upgraded integration tests to work with the latest version of node-tap.


September 27, 2016
  • Improved instrumentation of native promises.

    Native promises now use the same instrumentation as Bluebird, making instrumentation easier to maintain and more consistent across libraries.

  • Fixed issue with reloading normalization rules from the server.

    Upon reset, the agent will clear the existing naming rules, removing any vestigial rules that may have changed or been disabled.

  • Fixed issue with key transactions Apdex metric.

    Key transactions now effect the global Apdex metric according to their own ApdexT instead of the default ApdexT value.

  • Fixed issue with closing transactions when the request is aborted.

    Previously, aborted requests would result in the transaction remaining open indefinitely. Now the transaction will be correctly finished and its resources freed.

  • Fixed format of external calls metric.

    External service URLs will now be formatted the same as they are in the originating application.


September 14, 2016
  • Published with npm v2.


September 13, 2016
  • Added instrumentation of the param() function in Express.

    The agent will now create metrics and transaction segments when the Express param() function is called as a part of a route. This also fixes an issue with transaction naming when the HTTP response is ended within a param() method.

  • Fixed an issue with naming Express transactions that result in 404 errors.

    Previously transactions were not always correctly normalized for URLs that caused 404 errors. The transactions will now always be reported with the same normalized name (e.g. "get /").

  • Fixed instrumentation of Express v4.0 - v4.5.

    Previously transactions were not correctly named on older versions of Express 4.

  • Minor updates to logging.


September 1, 2016
  • The shutdown method is now on the stub API.

    Previously when the agent was disabled the stub API passed back on require did not have the shutdown method. Thanks goes to Vlad Fedosov (@StyleT) for this contribution!

  • Global timers will now be wrapped correctly regardless of being wrapped by something else.

    The logic to check whether to wrap the global timers was looking to see if the global timers were the same function reference as the ones in the timers module. This would break in cases where either the global or timers functions had been wrapped.

  • Director instrumentation now correctly handles the case of null route handlers being passed in.

    Previously the agent's director instrumentation would crash in cases of null route handlers in director.


August 25, 2016
  • A number of improvements and fixes to transaction naming rules.

    Added attributes terminate_chain, replace_all, and precedence to allow more control over how naming rules are executed. Please see the updated documentation in our README file.

    The order in which naming rules are executed can now be reversed with a feature flag reverse_naming_rules.

    When applying naming rules, the regular expression matching is now case insensitive.

    We have added a tool for testing naming rules. When the agent is installed, the tool can be run in terminal by executing node node_modules/.bin/newrelic-naming-rules.

    We have also improved our trace logging around transaction naming.

  • Fixed issue with reporting errors from domains.

    When an error is handled by using the error event of the domain, it is no longer reported as an uncaught exception.

  • Added trace logging to track number of transactions and segments in progress, and to better track segments created with the Express instrumentation.

  • Fixed mysql2 tests that were not being run correctly.


August 3, 2016
  • Reworked the SQL parser to handle new lines in the query.

    Previously the agent would have difficulty classifying queries with new lines in them. Thanks to Libin Lu (@evollu) for the fix!

  • Postgres instrumentation is now compatible with inputs with text getter attributes.

    Thanks again to Libin Lu (@evollu) for the fix!

  • Domain error handlers will now be scoped to the transaction the error occurred in.

    Previously, the 'error' event handlers would not be scoped to a transaction causing our API methods to not associate data correctly (e.g. using noticeError would not associate the error with the transaction and would instead be unscoped).


July 13, 2016
  • Removed excessive segment creation from PG instrumentation.

    For queries with many results we would create a segment for each result. This would result in excessive object allocation and then cause harsh GC thrashing.

  • Improved agent startup speed by ~10% by simplifying environment checks.

    Removed prolific fs.exists and fs.stat checks, instead simply handling the error for mis-used files which greatly reduces disk access.

  • Fixed a bug in agent connect that could cause an identity crisis under specific use cases.

    When using the agent with multiple app names, transaction information could be misattributed to other services if they share the same first app name. This resolves that by using all of the host names to uniquely identify the agent.

  • Added slightly more trace-level logging around the creation of segments.

  • Added examples for using the newrelic.createBackgroundTransaction method in a number of different use cases.


July 7, 2016
  • Director instrumentation that will now name the transaction correctly, as well as create segments corresponding to the handlers registered with director.

  • Transaction naming refactor - this should clear up some inconsistent naming issues in our router instrumentations.

    Previously the instrumentation was tasked with the maintenance of the transaction state name, now this has been abstracted into its own class to be used by instrumentations.

  • Express instrumentation refactored to scope transaction storage to the incoming request object.

    Previously the express instrumentation used a stack to track which router was expecting middleware to finish and keep track of which transaction is being executed. The new implementation has a stronger guarantee on scoping work to the correct transaction.

  • The agent now uses the correct units for slow queries - this fixes and issue where query traces in the databases tab were slower than the reported maximum.


June 15, 2016
  • The following attributes are now sent to Insights along with transaction events: databaseDuration, databaseCallCount.

  • Fixed a few issues with the Express instrumentation.

    Middleware functions mounted with a path variable now generate the correct middleware metrics. Routers mounted using route methods now generate the correct trace segments and times. Routers mounted on root path are now not included in trace when they contain no matching routes.

  • Updated Redis instrumentation to work with version 2.x of the redis module.

  • Improvements to error tracking on systems that have a lot of errors.

  • Other minor changes to tests and logging.


May 25, 2016
  • Express middleware metrics are now enabled by default.

  • The following attributes are now sent to Insights along with transaction events: externalDuration, externalCallCount, and queueDuration.

  • Custom SSL certificates (from the agent configuration) are now used even when a proxy is not explicitly defined. This is useful in some environments that use an implicit proxy for all network traffic.


May 5, 2016
  • Fixed duplicated external transactions for https requests in Node > 0.10.

    Any external transaction that used the https module to make the request would appear twice in transaction traces due to https.request internally using http.request. This has now been resolved.

  • Updated eslint dev dependency to 2.9.0 (was 0.24.1).

  • Fixed an issue with transaction naming precedence.

    Custom naming of transactions will no longer be replaced by names generated by the instrumentation.

  • Fixed tests which broke under Node 6.0.

    Node 6.0.0 changed some messaging and internal functionality which our tests were asserting on. These tests have been updated to work with either the new version or the older ones.

  • Fixed installing GCC 5 in Travis for testing native modules in Node >= 3.0.

    Starting in Node 3.0, native modules were compiled with C++11 features enabled. The version of GCC preinstalled on Travis was too old to support that so we now manually install GCC 5 and set it as the system compiler.

  • Fixed metrics that were being scoped to themselves.

    Some metrics were scoped to themselves causing a strange visual glitch in the RPM UI. This self-scoping has been removed.

  • Added tests for transaction naming with parallel requests in Express.


May 3, 2016
  • Fixed issue with checking listener count for uncaughtException and unhandledRejection global events.

  • Fixed a number of issues with promise instrumentation of Bluebird.


April 21, 2016
  • Added a .npmignore file to exclude non-essential files.

    The agent will now omit tests and examples on install from npm, drastically improving download times. Thanks to Serge Havas (@Sinewyk) for the contribution!

  • The agent now properly checks for custom SSL certificates.

    The check previously was falsely positive if there was an empty list of custom certificates. This caused red herrings to be admitted into the debug logs. Thanks to Seth Shober (@sethshober) for the fix!

  • Reworked promise instrumentation to be more reliable and reusable.

    Promise instrumentation has been rewritten to be applicable to any A+ compliant promise library. This change brings more consistent instrumentation of Bluebird promises.

    This change also allows users to see the execution order of chained promises in their Transaction Traces. This is an opt-in process and can be achieved by setting feature_flag.promise_segments to true in the agent config.

  • Promise error handling is now more consistent.

    Previously the agent would notice errors being emitted on 'unhandledRejection' regardless of other listeners. Errors coming in on the 'unhandledRejection' event will not be recorded if there are handlers for the event - this is more in line with our error handling practices in other instrumentations.

  • Logging has been reworked to reduce CPU overhead.

    The check to see if a logging call was valid happened fairly late in the logic, causing unnecessary work to be done regardless of logger state. This has been rectified, netting a large decrease in CPU overhead.


April 7, 2016
  • Added ioredis instrumentation.

    Big thanks to Guilherme Souza (@guilhermef) for the contribution!

  • Added a new shutdown call to the public API.

    Thanks to @echmykhun for the contribution!

    The new shutdown API call will gracefully stop the agent. It can optionally harvest any pending data waiting to be sent to the New Relic servers before shutting down.

    To read more about this new API, please read our README, or visit our docs page.

  • Fixed an issue in the express instrumentation related to inactive/lost transaction state.

    Thanks to Jacob Page (@DullReferenceException) for submitting this fix.

    Previously, the agent would crash if there was no active transaction when an Express middleware would handle the request.

  • Added support for truncated segment notifiers.

    Segments related to work that happens after a transaction has finished will now be labeled as Truncated in the UI.

  • The agent now uses MongoDB's APM API for its instrumentation.

    Method discovery for instrumentation is now done through MongoDB's APM API in newer versions of the MongoDB driver.


March 30, 2016
  • Added capturing errors from the unhandledRejection global event.

    If a promise is rejected with an error, and the error is not handled, the error will now be reported to New Relic.

  • Fixed issue with attaching an event handler every time Express was required.

  • Fixed issue with chained promises losing context.

    Previously the transaction state was getting lost when an error was thrown early in a promise chain.

  • Fixed issue with the agent crashing when an http Server did not have the address() getter.

  • Fixed issue with Express instrumentation when a wrapped layer object was missing a method.

  • Added more logging around the CAT feature.


March 23, 2016
  • Express instrumentation has been fundamentally reworked.

    This refactor includes a few bug fixes around error handling and transaction naming, as well as optional higher resolution traces.

    The agent will not report errors handled in an error handler it is monitoring - this is more in line with how the agent does error handling in other contexts.

    The agent will now name transactions correctly when an application responds from a middleware.

    Setting feature_flag.express_segments to true in the agent config will make the agent report the amount of time spent in each individual middleware per request


March 9, 2016
  • Added instrumentation of Bluebird promises.

    Previously, the transaction state could get lost when multiple promises resolved close to each other.

  • Fixed issue with PostgreSQL native instrumentation.

    Previously, calling require('pg').native more than once was causing the agent to crash.

  • Fixed issue with hapi instrumentation not returning value from Server.connection().

  • Various improvements to tests to make them more stable.


February 24, 2016
  • Added more HTTP request/response parameters to transactions.

    The agent now collects additional request/response HTTP headers (e.g. contentType, HTTP method, response status code). These can be used to filter and group errors in the Error analytics page, as well as events in Insights.

  • Fixed an issue with collecting errors when an Express error handler removed message and stack properties from the error object.


February 18, 2016
  • Fixed crashing bug on unhandled rejections in Q.

    Previously, the agent would cause the process to crash in the event of an unhandled rejection.

    Thanks to @mdlavin for this fix!


February 17, 2016
  • Added Q instrumentation.

    The node agent now accurately records programs using Q for promises.

    Thanks to @mdlavin for the contribution!

  • Added node-mysql2 support.

    Thanks to @jhollingworth for adding node-mysql2 support to the agent.

  • Query streaming in node-mysql now works while using the agent.

    Previously, due to the way node-mysql was instrumented query streaming would be forced off when the agent was collecting data. This is no longer the case and query streaming will work and be recorded as expected.


January 26, 2016
  • Corrected an issue where the agent would sometimes crash looking up the port of the HTTP server that a request came from.

    Previously, the agent assumed the HTTP server would always have an address, unfortunately this isn't the case if the HTTP server's .close() has been called.


January 20, 2016
  • Added support for the new Response Time Line and better representation of asynchronous data.

    This has many implications in the UI. The first is the Application Overview, in the past we've always just shown "node" and maybe "request queueing" on the response time graph. We now show you an application breakdown like our other language agents! This means you'll be able to see how much time was in HTTP externals, your various datastores, or spent in node itself. Overlaid on this will be your response time as a blue line.

    Next page that has been affected is our Transaction Overview page. Specifically when you click into a Transaction to see more detail. Previously we showed you a breakdown of the top time consumers in that transaction, both as a graph and as a table. Unfortunately that graph didn't show response time and the table would show percentages over 100%. Now, like the Application Overview, you will get a blue response time line and the breakdown table will have numbers that add up much more intuitively!

    Finally, our Transaction Trace view has also been updated. The change is very similar to the changes mentioned above for the breakdown table in the Transaction Overview page. You should no longer see percentages over 100% here either.

  • Transaction trace serialization is now 4x faster than before.

    This speedup will primarily affect those with large, deeply nested transactions. Though small transactions have seen some improvement as well.


December 30, 2015
  • Error totals are now reported.

    The agent now reports metrics that reflect the total number of errors that have occurred in web and background transactions.

  • Disabling SSL no longer requires the setting of a port.

    Previously, the agent required changing port in the config to 80 when disabling SSL. The agent will now default to port 80 if a port is not supplied and SSL is turned off.

  • Logging functions have been improved.

    The agent will now properly log error stack traces and can rate limit logging messages. To aid in debugging we have provided more logging about the public API.


November 18, 2015
  • Advanced Analytics for APM Errors

    With this release, the agent reports TransactionError events. These new events power the beta feature Advanced Analytics for APM Errors (apply here to participate). The error events are also available today through New Relic Insights.

    Advanced Analytics for APM Errors lets you see all of your errors with granular detail, filter and group by any attribute to analyze them, and take action to resolve issues through collaboration.

  • NEW_RELIC_LOG_ENABLED environment variable is now treated as a boolean.

    Previously, this option was treated as a string, causing it to not work for some use cases. Thanks to @jakecraige for contributing this fix!


November 5, 2015
  • newrelic.getBrowserTimingHeader() API now includes the full transaction name.

    Previously, the agent would use a fragment of the transaction name, causing Browser Monitoring transactions and APM transactions to not be cross linked. This change makes the cross linking work correctly.


October 29, 2015
  • The New Relic Node Agent now officially supports Node v4!

    We are excited to announce that the New Relic Node Agent officially supports Node v4.x! We've tested the agent across all major versions of Node used by New Relic customers to ensure a quality Node APM experience. New Relic recommends upgrading to Node v4.x for best Node Agent performance.

  • Corrected a parsing issue in the slow sql query parsing step.

    Previously, the agent would not be able to parse inputs to database libraries that specified sql as an option param. This was an issue with node-mysql, namely. The agent now correctly handles this case and registers the queries as expected.


October 14, 2015
  • Removed client support of the RC4 stream cipher for communicating with the New Relic servers.

    The RC4 cipher is considered unsafe and is generally being deprecated.

  • Fix for logging version number in Express instrumentation. Thanks @tregagnon.

    When an unsupported version of Express is detected, we log a message that contains the Express version number. The version is a string and was being logged as a number, resulting in NaN in the log message.

  • Agent is now more safe when recording memory stats.

    Previously, the agent would crash the process as it was gathering memory usage information (i.e. when process.memoryUsage threw an error). This defect is now guarded against with a try-catch.


August 20, 2015
  • Express and Connect instrumentation will no longer crash on Node 4

    As of ES6, the attribute will track if the function is a getter/a setter/is bound to (i.e. fn.bind().name -> 'bound ' + This new behavior caused the agent to crash on start up due to the way connect and express are instrumented. The agent is now more defensive of future implementations of ES6.


August 20, 2015
  • Errors will now respect its transaction's ignore state.

    When ignoring transactions, related errors will now also be ignored.

  • The agent can now handle immutable and frozen error objects.

    In rare cases the agent gets passed an immutable error object. The agent would then crash when trying to tag the error object with the current transaction. We now handle these errors properly.


August 6, 2015
  • Corrected a defect in the handling of uncaught exceptions

    This defect was surfaced in versions of node that did not have process._fatalException, namely v0.8. When an uncaught exception occurs, the agent now records the error and passes it along to the other uncaught exception handlers that have been registered. This was inverted before, passing along errors when there were no other error handlers present and rethrowing otherwise.


July 13, 2015
  • Moved concat-stream from dev dependencies to production dependencies.

    Last week we released v1.21.0 but forgot to move a dependency. We've removed v1.21.0 from and this release contains the changes from that version.


July 10, 2015
  • Added configurable host names.

    The agent now has configuration settings to allow configuration of custom host names. Set process_host.display_name to enable this.

    If this conifig is not set, the agent will continue to use the host name found through an os.hostname() call. Should this lookup fail somehow, process_host.ipv_preference can now be set to 4 or 6 to configure the type of ip address displayed in place of the host name.


June 23, 2015
  • Fixed a bug where custom events weren't being sent.

    In a refactor of our data collection cycle, we omited the custom events from the list of commands, this is now fixed.

  • Fixed a very rare bug where the custom event pool could be set to 10 instead of the user config value. This patch was contributed by shezarkhani, thanks!

    This case would only be hit if you disabled custom events via server sent config while there were custom events ready to be sent. Then you later reenabled it via server sent config. It would only occur for one data collection cycle then reset back to the correct size.


June 11, 2015
  • Fixed a bug in custom event recording limits.

    Previously, the agent would use the config value for max events (default of 1000) for the first harvest of custom events, then would use an internal default for the reservoir with max of 10 events for each harvest after that, resulting in less than the expected number of events being sent.

  • Exposed the custom_insights_events settings in the user config.

    You can now set custom_insights_events.enabled and custom_insights_events.max_samples_stored in your newrelic.js.

    Read more about these settings in our documentation.


June 5, 2015
  • Triaged a defect in native promise instrumentation

    Transactions used to be lost acrossed chained .then calls. The way promises are wrapped has been changed to fix this issue.

  • Added support for Slow Queries

    Slow Query information will now appear in the UI for Node agent users. This feature allows you to see a trace for slow datastore queries. Read more about this feature in our documentation


May 21, 2015
  • Fixed an issue with Error tracing

    Previously the agent could sometimes cause issues with user serialization of error objects after they passed through the error tracing code.

  • MongoDB cursor count method is now instrumented

    The count method on MongoDB cursors is now instrumented. Previously, count would not be included in transaction traces.

  • Fixed a typo in

    Previously the release notes for v1.19.1 were included as notes for 1.19.0. This has now fixed thanks to @bruun


May 14, 2015
  • Fixed a bug in native ES6 Promise instrumentation.

    Previously the Promise instrumentation would cause instanceof Promise to return false even if the object was a promise. This also caused an incompatibility with async-listener. instanceof checks will now work on both the wrapped and unwrapped Promise object.


May 6, 2015
  • Fixed a bug with error handling.

    Previously the agent could crash applications in certain situations where null was thrown rather than an Error object.

  • Filesystem interactions are now recorded in metrics

    The time spent in filesystem functions during a transaction will now be displayed in the transaction overview page per operation.


May 1, 2015
  • Fixed a bug in environment variable based configuration.

    Previously the agent would parse the NEW_RELIC_APDEX environment variable as a string rather than a float this could cause data to be sent to New Relic servers in an invalid format, preventing the data from being collected.

  • Fixed a bug with the error collector's handling of ignored status codes.

    Previously the agent would not properly ignore status codes if the status code was set using a string rather than a number.

  • Fixed a bug in mysql instrumentation.

    Previously the mysql instrumentation could cause errors when making mysql queries using an options object rather than a SQL string. The agent now handles arguments to the query method in a more robust way.


April 22, 2015
  • Fixed an inverted if in config loading.

    Previously, the config loader would log a warning on success, rather than failure. Configuration loading works as expected now.

  • Fixed a bug in process.nextTick instrumentation for io.js 1.8.1.

    Previously the agent would only pass the callback argument to process.nextTick. This did not cause issues in Node.js and older version of io.js, since additional arguments were ignored. In a recent change to io.js, process.nextTick was changed to pass any additional arguments to the callback, the same way setImmediate does. This change ensures all arguments are handled as expected.


April 16, 2015
  • Wrapped all our calls to JSON.parse in try/catch.

    Previously, only calls that were considered unsafe due to external data input were wrapped. We are taking a more defensive stance and wrapping them all now.

  • Timers attached to global are now instrumented correctly in all version of io.js.

    As of v1.6.3 of io.js, timers are no longer lazily loaded from the timers module, and are placed directly on the global object. The agent now takes this change into account and accurately wraps the timer methods.

  • Improved handling of cross-application tracing headers.

    Paths that include multibyte characters will now show up correctly in cross application maps


April 9, 2015
  • Wrapped all our calls to JSON.stringify in try/catch.

    Previously, only calls that were considered unsafe due to external data input were wrapped. We are taking a more defensive stance and wrapping them all now.


April 2, 2015
  • Names assigned to errors via now appear in the UI.

    Previously, the name of an error in the UI appeared as or with a default of Error. Now the common pattern of is respected and takes precedence.

  • Child segments of external calls will now be nested correctly.

    This change causes segments that make up external calls to nest under the call correctly. Previously, the child segments appeared as siblings to external calls.

  • The request_uri attribute on errors will now only include the path without any parameters.

    This behavior now matches the other New Relic agents.


March 26, 2015
  • Reduce agent CPU overhead by omitting setImmediate from traces.

    The change to setImmediate makes that function behave the same way as nextTick and other frequently-called functions that are already elided from Transaction Traces.

  • Mitigate a Node.js memory leak that can occur during TLS connections.

    There is an outstanding Node.js Core memory leak involving TLS connections. Clients specifying certificates, such as the New Relic Agent, quickly reveal this leak. We now mitigate this issue by using the default client certificates where possible. A new log message will be printed when the TLS memory leak workaround can not be used, such as when using a custom certificate with an HTTPS proxy.


March 19, 2015
  • Fixed a bug where external requests report times longer than the transactions that initiated them.

    External request segments are now always ended when an error occurs.

  • Fixed a bug that produced incorrect transaction names for some routes in express2 and express3.


March 12, 2015
  • Fixed a bug that interfered with listing the routes in Express apps.
  • Fixed a bug that caused custom transaction names to appear as "unknown".
  • Added more log detail when instrumentation fails to load.


March 5, 2015
  • Added instrumentation support for Postgres 4.x.
  • Added instrumentation support for Datastax's Cassandra driver.
  • Updated Oracle instrumentation to collect new datastore metrics.


February 25, 2015
  • Added instrumentation for modules in node core.
  • Added support for native Promises in Node.js 0.12 and io.js 1.x.
  • Traces will now contain separate segments for async waits and callbacks.
  • Updated instrumentation for MongoDB to support previously un-instrumented methods for 1.x and 2.x versions of the node-mongodb-native driver.
  • Fixed a bug in the recording of transaction metrics. Previously this would cause a duplicate of the transaction metric to be displayed in the transaction breakdown chart


February 20, 2015
  • Fixed a bug in the logger to respect the configured log level in all cases.


February 20, 2015
  • Fixed a bug in hapi 8 view segments. Previously, the segments weren't being ended when the view ended.

  • Added a configuration option to completely disable logging. logger.enabled defaults to true, if set to false it wont try to create the log file.


February 13, 2015
  • Enable http/https proxy features on all supported Node versions.

    Supported versions: Node.js 0.8, 0.10, 0.12 and io.js 1.x.

  • Fixed a bug in vhost detection in Hapi 8. This bug would result in a crash for users of vhosts.


February 6, 2015
  • Now New Relic Synthetics transaction tracing is on by default.

    The previous release had the Synthetics transaction tracing feature turned off by default.


February 6, 2015
  • Added support for New Relic Synthetics transaction tracing.

    New Relic Synthetics monitors your site from around the world. When you use Synthetics to monitor your Node application, up to 20 detailed transaction traces will now be captured every minute when the application is probed from Synthetics. To learn more about this feature, visit our documentation.


January 30, 2015
  • Preliminary Node.js 0.12 support.

    HTTP proxies are not supported on 0.12 yet. We don't recommend running the Agent on Node.js 0.11.15+ in production, but if you are testing on it, please let us know of any issues you encounter.


January 23, 2015
  • Added an API for recording custom Insights events. Read more about this in our documentation


January 16, 2015
  • Fixed a crash in express instrumentation in the handling of sub-routers.

  • Fixed a crash in http outbound connections when CAT is enabled and another library has frozen the http request headers.

  • Updated version checking to allow versions of the runtime >= 1.0.0. Thanks to Mark Stosberg for this patch!


January 9, 2015
  • The agent now logs the actual error when log file parsing fails. Thanks to knownasilya for this patch!

  • Fixed a crash where if domains were enabled config serialization would fail due to circular objects.


December 30, 2014
  • Errors that occur in background transactions now have custom parameters copied onto them in the same manner as web transactions.

  • Memcached instrumentation updated to account for additional arguments that might be passed to the command function that the agent wraps.


December 22, 2014
  • Custom web transactions can have their names changed by nr.setTransactionName(). Thanks to Matt Lavin for this patch!

  • Fixed a bug where Express instrumentation could crash if transaction state was lost in a sub-router.


December 18, 2014
  • Improved the Express instrumentation to be more defensive before doing property lookups, fixing a crash that could happen in an exceptional state.

  • Improved logging when the New Relic agent cannot connect to New Relic servers.

  • Make Cross Application Tracer header injection less aggressive fixing interaction with other libraries such as riak-js.


December 11, 2014
  • Added support for Hapi v8.

  • briandela contributed a fix for an crash that would occur when using hapi with vhosts.


December 5, 2014
  • Fixed a bug that caused some outbound http requests to show up in the New Relic UI as requests to localhost rather than the specified domain.

  • The agent no longer reports errors from outbound http requests if they were handled by the user's application


November 25, 2014
  • The node agent now instruments connections to Oracle Databases using the oracle driver. This patch was contributed by ryanwilliamquinn

  • Fixed an issue that would break kraken apps when the node agent was enabled. This patch was contributed by Lenny Markus


November 20, 2014
  • Added support for the the aggregate method on mongodb collections. This patch was contributed by taxilian


November 13, 2014
  • Fixed a bug in Cross Application Tracing where the agent would sometimes attempt to set a header after headers had already been sent.

  • Replaced the logger with one that is handles file writes properly lowering overall resource usage.

    This is a small change with a large impact. fs.createWriteStream returns whether data was queued or not. If it is queued it is recommended to wait on a drain event but this isn't manditory. Most loggers we've found ignore this event which leads to many writes getting buffered and a rapid increase in native heap size as well as lowering the process's ability to respond to requests.


November 6, 2014
  • Updated support for hapi 7.2 and higher.

    Hapi refactored how the server is instantiated and caused the agent to not be able to get transaction names. This release accounts for the update and enables full instrumentation.


November 6, 2014
  • This release was unpublished as it got packaged incorrectly.


October 31, 2014
  • Added support for Custom Metrics

    Custom metrics provides a way to send additional metrics up to New Relic APM, which can be viewed with Custom Dashboards. We have two APIs for this, recordMetric(name, value) and incrementMetric(name[, value]). Read more about this in our docs:

  • Fixed a bug in deeply nested transactions.

    Previously we allowed transactions to be nested to any depth. We've found in some cases this causes stack depth problems and are now limiting to 900 segments per transaction. We will still collect metrics on all segments, but transaction traces will only show the first 900.

  • Fixed a bug where custom tracers would show 0 time if the transaction ended n them.

    This may change the times you see for other types of tracers by a small amount. The change will reflect slightly more accurate timing.


October 23, 2014
  • Fixed a bug that would cause the application to crash on outbound connections when using node 0.8.

  • Fixed a bug that could sometimes cause the application to crash while parsing MySQL queries.


October 16, 2014
  • Added support for Label Categories

    The agent now supports setting Labels for your application on a per instance level, using either an environment variable, or a config file setting.

  • Improved transaction names for express 4

    express 4 added the ability to mount apps and routers at specific urls. The node agent would previously use only the portion of the route that was the last router or app matched as the transaction name. Transaction names will now include the entire matched route.

  • Added detection for uninstrumented instances of modules that should be instrumented

    The agent will now detect if an application has required a module before require('newrelic') .If this occurs, the agent will add a warning in the log file and display a warning banner in the UI.

  • Added more logging to custom instrumentation APIs at debug level.

    The logging was improved for the benefit of people using the following APIs: createTracer, createWebTransaction, createBackgroundTransaction, and endTransaction. It will log when transactions are created and when transactions are ended. It will also log when it can't create a tracer due to there being no active transaction.

  • Fixed a bug in QL instrumentation where the event emitter from query could not chain .on calls. This patch was contributed by sebastianhoitz.

  • Fixed a bug in createBackgroundTransaction where if the agent was disabled it didn't take a group argument. This patch was contributed by nullvariable.

  • Fixed a bug in our URL parsing where in Node v0.11.14 url.parse returns a differently shaped object than expected. This patch was contributed by atomantic

    Note: Node v0.11.x is not officially supported, but Node v0.12 will be and this patch helps us get ready for that.


October 10, 2014
  • Added support for Cross Application Tracing

    The agent now supports Cross Application Tracing, which allows the New Relic APM UI to display traces that span multiple applications.

  • Fixed a bug that would cause application to crash on request when using the kraken framework.

  • Loosened the restrictions on the app_name setting. Application names may now include any Unicode characters.


October 6, 2014
  • Fixed a type error while checking the payload size to be sent to the New Relic servers.

    When this happened the agent would fail to send the payload to New Relic. This was more likely to occur in higher throughput applications.


October 3, 2014
  • Fixed a bug where mutibyte characters would cause an error when sending data to the New Relic servers.


September 26, 2014
  • Updated hapi instrumentation to support the recently released v6.9.

  • Fixed a bug where an invalid package.json could cause the agent to crash while it recursed through node_modules gathering version details.

  • Properly name other SQL queries.

    Previously when the agent failed to parse SQL it would create a metric stating the database type, query type, and query table were all unknown. This has been changed to keep track of database type and create an appropriate other operation metric like other agents.


September 19, 2014
  • Custom Instrumentation functions now pass through the return value of their passed in callback.

  • Multiple improvements to PostgreSQL instrumentation

    When no callback was detected in the query functions, we were inserting our own. The insertion itself caused a crash. Adding a callback also modified the behavior of the pg module. Instead, we now listen for error or end events to finish segments.

    We now generate metrics for statement type/table combinations. Look for these in the database tab your APM Account!


September 11, 2014
  • Improved MongoDB find instrumentation.

    The mongo driver provides many different ways to invoke its API and find documents. In previous releases, some API invocations would create transaction trace segments that would not end properly, leading to inaccurately large segment times. This release now covers all the ways to find and iterate through documents, ensuring segment times are accurate.


September 5, 2014
  • We now support PostgreSQL via the pg driver.

    The Node.js agent now records the amount of time spent in transactions with PostgreSQL databases. This timing can be viewed in the Transactions dashboard within individual transactions and their traces.

    The agent supports all of the following pg usage scenarios:

    • Using the pure javascript API exposed directly from pg
    • Using the "native" API exposed from pg.native
    • Using the "native" API exposed directly from pg when the NODE_PG_FORCE_NATIVE environment variable is set
    • Using the pure javascript API from the pg.js module


August 28, 2014
  • Removed a preemptive DNS lookup of the New Relic servers that could cause errors when behind a proxy.


August 25, 2014
  • Fix to prevent proxy credentials transmission

    This update prevents proxy credentials set in the agent config file from being transmitted to New Relic.


August 22, 2014
  • MySQL Pooling Support

    Better support for mysql pooling, including connections that use createPoolCluster and createPool. Previously connections obtained through a pool could potentially be uninstrumented.


August 15, 2014


August 8, 2014
  • Fixed a bug in the express instrumentation where if you named an error handler function handle it would cause a recursion depth error.


July 30, 2014
  • Added a check for invalid characters in the app_name setting.

    The agent will now emit a warning and disable itself if any application name is invalid. Allowed characters are alphanumerics and certain punctuation characters ({}.?!')

  • Router queue time now properly handles floating point values.

  • Fixed a bug where a socket connection could throw a synchronous error and cause the application to crash.


July 24, 2014
  • We now support Cassandra via the node-cassandra-cql driver.

    New database instrumentation means that we can present you with the timing data for how long those queries take. Thanks to Aaron Silvas from GoDaddy for the initial implementation of the Cassandra instrumentation.

  • Router queue time now supports t=<number> in the X-REQUEST-START and X-QUEUE-START headers.


July 18, 2014
  • Agent now tracks metrics for router queue time. In addition to X-REQUEST-START, the agent now supports X-QUEUE-START header times. This metric will show up as "Request Queueing" in the Overview tab.


July 11, 2014
  • General release of proxy support for the agent to connect to New Relic.
    • HTTP/HTTPS support from the newrelic module to the proxy
    • HTTP/HTTPS support from the newrelic module to New Relic.
    • Basic proxy authentication.
    • Allow custom certificates during TLS negotiation.
    • For more information, read our docs here
  • Fix for enabling High Security Mode via an environment variable
  • Optimization to allow early garbage collection of TLS slab buffers.


July 2, 2014
  • Plain http routes (i.e. routes outside of a framework) now apply config naming rules early. See rules for naming and ignoring requests.

    This fixes a bug where generating the Browser Timing Header would not work without a framework (i.e. express, restify, hapi).

  • Beta support for connecting to newrelic via ssl through a proxy. See issue 128 for details.


June 26, 2014
  • The agent now reports the value of the NODE_ENV environment variable to New Relic.


June 20, 2014
  • Support for instrumenting a standalone express 4 router. See issue 154.
  • Set the default log level to info.


June 13, 2014
  • Captured parameters for express, restify, and hapi have been normalized.

    When capture_params is enabled the agent will collect route and query parameters. Previously express and restify only captured route params, and hapi only captured query params. This normalizes the behavior across the frameworks.

  • Fixed an issue with restify instrumentation that caused the agent to always collect route parameters.

    Users of restify who want to continue capturing route (and now query) parameters are advised to enable capture_params.

  • Fixed an issue where circular configs caused the agent to crash.


June 5, 2014
  • Fixed an issue where collected errors did not include captured and custom parameters.

  • Added the environment variable NEW_RELIC_HIGH_SECURITY. This correlates to the high_security setting in your newrelic.js for High Security Mode.


May 29, 2014
  • Client side setting of high_security is now supported.

    High Security Mode is a feature to prevent any sensitive data from being sent to New Relic. The local setting for the agent must match the server setting in the New Relic APM UI. If there is a mismatch, the agent will log a message and act as if it is disabled. A link to the docs for High Security Mode can be found here

    Attributes of high security mode (when enabled):

    • requires ssl
    • does not allow capturing of parameters,
    • does not allow custom parameters

    The default setting for High Security Mode is ‘false’.

    Note: If you currently have high security mode enabled within the New Relic APM UI, you have to add high_security: true to your local newrelic.js.

  • Fixed a bug in our instrumentation of restify, where if you were using the restify client with express as a web server, req.query would be overridden.


May 22, 2014
  • New Relic Insights support no longer requires a feature flag. If you are a paying customer, you'll begin to see data show up in Insights as soon as you upgrade to 1.6.0. The agent will send event data for every transaction up to 10,000 per minute. After that events are statistically sampled. Event data includes transaction timing, transaction name, and any custom parameters. You can read what is sent in more detail here.

    You can read more about Insights here. Documentation for configuring this feature can be found here.


May 15, 2014
  • Fix a bug where if the user disabled the error collector, error count would be carried over harvest cycles instead of reset. This would result in an ever increasing error count until the app was restarted.

  • New Relic Insights beta support. This is a feature for our paying customers. The support of Insights in the agent is beta, this means we don't recommend turning the feature on in production, but instead trying it out in development and staging environments.

    To enable Insights support add the following to your newrelic.js:

    feature_flag : {
      insights: true


May 8, 2014
  • On connect, the full newrelic module configuration is pushed to New Relic APM. Full config will be visible under the Agent initialization tab, under the Settings button in the APM application page.

    The reported settings will reflect the running agent config, which may differ from the newrelic.js file depending on server-side, and environmental configuration.


May 1, 2014
  • Express 4 support.

    Closes #132. Express 4 apps now have their transactions named correctly. Errors in the middleware chain are properly recorded.


April 24, 2014
  • Fix issue #118 where dangling symbolic links in the node_modules folder would crash the environment scraper.


April 18, 2014
  • Upgrade continuation-local-storage dependency to 3.0.0. The newrelic node module uses cls to help join asynchronous transaction segments. The latest cls module includes a fix that prevents contexts from leaking across transactions.


April 11, 2014
  • Add high-security compliance for accounts with enterprise security enabled. By default, the agent now works with high-security accounts, whereas previously agents would receive an Access Violation.
  • Add a .addCustomParameter(name, value) api call for adding custom parameters to transaction traces, and extend the .noticeError(error, customParameters) for adding additional parameters to error traces.
  • Documentation fix in the for ignoring routes.
  • Better support for disabling browser timing headers server side. Previously the agent would not pick up the server change until restart. The agent will now disable browser timing headers as soon as the next harvest cycle.
  • Fix a socket hangup error that was causing some agents to fail to handshake with the New Relic servers.


March 14, 2014
  • Browser monitoring! Real User Monitoring! Which is also known as RUM! Whatever it's called, it allows you to see how long your pages take to load, not just on the server side, but in the browser! Wow! It's super cool! We know a lot of you have been waiting for this, and it's here! It's manually set up with an API call! Check the README for details!
  • By default, all communication between New Relic for Node and New Relic's servers is now protected with crisp, clean TLS encryption. To minimize the CPU overhead of running connections over SSL (and it can be configured, see the README and the online documentation for details on how to return to plain HTTP), New Relic for Node is now using a keep-alive connection that will properly pipeline connections, for both HTTP and HTTPS.
  • Improved the timings for a large class of MongoDB / Mongoose use cases. If you've encountered the issue where MongoDB trace segments last for an absurdly long duration, this should help.


February 12, 2014
  • Includes a nearly total rewrite of the connection layer that the module uses to communicate with New Relic's servers:
    • More useful logs! All of the logging has been reviewed closely to maximize its value and usefulness at pretty much every level. In practice, this means that the messages logged at 'info' and higher should only be for things that are relevant to you as a customer, and at 'debug' and 'trace' should be much more useful for us when we help you isolate issues with New Relic in your applications.
    • See data faster! As part of the connection handshake with New Relic, the module will now send any performance metrics gathered during the startup cycle immediately, instead of waiting a minute for the first full harvest cycle.
    • Get data to New Relic more reliably! When the module has issues connecting to New Relic, it's more consistent and resilient about holding your performance data for later delivery.
    • Use less bandwidth! Performance data delivery to New Relic is now sequential instead of simultaneous. This means that the bandwidth used by New Relic will be less bursty, especially on hosts running many instrumented applications (or cluster workers).
    • Better implementation! There were a number of architectural problems with the old version of the connection layer, which (among other things) made it difficult to test. The new version is simpler, has a much cleaner API, and has many, many more tests.


January 31, 2014
  • Ignored status codes are now always casted to numbers so that people using environment-variable configuration or strings in config still get error status ignored properly.
  • If you disabled server-side configuration, the server was still able to set the value of apdex_t for your app. This was an oversight, and has been corrected.
  • Before, if you had request renaming rules, if the end result was the same as the match pattern (mapping /path to /path), they would be silently ignored. This has been fixed.
  • MySQL instrumentation handles callback more consistently, so the transaction tracer doesn't get confused and stop tracking transactions with MySQL calls in it.


January 17, 2014
  • Support for Spumko's Hapi! This support works with both Hapi 1.x and 2.0.0, and like our Express and Restify instrumentation will automatically name transactions after Hapi paths (get it) and time how long it takes to render views.
  • Before, transaction naming and ignoring rules didn't work with Express and Restify routes. This has been addressed and the documentation has been clarified. Much gratitude to everyone who helped us figure out how to get this right, and for dealing with the previous, unclear documentation.
  • Parameters in the ignored params list weren't being ignored in all cases.
  • A very annoyingly chatty log message had its priority level dropped several levels.


December 7, 2013
  • Before, there were certain circumstances under which an application would crash without New Relic installed, but wouldn't crash with it. This has been fixed, and applications with New Relic installed now crash consistently. The error tracer is now also considerably simpler.
  • Added a security policy. See the new section in or read
  • Future-proofed the MongoDB instrumentation and prevented the module from breaking GridFS.
  • Made a small tweak that should reduce the amount of blocking file I/O done by the module.
  • The module's instrumentation and harvest cycle will now not hold the process open in Node 0.9+. This should make it easier for processes to shut themselves down cleanly with New Relic running.
  • The environment information gatherer will no longer crash if it tries to read a directory where it's expecting a file.
  • Errors thrown during the execution of Express routes or Connect middlewares that were attached to requests that ended in HTTP status codes configured to be ignored by default will now be ignored correctly.
  • Made the module play nicer with Node's REPL. It no longer assumes that an application necessarily has a main module.
  • A few tweaks were made to support the CoolBeans dependency injection framework.
  • Several log messages were demoted to a less chatty level.


November 8, 2013
  • Added the infrastructure necessary to support key transactions and New Relic's new alerting policies.
  • The agent no longer renames transactions for requests that end in error to the gnomic and unhelpful '400/*' (or whatever the final HTTP status code ends up being). This should make the traced errors tab considerably more useful.
  • Improved instrumentation for legacy http.createClient and http.Client client methods. A few modules still use these legacy API calls, and the old instrumentation was just plain wrong.
  • Changed how the error tracer deals with certain kinds of errors to deal with differences between Node versions 0.8 and 0.10. It should now convert throws into fatal errors less frequently.
  • Removed useless fs.readDir instrumentation, which generated a lot of metrics but which New Relic was unable to display in any useful form. Maybe it will come back someday in a more useful incarnation.


November 5, 2013
  • Added a new call to the API, .noticeError. See the docs for details, but unlike the other calls on the API, you can use this to pass off errors anywhere in your app, not just from within web requests.
  • Ignoring slow (or polling) requests was only being applied to slow transaction traces. It now applies to metrics and transactions that end in errors.
  • MongoDB, Redis and Memcached now honor the capture_params and ignore_params settings.
  • New Relic for Node.js, like New Relic's other agents, has a sophisticated system for repeatedly trying to connect to New Relic's servers when the first attempt results in failure. This had been broken since (roughly) January. It works again now.
  • The built-in debugging for the transaction tracer was out of date with respect to the production tracer. This is fixed, and you're welcome to satisfy your curiosity by enabling it, but it's really not going to be useful to you unless you feel like taking the time to understand what the tracer is doing at a low level. Do not ever enable it in production, as it slaughters the tracer's performance and generates a huge pile of objects per transaction.


October 30, 2013
  • Added a new setIgnoreTransaction call to the exported API to allow explicit control over whether transactions should be ignored or not. Mark those polling routes to be ignored! Pull your crazy custom favicon.ico renderer out of the ignore list!
  • The module will no longer pollute MongoDB queries with New Relic-only parameters. Thanks to Alon Salant for identifying this issue, and all apologies to him for the trouble it caused him.
  • The instrumentation for MongoDB, memcached, Redis, and Express will now honor the setting of the capture_params configuration flag. Before the module always captured query parameters.
  • Fixed a problem that would cause New Relic for Node to fail on versions of Node between 0.8.0 and 0.8.3.
  • Upgraded to the newest version of continuation-local-storage, which has many fixes for dealing with monkeypatched EventEmitters.


October 24, 2013
  • General release. No code changes from v0.12.1.


  • The transaction namer wasn't respecting error_collector.ignore_error_codes. We've unified the code paths there so that this no longer happens, so that if the status code of a request is in the list of codes to be ignored, it's no longer rolled up under that status code and gets its normal name.


  • Changed how MongoDB, MySQL, memcached, and Redis metrics are reported to New Relic. This is part of a larger effort to make the Monitoring > Database tab of the New Relic UI more useful for Node developers. There will be a brief period where your dashboards will have both the old and new metrics, which could lead to some temporary duplication or metric names. These "duplicates" will gradually stop showing up as the reporting windows containing the old metric names expire. Be sure to let us know if you have strong feelings one way or another about this change, as it's a work in progress.
  • Updated the module's dependencies to fix another subtle bug in how error-handling works in Node 0.8.x. This should resolve the errors some users were seeing.


  • Fixed a crash in the tracer that could turn a recoverable application error into an unrecoverable process crash. Mea culpa, our apologies for the inconvenience if you ran into this. In our defence, the errors we're running into are getting ever more exotic as we get most of the common stuff nailed down.
  • Added the ability to use the preconfigured Azure Web Server name as the application name for a Node app. Thanks to New Relic .NET engineer Nick Floyd for the suggestion.


  • Added a license entry to package.json.
  • Due to an npm bug, the module package got huge. This one is much smaller.


  • The last build of the agent had a flaw in how it dealt with outbound requests that made it way too stringent about dealing with default ports. It is now more sane about defaults.
  • The behavior of configuration precedence is slightly different now. Previously, if there were list values set in the defaults, configuration file, environment variables, or server-side configuration, they would be concatenated instead of being overwritten. This made it impossible to override some of the defaults (most notably, it was impossible to not ignore HTTP status code 404 in the error tracer), so now the configuration file will overwrite the defaults, and environment variables will overwrite the configuration file. Values sent by New Relic will still be concatenated instead of overwriting, though (again, this only affects configuration variables with list values). Thanks to GitHub user grovr for identifying the problem!
  • The error tracer will collect errors off transactions after the first harvest cycle (thanks to GitHub user grovr for identifying this issue).
  • cluster users will no longer see occasional crashes due to New Relic's instrumentation.
  • Fixed a few minor documentation errors that made it tough to use the suggested ignoring rules for transactions.


  • Changed the module to not load the instrumentation at all if the agent is disabled via configuration. This will keep the module from leaking any resources when it's disabled.
  • The agent used to include query parameters in the name for outbound requests, making for unwieldy-looking trace segments. Those parameters are now stripped off, and if capture_params (and ignored_params) are enabled, parameters will be captured for (nicely-formatted) display.
  • Added a stubbed API so that when the agent is disabled, calls to the New Relic API will not throw. Add naming calls to your code with impunity!
  • The module now looks in many more places for newrelic.js before complaining that it can't be found. In order, it looks in the current working directory, the directory of the Node process's main module (normally whatever file you pass to node on the command line), the directory pointed to by the environment variable NEW_RELIC_HOME, the current process's $HOME, and the directory above the node_modules directory where newrelic is installed.


  • Fixed a major issue in the transaction tracer that affected users of certain Express middleware plugins. HUGE thanks to Nicolas Laplante for his assistance in isolating and reproducing the bug, and also to the denizens of #libuv for eyeballing my various unsuccessful attempts at a fix.
  • Fixed another issue in the tracer where certain objects were being wrapped too many times. Thanks to José F. Romaniello for confirming the fix.
  • Changed how requests handled by Express and Restify routes are named. This change is being rolled out both in this module and on the New Relic website, so there is a chance you will see the same route (or very similiar routes) show up twice in aggregated metrics.
  • Dropped the default apdex tolerating value from 500 milliseconds to 100 milliseconds. This means that transactions slower than 400 milliseconds will generate slow transaction traces. Read the documentation in on apdex_t and apdex_f for further details.


  • Fixed an error in the Connect and Express middleware instrumentation. Another tip of the hat to Jeff Howell at Kabam for identifying this problem and pointing to a solution!


  • Rewrote the MongoDB instrumentation. Big thanks to Jeff Howell at Kabam for demonstrating a much more reliable and simple approach than what we had before! Also expanded the number of MongoDB methods instrumented to include more of the common operations and indexing operations.
  • Changed the default value of the top_n configuration parameter. Read the documentation in lib/config.default.js for the details (we've taken another run at making the docs for top_n easier to understand), but the upshot is that by default you should see a greater diversity of slow transaction traces now.
  • Closed a hole in the transaction tracer related to Connect and Express-style middleware chains.
  • Fixed issues identified by testing against various versions of 0.11 and master.
  • Added guidelines for contributing to the module. Read for details.


  • Fixed a bug with the Connect instrumentation that would cause it to crash when using Connect's static middleware in strict mode. Using ES5 future reserved keywords for function names is a bad idea, and this is why, but static's name is highly unlikely to change. For those of you who are examining the state of your middleware stack after configuring it, you probably shouldn't be doing that, but if you run into problems with the New Relic agent installed, try changing your test to use name.indexOf('whatever') === 0 as the predicate instead of name === 'whatever'.


  • Prevent requests from being double-counted by changing the tracer to always reuse existing transactions rather than trying to nest them.
  • Changed the Connect instrumentation to preserve the names of middleware functions after wrapping them. If you need this change, you should probably change your code so you don't need it anymore.
  • Added a bunch of server-side configuration options that are known but unsupported to the agent.


  • IMPORTANT. There have been MAJOR CHANGES in how requests are named for display and aggregation in the New Relic user interface. Read the section in the README on transactions and request naming for details. For good measure, read it twice. If your requests are all still ending up named /*, read it a third time. This is especially true if you're not using Express or Restify, in which case you will almost certainly want to make changes in how you configure New Relic.
  • IMPORTANT. New Relic for Node.js now supports the full range of server-side configuration options offered by the New Relic web interface. By default, server-side settings will override the settings in your configuration file (or environment variables). You can disable server-side configuration by setting ignore_server_configuration to true in your configuration file (or setting NEW_RELIC_IGNORE_SERVER_CONFIGURATION to 'true').
  • BREAKING CHANGE: The New Relic module now exports an API to be used for naming transactions and for adding URL to transaction name mapping rules. If you were using require('newrelic') as an interface to the agent's configuration or its internals, you'll need to fix your code (also you probably shouldn't have been doing that).
  • BREAKING CHANGE: The configuration parameter transaction_tracer.trace_threshold has been renamed transaction_tracer.transaction_threshold to make it consistent with New Relic's other agents.
  • Applications using the Express or Restify routers will now have their requests named after the matching routes. These names can be overridden but the transaction-naming API.
  • There are new configuration parameters for adding rules for naming or ignoring requests. The README has a good example for how to keep from blowing out your average response time. You should read it!
  • Tweaked the calculation of exclusive time in transaction traces, which should make more of the transaction trace detail pages make sense.


  • Fixed a regression in beta-25 that caused the agent to incorrectly calculate an important timestamp, thus leading to data not showing up in New Relic.
  • Improved in-memory aggregation (when the connection between the agent and New Relic is unavailable or failing).


  • Fixed a serious error in how the agent handles communication errors when sending errors to New Relic. If you're running v0.10.0 or v0.10.1, upgrade sooner rather than later, as those versions are losing data.
  • Substantially improved the quality of reporting on errors noticed by the Node agent. Stack traces, scopes, and messages should be much better.


  • The instrumentation for http no longer assumes that the hostname for external requests will be named host (hostname is also allowed, and http.request() defaults to localhost).
  • The Node agent and New Relic's servers disagreed about what many metrics should be called. The agent was wrong and it regrets the error.
  • Minor tweaks to database instrumentation (MongoDB and MySQL) that could have a small but visible impact on the overview display.


  • IMPORTANT. The transaction tracer in this build is COMPLETELY NEW. This means that the agent will probably work just fine under Node 0.8 and newer, but Node versions 0.6 and older are presently unsupported, and support for them may or may not come back. However, the quality of the metrics gathered by the agent is now vastly improved.
  • There are over 100 commits included in this build. Every effort has been made to ensure that we will not crash your applications, but be aware there may be regressions.
  • Substantially more information is displayed by New Relic for slow transaction traces. How this information is displayed is a work in progress, as New Relic works to create a consistent user experience for developers writing both synchronous and asynchronous applications.
  • Most Redis and memcached operations will now provide details on which keys were involved in an operation.
  • The error tracer has been given a new coat of paint as well, and takes better advantage of Node domains, when they're available. Fewer errors should be double-counted, as well.
  • MongoDB instrumentation is substantially improved.
  • Express instrumentation now deals with the removal of the (very helpful) version field from recent versions of Express.
  • Exclusive durations are reported for metrics, improving transaction breakdowns.
  • Several bugs in the communication between the New Relic agent and New Relic's servers have been fixed.
  • Failed connection attempts between the agent and New Relic's servers no longer cause aggregated metrics to be lost, nor will this trigger an agent crash.


  • Capture request URL before Express can mess with it.


  • Don't try to connect without a license key.
  • Clear out previous connection listeners on failed connection attempts.
  • Don't crash when normalizing paths without a leading slash.


  • The implementation of domains changed in Node 0.10.x, which necessitated a fair amount of work on the error tracer to preserve the existing error tracer behavior.
  • The error tracer no longer improperly swallows thrown errors.
  • The agent no longer assumes that a home directory is set.
  • The agent now works correctly with the should assertion helper library.


  • HTTPS instrumentation is both more complete and far better tested.
  • Restify servers using HTTPS listeners should now be properly instrumented.


  • ; is now treated as a query separator in URLs, just like ?.
  • When using stdout or stderr for logging and not using a configuration file, logging will now work as expected.
  • The error-handling code for DNS lookup of New Relic's servers was itself erroneous. It should no longer crash instrumented apps when DNS lookup fails.
  • Simplified agent startup process.


  • Using fs.readdir will no longer crash the agent and your apps. Oops!
  • Added error-tracing middleware for Connect 1 & 2 applications, which includes Express 2 and 3 applications. This middleware is inserted automatically and transparently. Because it's common for end-user error handlers to not propagate errors (by calling next(error) from within the handler), the instrumentation inserts the middleware before the first error handler added to the middleware chain.
  • The node-redis driver now correctly traces Redis calls made without a callback.
  • Connections to New Relic that partially succeeded will now correctly keep attempting to connect until the connection succeeds or the number of retries is exhausted.
  • Added a handler for yet another kind of New Relic server error (RuntimeError).


  • For some of the modules instrumented by the agent (fs, http, Express 2 and 3), the error tracer now adds error tracing to wrapped function calls. This means that more of the functions in those modules will send traced errors to New Relic, even if they're trapping errors themselves. Also improves error tracer in versions of Node without domains. The error tracer rethrows all caught errors, so as to not alter behavior of instrumented apps.
  • The error count sent by the agent was frequently incorrect due to an off-by-one bug.
  • Include the entire stacktrace in traced errors.
  • When the agent fails to successfully connect to New Relic's servers, it will try 6 more times, progressively waiting longer between each failed attempt. If no connection can be made, the agent will shut itself down.
  • The agent no longer crashes instrumented applications when DNS resolution fails during the initial handshake with New Relic's servers. It logs the failures instead and retries later.
  • The agent no longer alters the behavior of the generic-pool module in a way that causes modules using it to break (including node-postgres).
  • In some cases, the domains-based error tracer was not working correctly.
  • The agent logs significantly more useful debugging information.


  • The agent's built-in compression for sending large payloads to New Relic wasn't correctly handling the Buffer returned by zlib, leading to a crash.


  • In some cases, the monkeypatching used by the instrumentation wasn't written sufficiently defensively, leading to applications crashing at startup when using the agent.
  • Changed how packages and dependencies are serialized when sent to New Relic's servers.


  • When New Relic's servers (or an intermediate proxy) returned a response with a status code other than 20x, the entire instrumented application would crash.
  • Some metric normalization rules were not being interpreted correctly, leading to malformed normalized metric names.
  • Metric normalization rules that specifed that matching metrics were to be ignored were not being enforced.


  • Fixed the agent's auto-restart support to cleanly shut down the connection (also fixed a bunch of bugs in restart).


  • When server-side configuration changes, the agent will now correctly restart when told to do so by New Relic's servers.
  • Correctly wrap net.Server.prototype.listen -- wasn't returning the server object, which broke some apps.
  • If you're on a SmartOS VM with a 64-bit base image and a 64-bit build of Node that's v0.8.5 or earlier, the agent will no longer cause Node to crash. Don't even ask.


  • Squared up the environment variable names with existing practice, especially with an eye towards conformity with Heroku documentation.
  • Flushed out all configuration used anywhere in the agent and made sure it was documented in config.default.js.
  • Using the new environment setting NEW_RELIC_NO_CONFIG_FILE, override the need to have a settings file at all.
  • Add the ability to send log output to stdout or stderr.


  • Can now configure the agent via environment variables. See for details.
  • Can now configure the location of the agent log via either logging.filepath in the configuration file, or NR_LOGGING_FILEPATH in the app's environment.
  • Turning off the error tracer via configuration now actually disables it.


  • Express view rendering was being instrumented improperly before, causing rendering to fail and Express to hang. Both Express 2 and 3 were affected, and both have been fixed.
  • When NODE_PATH is set, resolve NODE_PATH elements properly so that package lookup for environmental information gathering doesn't crash the app.
  • Now send the Node version along with the rest of the environment data.


  • Added first cut at support for error tracing via Node.js 0.8+ domains. Versions of Node.js that support it (v0.8.9 and above) will make a best-faith effort to clean up after errors.
  • Improved non-domain error handling on outbound HTTP requests.
  • Dramatically improved accuracy of HTTP request timing.


  • Be more careful in dealing with HTTP requests.


  • Further improvements to node-mongodb-native instrumentation.
  • Package now available via npm as "newrelic".


  • Send a list of the packages and dependencies available to an app on connection to New Relic servers.
  • Generally cleaned up submission of configuration information.
  • Added trace-level logging of instrumentation to help diagnose issues with transaction tracing.
  • Fixes to web error transaction reporting.


  • Added support for node-mysql 2.0.0a driver series.
  • Added support for Express 3.
  • Added rudimentary instrumentation for node-redis.
  • Added rudimentary support for generic-pool (for use with MySQL).
  • Fixed view instrumentation for Express.
  • Improved coverage of MongoDB driver.
  • Many small fixes to make logging more robust.
  • Don't return a partially initialized agent -- shut agent down gracefully if startup fails.


  • Fixed an issue in how transaction traces were serialized that kept them from being displayed within RPM.
  • Added request parameters to transaction traces, as well as URL normalization.
  • Reconciled segment names in transaction traces with the corresponding metric names.
  • Changed the logging module to bunyan. This means that logs are now stored as JSON. If you want pretty-printed logs, npm install -g bunyan and then use the bunyan CLI tool to format and filter the logs.
  • The agent now sets the logging level to the configured level. Logs sent to New Relic should have been captured at the 'trace' level for the duration of the beta.
  • Fixed metric -> ID renaming semantics.
  • Verified that agent works with Node 0.8's cluster module.


  • Completely new transaction tracer. Faster, simpler and vastly more deterministic, but the reworking likely introduced a bunch of new bugs. This also means that the agent no longer directly affects the call stack or overrides any of the core event-handling methods, which means the overhead of the transaction tracer is vastly reduced. Which is good, because you still can't turn it off.
  • Transaction traces should now report the correct caller-callee relationships.
  • Transaction tracer is now internally instrumented, for better debugging.
  • Added support for Restify.
  • Using the Node.js agent in Restify app no longer causes them to crash (fixes NA-47).
  • Improved support for Express (NA-8).
  • Lots of fixes to the MongoDB, MySQL and memcached instrumentation.
  • MongoDB instrumentation no longer crashes MongoDB apps that include the agent (NA-48).
  • More testing in Node.js 0.6.x (hard to completely test, as node-tap isn't that friendly to Node < 0.6.21).


  • Transaction trace durations are now reported properly (were seconds, now milliseconds).
  • The agent no longer causes Restify applications to crash.
  • The internal Node metrics sampler now shuts itself down properly.


  • Improved timing of Express / Connect request handlers.


  • Added support for internal supportability metrics (enabled via setting debug.internal_metrics to true in newrelic.js).


  • By popular demand, support for Node 0.6.x. Tested against versions 0.6.5 and 0.6.19.


  • Transaction traces no longer crash the RPM transaction trace viewer.
  • The Node.js agent now follows the rules for Top N slow trace gathering.
  • Compress large requests before submitting them to the New Relic collector.
  • trace_threshold can now be configured from the server, and is not hard coded to apdex_f.
  • The agent definitely doesn't work (for now) in Node 0.6.x and earlier. The agent will now notify developers (on the console) that it's refusing to start up under old versions, but won't crash the app.
  • Don't crash the instrumented app if config is missing.


  • The agent faithfully records and reports basic metrics.
  • The agent reports error metrics.
  • The agent gathers basic slow transaction trace data.
  • The agent reports transaction trace data.