@mks2508/better-logger 2.0.1 → 3.0.0

package/src/index.ts

@@ -98,7 +98,12 @@ export const groupEnd = () => getLogger().groupEnd();
 export const time = (label: string) => getLogger().time(label);
 export const timeEnd = (label: string) => getLogger().timeEnd(label);
 export const setGlobalPrefix = (prefix: string) => getLogger().setGlobalPrefix(prefix);
-export const scope = (prefix: string) => getLogger().scope(prefix);
+export const scope = (name: string) => getLogger().scope(name);
+export const component = (name: string) => getLogger().component(name);
+export const api = (name: string) => getLogger().api(name);
+export const badges = (badgeList: string[]) => getLogger().badges(badgeList);
+export const badge = (badgeName: string) => getLogger().badge(badgeName);
+export const clearBadges = () => getLogger().clearBadges();
 export const setVerbosity = (level: Verbosity) => getLogger().setVerbosity(level);
 export const addHandler = (handler: ILogHandler) => getLogger().addHandler(handler);
 export const setTheme = (theme: ThemeVariant) => getLogger().setTheme(theme);
@@ -122,7 +127,26 @@ export type {
     LogMetadata,
     StackInfo,
     TimerEntry,
-    OutputFormat
+    TimerResult,
+    OutputFormat,
+    IScopedLogger,
+    IAPILogger,
+    IComponentLogger,
+    Bindings,
+    SerializerFn,
+    SerializerContext,
+    SerializerConfig,
+    ISerializerRegistry,
+    HookLogEntry,
+    HookEvent,
+    HookCallback,
+    MiddlewareFn,
+    IHookManager,
+    TransportRecord,
+    TransportOptions,
+    TransportTarget,
+    ITransport,
+    StyleCacheConfig
 } from './types/index.js';
 
 // Styling utilities
@@ -141,6 +165,57 @@ export {
     AnalyticsLogHandler
 } from './handlers/index.js';
 
+// Serializers
+export { SerializerRegistry } from './serializers/index.js';
+
+// Hooks & Middleware
+export { HookManager } from './hooks/index.js';
+
+// Transports
+export {
+    TransportManager,
+    ConsoleTransport,
+    FileTransport,
+    HttpTransport
+} from './transports/index.js';
+
+// Style Cache
+export { StyleCache, getStyleCache } from './styling/StyleCache.js';
+
+// Enterprise feature function exports
+import type { SerializerFn, HookEvent, HookCallback, MiddlewareFn, TransportTarget } from './types/index.js';
+export const addSerializer = <T>(
+    type: new (...args: any[]) => T,
+    serializer: SerializerFn<T>,
+    priority?: number
+) => getLogger().addSerializer(type, serializer, priority);
+export const removeSerializer = <T>(type: new (...args: any[]) => T) =>
+    getLogger().removeSerializer(type);
+export const on = (event: HookEvent, callback: HookCallback, priority?: number) =>
+    getLogger().on(event, callback, priority);
+export const once = (event: HookEvent, callback: HookCallback, priority?: number) =>
+    getLogger().once(event, callback, priority);
+export const off = (event: HookEvent, callback: HookCallback) =>
+    getLogger().off(event, callback);
+export const use = (middleware: MiddlewareFn, priority?: number) =>
+    getLogger().use(middleware, priority);
+export const addTransport = (target: TransportTarget) =>
+    getLogger().addTransport(target);
+export const removeTransport = (id: string) =>
+    getLogger().removeTransport(id);
+export const flushTransports = () =>
+    getLogger().flushTransports();
+export const closeTransports = () =>
+    getLogger().closeTransports();
+
+// Scoped loggers
+export {
+    ScopedLogger,
+    APILogger,
+    ComponentLogger,
+    ContextLogger
+} from './ScopedLogger.js';
+
 // Constants
 export { DEFAULT_CONFIG } from './constants.js';
 

package/src/serializers/SerializerRegistry.ts

