newrelic 7.1.2 → 7.3.0

package/lib/grpc/connection.js

@@ -14,14 +14,14 @@ const util = require('util')
 
 const connectionStates = require('./connection/states')
 
-const protoOptions = {keepCase: true,
+const PROTO_OPTIONS = {keepCase: true,
   longs: String,
   enums: String,
   defaults: true,
   oneofs: true
 }
 
-const pathProtoDefinition = __dirname +
+const PROTO_DEFINITION_PATH = __dirname +
   '../../../lib/grpc/endpoints/infinite-tracing/v1.proto'
 
 const DEFAULT_RECONNECT_DELAY_MS = 15 * 1000
@@ -54,11 +54,13 @@ class GrpcConnection extends EventEmitter {
     this._metrics = metrics
     this._setState(connectionStates.disconnected)
 
-    this._endpoint = this.getTraceObserverEndpoint(traceObserverConfig)
     this._licensekey = null
     this._runId = null
     this._requestHeadersMap = null
 
+    this._endpoint = this.getTraceObserverEndpoint(traceObserverConfig)
+
+    this._client = null
     this.stream = null
   }
 
@@ -320,26 +322,48 @@ class GrpcConnection extends EventEmitter {
    * a stream for further writing.
    */
   _connectSpans() {
-    const packageDefinition = protoLoader.loadSync(pathProtoDefinition, protoOptions)
-
-    const serviceDefinition = grpc.loadPackageDefinition(
-      packageDefinition
-    ).com.newrelic.trace.v1
-
-    const credentials = this._generateCredentials(grpc)
-    const client = new serviceDefinition.IngestService(
-      this._endpoint,
-      credentials
-    )
+    if (!this._client) {
+      // Only create once to avoid potential memory leak.
+      // We create here (currently) for consistent error handling.
+      this._client = this._createClient(this._endpoint)
+    }
 
     const metadata =
       this._getMetadata(this._licenseKey, this._runId, this._requestHeadersMap, process.env)
 
-    const stream = client.recordSpan(metadata)
+    const stream = this._client.recordSpan(metadata)
     this._setupSpanStreamObservers(stream)
 
     return stream
   }
+
+  /**
+   * Creates gRPC service client to use for establishing gRPC streams.
+   *
+   * WARNING: creating a client more than once can result in a memory leak.
+   * ChannelImplementation and related objects will stay in memory even after
+   * the stream is closed and we do not have a handle to the client. Currently
+   * impacting grpc-js@1.2.11 and several earlier versions.
+   */
+  _createClient(endpoint) {
+    logger.trace('Creating gRPC client for: ', endpoint)
+
+    const packageDefinition = protoLoader.loadSync(PROTO_DEFINITION_PATH, PROTO_OPTIONS)
+
+    const protoDescriptor = grpc.loadPackageDefinition(
+      packageDefinition
+    )
+
+    const traceApi = protoDescriptor.com.newrelic.trace.v1
+
+    const credentials = this._generateCredentials(grpc)
+    const client = new traceApi.IngestService(
+      endpoint,
+      credentials
+    )
+
+    return client
+  }
 }
 
 module.exports = GrpcConnection

package/lib/instrumentation/core/async_hooks.js

@@ -40,7 +40,7 @@ function initialize(agent, shim) {
 }
 
 function tryAsyncHooks(agent, shim) {
-  var asyncHooks = null
+  let asyncHooks = null
   try {
     asyncHooks = require('async_hooks')
   } catch (e) {
@@ -50,19 +50,45 @@ function tryAsyncHooks(agent, shim) {
 
   // this map is reused to track the segment that was active when
   // the before callback is called to be replaced in the after callback
-  var segmentMap = new Map()
+  const segmentMap = new Map()
   module.exports.segmentMap = segmentMap
 
-  var hook = asyncHooks.createHook({
+  let hookHandlers = getStandardHooks(segmentMap, agent, shim)
+
+  if (agent.config.feature_flag.new_promise_tracking) {
+    logger.info('Enabling new promise tracking style via new_promise_tracking feature flag.')
+    hookHandlers = getPromiseResolveStyleHooks(segmentMap, agent, shim)
+  }
+
+  const hook = asyncHooks.createHook(hookHandlers)
+  hook.enable()
+
+  agent.on('unload', function disableHook() {
+    hook.disable()
+  })
+
+  return true
+}
+
+function getStandardHooks(segmentMap, agent, shim) {
+  const hooks = {
     init: function initHook(id, type, triggerId, promiseWrap) {
-      var transaction = agent.getTransaction()
-      var parentSegment = segmentMap.get(triggerId)
+      if (type !== 'PROMISE') {
+        return
+      }
+
+      const parentSegment = segmentMap.get(triggerId)
 
-      if (!parentSegment && !transaction || type !== 'PROMISE') {
+      if (parentSegment && !parentSegment.transaction.isActive()) {
+        // Stop propagating if the transaction was ended.
         return
       }
 
-      var activeSegment = shim.getActiveSegment() || parentSegment
+      if (!parentSegment && !agent.getTransaction()) {
+        return
+      }
+
+      const activeSegment = shim.getActiveSegment() || parentSegment
       if (promiseWrap && promiseWrap.promise) {
         promiseWrap.promise.__NR_id = id
       }
@@ -70,7 +96,7 @@ function tryAsyncHooks(agent, shim) {
     },
 
     before: function beforeHook(id) {
-      var hookSegment = segmentMap.get(id)
+      const hookSegment = segmentMap.get(id)
 
       if (!hookSegment) {
         return
@@ -80,7 +106,7 @@ function tryAsyncHooks(agent, shim) {
       shim.setActiveSegment(hookSegment)
     },
     after: function afterHook(id) {
-      var hookSegment = segmentMap.get(id)
+      const hookSegment = segmentMap.get(id)
 
       // hookSegment is the segment that was active before the promise
       // executed. If the promise is executing before a segment has been
@@ -96,11 +122,72 @@ function tryAsyncHooks(agent, shim) {
     destroy: function destHook(id) {
       segmentMap.delete(id)
     }
-  }).enable()
+  }
 
-  agent.on('unload', function disableHook() {
-    hook.disable()
-  })
+  return hooks
+}
 
-  return true
+function getPromiseResolveStyleHooks(segmentMap, agent, shim) {
+  const hooks = {
+    init: function initHook(id, type, triggerId, asyncResource) {
+      if (type !== 'PROMISE') {
+        return
+      }
+
+      let parentSegment = segmentMap.get(triggerId)
+
+      if (parentSegment && !parentSegment.transaction.isActive()) {
+        // Stop propagating if the transaction was ended.
+        return
+      }
+
+      if (!parentSegment && !agent.getTransaction()) {
+        return
+      }
+
+      const activeSegment = shim.getActiveSegment() || parentSegment
+      if (asyncResource && asyncResource.promise) {
+        asyncResource.promise.__NR_id = id
+      }
+
+      segmentMap.set(id, activeSegment)
+    },
+
+    before: function beforeHook(id) {
+      const hookSegment = segmentMap.get(id)
+
+      if (!hookSegment) {
+        return
+      }
+
+      segmentMap.set(id, shim.getActiveSegment())
+      shim.setActiveSegment(hookSegment)
+    },
+    after: function afterHook(id) {
+      const hookSegment = segmentMap.get(id)
+
+      // hookSegment is the segment that was active before the promise
+      // executed. If the promise is executing before a segment has been
+      // restored, hookSegment will be null and should be restored. Thus
+      // undefined is the only invalid value here.
+      if (hookSegment === undefined) {
+        return
+      }
+
+      segmentMap.set(id, shim.getActiveSegment())
+      shim.setActiveSegment(hookSegment)
+    },
+    promiseResolve: function promiseResolveHandler(id) {
+      const hookSegment = segmentMap.get(id)
+      segmentMap.delete(id)
+
+      if (hookSegment === undefined) {
+        return
+      }
+
+      shim.setActiveSegment(hookSegment)
+    }
+  }
+
+  return hooks
 }

package/lib/instrumentation/core/http.js

@@ -267,6 +267,11 @@ function wrapResponseEnd(agent, proto) {
         return end.apply(this, arguments)
       }
 
+      if (!txInfo.transaction.isActive()) {
+        logger.trace('wrappedResEnd invoked for ended transaction implying multiple invocations.')
+        return end.apply(this, arguments)
+      }
+
       // If an error happened, add it to the aggregator.
       if (txInfo.error) {
         if (!txInfo.errorHandled || urltils.isError(agent.config, this.statusCode)) {

package/lib/instrumentation/core/timers.js

@@ -61,7 +61,12 @@ function initialize(agent, timers, moduleName, shim) {
 
   function wrapSetImmediate(shim, fn) {
     return function wrappedSetImmediate() {
-      const args = shim.argsToArray.apply(shim, arguments)
+      const segment = shim.getActiveSegment()
+      if (!segment) {
+        return fn.apply(this, arguments)
+      }
+
+      const args = shim.argsToArray.apply(shim, arguments, segment)
       shim.bindSegment(args, shim.FIRST)
 
       return fn.apply(this, args)

package/lib/metrics/names.js

@@ -22,7 +22,8 @@ const SUPPORTABILITY = {
   NODEJS: 'Supportability/Nodejs',
   REGISTRATION: 'Supportability/Registration',
   EVENT_HARVEST: 'Supportability/EventHarvest',
-  INFINITE_TRACING: 'Supportability/InfiniteTracing'
+  INFINITE_TRACING: 'Supportability/InfiniteTracing',
+  FEATURES: 'Supportability/Features'
 }
 
 const ERRORS = {
@@ -249,6 +250,10 @@ const INFINITE_TRACING = {
   DRAIN_DURATION: SUPPORTABILITY.INFINITE_TRACING + '/Drain/Duration',
 }
 
+const FEATURES = {
+  CERTIFICATES: SUPPORTABILITY.FEATURES + '/Certificates'
+}
+
 module.exports = {
   ACTION_DELIMITER: '/',
   ALL: ALL,
@@ -266,6 +271,7 @@ module.exports = {
   EVENT_HARVEST: EVENT_HARVEST,
   EXPRESS: EXPRESS,
   EXTERNAL: EXTERNAL,
+  FEATURES,
   FS: FS,
   FUNCTION: FUNCTION,
   GC: GC,

package/lib/shim/shim.js

@@ -1895,7 +1895,12 @@ function shimRequire(filePath) {
   try {
     return require(path.resolve(this._moduleRoot, filePath))
   } catch (e) {
-    this.logger.debug('Failed to load %j: %s', filePath, e.stack)
+    this.logger.debug(
+      'Failed to load \'%s\' from module root: \'%s\'. Stack: %s',
+      filePath,
+      this._moduleRoot,
+      e.stack
+    )
     return null
   }
 }

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

@@ -72,6 +72,7 @@ function createStandardAggregator(config, collector, metrics) {
 }
 
 function validateInfiniteTracing(trace_observer) {
+  // TODO: Remove semver check when Node 10 support dropped.
   if (!psemver.satisfies('>=10.10.0')) {
     logger.warn(
       'Infinite tracing disabled: this version of Node is not supported (must be >=10.10.0)'

package/lib/spans/span-event.js

@@ -9,7 +9,7 @@ const Config = require('../config')
 const {truncate} = require('../util/byte-limit')
 
 const {DESTINATIONS} = require('../config/attribute-filter')
-const NAMES = require('../metrics/names')
+
 const HTTP_LIBRARY = 'http'
 const CLIENT_KIND = 'client'
 const CATEGORIES = {
@@ -18,6 +18,9 @@ const CATEGORIES = {
   GENERIC: 'generic'
 }
 
+const EXTERNAL_REGEX = /^(?:Truncated\/)?External\//
+const DATASTORE_REGEX = /^(?:Truncated\/)?Datastore\//
+
 const EMPTY_USER_ATTRS = Object.freeze(Object.create(null))
 
 /**
@@ -200,7 +203,7 @@ class HttpSpanEvent extends SpanEvent {
   }
 
   static testSegment(segment) {
-    return segment.name.startsWith(NAMES.EXTERNAL.PREFIX)
+    return EXTERNAL_REGEX.test(segment.name)
   }
 }
 
@@ -259,7 +262,7 @@ class DatastoreSpanEvent extends SpanEvent {
   }
 
   static testSegment(segment) {
-    return segment.name.startsWith(NAMES.DB.PREFIX)
+    return DATASTORE_REGEX.test(segment.name)
   }
 }
 

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

@@ -10,7 +10,7 @@ const {truncate} = require('../util/byte-limit')
 const Config = require('../config')
 
 const {DESTINATIONS} = require('../config/attribute-filter')
-const NAMES = require('../metrics/names')
+
 const HTTP_LIBRARY = 'http'
 const CLIENT_KIND = 'client'
 const CATEGORIES = {
@@ -19,6 +19,9 @@ const CATEGORIES = {
   GENERIC: 'generic'
 }
 
+const EXTERNAL_REGEX = /^(?:Truncated\/)?External\//
+const DATASTORE_REGEX = /^(?:Truncated\/)?Datastore\//
+
 /**
  * Specialized span event class for use with infinite streaming.
  * Currently designed to be sent over grpc via the v1.proto definition.
@@ -200,7 +203,7 @@ class StreamingHttpSpanEvent extends StreamingSpanEvent {
   }
 
   static isHttpSegment(segment) {
-    return segment.name.startsWith(NAMES.EXTERNAL.PREFIX)
+    return EXTERNAL_REGEX.test(segment.name)
   }
 }
 
@@ -269,7 +272,7 @@ class StreamingDatastoreSpanEvent extends StreamingSpanEvent {
   }
 
   static isDatastoreSegment(segment) {
-    return segment.name.startsWith(NAMES.DB.PREFIX)
+    return DATASTORE_REGEX.test(segment.name)
   }
 }
 

package/lib/transaction/index.js

@@ -225,9 +225,28 @@ Transaction.prototype.end = function end() {
   }
 
   this.agent.emit('transactionFinished', this)
+
+  // Do after emit so all post-processing can complete
+  this._cleanUneededReferences()
+
   return this
 }
 
+/**
+ * Cleans up references that will not be used later for processing such as
+ * transaction traces.
+ *
+ * Errors won't be needed for later processing but can contain extra details we
+ * don't want to hold in memory. Particularly, axios errors can result in indirect
+ * references to promises which will prevent them from being destroyed and result
+ * in a memory leak. This is due to the TraceSegment not getting removed from the
+ * async-hooks segmentMap because 'destroy' never fires.
+ */
+Transaction.prototype._cleanUneededReferences = function _cleanUneededReferences() {
+  this.userErrors = null
+  this.exceptions = null
+}
+
 /**
  * For web transactions, this represents the time from when the request was received
  * to when response was sent.  For background transactions, it is equal to duration
@@ -768,6 +787,11 @@ function _linkExceptionToSegment(exception) {
 Transaction.prototype.addException = _addException
 
 function _addException(exception) {
+  if (!this.isActive()) {
+    logger.trace('Transaction is not active. Not capturing error: ', exception)
+    return
+  }
+
   this._linkExceptionToSegment(exception)
   this.exceptions.push(exception)
 }
@@ -782,6 +806,11 @@ function _addException(exception) {
 Transaction.prototype.addUserError = _addUserError
 
 function _addUserError(exception) {
+  if (!this.isActive()) {
+    logger.trace('Transaction is not active. Not capturing user error: ', exception)
+    return
+  }
+
   this._linkExceptionToSegment(exception)
   this.userErrors.push(exception)
 }
@@ -879,6 +908,13 @@ Transaction.prototype.getIntrinsicAttributes = function getIntrinsicAttributes()
  */
 Transaction.prototype.acceptDistributedTraceHeaders = acceptDistributedTraceHeaders
 function acceptDistributedTraceHeaders(transportType, headers) {
+  if (headers == null || typeof headers !== 'object') {
+    logger.trace(
+      'Ignoring distributed trace headers for transaction %s. Headers not passed in as object.',
+      this.id)
+    return
+  }
+
   const transport = TRANSPORT_TYPES_SET[transportType] ? transportType : TRANSPORT_TYPES.UNKNOWN
 
   // assumes header keys already lowercase

package/newrelic.js

@@ -28,7 +28,7 @@ exports.config = {
      *
      * @env NEW_RELIC_DISTRIBUTED_TRACING_ENABLED
      */
-    enabled: false
+    enabled: true
   },
   logging: {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "7.1.2",
+  "version": "7.3.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [
@@ -125,7 +125,7 @@
     "docs": "npm ci && jsdoc -c ./jsdoc-conf.json --private -r .",
     "integration": "npm run prepare-test && npm run sub-install && time tap --no-esm test/integration/**/**/*.tap.js --timeout=180 --no-coverage",
     "prepare-test": "npm ci && npm run ca-gen && npm run ssl && npm run docker-env",
-    "lint": "eslint ./*.js lib test",
+    "lint": "eslint ./*.js lib test bin",
     "public-docs": "npm ci && jsdoc -c ./jsdoc-conf.json --tutorials examples/shim api.js lib/shim/ lib/transaction/handle.js && cp examples/shim/*.png out/",
     "publish-docs": "./bin/publish-docs.sh",
     "services": "./bin/docker-services.sh",
@@ -137,15 +137,14 @@
     "update-cross-agent-tests": "./bin/update-cats.sh",
     "versioned-tests": "./bin/run-versioned-tests.sh",
     "update-changelog-version": "node ./bin/update-changelog-version",
-    "versioned": "npm run prepare-test && time ./bin/run-versioned-tests.sh",
-    "version": "npm run update-changelog-version && git add ./NEWS.md"
+    "versioned": "npm run prepare-test && time ./bin/run-versioned-tests.sh"
   },
   "bin": {
     "newrelic-naming-rules": "./bin/test-naming-rules.js"
   },
   "dependencies": {
-    "@grpc/grpc-js": "^1.2.5",
-    "@grpc/proto-loader": "^0.5.5",
+    "@grpc/grpc-js": "^1.2.11",
+    "@grpc/proto-loader": "^0.5.6",
     "@newrelic/aws-sdk": "^3.1.0",
     "@newrelic/koa": "^5.0.0",
     "@newrelic/superagent": "^4.0.0",
@@ -199,5 +198,18 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/newrelic/node-newrelic.git"
-  }
+  },
+  "files": [
+    "index.js",
+    "api.js",
+    "stub_api.js",
+    "newrelic.js",
+    "README.md",
+    "LICENSE",
+    "NEWS.md",
+    "THIRD_PARTY_NOTICES.md",
+    "lib/",
+    "bin/tracetractor",
+    "bin/test-naming-rules.js"
+  ]
 }

package/CONTRIBUTING.md

@@ -1,135 +0,0 @@
-# Guidelines for Contributing Code
-
-New Relic welcomes code contributions by the Node community to this module, and
-have taken effort to make this process easy for both contributors and our
-development team.
-
-## Process
-
-### Feature Requests
-
-Feature requests should be submitted in the [Issue tracker](../../issues), with
-a description of the expected behavior & use case. Before submitting an Issue,
-please search for similar ones in the [closed
-issues](../../issues?q=is%3Aissue+is%3Aclosed+label%3Aenhancement).
-
-### Pull Requests
-
-We can only accept PRs for version v6.11.0 or greater due to open source
-licensing restrictions.
-
-### Code of Conduct
-
-Before contributing please read the [code of conduct](https://github.com/newrelic/.github/blob/main/CODE_OF_CONDUCT.md)
-
-Note that our [code of conduct](https://github.com/newrelic/.github/blob/main/CODE_OF_CONDUCT.md) applies to all platforms
-and venues related to this project; please follow it in all your interactions
-with the project and its participants.
-
-### Contributor License Agreement
-
-Keep in mind that when you submit your Pull Request, you'll need to sign the
-CLA via the click-through using CLA-Assistant. If you'd like to execute our
-corporate CLA, or if you have any questions, please drop us an email at
-opensource@newrelic.com.
-
-For more information about CLAs, please check out Alex Russell’s excellent
-post, [“Why Do I Need to Sign
-This?”](https://infrequently.org/2008/06/why-do-i-need-to-sign-this/).
-
-### Slack
-
-We host a public Slack with a dedicated channel for contributors and
-maintainers of open source projects hosted by New Relic. If you are
-contributing to this project, you're welcome to request access to the
-\#oss-contributors channel in the newrelicusers.slack.com workspace. To request
-access, see https://newrelicusers-signup.herokuapp.com/.
-
-## PR Guidelines
-
-### Version Support
-
-When contributing, keep in mind that New Relic customers (that's you!) are running many different versions of Node, some of them pretty old. Changes that depend on the newest version of Node will probably be rejected, especially if they replace something backwards compatible.
-
-Be aware that the instrumentation needs to work with a wide range of versions of the instrumented modules, and that code that looks nonsensical or overcomplicated may be that way for compatibility-related reasons. Read all the comments and check the related tests before deciding whether existing code is incorrect.
-
-If you’re planning on contributing a new feature or an otherwise complex contribution, we kindly ask you to start a conversation with the maintainer team by opening up an Github issue first.
-
-### General Guidelines
-
-In general, we try to limit adding third-party production dependencies. If one is necessary, please be prepared to make a clear case for the need.
-
-### Coding Style Guidelines/Conventions
-
-We use eslint to enforce certain coding standards. Please see our [.eslintrc](./.eslintrc.js) file for specific rule configuration.
-
-### Testing Guidelines
-
-The agent includes a suite of unit and functional tests which should be used to
-verify your changes don't break existing functionality.
-
-Unit tests are stored in `test/`. They're written in
-[node-tap](https://github.com/isaacs/node-tap), and have the extension `.test.js`.
-
-Generic functional tests are stored in `test/integration/`. They're written in
-[node-tap](https://github.com/isaacs/node-tap), and have the extension
-`.tap.js`.
-
-Functional tests against specific versions of instrumented modules are stored
-in `test/versioned/`. They are also written in `node-tap`.
-
-#### Setup
-
-To run the tests you need an openssl command-line binary, and some services:
-
-* Cassandra
-* Memcached
-* MongoDB
-* MySQL
-* Postgres
-* Redis
-
-If you have these all running locally on the standard ports, then you are good
-to go. However, the suggested path is to use [Docker](http://www.docker.com).
-If you use macOS or Windows, install [Docker Desktop]
-(https://www.docker.com/products/docker-desktop). Then, run `npm run services`
-to download and launch docker containers for each of the above services.
-
-If you have these services available on non-standard ports or elsewhere on your
-network, you can use the following environment variables to tell the tests
-where they are:
-
-* NR_NODE\_TEST_<service>\_HOST
-* NR_NODE\_TEST_<service>\_PORT
-
-The service token is the all-caps version of the service name listed above.
-
-#### Running Tests
-
-Running the test suite is simple. Just run:
-
-    npm test
-
-This will install all the necessary modules (and do any required SSL
-certificate creation) and run the unit tests in standalone mode, followed by
-the functional tests if all of the unit tests pass.
-
-If you don't feel like dealing with the hassle of setting up the servers, just
-the unit tests can be run with:
-
-    npm run unit
-
-#### Writing Tests
-
-For most contributions it is strongly recommended to add additional tests which
-exercise your changes. This helps us efficiently incorporate your changes into
-our mainline codebase and provides a safeguard that your change won't be broken
-by future development. Because of this, we require that all changes come with
-tests. You are welcome to submit pull requests with untested changes, but they
-won't be merged until you or the development team have an opportunity to write
-tests for them.
-
-There are some rare cases where code changes do not result in changed
-functionality (e.g. a performance optimization) and new tests are not required.
-In general, including tests with your pull request dramatically increases the
-chances it will be accepted.