feat: allow async beforeNotify functions to modify the notice object

packages/core/src/client.ts

@@ -166,8 +166,10 @@ export abstract class Client {
     // in case they modify them
     const sourceCodeData = notice && notice.backtrace ? notice.backtrace.map(trace => shallowClone(trace) as BacktraceFrame) : null
     const beforeNotifyResult = runBeforeNotifyHandlers(notice, this.__beforeNotifyHandlers)
-    if (!preConditionError && !beforeNotifyResult) {
-      this.logger.debug('skipping error report: beforeNotify handlers returned false', notice)
+
+
+    if (!preConditionError && !beforeNotifyResult.result) {
+      this.logger.debug('skipping error report: one or more beforeNotify handlers returned false', notice)
       preConditionError = new Error('beforeNotify handlers returned false')
     }
 
@@ -189,11 +191,13 @@ export abstract class Client {
     notice.__breadcrumbs = this.config.breadcrumbsEnabled ? breadcrumbs : []
 
     getSourceForBacktrace(sourceCodeData, this.__getSourceFileHandler)
-      .then(sourcePerTrace => {
+      .then(async (sourcePerTrace) => {
         sourcePerTrace.forEach((source, index) => {
           notice.backtrace[index].source = source
         })
 
+        // Make sure all of our promises have finished before sending the payload.
+        await Promise.allSettled(beforeNotifyResult.results)
         const payload = this.__buildPayload(notice)
         this.__transport
           .send({
@@ -223,7 +227,7 @@ export abstract class Client {
             this.logger.error('Error report failed: an unknown error occurred.', `message=${err.message}`)
             runAfterNotifyHandlers(notice, this.__afterNotifyHandlers, err)
           })
-      })
+        })
 
     return true
   }

packages/core/src/types.ts

@@ -38,7 +38,7 @@ export interface ServerlessConfig extends Config {
 }
 
 export interface BeforeNotifyHandler {
-  (notice?: Notice): boolean | void
+  (notice?: Notice): boolean | void | Promise<boolean | void>
 }
 
 export interface AfterNotifyHandler {

packages/core/src/util.ts

@@ -95,15 +95,25 @@ export async function getSourceForBacktrace(backtrace: BacktraceFrame[],
   return result
 }
 
-export function runBeforeNotifyHandlers(notice: Notice | null, handlers: BeforeNotifyHandler[]): boolean {
+export function runBeforeNotifyHandlers(notice: Notice | null, handlers: BeforeNotifyHandler[]): { results: ReturnType<BeforeNotifyHandler>[], result: boolean } {
+  const results: ReturnType<BeforeNotifyHandler>[] = []
   let result = true
   for (let i = 0, len = handlers.length; i < len; i++) {
     const handler = handlers[i]
-    if (handler(notice) === false) {
+
+    const handlerResult = handler(notice)
+
+    if (handlerResult === false) {
       result = false
     }
+
+    results.push(handlerResult)
+  }
+
+  return {
+    results,
+    result
   }
-  return result
 }
 
 export function runAfterNotifyHandlers(notice: Notice | null, handlers: AfterNotifyHandler[], error?: Error): boolean {

packages/core/test/client.test.ts

@@ -597,6 +597,56 @@ describe('client', function () {
         client.notify('should not report')
       })
     })
+
+    it('modifies the notice when an async function is provided', function () {
+      const funkyName = 'My funky name'
+
+      client.beforeNotify(async (notice) => {
+        const modifyName = () => new Promise<void>((resolve) => {
+          setTimeout(() => {
+            notice.name = funkyName
+            resolve()
+          })
+        })
+
+
+        await modifyName()
+      })
+
+      return new Promise<void>((resolve) => {
+        client.afterNotify((_err, notice) => {
+          expect(notice.name).toEqual(funkyName)
+          resolve()
+        })
+
+        expect(client.notify('Should report and modify notice')).toEqual(true)
+      })
+    })
+
+    it('modifies the notice when an async function is provided', function () {
+      const funkyName = 'My funky name'
+
+      client.beforeNotify(async (notice) => {
+        const modifyName = () => new Promise<void>((resolve) => {
+          setTimeout(() => {
+            notice.name = funkyName
+            resolve()
+          })
+        })
+
+
+        await modifyName()
+      })
+
+      return new Promise<void>((resolve) => {
+        client.afterNotify((_err, notice) => {
+          expect(notice.name).toEqual(funkyName)
+          resolve()
+        })
+
+        client.notify('Should report and modify notice')
+      })
+    })
   })
 
   describe('afterNotify', function () {

packages/core/test/util.test.ts

@@ -95,15 +95,15 @@ describe('utils', function () {
         () => false,
         () => true
       ]
-      expect(runBeforeNotifyHandlers(<never>{}, handlers)).toEqual(false)
+      expect(runBeforeNotifyHandlers(<never>{}, handlers).result).toEqual(false)
     })
 
     it('returns true when all handlers return true', function () {
       const handlers = [
         () => true,
         () => true
       ]
-      expect(runBeforeNotifyHandlers(<never>{}, handlers)).toEqual(true)
+      expect(runBeforeNotifyHandlers(<never>{}, handlers).result).toEqual(true)
     })
 
     it('passes the notice to handlers', function () {