feat: flush events on process exit (#1430)

Author: subzero10

packages/core/src/client.ts

@@ -325,6 +325,14 @@ export abstract class Client {
  })
  }
 
+ /**
+ * This method currently flushes the event (Insights) queue.
+ * In the future, it should also flush the error queue (assuming an error throttler is implemented).
+ */
+ flushAsync(): Promise<void> {
+ return this.__eventsLogger.flushAsync();
+ }
+
  __getBreadcrumbs() {
  return this.__store.getContents('breadcrumbs').slice()
  }

packages/core/src/throttled_events_logger.ts

@@ -30,17 +30,19 @@ export class ThrottledEventsLogger implements EventsLogger {
  }
  }
 
+ flushAsync(): Promise<void> {
+ this.logger.debug('[Honeybadger] Flushing events')
+ return this.send();
+ }
+
  private processQueue() {
  if (this.queue.length === 0 || this.isProcessing) {
  return
  }
 
  this.isProcessing = true
- const eventsData = this.queue.slice()
- this.queue = []
 
- const data = NdJson.stringify(eventsData)
- this.makeHttpRequest(data)
+ this.send()
  .then(() => {
  setTimeout(() => {
  this.isProcessing = false
@@ -57,6 +59,18 @@ export class ThrottledEventsLogger implements EventsLogger {
  })
  }
 
+ private async send(): Promise<void> {
+ if (this.queue.length === 0) {
+ return;
+ }
+
+ const eventsData = this.queue.slice()
+ this.queue = []
+
+ const data = NdJson.stringify(eventsData)
+ return this.makeHttpRequest(data)
+ }
+
  private async makeHttpRequest(data: string): Promise<void> {
  return this.transport
  .send({

packages/core/src/types.ts

@@ -11,6 +11,7 @@ export interface Logger {
 export interface EventsLogger {
  configure: (opts: Partial<Config>) => void
  log(data: EventPayload): void
+ flushAsync(): Promise<void>
 }
 
 export type EventPayload = {

packages/js/src/server.ts

@@ -4,6 +4,7 @@ import { Client, Util, Types, Plugins as CorePlugins } from '@honeybadger-io/cor
 import { getSourceFile, readConfigFromFileSystem } from './server/util'
 import uncaughtException from './server/integrations/uncaught_exception_plugin'
 import unhandledRejection from './server/integrations/unhandled_rejection_plugin'
+import shutdown from './server/integrations/shutdown_plugin'
 import { errorHandler, requestHandler } from './server/middleware'
 import { lambdaHandler } from './server/aws_lambda'
 import { ServerTransport } from './server/transport'
@@ -15,6 +16,7 @@ const { endpoint } = Util
 const DEFAULT_PLUGINS = [
  uncaughtException(),
  unhandledRejection(),
+ shutdown(),
  CorePlugins.events(),
 ]
 

packages/js/src/server/integrations/shutdown_monitor.ts

@@ -0,0 +1,70 @@
+import Client from '../../server'
+import { fatallyLogAndExitGracefully } from '../util'
+
+export default class ShutdownMonitor {
+
+ // SIGTERM is raised by AWS Lambda when the function is being shut down
+ // SIGINT is raised by the user pressing CTRL+C
+ private static KILL_SIGNALS = ['SIGTERM', 'SIGINT'] as const
+
+ protected __isReporting: boolean
+ protected __client: typeof Client
+ protected __listener: (signal: string) => void
+
+ constructor() {
+ this.__isReporting = false
+ this.__listener = this.makeListener()
+ }
+
+ setClient(client: typeof Client) {
+ this.__client = client
+ }
+
+ makeListener() {
+ // noinspection UnnecessaryLocalVariableJS
+ const honeybadgerShutdownListener = async (signal: NodeJS.Signals) => {
+ if (this.__isReporting || !this.__client) {
+ return
+ }
+
+ this.__isReporting = true
+
+ await this.__client.flushAsync()
+
+ this.__isReporting = false
+
+ if (!this.hasOtherShutdownListeners(signal)) {
+ fatallyLogAndExitGracefully(signal)
+ }
+ }
+
+ return honeybadgerShutdownListener
+ }
+
+ maybeAddListener() {
+ for (const signal of ShutdownMonitor.KILL_SIGNALS) {
+ const signalListeners = process.listeners(signal);
+ if (!signalListeners.includes(this.__listener)) {
+ process.on(signal, this.__listener)
+ }
+ }
+ }
+
+ maybeRemoveListener() {
+ for (const signal of ShutdownMonitor.KILL_SIGNALS) {
+ const signalListeners = process.listeners(signal);
+ if (signalListeners.includes(this.__listener)) {
+ process.removeListener(signal, this.__listener)
+ }
+ }
+ }
+
+ hasOtherShutdownListeners(signal: NodeJS.Signals) {
+ const otherListeners = process
+ .listeners(signal)
+ .filter(listener => listener !== this.__listener)
+
+ return otherListeners.length > 0;
+
+ }
+}

packages/js/src/server/integrations/shutdown_plugin.ts

@@ -0,0 +1,21 @@
+import { Types } from '@honeybadger-io/core'
+import Client from '../../server'
+import ShutdownMonitor from './shutdown_monitor'
+
+const shutdownMonitor = new ShutdownMonitor()
+
+export default function (): Types.Plugin {
+ return {
+ load: (client: typeof Client) => {
+ shutdownMonitor.setClient(client)
+ // at the moment, the shutdown monitor only sends events from the queue
+ // if we implement a queue for throttling errors, we won't have to check for `config.eventsEnabled`
+ if (client.config.eventsEnabled) {
+ shutdownMonitor.maybeAddListener()
+ } else {
+ shutdownMonitor.maybeRemoveListener()
+ }
+ },
+ shouldReloadOnConfigure: true,
+ }
+}

packages/js/src/server/integrations/uncaught_exception_monitor.ts

@@ -20,6 +20,7 @@ export default class UncaughtExceptionMonitor {
  }
 
  makeListener() {
+ // noinspection UnnecessaryLocalVariableJS
  const honeybadgerUncaughtExceptionListener = (uncaughtError: Error) => {
  if (this.__isReporting || !this.__client) { return }
 

packages/js/src/server/integrations/unhandled_rejection_monitor.ts

@@ -17,6 +17,7 @@ export default class UnhandledRejectionMonitor {
  }
 
  makeListener() {
+ // noinspection UnnecessaryLocalVariableJS
  const honeybadgerUnhandledRejectionListener = (reason: unknown, _promise: Promise<unknown>) => {
  this.__isReporting = true;
  this.__client.notify(reason as Types.Noticeable, { component: 'unhandledRejection' }, {

packages/js/src/server/util.ts

@@ -6,6 +6,11 @@ import { promisify } from 'util'
 
 const readFile = promisify(fs.readFile)
 
+export function fatallyLogAndExitGracefully(signal: NodeJS.Signals): never {
+ console.log(`[Honeybadger] Received ${signal}, exiting immediately`)
+ process.exit()
+}
+
 export function fatallyLogAndExit(err: Error, source: string): never {
  console.error(`[Honeybadger] Exiting process due to ${source}`)
  console.error(err.stack || err)

packages/js/test/e2e/playwright.config.ts

@@ -15,7 +15,7 @@ export default defineConfig({
  forbidOnly: !!process.env.CI,
  /* Retry on CI only */
  retries: process.env.CI ? 2 : 0,
- workers: 8,
+ workers: 4,
  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
  reporter: [
  [process.env.CI ? 'github' : 'list'],