weelog/dist/weelog.d.ts

Next-generation JavaScript logging library with performance tracking, memory monitoring, analytics, and advanced debugging features.

/**
 * WeeLog - Tiny Logging Library for JavaScript
 * Zero dependencies, browser and Node.js compatible
 */
export interface LoggerOptions {
    level?: LogLevel;
    enabled?: boolean;
    useTimestamp?: boolean;
    useHumanReadableTimestamp?: boolean;
    enablePerformanceTracking?: boolean;
    enableMemoryTracking?: boolean;
    logMemoryInline?: boolean;
    maxLogHistory?: number;
    enableLogAnalytics?: boolean;
    autoDetectEnvironment?: boolean;
    environment?: 'development' | 'production' | 'staging' | 'test';
    developmentConfig?: Partial<LoggerOptions>;
    productionConfig?: Partial<LoggerOptions>;
    stagingConfig?: Partial<LoggerOptions>;
    testConfig?: Partial<LoggerOptions>;
}
export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
export type LogInterceptor = (level: LogLevel, message: string, context?: string, data?: any) => void;
export interface LogEntry {
    level: LogLevel;
    message: string;
    context?: string;
    data?: any;
    timestamp: Date;
    formatted: string;
    performance?: PerformanceMetrics;
    memory?: MemoryInfo;
    stackTrace?: string;
    sessionId?: string;
}
export interface PerformanceMetrics {
    duration?: number;
    timestamp: number;
    memoryUsage?: number;
}
export interface MemoryInfo {
    used: number;
    total: number;
    percentage: number;
}
export interface LogAnalytics {
    totalLogs: number;
    logsByLevel: Record<LogLevel, number>;
    averageLogRate: number;
    errorRate: number;
    topContexts: Array<{
        context: string;
        count: number;
    }>;
}
export declare class Logger {
    private level;
    private enabled;
    private useTimestamp;
    private useHumanReadableTimestamp;
    private context?;
    private interceptors;
    private enablePerformanceTracking;
    private enableMemoryTracking;
    private logMemoryInline;
    private maxLogHistory;
    private enableLogAnalytics;
    private logHistory;
    private sessionId;
    private performanceMarks;
    private analytics;
    private detectedEnvironment;
    private readonly levels;
    private readonly colors;
    constructor(options?: LoggerOptions);
    /**
     * Detect the current environment
     */
    private detectEnvironment;
    /**
     * Apply environment-specific configuration
     */
    private applyEnvironmentConfig;
    /**
     * Get the detected environment
     */
    getEnvironment(): 'development' | 'production' | 'staging' | 'test';
    /**
     * Set the minimum log level
     */
    setLevel(level: LogLevel): Logger;
    /**
     * Enable or disable logging
     */
    enable(enabled: boolean): Logger;
    /**
     * Create a logger with a specific context
     */
    withContext(context: string): Logger;
    /**
     * Add a log interceptor callback
     */
    onLog(callback: LogInterceptor): Logger;
    /**
     * Generate a unique session ID
     */
    private generateSessionId;
    /**
     * Get memory usage information
     */
    private getMemoryInfo;
    /**
     * Format memory usage for inline display
     */
    private formatMemoryUsage;
    /**
     * Start performance tracking for a specific operation
     */
    startPerformanceTimer(label: string): Logger;
    /**
     * End performance tracking and log the duration
     */
    endPerformanceTimer(label: string, message?: string): LogEntry | null;
    /**
     * Log with automatic stack trace capture
     */
    trace(message: string, data?: any): LogEntry | null;
    /**
     * Get current analytics data
     */
    getAnalytics(): LogAnalytics;
    /**
     * Get log history
     */
    getLogHistory(): LogEntry[];
    /**
     * Clear log history
     */
    clearHistory(): Logger;
    /**
     * Export logs as JSON
     */
    exportLogs(): string;
    /**
     * Search logs by criteria
     */
    searchLogs(criteria: {
        level?: LogLevel;
        context?: string;
        message?: string;
        timeRange?: {
            start: Date;
            end: Date;
        };
    }): LogEntry[];
    /**
     * Check if a log level should be output
     */
    private shouldLog;
    /**
     * Format a log message
     */
    private formatMessage;
    /**
     * Process data object to apply human readable timestamps
     */
    private processDataTimestamps;
    /**
     * Internal log method
     */
    private log;
    /**
     * Update analytics data
     */
    private updateAnalytics;
    /**
     * Output formatted message to console with colors (browser only)
     */
    private outputToConsole;
    /**
     * Log a debug message
     */
    debug(message: string, data?: any): LogEntry | null;
    /**
     * Log an info message
     */
    info(message: string, data?: any): LogEntry | null;
    /**
     * Log a warning message
     */
    warn(message: string, data?: any): LogEntry | null;
    /**
     * Log an error message
     */
    error(message: string, data?: any): LogEntry | null;
}
export declare const log: (message: string, data?: any) => LogEntry | null;
export declare const info: (message: string, data?: any) => LogEntry | null;
export declare const warn: (message: string, data?: any) => LogEntry | null;
export declare const error: (message: string, data?: any) => LogEntry | null;
export declare const debug: (message: string, data?: any) => LogEntry | null;
export declare const success: (message: string, data?: any) => LogEntry | null;
export default Logger;
//# sourceMappingURL=weelog.d.ts.map