@qvlt/core-logger/dist/index.d.ts

Structured logging for web applications

interface Transport {
    write(batch: LogEvent[]): Promise<void> | void;
    flush?(): Promise<void> | void;
    destroy?(): void;
}

type Level = 'debug' | 'info' | 'warn' | 'error';
type BaseCtx = Record<string, unknown>;
interface LoggerInterface {
    log(lvl: Level, event: string, ctx?: BaseCtx, error?: unknown): void;
    debug(event: string, ctx?: BaseCtx): void;
    info(event: string, ctx?: BaseCtx): void;
    warn(event: string, ctx?: BaseCtx): void;
    error(event: string, ctx?: BaseCtx, error?: unknown): void;
    child(component: string, extra?: BaseCtx): LoggerInterface;
    time<T>(event: string, f: () => Promise<T> | T, c?: BaseCtx): Promise<T>;
}
type LogEvent = {
    ts: number;
    lvl: Level;
    app?: string;
    env?: string;
    ver?: string;
    component?: string;
    event: string;
    ctx?: BaseCtx;
    err?: {
        message: string;
        stack?: string;
        name?: string;
        code?: string | number;
    };
    traceId?: string;
    sessionId?: string;
};
type Init = {
    app: string;
    env: 'development' | 'test' | 'production';
    ver?: string;
    level?: Level;
    sample?: Partial<Record<Level, number>>;
    defaultCtx?: BaseCtx;
    maxBatch?: number;
    flushIntervalMs?: number;
    transport: Transport | Transport[];
};
declare class Logger implements LoggerInterface {
    private app;
    private env;
    private ver?;
    private level;
    private sample;
    private defaultCtx;
    private sessionId;
    private maxBatch;
    private flushIntervalMs;
    private transports;
    private maxQueue;
    private queue;
    private _flushTimer;
    private _onBeforeUnload?;
    private _onProcessExit?;
    constructor(init: Init);
    debug(event: string, ctx?: BaseCtx): void;
    info(event: string, ctx?: BaseCtx): void;
    warn(event: string, ctx?: BaseCtx): void;
    error(event: string, ctx?: BaseCtx, error?: unknown): void;
    time<T>(event: string, f: () => Promise<T> | T, c?: BaseCtx): Promise<T>;
    child(component: string, extra?: BaseCtx): LoggerInterface;
    log(lvl: Level, event: string, ctx?: BaseCtx, error?: unknown): void;
    flush(): void;
    destroy(): void;
    setDefaultContext(patch: Record<string, unknown>): void;
    setLevel(level: Level): this;
    setTransports(t: Transport | Transport[]): this;
}

declare global {
    var getLogger: {
        (): LoggerInterface;
        (component: string): LoggerInterface;
    };
}

declare function initializeLogger(config: {
    app: string;
    env: 'development' | 'test' | 'production';
    ver?: string;
    level?: Level;
    sample?: Partial<Record<Level, number>>;
    defaultCtx?: Record<string, unknown>;
    maxBatch?: number;
    flushIntervalMs?: number;
    transport: Transport | Transport[];
}): Promise<void>;
declare function shutdownLogger(): void;
declare function setDefaultLogContext(patch: Record<string, unknown>): void;
declare function getLogger(component?: string): LoggerInterface;
declare function installGlobalGetLogger(): void;

declare class ConsoleTransport implements Transport {
    write(batch: LogEvent[]): void;
}

declare class HttpTransport implements Transport {
    private endpoint;
    constructor(endpoint: string);
    write(batch: LogEvent[]): Promise<void>;
}

declare class StdoutTransport implements Transport {
    write(batch: LogEvent[]): void;
}

export { ConsoleTransport, HttpTransport, type Level, type LogEvent, Logger, StdoutTransport, type Transport, getLogger, initializeLogger, installGlobalGetLogger, setDefaultLogContext, shutdownLogger };