@@ -0,0 +1,173 @@
+import type {
+    SerializerFn,
+    SerializerContext,
+    SerializerEntry,
+    SerializerConfig,
+    ISerializerRegistry
+} from '../types/index.js';
+
+const DEFAULT_CONFIG: Required<SerializerConfig> = {
+    maxDepth: 5,
+    circular: 'placeholder',
+    preserveUndefined: false
+};
+
+export class SerializerRegistry implements ISerializerRegistry {
+    private serializers: Map<Function, SerializerEntry> = new Map();
+    private config: Required<SerializerConfig>;
+
+    constructor(config: SerializerConfig = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.registerDefaults();
+    }
+
+    private registerDefaults(): void {
+        this.add(Error, (err: Error) => ({
+            name: err.name,
+            message: err.message,
+            stack: err.stack?.split('\n').slice(0, 10),
+            ...(err.cause ? { cause: this.serialize(err.cause) } : {})
+        }), 100);
+
+        this.add(Date, (date: Date) => ({
+            iso: date.toISOString(),
+            timestamp: date.getTime()
+        }), 90);
+
+        this.add(RegExp, (regex: RegExp) => ({
+            pattern: regex.source,
+            flags: regex.flags
+        }), 90);
+
+        this.add(Map, (map: Map<any, any>, ctx) => {
+            const obj: Record<string, any> = {};
+            map.forEach((value, key) => {
+                const keyStr = typeof key === 'object' ? JSON.stringify(key) : String(key);
+                obj[keyStr] = this.serializeInternal(value, {
+                    ...ctx,
+                    depth: ctx.depth + 1,
+                    path: [...ctx.path, keyStr]
+                });
+            });
+            return { __type: 'Map', entries: obj };
+        }, 80);
+
+        this.add(Set, (set: Set<any>, ctx) => ({
+            __type: 'Set',
+            values: Array.from(set).map((v, i) =>
+                this.serializeInternal(v, {
+                    ...ctx,
+                    depth: ctx.depth + 1,
+                    path: [...ctx.path, `[${i}]`]
+                })
+            )
+        }), 80);
+
+        if (typeof Buffer !== 'undefined') {
+            this.add(Buffer as any, (buf: Buffer) => ({
+                __type: 'Buffer',
+                length: buf.length,
+                preview: buf.slice(0, 50).toString('hex')
+            }), 70);
+        }
+    }
+
+    add<T>(
+        type: new (...args: any[]) => T,
+        serializer: SerializerFn<T>,
+        priority: number = 50
+    ): void {
+        this.serializers.set(type, { type, serializer, priority });
+    }
+
+    remove<T>(type: new (...args: any[]) => T): boolean {
+        return this.serializers.delete(type);
+    }
+
+    has<T>(type: new (...args: any[]) => T): boolean {
+        return this.serializers.has(type);
+    }
+
+    getAll(): SerializerEntry[] {
+        return Array.from(this.serializers.values())
+            .sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50));
+    }
+
+    private findSerializer(value: any): SerializerEntry | null {
+        const sorted = this.getAll();
+        for (const entry of sorted) {
+            if (value instanceof entry.type) {
+                return entry;
+            }
+        }
+        return null;
+    }
+
+    private serializeInternal(value: any, context: SerializerContext): any {
+        if (value === null) return null;
+        if (value === undefined) return this.config.preserveUndefined ? undefined : '[undefined]';
+        if (typeof value === 'function') return `[Function: ${value.name || 'anonymous'}]`;
+        if (typeof value !== 'object') return value;
+
+        if (context.depth >= this.config.maxDepth) {
+            return '[Max Depth]';
+        }
+
+        if (context.seen.has(value)) {
+            switch (this.config.circular) {
+                case 'error':
+                    throw new Error(`Circular reference at ${context.path.join('.')}`);
+                case 'skip':
+                    return undefined;
+                case 'placeholder':
+                default:
+                    return '[Circular]';
+            }
+        }
+        context.seen.add(value);
+
+        const serializer = this.findSerializer(value);
+        if (serializer) {
+            return serializer.serializer(value, context);
+        }
+
+        if (Array.isArray(value)) {
+            return value.map((item, i) =>
+                this.serializeInternal(item, {
+                    ...context,
+                    depth: context.depth + 1,
+                    path: [...context.path, `[${i}]`]
+                })
+            );
+        }
+
+        const result: Record<string, any> = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = this.serializeInternal(val, {
+                ...context,
+                depth: context.depth + 1,
+                path: [...context.path, key]
+            });
+        }
+        return result;
+    }
+
+    serialize(value: any, config?: SerializerConfig): any {
+        const mergedConfig = { ...this.config, ...config };
+        return this.serializeInternal(value, {
+            depth: 0,
+            maxDepth: mergedConfig.maxDepth,
+            path: [],
+            seen: new WeakSet()
+        });
+    }
+}
+
+let _defaultRegistry: SerializerRegistry | null = null;
+
+export function getDefaultSerializerRegistry(): SerializerRegistry {
+    if (!_defaultRegistry) {
+        _defaultRegistry = new SerializerRegistry();
+    }
+    return _defaultRegistry;
+}

