@honeybadger-io/js 4.0.0-beta.5 → 4.0.2

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

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import Client from './client';
-import { AsyncLocalStorage } from "async_hooks";
+/** @ts-ignore */
+import type { AsyncLocalStorage } from 'async_hooks';
 export interface Logger {
     log(...args: unknown[]): unknown;
     info(...args: unknown[]): unknown;
@@ -36,6 +37,10 @@ export interface Config {
     __plugins: Plugin[];
     tags: unknown;
 }
+export interface ServerlessConfig extends Config {
+    reportTimeoutWarning: boolean;
+    timeoutWarningThresholdMs: number;
+}
 export interface BeforeNotifyHandler {
     (notice?: Notice): boolean | void;
 }
@@ -70,6 +75,10 @@ export interface Notice {
     afterNotify?: AfterNotifyHandler;
     [key: string]: unknown;
 }
+export interface BrowserConfig extends Config {
+    async: boolean;
+    maxErrors: number;
+}
 export declare type Noticeable = string | Error | Partial<Notice>;
 export interface BacktraceFrame {
     file: string;
@@ -90,6 +99,60 @@ export interface CGIData {
     HTTP_COOKIE: string | undefined;
     [x: string]: unknown;
 }
+export declare type ProcessStats = {
+    load: {
+        one: number;
+        five: number;
+        fifteen: number;
+    };
+    mem: {
+        total?: number;
+        free?: number;
+        buffers?: number;
+        cached?: number;
+        free_total?: number;
+    };
+};
+export declare type TransportOptions = {
+    method: 'GET' | 'POST';
+    headers?: Record<string, number | string | string[] | undefined>;
+    endpoint: string;
+    maxObjectDepth?: number;
+    logger: Logger;
+    async?: boolean;
+};
+export declare type NoticeTransportPayload = {
+    notifier: {
+        name: string;
+        url: string;
+        version: string;
+    };
+    breadcrumbs: {
+        enabled: boolean;
+        trail: BreadcrumbRecord[];
+    };
+    error: Pick<Notice, 'message' | 'backtrace' | 'fingerprint' | 'tags'> & {
+        class: string;
+    };
+    request: Pick<Notice, 'url' | 'component' | 'action' | 'context' | 'params' | 'session'> & {
+        cgi_data: unknown;
+    };
+    server: Pick<Notice, 'revision'> & {
+        pid?: number | undefined;
+        project_root?: string | undefined;
+        environment_name?: string | undefined;
+        hostname: string;
+        time: string;
+        stats?: ProcessStats | undefined;
+    };
+    details: Record<string, Record<string, unknown>>;
+};
+export interface Transport {
+    send(options: TransportOptions, payload?: NoticeTransportPayload | undefined): Promise<{
+        statusCode: number;
+        body: string;
+    }>;
+}
 export declare type HoneybadgerStore<T> = Pick<AsyncLocalStorage<T>, 'getStore' | 'run'>;
 export declare type DefaultStoreContents = {
     context: Record<string, unknown>;

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

@@ -1,11 +1,11 @@
 import Client from '../core/client';
-import { Logger, Config, BacktraceFrame, Notice, Noticeable, BeforeNotifyHandler, AfterNotifyHandler } from './types';
+import { Logger, BacktraceFrame, Notice, Noticeable, BeforeNotifyHandler, AfterNotifyHandler, Config, BrowserConfig } from './types';
 export declare function merge<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>>(obj1: T1, obj2: T2): T1 & T2;
 export declare function mergeNotice(notice1: Partial<Notice>, notice2: Partial<Notice>): Partial<Notice>;
 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 getSourceForBacktrace(backtrace: BacktraceFrame[], getSourceFileHandler: (path: string, cb: (fileContent: string) => void) => void, cb: (sourcePerTrace: Record<string, string>[]) => void): void;
+export declare function getSourceForBacktrace(backtrace: BacktraceFrame[], getSourceFileHandler: (path: string) => Promise<string>): Promise<Record<string, string>[]>;
 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 shallowClone<T>(obj: T): T | Record<string, unknown>;
@@ -23,9 +23,10 @@ export declare function makeNotice(thing: Noticeable): Partial<Notice>;
  * @param {!Function} replacement
  */
 export declare function instrument(object: Record<string, any>, name: string, replacement: (unknown: any) => void): void;
-export declare function endpoint(config: Config, path: string): string;
+export declare function endpoint(base: string, path: string): string;
 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;
+export declare function isBrowserConfig(config: BrowserConfig | Config): config is BrowserConfig;

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

@@ -1,4 +1,4 @@
-import { BreadcrumbRecord, HoneybadgerStore } from "../core/types";
+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

@@ -1,4 +1,5 @@
-import { Handler, Callback, Context } from 'aws-lambda';
+/** @ts-ignore */
+import type { 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>;

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

@@ -0,0 +1,9 @@
+import { Transport, TransportOptions, NoticeTransportPayload } from '../core/types';
+export declare class ServerTransport implements Transport {
+    send(options: TransportOptions, payload?: NoticeTransportPayload | undefined): Promise<{
+        statusCode: number;
+        body: string;
+    }>;
+    private isNoticePayload;
+    private appendMetadata;
+}

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

@@ -1,9 +1,9 @@
+import { ProcessStats } from '../core/types';
 export declare function fatallyLogAndExit(err: Error): never;
-export declare function getStats(cb: (stats: Record<string, unknown>) => void): void;
+export declare function getStats(): Promise<ProcessStats>;
 /**
  * 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;
+export declare function getSourceFile(path: string): Promise<string>;

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

@@ -1,14 +1,17 @@
 import Client from './core/client';
-import { Config } from './core/types';
+import { Config, ServerlessConfig } 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;
-    withRequest<R>(request: Record<symbol, unknown>, handler: (...args: never[]) => R, onError?: (...args: any[]) => any): R | void;
+    config: Config | ServerlessConfig;
+    constructor(opts?: Partial<Config | ServerlessConfig>);
+    factory(opts?: Partial<Config | ServerlessConfig>): this;
+    configure(opts?: Partial<Config | ServerlessConfig>): this;
+    checkIn(id: string): Promise<void>;
+    withRequest<R>(request: Record<symbol, unknown>, handler: (...args: never[]) => R, onError?: (...args: unknown[]) => unknown): R | void;
 }
 declare const _default: Honeybadger;
 export default _default;

package/dist/server/honeybadger.d.ts

@@ -1,14 +1,17 @@
 import Client from './types/core/client';
-import { Config } from './types/core/types';
+import { Config, ServerlessConfig } from './types/core/types';
 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;
-    withRequest<R>(request: Record<symbol, unknown>, handler: (...args: never[]) => R, onError?: (...args: any[]) => any): R | void;
+    config: Config | ServerlessConfig;
+    constructor(opts?: Partial<Config | ServerlessConfig>);
+    factory(opts?: Partial<Config | ServerlessConfig>): this;
+    configure(opts?: Partial<Config | ServerlessConfig>): this;
+    checkIn(id: string): Promise<void>;
+    withRequest<R>(request: Record<symbol, unknown>, handler: (...args: never[]) => R, onError?: (...args: unknown[]) => unknown): R | void;
 }
 declare const _default: Honeybadger;
 export default _default;