trakr/build/index.d.ts

Minimal utility for tracking performance

/// <reference types="node" />
interface Performance {
    now(): number;
    mark(name: string): void;
    measure(name: string, startMark: string, endMark: string): void;
}
interface Tracing {
    enable(): void;
    disable(): void;
    readonly enabled: boolean;
}
interface TraceEvents {
    createTracing(options: {
        categories: string[];
    }): Tracing;
}
export interface Stats {
    readonly cnt: number;
    readonly sum: number;
    readonly avg: number;
    readonly var: number;
    readonly std: number;
    readonly sem: number;
    readonly moe: number;
    readonly rme: number;
    readonly min: number;
    readonly max: number;
    readonly p50: number;
    readonly p90: number;
    readonly p95: number;
    readonly p99: number;
}
export declare class Stats {
    protected constructor();
    static compute(arr: number[], pop?: boolean): Stats;
    static max(arr: number[]): number;
    static min(arr: number[]): number;
    static sum(arr: number[]): number;
    static mean(arr: number[], sum?: number): number;
    static median(arr: number[]): number;
    static percentile(arr: number[], p: number): number;
    static ptile(arr: number[], p: number): number;
    static variance(arr: number[], pop?: boolean, mean?: number): number;
    static standardDeviation(arr: number[], pop?: boolean, mean?: number): number;
    static standardErrorOfMean(arr: number[], pop?: boolean, std?: number): number;
    static marginOfError(arr: number[], pop?: boolean, sem?: number): number;
    static relativeMarginOfError(arr: number[], pop?: boolean, moe?: number, mean?: number): number;
}
export declare class Tracer {
    readonly traceEvents?: TraceEvents;
    tracing?: Tracing;
    constructor(traceEvents?: TraceEvents);
    get enabled(): boolean;
    enable(categories?: string[]): void;
    disable(): void;
}
export declare const TRACER: Tracer;
export interface TrackerOptions {
    buf?: Buffer;
}
export declare abstract class Tracker {
    static create(options?: TrackerOptions): BoundedTracker | UnboundedTracker;
    readonly counters: Map<string, number>;
    constructor();
    count(name: string, val?: number): void;
    abstract add(name: string, val: number): void;
    abstract stats(pop?: boolean): Map<string, Stats>;
    protected push(dists: Map<string, number[]>, name: string, val: number): void;
    protected compute(dists: Map<string, number[]>, pop?: boolean): Map<any, any>;
}
declare class UnboundedTracker extends Tracker {
    protected readonly distributions: Map<string, number[]>;
    constructor();
    add(name: string, val: number): void;
    stats(pop?: boolean): Map<string, Stats>;
}
declare class BoundedTracker extends Tracker {
    protected readonly buf: Buffer;
    protected readonly next: {
        tag: number;
        loc: number;
        dloc: number;
    };
    protected readonly tags: Map<string, number>;
    protected readonly distributions: Map<string, number[]>;
    constructor(buf: Buffer);
    add(name: string, val: number): void;
    stats(pop?: boolean): Map<string, Stats>;
}
export interface TimerOptions extends TrackerOptions {
    trace?: boolean;
    perf?: Performance;
}
export declare abstract class Timer {
    static create(options?: TimerOptions): TracingTimer | BasicTimer;
    protected readonly tracker: Tracker;
    protected readonly perf: Performance;
    protected started?: number;
    protected stopped?: number;
    constructor(tracker: Tracker, perf: Performance);
    count(name: string, val?: number): void;
    get counters(): Map<string, number>;
    get duration(): number | undefined;
    start(): void;
    stop(): void;
    stats(pop?: boolean): Map<string, Stats>;
    abstract time(name: string): (a: any) => any;
}
declare class BasicTimer extends Timer {
    constructor(tracker: Tracker, perf: Performance);
    time(name: string): (a: any) => any;
}
declare class TracingTimer extends Timer {
    constructor(tracker: Tracker, perf: Performance);
    time(name: string): (a: any) => any;
}
export {};