@honeybadger-io/js 3.2.7 → 4.0.0-beta.1

package/dist/browser/types/browser/util.d.ts

@@ -3,7 +3,7 @@
  * @param {!HTMLElement} element
  * @return {string}
  */
-export declare function stringNameOfElement(element: any): string;
+export declare function stringNameOfElement(element: HTMLElement): string;
 export declare function stringSelectorOfElement(element: any): any;
 export declare function stringTextOfElement(element: any): any;
 export declare function nativeFetch(): boolean;

package/dist/browser/types/core/client.d.ts

@@ -1,9 +1,17 @@
-import { Config, Logger, BeforeNotifyHandler, AfterNotifyHandler, Notice, Noticeable } from './types';
+import { Config, Logger, BeforeNotifyHandler, AfterNotifyHandler, Notice, Noticeable, HoneybadgerStore, BreadcrumbRecord } from './types';
 export default class Client {
+    private __pluginsExecuted;
+    protected __store: HoneybadgerStore<{
+        context: Record<string, unknown>;
+        breadcrumbs: BreadcrumbRecord[];
+    }>;
+    protected __beforeNotifyHandlers: BeforeNotifyHandler[];
+    protected __afterNotifyHandlers: AfterNotifyHandler[];
+    protected __getSourceFileHandler: (path: string, cb: (fileContent: string) => void) => void;
     config: Config;
     logger: Logger;
     constructor(opts?: Partial<Config>);
-    factory(_opts?: Record<string, unknown>): unknown;
+    factory(_opts?: Partial<Config>): Client;
     getVersion(): string;
     configure(opts?: Partial<Config>): Client;
     beforeNotify(handler: BeforeNotifyHandler): Client;
@@ -11,6 +19,18 @@ export default class Client {
     setContext(context: Record<string, unknown>): Client;
     resetContext(context?: Record<string, unknown>): Client;
     clear(): Client;
-    notify(notice: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): Record<string, unknown> | false | unknown;
+    notify(noticeable: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): boolean;
+    /**
+     * An async version of {@link notify} that resolves only after the notice has been reported to Honeybadger.
+     * Implemented using the {@link afterNotify} hook.
+     * Rejects if for any reason the report failed to be reported.
+     * Useful in serverless environments (AWS Lambda).
+     */
+    notifyAsync(noticeable: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): Promise<void>;
+    protected makeNotice(noticeable: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): Notice | null;
     addBreadcrumb(message: string, opts?: Record<string, unknown>): Client;
+    protected __developmentMode(): boolean;
+    protected __send(_notice: Partial<Notice>): void;
+    protected __buildPayload(notice: Notice): Record<string, Record<string, unknown>>;
+    protected __constructTags(tags: unknown): Array<string>;
 }

package/dist/browser/types/core/error.d.ts

@@ -0,0 +1,3 @@
+export default class NotifyError extends Error {
+    constructor(message: any);
+}

package/dist/browser/types/core/store.d.ts

@@ -0,0 +1,7 @@
+import { HoneybadgerStore } from "./types";
+export declare class GlobalStore<T> implements HoneybadgerStore<T> {
+    private store;
+    constructor(store: T);
+    getStore(): T;
+    run<R, TArgs extends never[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
+}

package/dist/browser/types/core/types.d.ts

@@ -1,4 +1,6 @@
+/// <reference types="node" />
 import Client from './client';
+import { AsyncLocalStorage } from "async_hooks";
 export interface Logger {
     log(...args: unknown[]): unknown;
     info(...args: unknown[]): unknown;
@@ -16,7 +18,6 @@ export interface Config {
     component?: string;
     action?: string;
     revision?: string;
-    disabled: boolean;
     debug: boolean;
     reportData: boolean;
     breadcrumbsEnabled: boolean | {
@@ -33,13 +34,13 @@ export interface Config {
     enableUnhandledRejection: boolean;
     filters: string[];
     __plugins: Plugin[];
-    tags: any;
+    tags: unknown;
 }
 export interface BeforeNotifyHandler {
-    (notice: Notice): boolean | void;
+    (notice?: Notice): boolean | void;
 }
 export interface AfterNotifyHandler {
-    (error: any, notice: Notice): boolean | void;
+    (error: any, notice?: Notice): boolean | void;
 }
 export interface Plugin {
     load(client: Client): void;
@@ -67,6 +68,7 @@ export interface Notice {
     details: Record<string, Record<string, unknown>>;
     __breadcrumbs: BreadcrumbRecord[];
     afterNotify?: AfterNotifyHandler;
+    [key: string]: unknown;
 }
 export declare type Noticeable = string | Error | Partial<Notice>;
 export interface BacktraceFrame {
@@ -74,6 +76,7 @@ export interface BacktraceFrame {
     method: string;
     number: number;
     column: number;
+    source?: Record<string, string>;
 }
 export interface BreadcrumbRecord {
     category: string;
@@ -87,3 +90,4 @@ export interface CGIData {
     HTTP_COOKIE: string | undefined;
     [x: string]: unknown;
 }
+export declare type HoneybadgerStore<T> = Pick<AsyncLocalStorage<T>, 'getStore' | 'run'>;

package/dist/browser/types/core/util.d.ts

@@ -5,8 +5,9 @@ export declare function mergeNotice(notice1: Partial<Notice>, notice2: Partial<N
 export declare function objectIsEmpty(obj: any): boolean;
 export declare function objectIsExtensible(obj: any): boolean;
 export declare function makeBacktrace(stack: string, shift?: number): BacktraceFrame[];
-export declare function runBeforeNotifyHandlers(notice: any, handlers: BeforeNotifyHandler[]): boolean;
-export declare function runAfterNotifyHandlers(notice: any, handlers: AfterNotifyHandler[], error?: any): boolean;
+export declare function getSourceForBacktrace(backtrace: BacktraceFrame[], getSourceFileHandler: (path: string, cb: (fileContent: string) => void) => void, cb: (sourcePerTrace: Record<string, string>[]) => void): void;
+export declare function runBeforeNotifyHandlers(notice: Notice | null, handlers: BeforeNotifyHandler[]): boolean;
+export declare function runAfterNotifyHandlers(notice: Notice | null, handlers: AfterNotifyHandler[], error?: Error): boolean;
 export declare function newObject<T>(obj: T): T | Record<string, unknown>;
 export declare function sanitize(obj: any, maxDepth?: number): any;
 export declare function logger(client: Client): Logger;
@@ -27,3 +28,4 @@ export declare function generateStackTrace(): string;
 export declare function filter(obj: Record<string, unknown>, filters: string[]): Record<string, unknown>;
 export declare function filterUrl(url: string, filters: string[]): string;
 export declare function formatCGIData(vars: Record<string, unknown>, prefix?: string): Record<string, unknown>;
+export declare function clone<T>(obj: T): T;

package/dist/browser/types/server/async_store.d.ts

@@ -0,0 +1,5 @@
+import { BreadcrumbRecord, HoneybadgerStore } from "../core/types";
+export declare const AsyncStore: HoneybadgerStore<{
+    context: Record<string, unknown>;
+    breadcrumbs: BreadcrumbRecord[];
+}>;

package/dist/browser/types/server/aws_lambda.d.ts

@@ -0,0 +1,9 @@
+import { Handler, Callback, Context } from 'aws-lambda';
+export declare type SyncHandler<TEvent = any, TResult = any> = (event: TEvent, context: Context, callback: Callback<TResult>) => void;
+export declare type AsyncHandler<TEvent = any, TResult = any> = (event: TEvent, context: Context) => Promise<TResult>;
+export declare function lambdaHandler<TEvent = any, TResult = any>(handler: Handler<TEvent, TResult>): Handler<TEvent, TResult>;
+/**
+ * Removes AWS Lambda default listener that
+ * exits the process before letting us report to honeybadger.
+ */
+export declare function removeAwsDefaultUncaughtExceptionListener(): void;

package/dist/browser/types/server/integrations/uncaught_exception.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../core/types';
+export default function (): Plugin;

package/dist/browser/types/server/integrations/unhandled_rejection.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../core/types';
+export default function (): Plugin;

package/dist/browser/types/server/middleware.d.ts

@@ -0,0 +1,4 @@
+import { NextFunction, Request, Response } from 'express';
+import { Noticeable } from '../core/types';
+export declare function requestHandler(req: Request, res: Response, next: NextFunction): void;
+export declare function errorHandler(err: Noticeable, req: Request, _res: Response, next: NextFunction): unknown;

package/dist/browser/types/server/util.d.ts

@@ -0,0 +1,9 @@
+export declare function fatallyLogAndExit(err: Error): never;
+export declare function getStats(cb: (stats: Record<string, unknown>) => void): void;
+/**
+ * Get source file if possible, used to build `notice.backtrace.source`
+ *
+ * @param path to source code
+ * @param cb callback with fileContent
+ */
+export declare function getSourceFile(path: string, cb: (fileContent: string) => void): void;

package/dist/browser/types/server.d.ts

@@ -0,0 +1,14 @@
+import Client from './core/client';
+import { Config } from './core/types';
+import { errorHandler, requestHandler } from './server/middleware';
+import { lambdaHandler } from './server/aws_lambda';
+declare class Honeybadger extends Client {
+    errorHandler: typeof errorHandler;
+    requestHandler: typeof requestHandler;
+    lambdaHandler: typeof lambdaHandler;
+    constructor(opts?: Partial<Config>);
+    factory(opts?: Partial<Config>): Honeybadger;
+    run<R>(handler: (...args: never[]) => R, onError?: (...args: any[]) => any): R | void;
+}
+declare const _default: Honeybadger;
+export default _default;

package/dist/server/honeybadger.d.ts

@@ -1,12 +1,14 @@
 import Client from './types/core/client';
 import { Config } from './types/core/types';
-import { errorHandler, requestHandler, lambdaHandler } from './types/server/middleware';
+import { errorHandler, requestHandler } from './types/server/middleware';
+import { lambdaHandler } from './types/server/aws_lambda';
 declare class Honeybadger extends Client {
     errorHandler: typeof errorHandler;
     requestHandler: typeof requestHandler;
     lambdaHandler: typeof lambdaHandler;
     constructor(opts?: Partial<Config>);
     factory(opts?: Partial<Config>): Honeybadger;
+    run<R>(handler: (...args: never[]) => R, onError?: (...args: any[]) => any): R | void;
 }
 declare const _default: Honeybadger;
 export default _default;