package/src/serializers/index.ts

@@ -0,0 +1 @@
+export { SerializerRegistry, getDefaultSerializerRegistry } from './SerializerRegistry.js';

package/src/styling/StyleCache.ts

@@ -0,0 +1,131 @@
+import type { LogLevel, DevToolsTheme } from '../types/core.js';
+
+interface CacheKey {
+    level: LogLevel | 'success';
+    theme: DevToolsTheme;
+    presetName?: string;
+    hasPrefix: boolean;
+    hasLocation: boolean;
+}
+
+interface CacheEntry {
+    styles: string[];
+    format: string;
+    createdAt: number;
+    hits: number;
+}
+
+export interface StyleCacheConfig {
+    maxEntries?: number;
+    ttl?: number;
+    enabled?: boolean;
+}
+
+const DEFAULT_CONFIG: Required<StyleCacheConfig> = {
+    maxEntries: 100,
+    ttl: 5 * 60 * 1000,
+    enabled: true
+};
+
+export class StyleCache {
+    private cache: Map<string, CacheEntry> = new Map();
+    private config: Required<StyleCacheConfig>;
+    private hitCount = 0;
+    private missCount = 0;
+
+    constructor(config: StyleCacheConfig = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+
+    private generateKey(key: CacheKey): string {
+        return `${key.level}:${key.theme}:${key.presetName || 'default'}:${key.hasPrefix}:${key.hasLocation}`;
+    }
+
+    get(key: CacheKey): CacheEntry | null {
+        if (!this.config.enabled) return null;
+
+        const cacheKey = this.generateKey(key);
+        const entry = this.cache.get(cacheKey);
+
+        if (!entry) {
+            this.missCount++;
+            return null;
+        }
+
+        if (Date.now() - entry.createdAt > this.config.ttl) {
+            this.cache.delete(cacheKey);
+            this.missCount++;
+            return null;
+        }
+
+        entry.hits++;
+        this.cache.delete(cacheKey);
+        this.cache.set(cacheKey, entry);
+        this.hitCount++;
+
+        return entry;
+    }
+
+    set(key: CacheKey, format: string, styles: string[]): void {
+        if (!this.config.enabled) return;
+
+        const cacheKey = this.generateKey(key);
+
+        if (this.cache.size >= this.config.maxEntries) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+
+        this.cache.set(cacheKey, {
+            format,
+            styles: [...styles],
+            createdAt: Date.now(),
+            hits: 0
+        });
+    }
+
+    clear(): void {
+        this.cache.clear();
+        this.hitCount = 0;
+        this.missCount = 0;
+    }
+
+    getStats(): {
+        size: number;
+        maxSize: number;
+        hitRate: number;
+        hits: number;
+        misses: number;
+    } {
+        const total = this.hitCount + this.missCount;
+        return {
+            size: this.cache.size,
+            maxSize: this.config.maxEntries,
+            hitRate: total > 0 ? this.hitCount / total : 0,
+            hits: this.hitCount,
+            misses: this.missCount
+        };
+    }
+
+    setEnabled(enabled: boolean): void {
+        this.config.enabled = enabled;
+        if (!enabled) {
+            this.clear();
+        }
+    }
+
+    isEnabled(): boolean {
+        return this.config.enabled;
+    }
+}
+
+let _styleCache: StyleCache | null = null;
+
+export function getStyleCache(): StyleCache {
+    if (!_styleCache) {
+        _styleCache = new StyleCache();
+    }
+    return _styleCache;
+}

package/src/transports/ConsoleTransport.ts

@@ -0,0 +1,28 @@
+import type { TransportRecord, TransportOptions, ITransport, LogLevel } from '../types/index.js';
+
+export class ConsoleTransport implements ITransport {
+    readonly name = 'console';
+
+    constructor(private options?: TransportOptions) {}
+
+    write(record: TransportRecord): void {
+        const method = this.getConsoleMethod(record.level);
+        const prefix = record.prefix ? `[${record.prefix}] ` : '';
+        const location = record.location
+            ? ` (${record.location.file}:${record.location.line})`
+            : '';
+
+        console[method](`[${record.level.toUpperCase()}]${prefix} ${record.msg}${location}`);
+    }
+
+    private getConsoleMethod(level: LogLevel): 'log' | 'info' | 'warn' | 'error' {
+        switch (level) {
+            case 'debug': return 'log';
+            case 'info': return 'info';
+            case 'warn': return 'warn';
+            case 'error':
+            case 'critical': return 'error';
+            default: return 'log';
+        }
+    }
+}

package/src/transports/FileTransport.ts

@@ -0,0 +1,53 @@
+import type { TransportRecord, TransportOptions, ITransport } from '../types/index.js';
+
+export interface FileTransportOptions extends TransportOptions {
+    destination?: string;
+}
+
+export class FileTransport implements ITransport {
+    readonly name = 'file';
+    private buffer: string[] = [];
+    private flushTimer?: ReturnType<typeof setInterval>;
+    private options: FileTransportOptions;
+
+    constructor(options?: FileTransportOptions) {
+        this.options = options || {};
+
+        if (this.options.flushInterval) {
+            this.flushTimer = setInterval(() => this.flush(), this.options.flushInterval);
+        }
+    }
+
+    write(record: TransportRecord): void {
+        const line = JSON.stringify(record) + '\n';
+        this.buffer.push(line);
+
+        if (this.buffer.length >= (this.options.batchSize || 100)) {
+            this.flush();
+        }
+    }
+
+    async flush(): Promise<void> {
+        if (this.buffer.length === 0) return;
+
+        const lines = this.buffer.join('');
+        this.buffer = [];
+
+        if (typeof globalThis.process !== 'undefined' && typeof require === 'function') {
+            try {
+                const fs = require('fs');
+                const dest = this.options.destination || 'app.log';
+                fs.appendFileSync(dest, lines);
+            } catch {
+                // Silent fail in browser or if fs not available
+            }
+        }
+    }
+
+    close(): void {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        this.flush();
+    }
+}

package/src/transports/HttpTransport.ts

@@ -0,0 +1,56 @@
+import type { TransportRecord, TransportOptions, ITransport } from '../types/index.js';
+
+export interface HttpTransportOptions extends TransportOptions {
+    url?: string;
+    headers?: Record<string, string>;
+}
+
+export class HttpTransport implements ITransport {
+    readonly name = 'http';
+    private buffer: TransportRecord[] = [];
+    private flushTimer?: ReturnType<typeof setInterval>;
+    private options: HttpTransportOptions;
+
+    constructor(options?: HttpTransportOptions) {
+        this.options = options || {};
+
+        if (this.options.flushInterval) {
+            this.flushTimer = setInterval(() => this.flush(), this.options.flushInterval);
+        }
+    }
+
+    write(record: TransportRecord): void {
+        this.buffer.push(record);
+
+        if (this.buffer.length >= (this.options.batchSize || 50)) {
+            this.flush();
+        }
+    }
+
+    async flush(): Promise<void> {
+        if (this.buffer.length === 0 || !this.options.url) return;
+
+        const records = [...this.buffer];
+        this.buffer = [];
+
+        try {
+            await fetch(this.options.url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.options.headers
+                },
+                body: JSON.stringify({ logs: records })
+            });
+        } catch {
+            this.buffer.unshift(...records);
+        }
+    }
+
+    close(): void {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        this.flush();
+    }
+}

