newrelic 7.2.1 → 7.3.0

package/NEWS.md

@@ -1,3 +1,15 @@
+### v7.3.0 (2021-04-06)
+
+* Added new feature-flag 'new_promise_tracking' which enables cleaning up of segment references on native promise resolve instead of destroy. Includes usage of async-await. This can be enabled via `feature_flag: { new_promise_tracking: true }` in the config file or `NEW_RELIC_FEATURE_FLAG_NEW_PROMISE_TRACKING=1` in your ENV vars.
+
+  Applications with heavy promise usage or high-throughput applications with some promise usage should see moderate to high reduction in memory usage and may see a slight reduction in CPU usage. A bump in throughput may also be noticed in some cases. Results will vary by application.
+  
+  If you are experiencing high overhead levels with your promise usage and the agent attached, we recommend testing your application with  'new_promise_tracking' set to true to see if overhead is reduced. You'll also want to verify your data is still being captured correctly in case it falls into a known or unknown limitation of this approach.  **NOTE: chaining of promise continuations onto an already resolved promise across an async hop (scheduled timer) will result in state-loss with this new functionality turned on. This is a less-common use-case but worth considering with your applications.**
+
+* Fixed memory leak introduced when Infinite Tracing is enabled.
+
+  When Infinite Tracing endpoints reconnected they would instantiate a new gRPC client prior to calling `client.recordSpan()`. It appears several objects created by grpc-js (`ChannelImplementation` and child objects, promises, etc.) are held in memory indefinitely due to scheduled timers even when the client is no-longer referenced and the associated stream closed. We now avoid this situation by only creating the client once and then reusing it to establish new stream connections.
+
 ### v7.2.1 (2021-03-29)
 
 * Dev-only sub-dependency bump of 'y18n' to clear npm audit warnings.

package/lib/feature_flags.js

@@ -15,7 +15,8 @@ exports.prerelease = {
   fastify_instrumentation: false,
   // Starts by defaulting true as introducing for deprecation/removal purposes.
   // Will eventually set false prior full removal of feature.
-  certificate_bundle: true
+  certificate_bundle: true,
+  new_promise_tracking: false
 }
 
 // flags that are no longer used for released features

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) {
@@ -53,7 +53,25 @@ function tryAsyncHooks(agent, shim) {
   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) {
       if (type !== 'PROMISE') {
         return
@@ -78,7 +96,7 @@ function tryAsyncHooks(agent, shim) {
     },
 
     before: function beforeHook(id) {
-      var hookSegment = segmentMap.get(id)
+      const hookSegment = segmentMap.get(id)
 
       if (!hookSegment) {
         return
@@ -88,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
@@ -104,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newrelic",
-  "version": "7.2.1",
+  "version": "7.3.0",
   "author": "New Relic Node.js agent team <nodejs@newrelic.com>",
   "license": "Apache-2.0",
   "contributors": [