fix: exit process on unhandledRejection (#950)

honeybadger-io · Nov 26, 2022 · ffff051 · ffff051
1 parent 2a4dd4e
commit ffff051
Show file tree

Hide file tree

Showing 4 changed files with 81 additions and 19 deletions.
diff --git a/packages/js/rollup.config.js b/packages/js/rollup.config.js
@@ -45,7 +45,8 @@ export default [
     external: ['http', 'https', 'url', 'os', 'fs', 'util', 'domain', 'async_hooks'],
     output: {
       file: pkg.main,
-      format: 'cjs'
+      format: 'cjs',
+      sourcemap: true
     },
     plugins: sharedPlugins
   }

diff --git a/packages/js/src/server/integrations/uncaught_exception.ts b/packages/js/src/server/integrations/uncaught_exception.ts
@@ -3,7 +3,8 @@ import { fatallyLogAndExit } from '../util'
 import Client from '../../server'
 import { removeAwsDefaultUncaughtExceptionListener } from '../aws_lambda'
 
-let count = 0
+let isReporting = false
+let handlerAlreadyCalled = false
 
 function removeAwsLambdaListener() {
   const isLambda = !!process.env.LAMBDA_TASK_ROOT
@@ -14,28 +15,58 @@ function removeAwsLambdaListener() {
   removeAwsDefaultUncaughtExceptionListener()
 }
 
+/**
+ * If there are no other uncaughtException listeners,
+ * we want to report the exception to Honeybadger and
+ * mimic the default behavior of NodeJs,
+ * which is to exit the process with code 1
+ */
+function hasOtherUncaughtExceptionListeners() {
+  return process.listeners('uncaughtException').length > 1
+}
+
 export default function (): Types.Plugin {
   return {
     load: (client: typeof Client) => {
-      if (!client.config.enableUncaught) { return }
+      if (!client.config.enableUncaught) {
+        return
+      }
 
       removeAwsLambdaListener()
 
+
       process.on('uncaughtException', function honeybadgerUncaughtExceptionListener(uncaughtError) {
-        // Prevent recursive errors
-        if (count > 1) { fatallyLogAndExit(uncaughtError) }
-
-        if (client.config.enableUncaught) {
-          client.notify(uncaughtError, {
-            afterNotify: (_err, _notice) => {
-              count += 1
-              client.config.afterUncaught(uncaughtError)
-            }
-          })
-        } else {
-          count += 1
+        if (!client.config.enableUncaught) {
           client.config.afterUncaught(uncaughtError)
+          if (!hasOtherUncaughtExceptionListeners()) {
+            fatallyLogAndExit(uncaughtError)
+          }
+          return
+        }
+
+        // report only the first error - prevent reporting recursive errors
+        if (handlerAlreadyCalled) {
+          if (!hasOtherUncaughtExceptionListeners()) {
+            fatallyLogAndExit(uncaughtError)
+          }
+          return
+        }
+
+        if (isReporting) {
+          return
         }
+
+        isReporting = true
+        client.notify(uncaughtError, {
+          afterNotify: (_err, _notice) => {
+            isReporting = false
+            handlerAlreadyCalled = true
+            client.config.afterUncaught(uncaughtError)
+            if (!hasOtherUncaughtExceptionListeners()) {
+              fatallyLogAndExit(uncaughtError)
+            }
+          }
+        })
       })
     }
   }

diff --git a/packages/js/src/server/integrations/unhandled_rejection.ts b/packages/js/src/server/integrations/unhandled_rejection.ts
@@ -1,14 +1,43 @@
 import { Types } from '@honeybadger-io/core'
 import Client from '../../server'
+import { fatallyLogAndExit } from '../util'
+
+let isReporting = false
+
+/**
+ * If there are no other unhandledRejection listeners,
+ * we want to report the exception to Honeybadger and
+ * mimic the default behavior of NodeJs,
+ * which is to exit the process with code 1
+ */
+function hasOtherUnhandledRejectionListeners() {
+  return process.listeners('unhandledRejection').length > 1
+}
 
 export default function (): Types.Plugin {
   return {
     load: (client: typeof Client) => {
-      if (!client.config.enableUnhandledRejection) { return }
+      if (!client.config.enableUnhandledRejection) {
+        return
+      }
+
+      process.on('unhandledRejection', function honeybadgerUnhandledRejectionListener(reason, _promise) {
+        if (!client.config.enableUnhandledRejection) {
+          if (!hasOtherUnhandledRejectionListeners() && !isReporting) {
+            fatallyLogAndExit(reason as Error)
+          }
+          return
+        }
 
-      process.on('unhandledRejection', function (reason, _promise) {
-        if (!client.config.enableUnhandledRejection) { return }
-        client.notify(reason as Types.Noticeable, { component: 'unhandledRejection' })
+        isReporting = true;
+        client.notify(reason as Types.Noticeable, { component: 'unhandledRejection' }, {
+          afterNotify: () => {
+            isReporting = false;
+            if (!hasOtherUnhandledRejectionListeners()) {
+              fatallyLogAndExit(reason as Error)
+            }
+          }
+        })
       })
     }
   }

diff --git a/tsconfig.base.json b/tsconfig.base.json
@@ -7,6 +7,7 @@
     "noImplicitAny": false,
     "declaration": true,
     "declarationMap": true,
+    "sourceMap": true,
     "stripInternal": true,
     "skipLibCheck": true
   }