legal-markdown-js/dist/extensions/pipeline/pipeline-logger.d.ts

Node.js implementation of LegalMarkdown for processing legal documents with markdown and YAML - Complete feature parity with Ruby version

/**
 * @fileoverview Pipeline Logging System for Legal Markdown Processing
 *
 * This module provides comprehensive logging capabilities for the Legal Markdown
 * processing pipeline. It supports multiple logging levels, structured output,
 * performance metrics, and integration with external monitoring systems.
 *
 * Features:
 * - Structured logging with consistent format
 * - Performance metrics and timing
 * - Debug output with step-by-step visibility
 * - Error tracking and reporting
 * - Configurable log levels and outputs
 * - Integration with pipeline events
 * - Memory usage tracking
 * - Field tracking logging
 *
 * @example
 * ```typescript
 * import { PipelineLogger, ConsolePipelineLogger } from './pipeline-logger';
 *
 * const logger = new ConsolePipelineLogger({
 *   level: 'debug',
 *   enableMetrics: true,
 *   enableColors: true
 * });
 *
 * logger.startPipeline({ steps: [], fieldTrackingMode: 'centralized' });
 * logger.startStep('mixins', 1500);
 * logger.completeStep('mixins', stepResult);
 * logger.completePipeline(pipelineResult);
 * ```
 */
import { PipelineConfig, PipelineResult, StepResult, ProcessingError } from './types';
/**
 * Log level enumeration for controlling output verbosity
 *
 * @enum {string} LogLevel
 */
export declare enum LogLevel {
    ERROR = "error",
    WARN = "warn",
    INFO = "info",
    DEBUG = "debug",
    TRACE = "trace"
}
/**
 * Configuration options for pipeline loggers
 *
 * @interface PipelineLoggerConfig
 * @example
 * ```typescript
 * const config: PipelineLoggerConfig = {
 *   level: LogLevel.DEBUG,
 *   enableMetrics: true,
 *   enableColors: true,
 *   enableTimestamps: true,
 *   prefix: '[LEGAL-MD]',
 *   outputFormat: 'structured'
 * };
 * ```
 */
export interface PipelineLoggerConfig {
    /** Minimum log level to output */
    level?: LogLevel;
    /** Whether to enable performance metrics collection */
    enableMetrics?: boolean;
    /** Whether to use colors in console output */
    enableColors?: boolean;
    /** Whether to include timestamps in log messages */
    enableTimestamps?: boolean;
    /** Prefix for all log messages */
    prefix?: string;
    /** Output format style */
    outputFormat?: 'simple' | 'structured' | 'json';
    /** Whether to track memory usage */
    enableMemoryTracking?: boolean;
}
/**
 * Base interface for pipeline logging systems
 *
 * @interface PipelineLogger
 * @example
 * ```typescript
 * class CustomLogger implements PipelineLogger {
 *   startPipeline(config: PipelineConfig): void {
 *     this.log('info', 'Pipeline starting with config', config);
 *   }
 *
 *   startStep(stepName: string, inputSize: number): void {
 *     this.log('debug', `Step ${stepName} starting`, { inputSize });
 *   }
 * }
 * ```
 */
export interface PipelineLogger {
    /**
     * Called when pipeline execution begins
     *
     * @param config - Pipeline configuration
     */
    startPipeline(config: PipelineConfig): void;
    /**
     * Called when a step begins execution
     *
     * @param stepName - Name of the step starting
     * @param inputSize - Size of input content in characters
     */
    startStep(stepName: string, inputSize: number): void;
    /**
     * Called when a step completes successfully
     *
     * @param stepName - Name of the completed step
     * @param result - Step execution result
     */
    completeStep(stepName: string, result: StepResult): void;
    /**
     * Called when a step is skipped
     *
     * @param stepName - Name of the skipped step
     * @param reason - Reason for skipping
     */
    skipStep(stepName: string, reason: string): void;
    /**
     * Called when a step encounters an error
     *
     * @param stepName - Name of the failed step
     * @param error - Error that occurred
     */
    errorStep(stepName: string, error: ProcessingError): void;
    /**
     * Called when the entire pipeline completes
     *
     * @param result - Complete pipeline result
     */
    completePipeline(result: PipelineResult): void;
    /**
     * Called when the pipeline fails critically
     *
     * @param error - Critical error that caused failure
     */
    errorPipeline(error: ProcessingError): void;
    /**
     * Log field tracking information
     *
     * @param fieldName - Name of the field
     * @param action - Action performed on the field
     * @param metadata - Additional field metadata
     */
    logFieldTracking(fieldName: string, action: string, metadata?: Record<string, any>): void;
    /**
     * Generate a complete pipeline execution report
     *
     * @returns Formatted report string
     */
    generateReport(): string;
}
/**
 * Console-based pipeline logger with rich formatting
 *
 * @class ConsolePipelineLogger
 * @example
 * ```typescript
 * const logger = new ConsolePipelineLogger({
 *   level: LogLevel.DEBUG,
 *   enableColors: true,
 *   enableMetrics: true
 * });
 *
 * // Use with pipeline manager
 * const pipeline = new PipelineManager(logger);
 * ```
 */
export declare class ConsolePipelineLogger implements PipelineLogger {
    private config;
    private startTime;
    private stepTimings;
    private metrics;
    constructor(config?: PipelineLoggerConfig);
    startPipeline(config: PipelineConfig): void;
    startStep(stepName: string, inputSize: number): void;
    completeStep(stepName: string, result: StepResult): void;
    skipStep(stepName: string, reason: string): void;
    errorStep(stepName: string, error: ProcessingError): void;
    completePipeline(result: PipelineResult): void;
    errorPipeline(error: ProcessingError): void;
    logFieldTracking(fieldName: string, action: string, metadata?: Record<string, any>): void;
    generateReport(): string;
    private resetMetrics;
    private shouldLog;
    private log;
    private colorizeLevel;
    private formatBytes;
    private formatSizeChange;
    private getMemoryUsage;
    private trackMemoryUsage;
    private logMetricsSummary;
}
/**
 * Null logger that discards all log messages (useful for testing)
 *
 * @class NullPipelineLogger
 */
export declare class NullPipelineLogger implements PipelineLogger {
    startPipeline(): void;
    startStep(): void;
    completeStep(): void;
    skipStep(): void;
    errorStep(): void;
    completePipeline(): void;
    errorPipeline(): void;
    logFieldTracking(): void;
    generateReport(): string;
}
//# sourceMappingURL=pipeline-logger.d.ts.map