@neo-one/monitor/types.d.ts

NEO•ONE monitoring.

/// <reference types="node" />
import { IncomingMessage } from 'http';
import { Context } from 'koa';
export declare type LogField = 'error.kind' | 'error.object' | 'event' | 'message' | 'stack';
export declare type Label = string;
export declare type LabelValue = string | number | boolean | void | undefined;
export interface Labels {
    readonly [label: string]: LabelValue;
}
export declare type LogLevel = 'error' | 'warn' | 'info' | 'verbose' | 'debug' | 'silly';
export declare type LogLevelOption = LogLevel | {
    readonly log: LogLevel;
    readonly span?: LogLevel;
};
export declare enum KnownLabel {
    SERVICE = "service",
    COMPONENT = "component",
    DB_INSTANCE = "db.instance",
    DB_STATEMENT = "db.statement",
    DB_TYPE = "db.type",
    DB_USER = "db.user",
    ERROR = "error",
    ERROR_KIND = "error.kind",
    ERROR_OBJECT = "error.object",
    ERROR_STACK = "stack",
    HTTP_METHOD = "http.method",
    HTTP_STATUS_CODE = "http.status_code",
    HTTP_URL = "http.url",
    MESSAGE_BUS_DESTINATION = "message_bus.destination",
    PEER_ADDRESS = "peer.address",
    PEER_HOSTNAME = "peer.hostname",
    PEER_IPV4 = "peer.ipv4",
    PEER_IPV6 = "peer.ipv6",
    PEER_PORT = "peer.port",
    PEER_SERVICE = "peer.service",
    SAMPLING_PRIORITY = "sampling.priority",
    SPAN_KIND = "span.kind",
    DB_STATEMENT_SUMMARY = "db.statement.summary",
    HTTP_PATH = "http.path",
    HTTP_FULLPATH = "http.full_path",
    HTTP_USER_AGENT = "http.user_agent",
    HTTP_REQUEST_SIZE = "http.request.size",
    HTTP_HEADERS = "http.headers",
    HTTP_REQUEST_PROTOCOL = "http.request.protocol",
    HTTP_REQUEST_QUERY = "http.request.query",
    RPC_METHOD = "rpc.method",
    RPC_TYPE = "rpc.type"
}
export declare enum Format {
    HTTP = "http_headers",
    TEXT = "text_map",
    BINARY = "binary"
}
export interface Carrier {
    readonly __carrier: undefined;
}
export interface CollectedLoggerLogOptions {
    readonly name: string;
    readonly level: LogLevel;
    readonly message?: string;
    readonly labels?: Labels;
    readonly data?: Labels;
    readonly error?: {
        readonly message?: string;
        readonly stack?: string;
        readonly code?: string;
    };
}
export interface MetricOptions {
    readonly name: string;
    readonly help?: string;
    readonly labelNames?: readonly Label[];
    readonly labels?: readonly Labels[];
}
export interface BucketedMetricOptions extends MetricOptions {
    readonly buckets?: readonly number[];
}
export interface PercentiledMetricOptions extends MetricOptions {
    readonly percentiles?: readonly number[];
}
export declare type AllMetricOptions = MetricOptions | BucketedMetricOptions | PercentiledMetricOptions;
export interface MetricValue {
    readonly countOrLabels?: Labels | number;
    readonly count?: number;
}
export interface CollectedMetric<T extends MetricOptions | BucketedMetricOptions> {
    readonly metric: T;
    readonly values: readonly MetricValue[];
}
export interface CollectedMetrics<T extends MetricOptions | BucketedMetricOptions> {
    readonly [name: string]: CollectedMetric<T>;
}
export interface MetricCollection {
    readonly counters: CollectedMetrics<MetricOptions>;
    readonly histograms: CollectedMetrics<BucketedMetricOptions>;
}
export interface Report {
    readonly logs: readonly CollectedLoggerLogOptions[];
    readonly metrics: MetricCollection;
}
export interface CounterBase {
    inc(count?: number): void;
    inc(labels?: Labels, count?: number): void;
}
export interface Counter extends CounterBase {
    readonly getLabelNames: () => readonly Label[];
}
export interface GaugeBase {
    inc(count?: number): void;
    inc(labels?: Labels, count?: number): void;
    dec(count?: number): void;
    dec(labels?: Labels, count?: number): void;
    set(value: number): void;
    set(labels: Labels, value: number): void;
}
export interface Gauge extends GaugeBase {
    readonly getLabelNames: () => readonly Label[];
}
export interface HistogramBase {
    observe(value: number): void;
    observe(labels: Labels, value: number): void;
}
export interface Histogram extends HistogramBase {
    readonly getLabelNames: () => readonly Label[];
}
export interface SummaryBase {
    observe(value: number): void;
    observe(labels: Labels, value: number): void;
}
export interface Summary extends SummaryBase {
    readonly getLabelNames: () => readonly Label[];
}
export declare type Metric = Counter | Gauge | Histogram | Summary;
export interface MetricsFactory {
    readonly reset_forTest: () => void;
    readonly createCounter: (options: MetricOptions) => Counter;
    readonly createGauge: (options: MetricOptions) => Gauge;
    readonly createHistogram: (options: BucketedMetricOptions) => Histogram;
    readonly createSummary: (options: PercentiledMetricOptions) => Summary;
    readonly setFactory: (factory: MetricsFactory) => void;
}
export interface LogOptions {
    readonly name: string;
    readonly message?: string;
    readonly level?: LogLevel;
    readonly metric?: Counter;
    readonly error?: {
        readonly metric?: Counter;
        readonly error?: Error | undefined;
        readonly message?: string;
        readonly level?: LogLevel;
    };
}
export interface CaptureLogOptions {
    readonly name: string;
    readonly message?: string;
    readonly level?: LogLevel;
    readonly metric?: Counter;
    readonly error?: string | {
        readonly metric?: Counter;
        readonly message?: string;
        readonly level?: LogLevel;
    };
}
export interface LogErrorOptions {
    readonly name: string;
    readonly message?: string;
    readonly error: Error;
    readonly level?: LogLevel;
    readonly metric?: Counter;
}
export interface Reference {
    readonly __brand: 'Reference';
}
export interface SpanOptions {
    readonly name: string;
    readonly level?: LogLevel;
    readonly metric?: {
        readonly total: Histogram | Summary;
        readonly error: Counter;
    };
    readonly references?: ReadonlyArray<Reference | void>;
    readonly trace?: boolean;
}
export interface CaptureSpanOptions {
    readonly name: string;
    readonly level?: LogLevel;
    readonly metric?: {
        readonly total: Histogram | Summary;
        readonly error: Counter;
    };
    readonly references?: ReadonlyArray<Reference | void>;
    readonly trace?: boolean;
}
export interface CaptureSpanLogOptions {
    readonly name: string;
    readonly message?: string;
    readonly level?: LogLevelOption;
    readonly metric?: {
        readonly total: Histogram | Summary;
        readonly error: Counter;
    };
    readonly error?: string | {
        readonly message?: string;
        readonly level?: LogLevel;
    };
    readonly references?: ReadonlyArray<Reference | void>;
    readonly trace?: boolean;
}
export interface Monitor {
    readonly labels: typeof KnownLabel;
    readonly formats: typeof Format;
    readonly at: (component: string) => Monitor;
    readonly withLabels: (labels: Labels) => Monitor;
    readonly withData: (data: Labels) => Monitor;
    readonly forContext: (ctx: Context) => Monitor;
    readonly forMessage: (message: IncomingMessage) => Monitor;
    readonly log: (options: LogOptions) => void;
    readonly captureLog: <TResult>(func: (monitor: CaptureMonitor) => TResult, options: CaptureLogOptions) => TResult;
    readonly logError: (options: LogErrorOptions) => void;
    readonly startSpan: (options: SpanOptions) => Span;
    readonly captureSpan: <TResult>(func: (span: CaptureMonitor) => TResult, options: CaptureSpanOptions) => TResult;
    readonly captureSpanLog: <TResult>(func: (span: CaptureMonitor) => TResult, options: CaptureSpanLogOptions) => TResult;
    readonly childOf: <T extends SpanContext | Monitor | undefined>(span: T) => T extends undefined ? undefined : Reference;
    readonly followsFrom: <T extends SpanContext | Monitor | undefined>(span: T) => T extends undefined ? undefined : Reference;
    readonly extract: (format: Format, carrier: Carrier) => SpanContext | undefined;
    readonly inject: (format: Format, carrier: Carrier) => void;
    readonly now: () => number;
    readonly nowSeconds: () => number;
    readonly serveMetrics: (port: number) => void;
    readonly report: (report: Report) => void;
    readonly close: (callback: () => void) => void;
}
export interface SpanContext {
    readonly __brand: 'SpanContext';
}
export interface CaptureMonitor extends Monitor {
    readonly setLabels: (labels: Labels) => void;
    readonly setData: (data: Labels) => void;
}
export interface Span extends CaptureMonitor {
    readonly end: (error?: boolean) => void;
}
export interface LoggerLogOptions {
    readonly name: string;
    readonly level: LogLevel;
    readonly message?: string;
    readonly labels?: Labels;
    readonly data?: Labels;
    readonly error?: Error | undefined;
}
export interface Logger {
    readonly log: (options: LoggerLogOptions) => void;
    readonly close: (callback: () => void) => void;
}