package/src/transports/TransportManager.ts

@@ -0,0 +1,130 @@
+import type {
+    TransportRecord,
+    TransportTarget,
+    TransportOptions,
+    ITransport,
+    ITransportManager,
+    LogLevel
+} from '../types/index.js';
+import { LOG_LEVELS } from '../types/index.js';
+
+function generateTransportId(): string {
+    return `transport-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
+}
+
+interface TransportEntry {
+    id: string;
+    transport: ITransport;
+    options: TransportOptions;
+    level: LogLevel;
+    levelValue: number;
+}
+
+export class TransportManager implements ITransportManager {
+    private transports: Map<string, TransportEntry> = new Map();
+    private defaultLevel: LogLevel = 'info';
+
+    constructor(defaultLevel?: LogLevel) {
+        if (defaultLevel) {
+            this.defaultLevel = defaultLevel;
+        }
+    }
+
+    add(target: TransportTarget): string {
+        const id = generateTransportId();
+        const level = target.level || this.defaultLevel;
+
+        let transport: ITransport;
+
+        if (typeof target.target === 'string') {
+            throw new Error(`String transport targets not supported. Use inline transport object.`);
+        } else {
+            transport = target.target;
+        }
+
+        const entry: TransportEntry = {
+            id,
+            transport,
+            options: target.options || {},
+            level,
+            levelValue: LOG_LEVELS[level]
+        };
+
+        this.transports.set(id, entry);
+        return id;
+    }
+
+    remove(id: string): boolean {
+        const entry = this.transports.get(id);
+        if (entry) {
+            entry.transport.close?.();
+            return this.transports.delete(id);
+        }
+        return false;
+    }
+
+    async write(record: TransportRecord): Promise<void> {
+        const promises: Promise<void>[] = [];
+
+        for (const entry of this.transports.values()) {
+            if (record.levelValue < entry.levelValue) {
+                continue;
+            }
+
+            let transformedRecord = record;
+            if (entry.options.transform) {
+                const result = entry.options.transform(record);
+                if (result === null) continue;
+                transformedRecord = result;
+            }
+
+            const result = entry.transport.write(transformedRecord);
+            if (result instanceof Promise) {
+                promises.push(result);
+            }
+        }
+
+        await Promise.all(promises);
+    }
+
+    async flush(): Promise<void> {
+        const promises: Promise<void>[] = [];
+
+        for (const entry of this.transports.values()) {
+            if (entry.transport.flush) {
+                const result = entry.transport.flush();
+                if (result instanceof Promise) {
+                    promises.push(result);
+                }
+            }
+        }
+
+        await Promise.all(promises);
+    }
+
+    async close(): Promise<void> {
+        await this.flush();
+
+        const promises: Promise<void>[] = [];
+
+        for (const entry of this.transports.values()) {
+            if (entry.transport.close) {
+                const result = entry.transport.close();
+                if (result instanceof Promise) {
+                    promises.push(result);
+                }
+            }
+        }
+
+        await Promise.all(promises);
+        this.transports.clear();
+    }
+
+    get count(): number {
+        return this.transports.size;
+    }
+
+    list(): string[] {
+        return Array.from(this.transports.keys());
+    }
+}

package/src/transports/index.ts

@@ -0,0 +1,4 @@
+export { TransportManager } from './TransportManager.js';
+export { ConsoleTransport } from './ConsoleTransport.js';
+export { FileTransport, type FileTransportOptions } from './FileTransport.js';
+export { HttpTransport, type HttpTransportOptions } from './HttpTransport.js';