nightingale-logger
Version:
Logger for browser and node
256 lines • 8.98 kB
TypeScript
import { Level } from "nightingale-levels";
import type { Handler, LogRecord, Metadata, MetadataStyles, Processor, Styles } from "nightingale-types";
export { Level } from "nightingale-levels";
export interface Options<T extends Metadata> {
symbol?: string;
metadataStyles?: MetadataStyles<T>;
styles?: Styles;
}
export interface ComputedConfigForKey {
handlers: Handler[];
processors: Processor[];
}
export interface ExtendedFunctionNameMetadata {
functionName: string;
}
export interface Config {
handler?: Handler;
handlers?: Handler[];
key?: string;
keys?: string[];
pattern?: RegExp;
processor?: Processor;
processors?: Processor[];
stop?: boolean;
}
declare global {
var __NIGHTINGALE_CONFIG: Config[];
var __NIGHTINGALE_LOGGER_MAP_CACHE: Map<string, ComputedConfigForKey>;
var __NIGHTINGALE_CONFIG_DEFAULT: ComputedConfigForKey;
var __NIGHTINGALE_GLOBAL_HANDLERS: unknown;
var __NIGHTINGALE_GET_CONFIG_FOR_LOGGER: (key: string) => ComputedConfigForKey;
var __NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD: (key: string, level: number) => ComputedConfigForKey;
}
/**
* Interface that allows you to log records.
* This records are treated by handlers
*/
export declare class Logger {
private contextObject?;
readonly key: string;
readonly displayName?: string;
/**
* Create a new Logger
*
* @param {string} key
* @param {string} [displayName]
*/
constructor(key: string, displayName?: string);
/** @private */
protected getHandlersAndProcessors(recordLevel: number): ComputedConfigForKey;
/** @private */
getConfig(): Readonly<ComputedConfigForKey>;
/**
* Create a child logger
*/
child(childSuffixKey: string, childDisplayName?: string): Logger;
/**
* Create a new Logger with the same key a this attached context
*
* @example
* ```typescript
* const loggerMyService = new Logger('app:myService');
* function someAction(arg1) {
* const logger = loggerMyService.context({ arg1 });
* logger.enter(someAction);
* // do stuff
* logger.info('info');
* // do stuff
* logger.exit(someAction);
* }
* ```
*
*/
context(context: Record<string, unknown>): Logger;
/**
* Get the context of this logger
*/
getContextObject(): Readonly<Record<string, unknown>> | undefined;
/**
* Set the context of this logger
*
* @param {Object} context
*/
setContext(context: Record<string, unknown>): void;
/**
* Extends existing context of this logger
*/
extendsContext(extendedContext: Record<string, unknown>): void;
/**
* Handle a record
*
* Use this only if you know what you are doing.
*/
addRecord<T extends Metadata>(record: Readonly<LogRecord<T>>): void;
/**
* Log a message
*/
log<T extends Metadata>(messageOrError: Error | string, metadata?: T, level?: Level, options?: Options<T>): void;
/**
* Log a trace message
*/
trace<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log a debug message
*/
debug<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Notice an info message
*/
notice<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an info message
*/
info<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log a warn message
*/
warn<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an error message
*
* @example
* ```typescript
* const logger = new Logger('something');
* try {
* throw new Error('Always throws here');
* } catch (error) {
* logger.error('caught error', { error });
* }
* ```
*/
error<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an critical message
*/
critical<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log a fatal message
*
* @example
* ```typescript
* const logger = new Logger('something');
* try {
* throw new Error('Always throws here');
* } catch (error) {
* logger.error('caught error', { error });
* process.exit(1);
* }
*/
fatal<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an alert message
*/
alert<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an inspected value
*/
inspectValue<T extends Metadata>(value: unknown, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log a debugged var
*/
inspectVar<T extends Metadata>(varName: string, varValue: unknown, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Alias for infoSuccess
*/
success<T extends Metadata>(message: string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an info success message
*/
infoSuccess<T extends Metadata>(message: string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an debug success message
*/
debugSuccess<T extends Metadata>(message: string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Alias for infoFail
*/
fail<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an info fail message
*/
infoFail<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an debug fail message
*/
debugFail<T extends Metadata>(messageOrError: Error | string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* @returns {number} time to pass to timeEnd
*/
time<T extends Metadata>(message?: string, metadata?: T, metadataStyles?: MetadataStyles<T>, level?: number): number;
infoTime<T extends Metadata>(message?: string, metadata?: T, metadataStyles?: MetadataStyles<T>): number;
/**
* Finds difference between when this method
* was called and when the respective time method
* was called, then logs out the difference
* and deletes the original record
*/
timeEnd<T extends Metadata>(startTime: number, message: string, metadata?: T, metadataStyles?: MetadataStyles<T>, level?: number, options?: Options<T>): void;
/**
* Like timeEnd, but with INFO level
*/
infoTimeEnd<T extends Metadata>(time: number, message: string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Like timeEnd, but with INFO level
*/
infoSuccessTimeEnd<T extends Metadata>(time: number, message: string, metadata?: T, metadataStyles?: MetadataStyles<T>): void;
/**
* Log an enter in a function
*
* @example
* ```typescript
* class A {
* method(arg1) {
* logger.enter(method, { arg1 });
* // Do your stuff
* }
* }
* ```
*
*/
enter<T extends Metadata, Fn extends (...args: unknown[]) => unknown>(fn: Fn, metadata?: T, metadataStyles?: MetadataStyles<ExtendedFunctionNameMetadata & T>): void;
/**
* Log an exit in a function
*
* @example
* ```typescript
* const logger = new Logger('myNamespace:A');
* class A {
* method(arg1) {
* // Do your stuff
* logger.exit(method, { arg1 });
* }
* }
* ```
*/
exit<T extends Metadata, Fn extends (...args: unknown[]) => unknown>(fn: Fn, metadata?: T, metadataStyles?: MetadataStyles<ExtendedFunctionNameMetadata & T>): void;
/**
* Wrap around a function to log enter and exit of a function
*
* @example
* ```typescript
* const logger = new Logger('myNamespace:A');
* class A {
* method() {
* logger.wrap(method, () => {
* // Do your stuff
* });
* }
* }
* ```
*/
wrap<Fn extends (...args: unknown[]) => unknown>(fn: Fn, callback: () => void): void;
wrap<T extends Metadata, Fn extends (...args: unknown[]) => unknown>(fn: Fn, metadata: T, callback: () => void): void;
wrap<T extends Metadata, Fn extends (...args: unknown[]) => unknown>(fn: Fn, metadata: T, metadataStyles: MetadataStyles<T>, callback: () => void): void;
}
//# sourceMappingURL=index.d.ts.map