Clears error collections on transaction end after processing.

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)) {

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)
 }

test/unit/transaction.test.js

@@ -1555,6 +1555,64 @@ describe('Transaction', function() {
   })
 })
 
+tap.test('transaction end', (t) => {
+  t.autoend()
+
+  let agent = null
+  let transaction = null
+
+  t.beforeEach((done) => {
+    agent = helper.loadMockedAgent({
+      attributes: {
+        enabled: true,
+        include: ['request.parameters.*']
+      },
+      distributed_tracing: {
+        enabled: true
+      }
+    })
+
+    transaction = new Transaction(agent)
+
+    done()
+  })
+
+  t.afterEach((done) => {
+    helper.unloadAgent(agent)
+
+    agent = null
+    transaction = null
+
+    done()
+  })
+
+  t.test('should clear errors', (t) => {
+    transaction.userErrors.push(new Error('user sadness'))
+    transaction.exceptions.push(new Error('things went bad'))
+
+    transaction.end()
+
+    t.equal(transaction.userErrors, null)
+    t.equal(transaction.exceptions, null)
+
+    t.end()
+  })
+
+  t.test('should not clear errors until after transactionFinished event', (t) => {
+    transaction.userErrors.push(new Error('user sadness'))
+    transaction.exceptions.push(new Error('things went bad'))
+
+    agent.on('transactionFinished', (endedTransaction) => {
+      t.equal(endedTransaction.userErrors.length, 1)
+      t.equal(endedTransaction.exceptions.length, 1)
+
+      t.end()
+    })
+
+    transaction.end()
+  })
+})
+
 tap.test('when being named with finalizeNameFromUri', (t) => {
   t.autoend()