@contember/logger 1.2.0-alpha.16

package/src/impl.ts

@@ -0,0 +1,141 @@
+import {
+	LogEntry,
+	LogEntryFormatted,
+	Logger,
+	LoggerAttributes,
+	LoggerChildOptions,
+	LoggerHandler,
+	LoggerOptions,
+	LogLevel,
+} from './types'
+import { LogLevels } from './levels'
+import { formatLogEntryAttributes, formatLoggerAttributes, FormattedAttributes, stringify } from './formatting'
+import { LoggerHandlerList } from './handlers/LoggerHandlerList'
+import { withLogger } from './proxy'
+
+export const createLogger = (
+	handler: LoggerHandler,
+	attributes: LoggerAttributes = {},
+	options: LoggerOptions = {},
+): Logger => {
+	return LoggerImpl.create(handler, attributes, options)
+}
+
+
+export class LoggerImpl implements Logger {
+
+	public readonly attributes: LoggerAttributes
+	private formattedAttributes: FormattedAttributes | undefined
+	private minLevelValue: number
+	private handlerList: LoggerHandlerList | undefined
+
+	private constructor(
+		private handler: LoggerHandler,
+		private readonly ownAttributes: LoggerAttributes,
+		private readonly depth: number,
+		private readonly parent: LoggerImpl | undefined,
+		private readonly options: LoggerOptions,
+	) {
+		this.attributes = { ...parent?.attributes, ...ownAttributes }
+		this.minLevelValue = handler.getMinLevel()
+	}
+
+	public static create(
+		handler: LoggerHandler,
+		attributes: LoggerAttributes = {},
+		options: LoggerOptions = {},
+	) {
+		return new LoggerImpl(handler, attributes, 0, undefined, options)
+	}
+
+	public crit(messageOrError: unknown, attributes?: LoggerAttributes) {
+		this.minLevelValue <= LogLevels.crit.value && this.log(LogLevels.crit, messageOrError, attributes)
+	}
+
+	public error(messageOrError: unknown, attributes?: LoggerAttributes) {
+		this.minLevelValue <= LogLevels.error.value && this.log(LogLevels.error, messageOrError, attributes)
+	}
+
+	public warn(messageOrError: unknown, attributes?: LoggerAttributes) {
+		this.minLevelValue <= LogLevels.warn.value && this.log(LogLevels.warn, messageOrError, attributes)
+	}
+
+	public info(messageOrError: unknown, attributes?: LoggerAttributes) {
+		this.minLevelValue <= LogLevels.info.value && this.log(LogLevels.info, messageOrError, attributes)
+	}
+
+	public debug(messageOrError: unknown, attributes?: LoggerAttributes) {
+		this.minLevelValue <= LogLevels.debug.value && this.log(LogLevels.debug, messageOrError, attributes)
+	}
+
+	public child(attributes: LoggerAttributes = {}, options: Partial<LoggerChildOptions> = {}): Logger {
+		const newHandler = options.handler ? options.handler(this.handler, this.options) : this.handler
+		return new LoggerImpl(newHandler, attributes, this.depth + 1, this, { ...this.options, ...options })
+	}
+
+	public async scope<T>(cb: (logger: Logger) => Promise<T> | T, attributes: LoggerAttributes = {}, options: Partial<LoggerChildOptions> = {}): Promise<T> {
+		const logger = this.child(attributes, options)
+		try {
+			return await withLogger(logger, () => cb(logger))
+		} finally {
+			logger.close()
+		}
+	}
+
+	private log(level: LogLevel, errorOrMessage: unknown, { error: errorAttr, message: messageAttr, ...attributes }: LoggerAttributes = {}) {
+		const error: unknown | undefined = typeof errorOrMessage !== 'string' ? errorOrMessage : errorAttr
+		const message: string = typeof errorOrMessage === 'string'
+			? errorOrMessage
+			: (typeof messageAttr === 'string')
+				? messageAttr
+				: typeof error === 'object' && error !== null && typeof (error as any).message === 'string'
+					? (error as any).message
+					: 'unknown error'
+
+		const now = new Date()
+		let formatted: LogEntryFormatted
+		const entry: LogEntry = {
+			level,
+			error,
+			message,
+			ownAttributes: attributes,
+			time: now,
+			isoTime: now.toISOString(),
+			depth: this.depth,
+			loggerAttributes: this.attributes,
+			format: () => {
+				return formatted ??= {
+					attributes: formatLogEntryAttributes(this.getFormattedAttributes(), entry),
+					message: stringify(entry.message),
+					error: entry.error ? `, "error": ${stringify(entry.error)}` : '',
+				}
+			},
+		}
+		this.handler.handle(entry)
+	}
+
+	addHandler(handler: LoggerHandler): void {
+		if (!this.handlerList) {
+			this.handlerList = new LoggerHandlerList([this.handler])
+			this.handler = this.handlerList
+		}
+		this.handlerList.addHandler(handler)
+		this.minLevelValue = Math.min(this.minLevelValue, handler.getMinLevel())
+	}
+
+	close(): void {
+		this.handler.close()
+	}
+
+	private getFormattedAttributes(): FormattedAttributes {
+		if (this.formattedAttributes) {
+			return this.formattedAttributes
+		}
+		const parentAttributes = this.parent?.getFormattedAttributes()
+		this.formattedAttributes = formatLoggerAttributes(parentAttributes, this.ownAttributes)
+		return this.formattedAttributes
+	}
+}
+
+
+

