logixia 1.0.3 → 1.1.2

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from "async_hooks";
+import { AsyncLocalStorage } from "node:async_hooks";
 import * as _nestjs_common0 from "@nestjs/common";
 import { CallHandler, ExecutionContext, InjectionToken, LoggerService, MiddlewareConsumer, ModuleMetadata, NestInterceptor, NestModule, OptionalFactoryDependency, Type } from "@nestjs/common";
 import { Observable } from "rxjs";
@@ -11,9 +11,9 @@ interface HttpRequest {
   method: string;
   url: string;
   headers: Record<string, string | string[]>;
-  query?: Record<string, any>;
-  params?: Record<string, any>;
-  body?: any;
+  query?: Record<string, unknown>;
+  params?: Record<string, unknown>;
+  body?: unknown;
   ip?: string;
   userAgent?: string;
   timestamp: number;
@@ -21,14 +21,14 @@ interface HttpRequest {
 interface HttpResponse {
   statusCode: number;
   headers: Record<string, string | string[]>;
-  body?: any;
+  body?: unknown;
   timestamp: number;
   contentLength?: number;
 }
 interface HttpError extends Error {
   statusCode?: number;
   code?: string;
-  details?: Record<string, any>;
+  details?: Record<string, unknown>;
 }
 interface RequestTiming {
   start: number;
@@ -63,7 +63,7 @@ declare const LogLevel: {
   readonly TRACE: "trace";
   readonly VERBOSE: "verbose";
 };
-type LogLevel = typeof LogLevel[keyof typeof LogLevel];
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
 type LogLevelString = LogLevel | (string & {});
 type LogColor = 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white' | 'gray' | 'grey' | 'brightRed' | 'brightGreen' | 'brightYellow' | 'brightBlue' | 'brightMagenta' | 'brightCyan' | 'brightWhite';
 type LogFieldKey = 'timestamp' | 'level' | 'appName' | 'service' | 'traceId' | 'message' | 'payload' | 'timeTaken' | 'context' | 'requestId' | 'userId' | 'sessionId' | 'environment';
@@ -80,6 +80,43 @@ interface TraceIdConfig {
   contextKey?: string;
   extractor?: TraceIdExtractorConfig;
 }
+interface RedactConfig {
+  /**
+   * Dot-notation field paths to redact. Supports `*` (one segment) and `**` (any depth).
+   * @example `['req.headers.authorization', '*.password', 'user.creditCard']`
+   */
+  paths?: string[];
+  /**
+   * Regex patterns applied to string values — replaces matches with the censor string.
+   * @example `[/Bearer\s+\S+/gi, /sk-[a-z0-9]{32,}/gi]`
+   */
+  patterns?: RegExp[];
+  /** Replacement value for redacted content. Default: `"[REDACTED]"` */
+  censor?: string;
+}
+/**
+ * Per-namespace log level overrides.
+ * Keys are namespace patterns (dot-separated, `*` wildcard); values are log levels.
+ *
+ * @example
+ * ```ts
+ * namespaceLevels: {
+ *   'db.*':    'debug',   // all db.* namespaces → DEBUG
+ *   'http.*':  'warn',    // all http.* → WARN only
+ *   'payment': 'trace',   // payment namespace → TRACE
+ * }
+ * ```
+ * ENV overrides: `LOGIXIA_LEVEL_DB=debug` maps to namespace `db`.
+ */
+type NamespaceLevels = Record<string, LogLevelString>;
+interface GracefulShutdownConfig {
+  /** Auto-register SIGTERM/SIGINT handlers to flush this logger on exit. Default: false */
+  enabled: boolean;
+  /** Max ms to wait for transports to flush. Default: 5000 */
+  timeout?: number;
+  /** Signals to listen on. Default: ['SIGTERM', 'SIGINT'] */
+  signals?: NodeJS.Signals[];
+}
 interface LoggerConfig<TLevels extends Record<string, number> = Record<string, number>> {
   appName?: string;
   environment?: Environment;
@@ -96,17 +133,34 @@ interface LoggerConfig<TLevels extends Record<string, number> = Record<string, n
     colors?: Record<string, LogColor>;
   } | undefined;
   fields?: Partial<Record<LogFieldKey, string | boolean>>;
-  [key: string]: any;
+  /**
+   * Built-in log redaction — masks sensitive fields before they reach any transport.
+   * @see RedactConfig
+   */
+  redact?: RedactConfig;
+  /**
+   * Per-namespace log level overrides.
+   * A child logger's context is used as its namespace for matching.
+   * ENV vars `LOGIXIA_LEVEL_<NS>=<level>` also apply.
+   */
+  namespaceLevels?: NamespaceLevels;
+  /**
+   * Automatically register SIGTERM/SIGINT handlers that flush all transports
+   * before the process exits — prevents losing the last N seconds of logs on
+   * deployments / restarts.
+   */
+  gracefulShutdown?: boolean | GracefulShutdownConfig;
+  [key: string]: unknown;
 }
 interface IBaseLogger {
-  error(message: string, data?: Record<string, any>): Promise<void>;
-  error(error: Error, data?: Record<string, any>): Promise<void>;
-  warn(message: string, data?: Record<string, any>): Promise<void>;
-  info(message: string, data?: Record<string, any>): Promise<void>;
-  debug(message: string, data?: Record<string, any>): Promise<void>;
-  trace(message: string, data?: Record<string, any>): Promise<void>;
-  verbose(message: string, data?: Record<string, any>): Promise<void>;
-  logLevel(level: string, message: string, data?: Record<string, any>): Promise<void>;
+  error(message: string, data?: Record<string, unknown>): Promise<void>;
+  error(error: Error, data?: Record<string, unknown>): Promise<void>;
+  warn(message: string, data?: Record<string, unknown>): Promise<void>;
+  info(message: string, data?: Record<string, unknown>): Promise<void>;
+  debug(message: string, data?: Record<string, unknown>): Promise<void>;
+  trace(message: string, data?: Record<string, unknown>): Promise<void>;
+  verbose(message: string, data?: Record<string, unknown>): Promise<void>;
+  logLevel(level: string, message: string, data?: Record<string, unknown>): Promise<void>;
   time(label: string): void;
   timeEnd(label: string): Promise<number | undefined>;
   timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;
@@ -125,10 +179,10 @@ interface IBaseLogger {
   getTransportLevels(transportId: string): string[] | undefined;
   clearTransportLevelPreferences(): void;
   getAvailableTransports(): string[];
-  child(context: string, data?: Record<string, any>): ILogger;
+  child(context: string, data?: Record<string, unknown>): ILogger;
   close(): Promise<void>;
 }
-type CustomLevelMethods<T extends Record<string, number>> = { [K in keyof T]: (message: string, data?: Record<string, any>) => Promise<void> };
+type CustomLevelMethods<T extends Record<string, number>> = { [K in keyof T]: (message: string, data?: Record<string, unknown>) => Promise<void> };
 type ILogger<TLevels extends Record<string, number> = {}> = IBaseLogger & CustomLevelMethods<TLevels>;
 interface ILoggerDefault extends IBaseLogger {}
 type LoggerWithLevels<T extends LoggerConfig<any>> = T['levelOptions'] extends {
@@ -142,7 +196,7 @@ interface LogEntry {
   environment?: string;
   traceId?: string;
   message: string;
-  payload?: Record<string, any>;
+  payload?: Record<string, unknown>;
   context?: string;
   error?: Error;
 }
@@ -158,7 +212,7 @@ interface TimingEntry {
   duration?: number;
 }
 interface ContextData {
-  [key: string]: any;
+  [key: string]: unknown;
 }
 interface ILogFormatter {
   format(entry: LogEntry): string;
@@ -203,33 +257,45 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<any> = LoggerConfig> im
   private contextData;
   private transportManager?;
   private fieldState;
-  constructor(config: TConfig, context?: string);
+  /** Stable fallback trace ID generated ONCE per logger instance. */
+  private readonly fallbackTraceId;
+  /** Numeric value for each known log level — built once, read on every log call. */
+  private _levelValues;
+  /** Numeric threshold for the currently active log level. */
+  private _minLevelValue;
+  /** Pre-built ANSI color codes to avoid recreating the object in colorize(). */
+  private _colorMap;
+  /** Pre-computed field-enabled booleans so isFieldEnabled() isn't called per log. */
+  private _fieldCache;
+  /** True when contextData is non-empty — avoids Object.keys() check on hot path. */
+  private _hasContextData;
   /**
-   * Create dynamic methods for custom levels
+   * Pre-computed `[INFO] `, `[WARN] ` etc. strings — avoids a colorize() call per log.
+   * Key: lowercase level name. Value: formatted bracket string ready to concatenate.
    */
+  private _formattedLevels;
+  /** Pre-computed `[appName] ` string — avoids template literal allocation per log. */
+  private _formattedAppName;
+  /** True when a redact config is present — short-circuits applyRedaction when false. */
+  private _hasRedact;
+  constructor(config: TConfig, context?: string);
+  private setupGracefulShutdown;
   private createCustomLevelMethods;
   /**
-   * Error logging with overloads
-   */
-  error(messageOrError: string | Error, data?: Record<string, any>): Promise<void>;
-  warn(message: string, data?: Record<string, any>): Promise<void>;
-  info(message: string, data?: Record<string, any>): Promise<void>;
-  debug(message: string, data?: Record<string, any>): Promise<void>;
-  trace(message: string, data?: Record<string, any>): Promise<void>;
-  verbose(message: string, data?: Record<string, any>): Promise<void>;
-  /**
-   * Log with custom level
-   */
-  logLevel(level: string, message: string, data?: Record<string, any>): Promise<void>;
-  /**
-   * Timing methods
+   * Rebuild all hot-path caches after any config mutation or level change.
+   * Keeps the actual log() call free of allocations in the common case.
    */
+  private _buildPerfCaches;
+  error(messageOrError: string | Error, data?: Record<string, unknown>): Promise<void>;
+  warn(message: string, data?: Record<string, unknown>): Promise<void>;
+  info(message: string, data?: Record<string, unknown>): Promise<void>;
+  debug(message: string, data?: Record<string, unknown>): Promise<void>;
+  trace(message: string, data?: Record<string, unknown>): Promise<void>;
+  verbose(message: string, data?: Record<string, unknown>): Promise<void>;
+  logLevel(level: string, message: string, data?: Record<string, unknown>): Promise<void>;
   time(label: string): void;
   timeEnd(label: string): Promise<number | undefined>;
   timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;
-  /**
-   * Level and context management
-   */
   setLevel(level: LogLevelString): void;
   getLevel(): LogLevelString;
   setContext(context: string): void;
@@ -245,46 +311,33 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<any> = LoggerConfig> im
   getTransportLevels(transportId: string): string[] | undefined;
   clearTransportLevelPreferences(): void;
   getAvailableTransports(): string[];
-  /**
-   * Create child logger
-   */
-  child(context: string, data?: Record<string, any>): ILogger;
-  /**
-   * Flush all transports
-   */
+  child(context: string, data?: Record<string, unknown>): ILogger;
   flush(): Promise<void>;
-  /**
-   * Check health of all transports
-   */
   healthCheck(): Promise<{
     healthy: boolean;
-    details: Record<string, any>;
+    details: Record<string, unknown>;
   }>;
-  /**
-   * Close logger and cleanup resources
-   */
   close(): Promise<void>;
-  /**
-   * Core logging method
-   */
   private log;
   /**
-   * Format log entry according to configuration
-   */
-  private formatLog;
-  /**
-   * Colorize text based on color name
+   * Hot-path level check: a single Map lookup + integer compare.
+   * The level map and threshold are pre-built in _buildPerfCaches().
    */
-  private colorize;
   private shouldLog;
   /**
-   * Output log to console or other destinations
+   * Feature 3: Resolve the effective log level for this logger instance.
+   *
+   * Priority:
+   *  1. ENV `LOGIXIA_LEVEL_<NS_UPPER>` (e.g. LOGIXIA_LEVEL_DB for ns "db" or "db.queries")
+   *  2. Matching `namespaceLevels` config entry (longer pattern = more specific, wins)
+   *  3. Global `LOGIXIA_LEVEL` ENV override
+   *  4. `levelOptions.level` (resolved via Feature 5 in constructor)
    */
+  private resolveEffectiveLevel;
+  private formatLog;
+  private colorize;
   private output;
 }
-/**
- * Factory function to create a typed logger with custom levels
- */
 declare function createLogger$1<T extends LoggerConfig<any>>(config: T, context?: string): LoggerWithLevels<T>;
 //#endregion
 //#region src/core/logitron-nestjs.service.d.ts
@@ -295,17 +348,17 @@ declare class LogixiaLoggerService implements LoggerService {
   /**
    * NestJS LoggerService interface implementation
    */
-  log(message: any, context?: string): void;
-  error(message: any, trace?: string, context?: string): void;
-  warn(message: any, context?: string): void;
-  debug(message: any, context?: string): void;
-  verbose(message: any, context?: string): void;
+  log(message: unknown, context?: string): void;
+  error(message: unknown, trace?: string, context?: string): void;
+  warn(message: unknown, context?: string): void;
+  debug(message: unknown, context?: string): void;
+  verbose(message: unknown, context?: string): void;
   /**
    * Extended Logitron methods
    */
-  info(message: string, data?: Record<string, any>): Promise<void>;
-  trace(message: string, data?: Record<string, any>): Promise<void>;
-  logLevel(level: string, message: string, data?: Record<string, any>): Promise<void>;
+  info(message: string, data?: Record<string, unknown>): Promise<void>;
+  trace(message: string, data?: Record<string, unknown>): Promise<void>;
+  logLevel(level: string, message: string, data?: Record<string, unknown>): Promise<void>;
   /**
    * Timing methods
    */
@@ -322,7 +375,7 @@ declare class LogixiaLoggerService implements LoggerService {
   /**
    * Create child logger
    */
-  child(context: string, data?: Record<string, any>): LogixiaLoggerService;
+  child(context: string, data?: Record<string, unknown>): LogixiaLoggerService;
   /**
    * Get current trace ID
    */
@@ -366,7 +419,7 @@ declare const LOGIXIA_LOGGER_PREFIX = "LOGIXIA_LOGGER_";
 interface LogixiaAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
   useExisting?: Type<LogixiaOptionsFactory>;
   useClass?: Type<LogixiaOptionsFactory>;
-  useFactory?: (...args: any[]) => Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
+  useFactory?: (...args: unknown[]) => Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
   inject?: Array<InjectionToken | OptionalFactoryDependency>;
 }
 interface LogixiaOptionsFactory {
@@ -421,7 +474,7 @@ declare class LogixiaLoggerModule implements NestModule {
     imports: (Type<any> | _nestjs_common0.DynamicModule | Promise<_nestjs_common0.DynamicModule> | _nestjs_common0.ForwardReference<any>)[];
     providers: ({
       provide: string;
-      useFactory: (...args: any[]) => Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
+      useFactory: (...args: unknown[]) => Promise<Partial<LoggerConfig>> | Partial<LoggerConfig>;
       inject: (InjectionToken | OptionalFactoryDependency)[];
     } | {
       provide: string;
@@ -515,9 +568,89 @@ declare class TextFormatter implements ILogFormatter {
   static createMinimal(): TextFormatter;
 }
 //#endregion
+//#region src/utils/error.utils.d.ts
+/**
+ * Serialize an Error into a plain JSON-safe object, including:
+ *  - `name`, `message`, `stack`
+ *  - `cause` (recursively serialized, full ES2022 chain)
+ *  - `errors` (for AggregateError)
+ *  - standard Node.js error fields (`code`, `statusCode`, `errno`, …)
+ *  - any other enumerable own properties
+ */
+declare function serializeError(error: Error, options?: ErrorSerializationOptions): Record<string, unknown>;
+/**
+ * Type guard: returns true if the value looks like an Error object.
+ */
+declare function isError(value: unknown): value is Error;
+/**
+ * Coerce any thrown value into a proper Error instance.
+ */
+declare function normalizeError(error: unknown): Error;
+//#endregion
+//#region src/utils/redact.utils.d.ts
+/**
+ * Deep-clone and redact an object according to the given RedactConfig.
+ * Non-objects are returned as-is (with pattern replacement on strings).
+ *
+ * The function is intentionally non-mutating — it returns a new object.
+ */
+declare function redactObject(obj: Record<string, unknown>, config: RedactConfig, _currentPath?: string): Record<string, unknown>;
+/**
+ * Apply redaction to a log payload (top-level call convenience wrapper).
+ * Returns a new object — never mutates the input.
+ */
+declare function applyRedaction(payload: Record<string, unknown> | undefined, config: RedactConfig | undefined): Record<string, unknown> | undefined;
+//#endregion
+//#region src/utils/shutdown.utils.d.ts
+/**
+ * Graceful shutdown utilities for Logixia
+ *
+ * Ensures all in-flight logs are flushed to every transport before the process
+ * exits on SIGTERM / SIGINT — solving the "last N seconds of logs are lost on
+ * deployment" problem reported in Pino issue #2002 and LogDNA issue #15.
+ */
+interface FlushOnExitOptions {
+  /** How long (ms) to wait for transports to flush before force-exiting. Default: 5000 */
+  timeout?: number;
+  /** OS signals that trigger a graceful flush. Default: ['SIGTERM', 'SIGINT'] */
+  signals?: NodeJS.Signals[];
+  /** Called just before flushing starts — useful for stopping traffic intake */
+  beforeFlush?: () => void | Promise<void>;
+  /** Called after all loggers have flushed successfully */
+  afterFlush?: () => void | Promise<void>;
+}
+type Closeable = {
+  close(): Promise<void>;
+};
+/**
+ * Register a logger instance so it is included in the graceful shutdown flush.
+ * Called automatically when `gracefulShutdown: true` is set in logger config.
+ */
+declare function registerForShutdown(logger: Closeable): void;
+/**
+ * Deregister a logger (e.g. after `logger.close()` is called manually).
+ */
+declare function deregisterFromShutdown(logger: Closeable): void;
+/**
+ * Register SIGTERM / SIGINT handlers that flush all registered loggers before
+ * the process exits. Idempotent — calling multiple times is safe.
+ *
+ * @example
+ * ```ts
+ * import { flushOnExit } from 'logixia';
+ * flushOnExit({ timeout: 5000 });
+ * ```
+ */
+declare function flushOnExit(options?: FlushOnExitOptions): void;
+/**
+ * Remove all graceful shutdown handlers and clear the registry.
+ * Primarily useful in tests.
+ */
+declare function resetShutdownHandlers(): void;
+//#endregion
 //#region src/utils/trace.utils.d.ts
 declare const traceStorage: AsyncLocalStorage<{
-  [key: string]: any;
+  [key: string]: unknown;
   traceId: string;
 }>;
 /**
@@ -529,35 +662,823 @@ declare function generateTraceId(): string;
  */
 declare function getCurrentTraceId(): string | undefined;
 /**
- * Set trace ID in async context
+ * Set trace ID in the CURRENT async context without starting a new one.
+ *
+ * ⚠️  Uses `enterWith()` which mutates the context for the current async
+ * execution and ALL futures spawned from it. Prefer `runWithTraceId()` when
+ * you can wrap the operation in a callback, as it creates a properly-scoped
+ * child context. Use `setTraceId()` only when you cannot use `runWithTraceId()`
+ * (e.g., inside a class constructor or a non-callback async entry point).
  */
-declare function setTraceId(traceId: string, data?: Record<string, any>): void;
+declare function setTraceId(traceId: string, data?: Record<string, unknown>): void;
 /**
  * Run function with trace ID context
  */
-declare function runWithTraceId<T>(traceId: string, fn: () => T, data?: Record<string, any>): T;
+declare function runWithTraceId<T>(traceId: string, fn: () => T, data?: Record<string, unknown>): T;
 /**
  * Extract trace ID from request using configuration
  */
-declare function extractTraceId(request: any, config: TraceIdExtractorConfig): string | undefined;
+declare function extractTraceId(request: unknown, config: TraceIdExtractorConfig): string | undefined;
+/**
+ * Default headers checked for incoming trace ID propagation, in priority order:
+ *   traceparent (W3C/OTel) → x-trace-id → x-request-id → x-correlation-id → trace-id
+ */
+declare const DEFAULT_TRACE_HEADERS: string[];
 /**
  * Create trace ID middleware for Express/NestJS
  */
-declare function createTraceMiddleware(config: TraceIdConfig): (req: any, res: any, next: any) => void;
+declare function createTraceMiddleware(config: TraceIdConfig): (req: unknown, res: unknown, next: () => void) => void;
 //#endregion
-//#region src/utils/error.utils.d.ts
+//#region src/search/types/search.types.d.ts
+/**
+ * Search filter options
+ */
+interface SearchFilters {
+  levels?: string[];
+  services?: string[];
+  traceIds?: string[];
+  timeRange?: TimeRange;
+  userIds?: string[];
+  sessionIds?: string[];
+  contexts?: string[];
+  excludePatterns?: string[];
+  minSeverity?: number;
+  hasError?: boolean;
+  customFields?: Record<string, unknown>;
+}
+/**
+ * Time range for filtering logs
+ */
+interface TimeRange {
+  start: Date | number;
+  end?: Date | number;
+  relative?: RelativeTime;
+}
 /**
- * Serialize error object to JSON-safe format
+ * Relative time specification
  */
-declare function serializeError(error: Error, options?: ErrorSerializationOptions): Record<string, any>;
+interface RelativeTime {
+  value: number;
+  unit: 'seconds' | 'minutes' | 'hours' | 'days';
+}
 /**
- * Check if value is an Error instance
+ * Search result with metadata
  */
-declare function isError(value: any): value is Error;
+interface SearchResult {
+  log: LogEntry;
+  score: number;
+  highlights?: SearchHighlight[];
+  matches?: SearchMatch[];
+  context?: LogEntry[];
+  relatedLogs?: RelatedLog[];
+}
 /**
- * Create error from various input types
+ * Search highlight information
  */
-declare function normalizeError(error: any): Error;
+interface SearchHighlight {
+  field: string;
+  fragments: string[];
+  matchedTerms: string[];
+}
+/**
+ * Search match details
+ */
+interface SearchMatch {
+  field: string;
+  value: string;
+  position: number;
+  length: number;
+}
+/**
+ * Related log entry
+ */
+interface RelatedLog {
+  log: LogEntry;
+  relationship: RelationshipType;
+  score: number;
+}
+/**
+ * Type of relationship between logs
+ */
+type RelationshipType = 'same_trace' | 'same_user' | 'same_session' | 'temporal_proximity' | 'error_cascade' | 'similar_pattern';
+/**
+ * Correlated logs grouped by trace ID or other criteria
+ */
+interface CorrelatedLogs {
+  traceId?: string;
+  correlationKey: string;
+  logs: LogEntry[];
+  timeline: TimelineEvent[];
+  summary?: LogCorrelationSummary;
+}
+/**
+ * Timeline event for correlated logs
+ */
+interface TimelineEvent {
+  timestamp: Date;
+  log: LogEntry;
+  eventType: 'start' | 'end' | 'error' | 'milestone' | 'info';
+  duration?: number;
+}
+/**
+ * Summary of correlated logs
+ */
+interface LogCorrelationSummary {
+  totalLogs: number;
+  errorCount: number;
+  warningCount: number;
+  duration?: number;
+  services: string[];
+  criticalPath?: LogEntry[];
+}
+/**
+ * Similar log entry
+ */
+interface SimilarLog {
+  log: LogEntry;
+  similarity: number;
+  matchedPatterns: string[];
+  reason: string;
+}
+/**
+ * Search query with metadata
+ */
+interface SearchQuery {
+  query: string;
+  filters?: SearchFilters;
+  options?: SearchOptions;
+  timestamp: Date;
+  userId?: string;
+}
+/**
+ * Search options
+ */
+interface SearchOptions {
+  limit?: number;
+  offset?: number;
+  sortBy?: SortField;
+  sortOrder?: 'asc' | 'desc';
+  includeContext?: boolean;
+  contextSize?: number;
+  highlightMatches?: boolean;
+  findSimilar?: boolean;
+  correlate?: boolean;
+  semanticSearch?: boolean;
+}
+/**
+ * Sort field options
+ */
+type SortField = 'timestamp' | 'level' | 'score' | 'relevance';
+/**
+ * Search suggestion
+ */
+interface SearchSuggestion {
+  text: string;
+  type: SuggestionType;
+  category?: string;
+  frequency?: number;
+  lastUsed?: Date;
+}
+/**
+ * Suggestion type
+ */
+type SuggestionType = 'field' | 'value' | 'operator' | 'query_history' | 'pattern' | 'filter';
+/**
+ * Search statistics
+ */
+interface SearchStats {
+  totalResults: number;
+  executionTime: number;
+  indexSize: number;
+  cacheHitRate?: number;
+  topTerms?: string[];
+}
+/**
+ * Semantic index for intelligent search
+ */
+interface SemanticIndex {
+  version: string;
+  indexedCount: number;
+  lastUpdated: Date;
+  embeddings?: Map<string, number[]>;
+  clusters?: LogCluster[];
+}
+/**
+ * Log cluster for grouping similar logs
+ */
+interface LogCluster {
+  id: string;
+  centroid: number[];
+  logs: LogEntry[];
+  pattern: string;
+  frequency: number;
+  labels?: string[];
+}
+/**
+ * Log pattern for pattern recognition
+ */
+interface LogPattern {
+  id: string;
+  pattern: string;
+  regex?: RegExp;
+  examples: LogEntry[];
+  frequency: number;
+  lastSeen: Date;
+  category?: string;
+  severity?: string;
+}
+/**
+ * Anomaly detection result
+ */
+interface AnomalyDetection {
+  log: LogEntry;
+  anomalyScore: number;
+  reason: string;
+  expectedPattern?: string;
+  deviations: string[];
+}
+/**
+ * Natural language query parsed result
+ */
+interface ParsedNLQuery {
+  originalQuery: string;
+  intent: QueryIntent;
+  entities: QueryEntity[];
+  filters: SearchFilters;
+  timeRange?: TimeRange;
+  confidence: number;
+}
+/**
+ * Query intent
+ */
+type QueryIntent = 'find_errors' | 'trace_request' | 'find_user_activity' | 'performance_analysis' | 'find_similar' | 'time_range_query' | 'correlation' | 'general_search';
+/**
+ * Query entity extracted from natural language
+ */
+interface QueryEntity {
+  type: EntityType;
+  value: string;
+  field?: string;
+  confidence: number;
+}
+/**
+ * Entity type
+ */
+type EntityType = 'level' | 'service' | 'user_id' | 'trace_id' | 'time' | 'error_type' | 'field_value';
+/**
+ * Search preset for saving common searches
+ */
+interface SearchPreset {
+  id: string;
+  name: string;
+  description?: string;
+  query: string;
+  filters: SearchFilters;
+  options: SearchOptions;
+  createdAt: Date;
+  updatedAt: Date;
+  userId?: string;
+  shared?: boolean;
+}
+/**
+ * Export options for search results
+ */
+interface ExportOptions {
+  format: 'json' | 'csv' | 'text';
+  includeMetadata?: boolean;
+  filename?: string;
+  fields?: string[];
+}
+//#endregion
+//#region src/search/search-manager.d.ts
+/**
+ * Configuration for search manager
+ */
+interface SearchManagerConfig {
+  enableNLP?: boolean;
+  enablePatternRecognition?: boolean;
+  enableCorrelation?: boolean;
+  maxIndexSize?: number;
+  autoOptimize?: boolean;
+}
+/**
+ * Main search manager class
+ */
+declare class SearchManager {
+  private searchEngine;
+  private indexer;
+  private patternEngine?;
+  private correlationEngine?;
+  private config;
+  constructor(config?: SearchManagerConfig);
+  /**
+   * Index new logs
+   */
+  indexLogs(logs: LogEntry[]): Promise<void>;
+  /**
+   * Add a single log to the index
+   */
+  indexLog(log: LogEntry): Promise<void>;
+  /**
+   * Perform a search
+   */
+  search(query: string, filters?: SearchFilters, options?: SearchOptions): Promise<SearchResult[]>;
+  /**
+   * Perform a natural language search
+   */
+  naturalLanguageSearch(query: string): Promise<SearchResult[]>;
+  /**
+   * Find logs correlated by trace ID
+   */
+  correlateByTraceId(traceId: string): Promise<CorrelatedLogs>;
+  /**
+   * Find similar logs
+   */
+  findSimilarLogs(logEntry: LogEntry, limit?: number): Promise<SimilarLog[]>;
+  /**
+   * Find logs related to a given log
+   */
+  findRelatedLogs(log: LogEntry, limit?: number): Promise<RelatedLog[]>;
+  /**
+   * Get search suggestions
+   */
+  getSuggestions(partialQuery: string, limit?: number): Promise<SearchSuggestion[]>;
+  /**
+   * Get search statistics
+   */
+  getStats(): Promise<SearchStats>;
+  /**
+   * Parse natural language query
+   */
+  parseNaturalLanguageQuery(query: string): Promise<ParsedNLQuery>;
+  /**
+   * Save a search preset
+   */
+  savePreset(preset: Omit<SearchPreset, 'id' | 'createdAt' | 'updatedAt'>): Promise<SearchPreset>;
+  /**
+   * Get saved presets
+   */
+  getPresets(userId?: string): Promise<SearchPreset[]>;
+  /**
+   * Delete a preset
+   */
+  deletePreset(presetId: string): Promise<void>;
+  /**
+   * Detect log patterns
+   */
+  detectPatterns(): Promise<LogPattern[]>;
+  /**
+   * Get detected patterns
+   */
+  getPatterns(): LogPattern[];
+  /**
+   * Detect anomalies in logs
+   */
+  detectAnomalies(): Promise<AnomalyDetection[]>;
+  /**
+   * Correlate logs by multiple criteria
+   */
+  correlateByMultipleCriteria(criteria: {
+    traceId?: boolean;
+    userId?: boolean;
+    sessionId?: boolean;
+    temporal?: boolean;
+    errorCascade?: boolean;
+  }): Promise<Map<string, CorrelatedLogs>>;
+  /**
+   * Analyze error cascades
+   */
+  analyzeErrorCascade(traceId: string): Promise<{
+    rootCause?: LogEntry;
+    cascade: LogEntry[];
+    impactedServices: string[];
+  }>;
+  /**
+   * Export search results
+   */
+  exportResults(results: SearchResult[], options: ExportOptions): Promise<string>;
+  /**
+   * Clear all indexed data
+   */
+  clearIndex(): Promise<void>;
+  /**
+   * Optimize the index
+   */
+  optimizeIndex(): Promise<void>;
+  /**
+   * Get index statistics
+   */
+  getIndexStats(): Promise<{
+    totalDocuments: number;
+    indexSize: number;
+    lastOptimized?: Date;
+  }>;
+  /**
+   * Remove old logs
+   */
+  removeOldLogs(olderThan: Date): Promise<number>;
+  private exportAsJSON;
+  private exportAsCSV;
+  private exportAsText;
+  private filterFields;
+  private getNestedValue;
+  private escapeCSVValue;
+}
+//#endregion
+//#region src/search/core/log-indexer.interface.d.ts
+/**
+ * Log indexer interface
+ */
+interface ILogIndexer {
+  /**
+   * Index a single log entry
+   * @param log - Log entry to index
+   */
+  indexLog(log: LogEntry): Promise<void>;
+  /**
+   * Index multiple log entries in batch
+   * @param logs - Array of log entries to index
+   */
+  indexBatch(logs: LogEntry[]): Promise<void>;
+  /**
+   * Build semantic index for intelligent search
+   * @param logs - Array of log entries to build index from
+   * @returns Semantic index
+   */
+  buildSemanticIndex(logs: LogEntry[]): Promise<SemanticIndex>;
+  /**
+   * Update search suggestions based on search history
+   * @param searchHistory - Array of past search queries
+   */
+  updateSearchSuggestions(searchHistory: SearchQuery[]): Promise<void>;
+  /**
+   * Optimize the index for better performance
+   */
+  optimizeIndex(): Promise<void>;
+  /**
+   * Clear the index
+   */
+  clearIndex(): Promise<void>;
+  /**
+   * Get index statistics
+   * @returns Index statistics
+   */
+  getIndexStats(): Promise<{
+    totalDocuments: number;
+    indexSize: number;
+    lastOptimized?: Date;
+  }>;
+  /**
+   * Remove logs older than specified time
+   * @param olderThan - Remove logs older than this date
+   * @returns Number of logs removed
+   */
+  removeOldLogs(olderThan: Date): Promise<number>;
+}
+//#endregion
+//#region src/search/core/basic-log-indexer.d.ts
+/**
+ * Basic log indexer implementation
+ */
+declare class BasicLogIndexer implements ILogIndexer {
+  private options?;
+  private index;
+  private fieldIndices;
+  private semanticIndex;
+  private lastOptimized?;
+  constructor(options?: {
+    maxIndexSize?: number;
+    autoOptimize?: boolean;
+    optimizeThreshold?: number;
+  } | undefined);
+  /**
+   * Index a single log entry
+   */
+  indexLog(log: LogEntry): Promise<void>;
+  /**
+   * Index multiple log entries in batch
+   */
+  indexBatch(logs: LogEntry[]): Promise<void>;
+  /**
+   * Build semantic index for intelligent search
+   */
+  buildSemanticIndex(logs: LogEntry[]): Promise<SemanticIndex>;
+  /**
+   * Update search suggestions based on search history
+   */
+  updateSearchSuggestions(searchHistory: SearchQuery[]): Promise<void>;
+  /**
+   * Optimize the index for better performance
+   */
+  optimizeIndex(): Promise<void>;
+  /**
+   * Clear the index
+   */
+  clearIndex(): Promise<void>;
+  /**
+   * Get index statistics
+   */
+  getIndexStats(): Promise<{
+    totalDocuments: number;
+    indexSize: number;
+    lastOptimized?: Date;
+  }>;
+  /**
+   * Remove logs older than specified time
+   */
+  removeOldLogs(olderThan: Date): Promise<number>;
+  /**
+   * Search logs by field
+   */
+  searchByField(field: string, value: string): LogEntry[];
+  /**
+   * Get all indexed logs
+   */
+  getAllLogs(): LogEntry[];
+  private initializeFieldIndices;
+  private updateFieldIndices;
+  private addToFieldIndex;
+  private removeFromFieldIndices;
+  private generateLogId;
+  private calculateIndexSize;
+  private removeOldestLogs;
+  private clusterLogs;
+}
+//#endregion
+//#region src/search/core/search-engine.interface.d.ts
+/**
+ * Main search engine interface
+ */
+interface ILogSearchEngine {
+  /**
+   * Perform a full-text search across logs
+   * @param query - Search query string
+   * @param filters - Optional filters to narrow down results
+   * @param options - Search options
+   * @returns Array of search results
+   */
+  search(query: string, filters?: SearchFilters, options?: SearchOptions): Promise<SearchResult[]>;
+  /**
+   * Perform a natural language search
+   * @param query - Natural language query
+   * @returns Array of search results
+   */
+  naturalLanguageSearch(query: string): Promise<SearchResult[]>;
+  /**
+   * Find logs correlated by trace ID
+   * @param traceId - Trace ID to correlate logs
+   * @returns Correlated logs
+   */
+  correlateByTraceId(traceId: string): Promise<CorrelatedLogs>;
+  /**
+   * Find logs similar to a given log entry
+   * @param logEntry - Log entry to find similar logs for
+   * @param limit - Maximum number of similar logs to return
+   * @returns Array of similar logs
+   */
+  findSimilarLogs(logEntry: LogEntry, limit?: number): Promise<SimilarLog[]>;
+  /**
+   * Get search suggestions based on partial query
+   * @param partialQuery - Partial query string
+   * @param limit - Maximum number of suggestions
+   * @returns Array of suggestions
+   */
+  getSuggestions(partialQuery: string, limit?: number): Promise<SearchSuggestion[]>;
+  /**
+   * Get search statistics
+   * @returns Search statistics
+   */
+  getStats(): Promise<SearchStats>;
+  /**
+   * Parse natural language query
+   * @param query - Natural language query
+   * @returns Parsed query with intent and entities
+   */
+  parseNaturalLanguageQuery(query: string): Promise<ParsedNLQuery>;
+  /**
+   * Save a search preset
+   * @param preset - Search preset to save
+   * @returns Saved preset with ID
+   */
+  savePreset(preset: Omit<SearchPreset, 'id' | 'createdAt' | 'updatedAt'>): Promise<SearchPreset>;
+  /**
+   * Get saved presets
+   * @param userId - Optional user ID to filter presets
+   * @returns Array of presets
+   */
+  getPresets(userId?: string): Promise<SearchPreset[]>;
+  /**
+   * Delete a preset
+   * @param presetId - ID of preset to delete
+   */
+  deletePreset(presetId: string): Promise<void>;
+}
+//#endregion
+//#region src/search/core/basic-search-engine.d.ts
+/**
+ * Basic search engine implementation
+ */
+declare class BasicSearchEngine implements ILogSearchEngine {
+  private options?;
+  private logs;
+  private presets;
+  private searchHistory;
+  private suggestionCache;
+  constructor(options?: {
+    maxHistorySize?: number;
+    cacheSize?: number;
+  } | undefined);
+  /**
+   * Add logs to the search index
+   */
+  addLogs(logs: LogEntry[]): void;
+  /**
+   * Clear all logs from the index
+   */
+  clearLogs(): void;
+  /**
+   * Get all indexed logs
+   */
+  getLogs(): LogEntry[];
+  /**
+   * Perform a full-text search across logs
+   */
+  search(query: string, filters?: SearchFilters, options?: SearchOptions): Promise<SearchResult[]>;
+  /**
+   * Natural language search (basic implementation)
+   */
+  naturalLanguageSearch(query: string): Promise<SearchResult[]>;
+  /**
+   * Find logs correlated by trace ID
+   */
+  correlateByTraceId(traceId: string): Promise<CorrelatedLogs>;
+  /**
+   * Find similar logs based on content similarity
+   */
+  findSimilarLogs(logEntry: LogEntry, limit?: number): Promise<SimilarLog[]>;
+  /**
+   * Get search suggestions
+   */
+  getSuggestions(partialQuery: string, limit?: number): Promise<SearchSuggestion[]>;
+  /**
+   * Get search statistics
+   */
+  getStats(): Promise<SearchStats>;
+  /**
+   * Parse natural language query
+   */
+  parseNaturalLanguageQuery(query: string): Promise<ParsedNLQuery>;
+  /**
+   * Save a search preset
+   */
+  savePreset(preset: Omit<SearchPreset, 'id' | 'createdAt' | 'updatedAt'>): Promise<SearchPreset>;
+  /**
+   * Get saved presets
+   */
+  getPresets(userId?: string): Promise<SearchPreset[]>;
+  /**
+   * Delete a preset
+   */
+  deletePreset(presetId: string): Promise<void>;
+  private applyFilters;
+  private performTextSearch;
+  private getSearchableText;
+  private getHighlightFragments;
+  private applySorting;
+  private applyPagination;
+  private enrichWithContext;
+  private calculateSimilarity;
+  private calculateTextSimilarity;
+  private findMatchedPatterns;
+  private generateSimilarityReason;
+  private extractTimeRange;
+  private addToSearchHistory;
+  private getTopTerms;
+  private generateId;
+}
+//#endregion
+//#region src/search/engines/correlation-engine.d.ts
+/**
+ * Correlation engine for log analysis
+ */
+declare class CorrelationEngine {
+  private options?;
+  constructor(options?: {
+    maxCorrelationDistance?: number;
+    temporalWindowMs?: number;
+    minSimilarityScore?: number;
+  } | undefined);
+  /**
+   * Find logs related to a given log entry
+   */
+  findRelatedLogs(log: LogEntry, allLogs: LogEntry[], limit?: number): Promise<RelatedLog[]>;
+  /**
+   * Correlate logs by multiple criteria
+   */
+  correlateByMultipleCriteria(logs: LogEntry[], criteria: {
+    traceId?: boolean;
+    userId?: boolean;
+    sessionId?: boolean;
+    temporal?: boolean;
+    errorCascade?: boolean;
+  }): Promise<Map<string, CorrelatedLogs>>;
+  /**
+   * Build a timeline from correlated logs
+   */
+  buildTimeline(logs: LogEntry[]): TimelineEvent[];
+  /**
+   * Analyze error cascades
+   */
+  analyzeErrorCascade(logs: LogEntry[]): Promise<{
+    rootCause?: LogEntry;
+    cascade: LogEntry[];
+    impactedServices: string[];
+  }>;
+  private correlateByTraceId;
+  private correlateByUserId;
+  private correlateBySessionId;
+  private correlateByTemporalProximity;
+  private correlateErrorCascades;
+  private buildErrorCascade;
+  private findRelationships;
+  private calculateRelationshipScore;
+  private haveSimilarPattern;
+  private normalizeMessage;
+  private determineEventType;
+  private deduplicateRelatedLogs;
+  private convertToCorrelatedLogs;
+  private generateSummary;
+}
+//#endregion
+//#region src/search/engines/nlp-search-engine.d.ts
+/**
+ * NLP-enhanced search engine
+ */
+declare class NLPSearchEngine extends BasicSearchEngine {
+  private intentPatterns;
+  private entityPatterns;
+  constructor(options?: Record<string, unknown>);
+  /**
+   * Enhanced natural language query parsing
+   */
+  parseNaturalLanguageQuery(query: string): Promise<ParsedNLQuery>;
+  /**
+   * Enhanced natural language search
+   */
+  naturalLanguageSearch(query: string): Promise<SearchResult[]>;
+  private initializePatterns;
+  private detectIntent;
+  private extractEntities;
+  private applyEntityToFilter;
+  private extractAdvancedTimeRange;
+  private calculateConfidence;
+  private getOptionsForIntent;
+  private extractCleanQuery;
+}
+//#endregion
+//#region src/search/engines/pattern-recognition-engine.d.ts
+/**
+ * Pattern recognition engine for log analysis
+ */
+declare class PatternRecognitionEngine {
+  private options?;
+  private patterns;
+  private patternFrequencies;
+  constructor(options?: {
+    minFrequency?: number;
+    maxPatterns?: number;
+    anomalyThreshold?: number;
+  } | undefined);
+  /**
+   * Analyze logs and detect patterns
+   */
+  analyzePatterns(logs: LogEntry[]): Promise<LogPattern[]>;
+  /**
+   * Detect anomalies in logs
+   */
+  detectAnomalies(logs: LogEntry[]): Promise<AnomalyDetection[]>;
+  /**
+   * Find patterns matching a log entry
+   */
+  findMatchingPatterns(log: LogEntry): LogPattern[];
+  /**
+   * Get all detected patterns
+   */
+  getPatterns(): LogPattern[];
+  /**
+   * Get pattern by ID
+   */
+  getPattern(patternId: string): LogPattern | undefined;
+  private extractMessagePatterns;
+  private extractErrorPatterns;
+  private extractTimingPatterns;
+  private normalizeMessage;
+  private extractErrorPattern;
+  private calculateAnomalyScore;
+  private generateAnomalyReason;
+  private findDeviations;
+  private doesLogMatchPattern;
+}
 //#endregion
 //#region src/index.d.ts
 /**
@@ -644,10 +1565,6 @@ declare const logger: LogixiaLogger<{
   };
   outputs: string[];
 }>;
-/**
- * Export default configuration for reference
- */
-
 //#endregion
-export { ContextData, CustomLevelMethods, DEFAULT_CONFIG, DEFAULT_LOG_COLORS, DEFAULT_LOG_LEVELS, Environment, ErrorSerializationOptions, ExtractLevels, HttpError, HttpRequest, HttpResponse, IBaseLogger, ILogFormatter, ILogger, ILoggerDefault, JsonFormatter, KafkaTraceInterceptor, LOGIXIA_LOGGER_CONFIG, LOGIXIA_LOGGER_PREFIX, LogColor, LogEntry, LogFieldKey, LogLevel, LogLevelString, LoggerConfig, type LoggerConfig as LoggerConfigInterface, LoggerWithLevels, LogixiaAsyncOptions, LogixiaLogger, LogixiaLoggerModule, LogixiaLoggerService, LogixiaOptionsFactory, RequestContext, RequestMetrics, RequestTiming, TextFormatter, TimingEntry, TraceIdConfig, TraceIdExtractorConfig, WebSocketTraceInterceptor, createLogger, createLoggerService, createTraceMiddleware, extractTraceId, generateTraceId, getCurrentTraceId, isError, logger, normalizeError, runWithTraceId, serializeError, setTraceId, traceStorage };
+export { AnomalyDetection, BasicLogIndexer, BasicSearchEngine, ContextData, CorrelatedLogs, CorrelationEngine, CustomLevelMethods, DEFAULT_CONFIG, DEFAULT_LOG_COLORS, DEFAULT_LOG_LEVELS, DEFAULT_TRACE_HEADERS, EntityType, Environment, ErrorSerializationOptions, ExportOptions, ExtractLevels, FlushOnExitOptions, GracefulShutdownConfig, HttpError, HttpRequest, HttpResponse, IBaseLogger, ILogFormatter, ILogIndexer, ILogSearchEngine, ILogger, ILoggerDefault, JsonFormatter, KafkaTraceInterceptor, LOGIXIA_LOGGER_CONFIG, LOGIXIA_LOGGER_PREFIX, LogCluster, LogColor, LogCorrelationSummary, LogEntry, LogFieldKey, LogLevel, LogLevelString, LogPattern, LoggerConfig, type LoggerConfig as LoggerConfigInterface, LoggerWithLevels, LogixiaAsyncOptions, LogixiaLogger, LogixiaLoggerModule, LogixiaLoggerService, LogixiaOptionsFactory, NLPSearchEngine, NamespaceLevels, ParsedNLQuery, PatternRecognitionEngine, QueryEntity, QueryIntent, type RedactConfig, RelatedLog, RelationshipType, RelativeTime, RequestContext, RequestMetrics, RequestTiming, SearchFilters, SearchHighlight, SearchManager, SearchManagerConfig, SearchMatch, SearchOptions, SearchPreset, SearchQuery, SearchResult, SearchStats, SearchSuggestion, SemanticIndex, SimilarLog, SortField, SuggestionType, TextFormatter, TimeRange, TimelineEvent, TimingEntry, TraceIdConfig, TraceIdExtractorConfig, WebSocketTraceInterceptor, applyRedaction, createLogger, createLoggerService, createTraceMiddleware, deregisterFromShutdown, extractTraceId, flushOnExit, generateTraceId, getCurrentTraceId, isError, logger, normalizeError, redactObject, registerForShutdown, resetShutdownHandlers, runWithTraceId, serializeError, setTraceId, traceStorage };
 //# sourceMappingURL=index.d.mts.map