rollbar/index.d.ts

Effortlessly track and debug errors in your JavaScript applications with Rollbar. This package includes advanced error tracking features and an intuitive interface to help you identify and fix issues more quickly.

// Type definitions for rollbar
// Project: Rollbar

export = Rollbar;

declare class Rollbar {
  constructor(options?: Rollbar.Configuration);
  static init(options: Rollbar.Configuration): Rollbar;
  static setComponents(components: Rollbar.Components): void;

  public global(options: Rollbar.Configuration): Rollbar;
  public configure(options: Rollbar.Configuration): Rollbar;
  public lastError(): Rollbar.MaybeError;

  public log(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
  public debug(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
  public info(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
  public warn(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
  public warning(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
  public error(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
  public critical(...args: Rollbar.LogArgument[]): Rollbar.LogResult;
  public wait(callback: () => void): void;

  public captureEvent(
    metadata: object,
    level: Rollbar.Level,
  ): Rollbar.TelemetryEvent;

  public lambdaHandler<T = object>(
    handler: Rollbar.LambdaHandler<T>,
  ): Rollbar.LambdaHandler<T>;

  public errorHandler(): Rollbar.ExpressErrorHandler;

  // Used with rollbar-react for rollbar-react-native compatibility.
  public rollbar: Rollbar;

  // Exposed only for testing, should be changed via the configure method
  // DO NOT MODIFY DIRECTLY
  public options: Rollbar.Configuration;
}

declare namespace Rollbar {
  export type LambdaHandler<TEvent = any, TResult = any, TContext = any> = (
    event: TEvent,
    context: TContext,
    callback: Callback<TResult>,
  ) => void | Promise<TResult>;
  export type MaybeError = Error | undefined | null;
  export type Level = 'debug' | 'info' | 'warning' | 'error' | 'critical';
  export type Dictionary = { [key: string]: unknown };
  /**
   * {@link https://docs.rollbar.com/docs/rollbarjs-configuration-reference#reference}
   */
  export interface Configuration {
    accessToken?: string;
    addErrorContext?: boolean;
    addRequestData?: (data: Dictionary, req: Dictionary) => void;
    autoInstrument?: AutoInstrumentOptions;
    captureDeviceInfo?: boolean;
    captureEmail?: boolean;
    captureIp?: boolean | 'anonymize';
    captureLambdaTimeouts?: boolean;
    captureUncaught?: boolean;
    captureUnhandledRejections?: boolean;
    captureUsername?: boolean;
    checkIgnore?: (
      isUncaught: boolean,
      args: LogArgument[],
      item: Dictionary,
    ) => boolean;
    /**
     * `codeVersion` takes precedence over `code_version`, if provided.
     * `client.javascript.code_version` takes precedence over both top level properties.
     */
    codeVersion?: string;
    /**
     * `codeVersion` takes precedence over `code_version`, if provided.
     * `client.javascript.code_version` takes precedence over both top level properties.
     */
    code_version?: string;
    enabled?: boolean;
    endpoint?: string;
    exitOnUncaughtException?: boolean;
    environment?: string;
    filterTelemetry?: (e: TelemetryEvent) => boolean;
    host?: string; // used in node only
    hostBlackList?: string[]; // deprecated
    hostBlockList?: string[];
    hostWhiteList?: string[]; // deprecated
    hostSafeList?: string[];
    ignoredMessages?: (string | RegExp)[];
    ignoreDuplicateErrors?: boolean;
    includeItemsInTelemetry?: boolean;
    inspectAnonymousErrors?: boolean;
    itemsPerMinute?: number;
    locals?: LocalsOptions;
    logLevel?: Level;
    maxItems?: number;
    maxRetries?: number;
    maxTelemetryEvents?: number;
    nodeSourceMaps?: boolean;
    onSendCallback?: (
      isUncaught: boolean,
      args: LogArgument[],
      item: Dictionary,
    ) => void;
    overwriteScrubFields?: boolean;
    payload?: Payload;
    reportLevel?: Level;
    retryInterval?: number | null;
    rewriteFilenamePatterns?: string[];
    scrubFields?: string[];
    scrubHeaders?: string[];
    scrubPaths?: string[];
    scrubRequestBody?: boolean;
    scrubTelemetryInputs?: boolean;
    sendConfig?: boolean;
    stackTraceLimit?: number;
    telemetryScrubber?: TelemetryScrubber;
    timeout?: number;
    transform?: (data: Dictionary, item: Dictionary) => void | Promise<void>;
    transmit?: boolean;
    uncaughtErrorLevel?: Level;
    verbose?: boolean;
    version?: string;
    wrapGlobalEventHandlers?: boolean;
  }
  export type Callback<TResponse = any> = (
    err: MaybeError,
    response: TResponse,
  ) => void;
  export type LogArgument =
    | string
    | Error
    | object
    | Dictionary
    | Callback
    | Date
    | any[]
    | undefined;
  export interface LogResult {
    uuid: string;
  }
  export interface TelemetryEvent {
    level: Level;
    type: string;
    timestamp_ms: number;
    body: Dictionary;
    source: string;
    uuid?: string;
  }
  export type AutoInstrumentOptions = boolean | AutoInstrumentSettings;
  export interface AutoInstrumentSettings {
    network?: boolean;
    networkResponseHeaders?: boolean | string[];
    networkResponseBody?: boolean;
    networkRequestBody?: boolean;
    log?: boolean;
    dom?: boolean;
    navigation?: boolean;
    connectivity?: boolean;
    contentSecurityPolicy?: boolean;
    errorOnContentSecurityPolicy?: boolean;
  }
  export type TelemetryScrubber = (
    description: TelemetryScrubberInput,
  ) => boolean;
  export type TelemetryScrubberInput = DomDescription | null;
  export interface DomDescription {
    tagName: string;
    id: string | undefined;
    classes: string[] | undefined;
    attributes: DomAttribute[];
  }
  export type DomAttributeKey = 'type' | 'name' | 'title' | 'alt';
  export interface DomAttribute {
    key: DomAttributeKey;
    value: string;
  }
  export type ExpressErrorHandler = (
    err: any,
    request: any,
    response: any,
    next: ExpressNextFunction,
  ) => any;
  export interface ExpressNextFunction {
    (err?: any): void;
  }
  class Locals {}
  export type LocalsType = typeof Locals;
  export type LocalsOptions = LocalsType | LocalsSettings;
  export interface LocalsSettings {
    module: LocalsType;
    enabled?: boolean;
    uncaughtOnly?: boolean;
    depth?: number;
    maxProperties?: number;
    maxArray?: number;
  }

  class Telemeter {}
  class Instrumenter {}

  export type TelemeterType = typeof Telemeter;
  export type InstrumenterType = typeof Instrumenter;
  export type TruncationType = object;
  export type ScrubType = (
    data: object,
    scrubFields?: string[],
    scrubPaths?: string[],
  ) => object;
  export type WrapGlobalsType = (
    window?: any,
    handler?: any,
    shim?: any,
  ) => void;
  export type PolyfillJSONType = (JSON: any) => any;

  export interface Components {
    telemeter?: TelemeterType;
    instrumenter?: InstrumenterType;
    polyfillJSON?: PolyfillJSONType;
    wrapGlobals?: WrapGlobalsType;
    scrub?: ScrubType;
    truncation?: TruncationType;
  }

  /**
   * @deprecated number is deprecated for this field
   */
  export type DeprecatedNumber = number;

  /**
   * {@link https://docs.rollbar.com/docs/rollbarjs-configuration-reference#payload-1}
   */
  export interface Payload {
    person?: {
      id: string | DeprecatedNumber | null;
      username?: string;
      email?: string;
      [property: string]: any;
    };
    context?: any;
    client?: {
      javascript?: {
        /**
         * Version control number (i.e. git SHA) of the current revision. Used for linking filenames in stacktraces to GitHub.
         * Note: for the purposes of nesting under the payload key, only code_version will correctly set the value in the final item.
         * However, if you wish to set this code version at the top level of the configuration object rather than nested under
         * the payload key, we will accept both codeVersion and code_version with codeVersion given preference if both happened
         * to be defined. Furthermore, if code_version is nested under the payload key this will have the final preference over
         * any value set at the top level.
         */
        code_version?: string | DeprecatedNumber;
        /**
         * When true, the Rollbar service will attempt to find and apply source maps to all frames in the stack trace.
         * @default false
         */
        source_map_enabled?: boolean;
        /**
         * When true, the Rollbar service will attempt to apply source maps to frames even if they are missing column numbers.
         * Works best when the minified javascript file is generated using newlines instead of semicolons.
         * @default false
         */
        guess_uncaught_frames?: boolean;
        [property: string]: any;
      };
      [property: string]: any;
    };
    /**
     * The environment that your code is running in.
     * @default undefined
     */
    environment?: string;
    server?: {
      /**
       * @default master
       */
      branch?: string;
      /**
       * The hostname of the machine that rendered the page.
       */
      host?: string;
      /**
       * It is used in two different ways: `source maps`, and `source control`.
       *
       * If you are looking for more information on it please go to:
       * {@link https://docs.rollbar.com/docs/source-maps}
       * {@link https://docs.rollbar.com/docs/source-control}
       */
      root?: string;
      [property: string]: any;
    };
    [property: string]: any;
  }
}