package/src/index.ts

@@ -0,0 +1,9 @@
+export { createLogger } from './impl'
+export * from './types'
+export * from './levels'
+export * from './proxy'
+export * from './handlers/FingerCrossedLoggerHandler'
+export * from './handlers/JsonStreamLoggerHandler'
+export * from './handlers/PrettyPrintLoggerHandler'
+export * from './handlers/LoggerHandlerList'
+export * from './handlers/NullLoggerHandler'

package/src/levels.ts

@@ -0,0 +1,7 @@
+export const LogLevels = {
+	debug: { name: 'debug', value: 10 },
+	info: { name: 'info', value: 20 },
+	warn: { name: 'warn', value: 30 },
+	error: { name: 'error', value: 40 },
+	crit: { name: 'crit', value: 50 },
+}

package/src/proxy.ts

@@ -0,0 +1,60 @@
+import { Logger, LoggerAttributes, LoggerHandler, LoggerOptions } from './types'
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+const loggerStore = new AsyncLocalStorage<Logger>()
+
+class CurrentLoggerProxy implements Logger {
+	crit(a: any, b?: any, c?: any) {
+		getLogger().crit(a, b)
+	}
+
+	error(a: any, b?: any, c?: any) {
+		getLogger().error(a, b)
+	}
+
+	warn(a: any, b?: any, c?: any) {
+		getLogger().warn(a, b)
+	}
+
+	info(a: any, b?: any, c?: any) {
+		getLogger().info(a, b)
+	}
+
+	debug(a: any, b?: any, c?: any) {
+		getLogger().crit(a, b)
+	}
+
+	child(attributes?: LoggerAttributes, options?: Partial<LoggerOptions>): Logger {
+		return getLogger().child(attributes, options)
+	}
+
+	get attributes() {
+		return getLogger().attributes
+	}
+
+	close(): void {
+		getLogger().close()
+	}
+
+	scope<T>(cb: (logger: Logger) => (Promise<T> | T), attributes?: LoggerAttributes, options?: Partial<LoggerOptions>): Promise<T> {
+		return getLogger().scope(cb, attributes, options)
+	}
+
+	addHandler(handler: LoggerHandler): void {
+		getLogger().addHandler(handler)
+	}
+}
+
+export const logger: Logger = new CurrentLoggerProxy()
+
+export const withLogger = <R>(logger: Logger, callback: () => R): R => {
+	return loggerStore.run(logger, callback)
+}
+
+export const getLogger = (): Logger => {
+	const logger = loggerStore.getStore()
+	if (!logger) {
+		throw new Error('Logger was not set')
+	}
+	return logger
+}

package/src/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "../tsconfig.settings.json",
+	"compilerOptions": {
+		"esModuleInterop": true,
+		"outDir": "../dist/src"
+	}
+}

package/src/types.ts

@@ -0,0 +1,57 @@
+import { FingerCrossedLoggerHandlerOptions } from './handlers/FingerCrossedLoggerHandler'
+
+export type LogFn = ((errorOrMessage: unknown, attributes?: LoggerAttributes) => void)
+
+export interface Logger {
+	attributes: LoggerAttributes
+
+	crit: LogFn
+	error: LogFn
+	warn: LogFn
+	info: LogFn
+	debug: LogFn
+
+	child(attributes?: LoggerAttributes, options?: Partial<LoggerChildOptions>): Logger
+	scope<T>(cb: (logger: Logger) => Promise<T> | T, attributes?: LoggerAttributes, options?: Partial<LoggerChildOptions>): Promise<T>
+	close(): void
+
+	addHandler(handler: LoggerHandler): void
+}
+
+export interface LoggerHandler {
+	getMinLevel(): number
+	handle(logEntry: LogEntry): void
+	close(): void
+}
+
+export type LoggerAttributes = {
+	error?: unknown
+	message?: string
+} & {
+	[key: string | symbol]: any
+}
+
+export type LogLevel = { name: string; value: number }
+
+export type LogEntry = {
+	level: LogLevel
+	time: Date
+	isoTime: string
+	message: string
+	error?: unknown
+	ownAttributes: LoggerAttributes
+	loggerAttributes: LoggerAttributes
+	depth: number
+	format: () => LogEntryFormatted
+}
+export type LogEntryFormatted = { attributes: string; message: string; error: string }
+
+export type LoggerHandlerFactory = (current: LoggerHandler, globalOptions: LoggerOptions) => LoggerHandler
+
+export interface LoggerOptions {
+	fingerCrossedOptions?: Partial<FingerCrossedLoggerHandlerOptions>
+}
+
+export interface LoggerChildOptions extends LoggerOptions {
+	handler?: LoggerHandlerFactory
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+	"files": [],
+	"include": [],
+	"references": [{ "path": "./src" }]
+}

package/tsconfig.settings.json

@@ -0,0 +1,3 @@
+{
+	"extends": "../../tsconfig.settings.json"
+}