@visulima/pail 4.0.0-alpha.11 → 4.0.0-alpha.12

package/dist/processor/redact-processor.d.ts

@@ -1,44 +1,63 @@
-import type { RedactOptions, Rules } from "@visulima/redact";
-import type { Meta, Processor } from "../types.d.ts";
+import { M as Meta, P as Processor } from "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+type StringAnonymize = {
+  key: string;
+  pattern: RegExp | string;
+  replacement?: string;
+};
+type Anonymize = {
+  deep?: boolean;
+  key: string;
+  pattern?: RegExp | string;
+  replacement?: unknown;
+};
+type Rules = (Anonymize | StringAnonymize | number | string)[];
+type RedactOptions = {
+  exclude?: (number | string)[];
+  logger?: {
+    debug: (message?: unknown, ...optionalParameters: unknown[]) => void;
+  };
+};
 /**
- * Redact Processor.
- *
- * A processor that redacts sensitive information from log messages and metadata.
- * Uses the {@link https://visulima.com/packages/redact/|@visulima/redact} library to identify and mask sensitive data like
- * passwords, API keys, credit card numbers, and other PII.
- * @template L - The log level type
- * @example
- * ```typescript
- * import { createPail } from "@visulima/pail";
- * import RedactProcessor from "@visulima/pail/processor/redact";
- *
- * const logger = createPail({
- *   processors: [new RedactProcessor()]
- * });
- *
- * logger.info("User login", {
- *   username: "john",
- *   password: "secret123",  // Will be redacted
- *   apiKey: "sk-123456"    // Will be redacted
- * });
- * ```
- */
+* Redact Processor.
+*
+* A processor that redacts sensitive information from log messages and metadata.
+* Uses the {@link https://visulima.com/packages/redact/|@visulima/redact} library to identify and mask sensitive data like
+* passwords, API keys, credit card numbers, and other PII.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+* import RedactProcessor from "@visulima/pail/processor/redact";
+*
+* const logger = createPail({
+*   processors: [new RedactProcessor()]
+* });
+*
+* logger.info("User login", {
+*   username: "john",
+*   password: "secret123",  // Will be redacted
+*   apiKey: "sk-123456"    // Will be redacted
+* });
+* ```
+*/
 declare class RedactProcessor<L extends string = string> implements Processor<L> {
-    #private;
-    /**
-     * Creates a new RedactProcessor instance.
-     * @param rules Custom redaction rules (uses standardRules if not provided)
-     * @param options Additional redaction options
-     */
-    constructor(rules?: Rules, options?: RedactOptions);
-    /**
-     * Processes log metadata to redact sensitive information.
-     *
-     * Applies redaction rules to the message, context, and error properties
-     * in the log metadata to prevent sensitive data from being logged.
-     * @param meta The log metadata to process
-     * @returns The processed metadata with sensitive data redacted
-     */
-    process(meta: Meta<L>): Meta<L>;
+  #private;
+  /**
+  * Creates a new RedactProcessor instance.
+  * @param rules Custom redaction rules (uses standardRules if not provided)
+  * @param options Additional redaction options
+  */
+  constructor(rules?: Rules, options?: RedactOptions);
+  /**
+  * Processes log metadata to redact sensitive information.
+  *
+  * Applies redaction rules to the message, context, and error properties
+  * in the log metadata to prevent sensitive data from being logged.
+  * @param meta The log metadata to process
+  * @returns The processed metadata with sensitive data redacted
+  */
+  process(meta: Meta<L>): Meta<L>;
 }
-export default RedactProcessor;
+export { RedactProcessor as default };

package/dist/processor/sampling-processor.d.ts

@@ -1,111 +1,112 @@
-import type { Meta, Processor } from "../types.d.ts";
+import { M as Meta, P as Processor } from "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * Head sampling configuration.
- *
- * Controls random sampling rates per log level. Each key is a log level name
- * and the value is the percentage (0-100) of logs at that level to keep.
- * Levels not listed default to 100 (keep all).
- * @example
- * ```typescript
- * const headSampling: HeadSamplingConfig = {
- *   debug: 0,      // Drop all debug logs
- *   informational: 10,  // Keep 10% of info logs
- *   warning: 50,   // Keep 50% of warning logs
- *   error: 100,    // Keep all error logs
- * };
- * ```
- */
+* Head sampling configuration.
+*
+* Controls random sampling rates per log level. Each key is a log level name
+* and the value is the percentage (0-100) of logs at that level to keep.
+* Levels not listed default to 100 (keep all).
+* @example
+* ```typescript
+* const headSampling: HeadSamplingConfig = {
+*   debug: 0,      // Drop all debug logs
+*   informational: 10,  // Keep 10% of info logs
+*   warning: 50,   // Keep 50% of warning logs
+*   error: 100,    // Keep all error logs
+* };
+* ```
+*/
 type HeadSamplingConfig = Partial<Record<string, number>>;
 /**
- * Tail sampling condition function.
- *
- * A function that receives the log metadata and returns true if the log
- * should be force-kept regardless of head sampling. This allows keeping
- * important logs based on their content (e.g., errors, slow operations).
- * @template L - The log level type
- */
+* Tail sampling condition function.
+*
+* A function that receives the log metadata and returns true if the log
+* should be force-kept regardless of head sampling. This allows keeping
+* important logs based on their content (e.g., errors, slow operations).
+* @template L - The log level type
+*/
 type TailSamplingCondition<L extends string = string> = (meta: Readonly<Meta<L>>) => boolean;
 /**
- * Sampling processor configuration options.
- */
+* Sampling processor configuration options.
+*/
 interface SamplingProcessorOptions<L extends string = string> {
-    /**
-     * Head sampling rates per log level.
-     *
-     * A map of log level to sampling percentage (0-100).
-     * Levels not specified default to 100 (keep all).
-     * Set to 0 to drop all logs at that level.
-     */
-    head?: HeadSamplingConfig;
-    /**
-     * Tail sampling conditions.
-     *
-     * An array of condition functions that can force-keep a log entry
-     * even if it was dropped by head sampling. If any condition returns true,
-     * the log is kept.
-     */
-    tail?: TailSamplingCondition<L>[];
+  /**
+  * Head sampling rates per log level.
+  *
+  * A map of log level to sampling percentage (0-100).
+  * Levels not specified default to 100 (keep all).
+  * Set to 0 to drop all logs at that level.
+  */
+  head?: HeadSamplingConfig;
+  /**
+  * Tail sampling conditions.
+  *
+  * An array of condition functions that can force-keep a log entry
+  * even if it was dropped by head sampling. If any condition returns true,
+  * the log is kept.
+  */
+  tail?: TailSamplingCondition<L>[];
 }
 /**
- * Sampling Processor.
- *
- * Inspired by evlog's production sampling strategy, this processor implements
- * both head sampling (random per-level) and tail sampling (force-keep based
- * on conditions) to control log volume in production environments.
- *
- * **Head sampling** randomly drops a percentage of logs per level. This is
- * evaluated first and provides broad volume control.
- *
- * **Tail sampling** can override head sampling to force-keep important logs
- * based on their content. For example, you might drop 90% of info logs but
- * force-keep any that contain error information or relate to slow operations.
- *
- * When a log is dropped by sampling, the processor sets a `__dropped: true`
- * boolean flag on the meta object. Reporters should check for this flag and
- * skip entries where `__dropped` is `true`.
- * @template L - The log level type
- * @example
- * ```typescript
- * import { createPail } from "@visulima/pail";
- * import SamplingProcessor from "@visulima/pail/processor/sampling";
- *
- * const logger = createPail({
- *   processors: [
- *     new SamplingProcessor({
- *       head: {
- *         debug: 0,         // Drop all debug logs
- *         informational: 10, // Keep 10% of info logs
- *         warning: 50,      // Keep 50% of warnings
- *         error: 100,       // Keep all errors
- *       },
- *       tail: [
- *         // Force-keep logs with errors regardless of head sampling
- *         (meta) => meta.error !== undefined,
- *         // Force-keep logs from critical scopes
- *         (meta) => meta.scope?.includes("payment") ?? false,
- *       ],
- *     }),
- *   ],
- * });
- * ```
- */
+* Sampling Processor.
+*
+* Inspired by evlog's production sampling strategy, this processor implements
+* both head sampling (random per-level) and tail sampling (force-keep based
+* on conditions) to control log volume in production environments.
+*
+* **Head sampling** randomly drops a percentage of logs per level. This is
+* evaluated first and provides broad volume control.
+*
+* **Tail sampling** can override head sampling to force-keep important logs
+* based on their content. For example, you might drop 90% of info logs but
+* force-keep any that contain error information or relate to slow operations.
+*
+* When a log is dropped by sampling, the processor sets a `__dropped: true`
+* boolean flag on the meta object. Reporters should check for this flag and
+* skip entries where `__dropped` is `true`.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+* import SamplingProcessor from "@visulima/pail/processor/sampling";
+*
+* const logger = createPail({
+*   processors: [
+*     new SamplingProcessor({
+*       head: {
+*         debug: 0,         // Drop all debug logs
+*         informational: 10, // Keep 10% of info logs
+*         warning: 50,      // Keep 50% of warnings
+*         error: 100,       // Keep all errors
+*       },
+*       tail: [
+*         // Force-keep logs with errors regardless of head sampling
+*         (meta) => meta.error !== undefined,
+*         // Force-keep logs from critical scopes
+*         (meta) => meta.scope?.includes("payment") ?? false,
+*       ],
+*     }),
+*   ],
+* });
+* ```
+*/
 declare class SamplingProcessor<L extends string = string> implements Processor<L> {
-    #private;
-    /**
-     * Creates a new SamplingProcessor instance.
-     * @param options Sampling configuration options
-     */
-    constructor(options?: SamplingProcessorOptions<L>);
-    /**
-     * Processes log metadata to apply sampling rules.
-     *
-     * First evaluates head sampling (random per-level), then checks tail
-     * sampling conditions. If a log is dropped, the meta is marked with
-     * `__dropped: true` so reporters can skip it.
-     * @param meta The log metadata to process
-     * @returns The processed metadata, potentially marked as dropped
-     */
-    process(meta: Meta<L>): Meta<L>;
+  #private;
+  /**
+  * Creates a new SamplingProcessor instance.
+  * @param options Sampling configuration options
+  */
+  constructor(options?: SamplingProcessorOptions<L>);
+  /**
+  * Processes log metadata to apply sampling rules.
+  *
+  * First evaluates head sampling (random per-level), then checks tail
+  * sampling conditions. If a log is dropped, the meta is marked with
+  * `__dropped: true` so reporters can skip it.
+  * @param meta The log metadata to process
+  * @returns The processed metadata, potentially marked as dropped
+  */
+  process(meta: Meta<L>): Meta<L>;
 }
-export default SamplingProcessor;
-export type { HeadSamplingConfig, SamplingProcessorOptions, TailSamplingCondition };
+export { type HeadSamplingConfig, type SamplingProcessorOptions, type TailSamplingCondition, SamplingProcessor as default };

package/dist/reporter/file/json-file-reporter.d.ts

@@ -1,46 +1,95 @@
-import type { Options as RfsOptions } from "rotating-file-stream";
-import type { AbstractJsonReporterOptions } from "../json/abstract-json-reporter.d.ts";
-import { AbstractJsonReporter } from "../json/abstract-json-reporter.d.ts";
-import RotatingFileStream from "./utils/rotating-file-stream.d.ts";
+import { Options } from 'rotating-file-stream';
+import { A as AbstractJsonReporterOptions, a as AbstractJsonReporter } from "../../packem_shared/abstract-json-reporter.d-BAgznjyU.js";
+import 'safe-stable-stringify';
+import "../../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * Options for configuring the JsonFileReporter.
- */
-export type FileReporterOptions = AbstractJsonReporterOptions & RfsOptions & {
-    /** Path to the log file */
-    filePath: string;
-    /** Whether to write immediately to disk instead of buffering */
-    writeImmediately?: boolean;
+* Rotating File Stream.
+*
+* A wrapper for the `rotating-file-stream` module that provides optional immediate
+* writing to disk by creating and closing a new stream on each write operation.
+* This is useful for ensuring log messages are written immediately rather than buffered.
+* @example
+* ```typescript
+* // Buffered writing (default)
+* const bufferedStream = new RotatingFileStream("/var/log/app.log", false, {
+*   interval: "1d",
+*   size: "10M"
+* });
+*
+* // Immediate writing
+* const immediateStream = new RotatingFileStream("/var/log/app.log", true, {
+*   interval: "1d"
+* });
+* ```
+*/
+declare class RotatingFileStream {
+  #private;
+  /**
+  * Creates a new RotatingFileStream instance.
+  * @param filePath Path to the log file
+  * @param writeImmediately Whether to write immediately or buffer writes
+  * @param options Options for the rotating file stream
+  * @throws {Error} If the 'rotating-file-stream' package is not installed
+  */
+  constructor(filePath: string, writeImmediately?: boolean, options?: Options);
+  /**
+  * Writes a message to the rotating file stream.
+  *
+  * If writeImmediately was set to true in the constructor, a new stream
+  * is created for each write operation. Otherwise, uses the buffered stream.
+  * @param message The message to write to the file
+  */
+  write(message: string): void;
+  /**
+  * Ends the rotating file stream.
+  *
+  * Closes the underlying stream. When `writeImmediately` is not `true`,
+  * calling `write` after calling this method will throw an error.
+  */
+  end(): void;
+}
+/**
+* Options for configuring the JsonFileReporter.
+*/
+type FileReporterOptions = AbstractJsonReporterOptions & Options & {
+  /** Path to the log file */
+  filePath: string;
+  /** Whether to write immediately to disk instead of buffering */
+  writeImmediately?: boolean;
 };
 /**
- * JSON File Reporter.
- *
- * A reporter that writes structured JSON log entries to rotating files on disk.
- * Supports automatic file rotation based on size, time intervals, and compression.
- * @template L - The log level type
- * @example
- * ```typescript
- * const reporter = new JsonFileReporter({
- *   filePath: "/var/log/app.log",
- *   interval: "1d", // Rotate daily
- *   size: "10M",   // Rotate when file reaches 10MB
- *   compress: "gzip"
- * });
- *
- * logger.registerReporters([reporter]);
- * ```
- */
-export declare class JsonFileReporter<L extends string = string> extends AbstractJsonReporter<L> {
-    /** The rotating file stream instance */
-    protected stream: RotatingFileStream;
-    /**
-     * Creates a new JsonFileReporter instance.
-     * @param options Configuration options for file rotation and JSON formatting
-     */
-    constructor(options: FileReporterOptions);
-    /**
-     * Writes a JSON message to the rotating file stream.
-     * @param message The JSON-formatted log message to write
-     * @protected
-     */
-    protected _log(message: string): void;
+* JSON File Reporter.
+*
+* A reporter that writes structured JSON log entries to rotating files on disk.
+* Supports automatic file rotation based on size, time intervals, and compression.
+* @template L - The log level type
+* @example
+* ```typescript
+* const reporter = new JsonFileReporter({
+*   filePath: "/var/log/app.log",
+*   interval: "1d", // Rotate daily
+*   size: "10M",   // Rotate when file reaches 10MB
+*   compress: "gzip"
+* });
+*
+* logger.registerReporters([reporter]);
+* ```
+*/
+declare class JsonFileReporter<L extends string = string> extends AbstractJsonReporter<L> {
+  /** The rotating file stream instance */
+  protected stream: RotatingFileStream;
+  /**
+  * Creates a new JsonFileReporter instance.
+  * @param options Configuration options for file rotation and JSON formatting
+  */
+  constructor(options: FileReporterOptions);
+  /**
+  * Writes a JSON message to the rotating file stream.
+  * @param message The JSON-formatted log message to write
+  * @protected
+  */
+  protected override _log(message: string): void;
 }
+export { FileReporterOptions, JsonFileReporter };