@visulima/pail 4.0.0-alpha.8 → 4.0.0

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

@@ -1,70 +1,74 @@
-import type { Meta, Processor } from "../types.d.ts";
+import { M as Meta, P as Processor } from "../packem_shared/types.d-bWnqHJKL.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'type-fest';
 /**
- * Configuration options for the OpenTelemetry processor.
- */
-export interface OpenTelemetryProcessorOptions {
-    /**
-     * Field name for the span ID. Defaults to 'span_id'
-     */
-    spanIdFieldName?: string;
-    /**
-     * If specified, all trace fields will be nested under this key
-     */
-    traceFieldName?: string;
-    /**
-     * Field name for the trace flags. Defaults to 'trace_flags'
-     */
-    traceFlagsFieldName?: string;
-    /**
-     * Field name for the trace ID. Defaults to 'trace_id'
-     */
-    traceIdFieldName?: string;
+* Configuration options for the OpenTelemetry processor.
+*/
+interface OpenTelemetryProcessorOptions {
+  /**
+  * Field name for the span ID. Defaults to 'span_id'
+  */
+  spanIdFieldName?: string;
+  /**
+  * If specified, all trace fields will be nested under this key
+  */
+  traceFieldName?: string;
+  /**
+  * Field name for the trace flags. Defaults to 'trace_flags'
+  */
+  traceFlagsFieldName?: string;
+  /**
+  * Field name for the trace ID. Defaults to 'trace_id'
+  */
+  traceIdFieldName?: string;
 }
 /**
- * OpenTelemetry Processor.
- *
- * A processor that adds OpenTelemetry trace context to log metadata.
- * Extracts trace ID, span ID, and trace flags from the active OpenTelemetry span
- * and adds them to the log context for distributed tracing correlation.
- * @template L - The log level type
- * @example
- * ```typescript
- * import { createPail } from "@visulima/pail";
- * import { OpenTelemetryProcessor } from "@visulima/pail/processor/opentelemetry";
- *
- * const logger = createPail({
- *   processors: [new OpenTelemetryProcessor()]
- * });
- *
- * logger.info("Processing request");
- * // Context includes: { trace_id: "...", span_id: "...", trace_flags: "01" }
- * ```
- * @example
- * ```typescript
- * // With custom field names
- * const logger = createPail({
- *   processors: [new OpenTelemetryProcessor({
- *     traceFieldName: "trace",
- *     traceIdFieldName: "traceId",
- *     spanIdFieldName: "spanId"
- *   })]
- * });
- * ```
- */
-export declare class OpenTelemetryProcessor<L extends string = string> implements Processor<L> {
-    #private;
-    /**
-     * Creates a new OpenTelemetryProcessor instance.
-     * @param options Configuration options for field names and nesting
-     */
-    constructor(options?: OpenTelemetryProcessorOptions);
-    /**
-     * Processes log metadata to add OpenTelemetry trace context.
-     *
-     * Extracts trace information from the active OpenTelemetry span and adds it
-     * to the log context. If no valid span is found, the metadata is returned unchanged.
-     * @param meta The log metadata to process
-     * @returns The processed metadata with trace context added
-     */
-    process(meta: Meta<L>): Meta<L>;
+* OpenTelemetry Processor.
+*
+* A processor that adds OpenTelemetry trace context to log metadata.
+* Extracts trace ID, span ID, and trace flags from the active OpenTelemetry span
+* and adds them to the log context for distributed tracing correlation.
+* @template L - The log level type
+* @example
+* ```typescript
+* import { createPail } from "@visulima/pail";
+* import { OpenTelemetryProcessor } from "@visulima/pail/processor/opentelemetry";
+*
+* const logger = createPail({
+*   processors: [new OpenTelemetryProcessor()]
+* });
+*
+* logger.info("Processing request");
+* // Context includes: { trace_id: "...", span_id: "...", trace_flags: "01" }
+* ```
+* @example
+* ```typescript
+* // With custom field names
+* const logger = createPail({
+*   processors: [new OpenTelemetryProcessor({
+*     traceFieldName: "trace",
+*     traceIdFieldName: "traceId",
+*     spanIdFieldName: "spanId"
+*   })]
+* });
+* ```
+*/
+declare class OpenTelemetryProcessor<L extends string = string> implements Processor<L> {
+  #private;
+  /**
+  * Creates a new OpenTelemetryProcessor instance.
+  * @param options Configuration options for field names and nesting
+  */
+  constructor(options?: OpenTelemetryProcessorOptions);
+  /**
+  * Processes log metadata to add OpenTelemetry trace context.
+  *
+  * Extracts trace information from the active OpenTelemetry span and adds it
+  * to the log context. If no valid span is found, the metadata is returned unchanged.
+  * @param meta The log metadata to process
+  * @returns The processed metadata with trace context added
+  */
+  process(meta: Meta<L>): Meta<L>;
 }
+export { OpenTelemetryProcessor, OpenTelemetryProcessorOptions };

package/dist/processor/opentelemetry-processor.js

@@ -1,52 +1 @@
-import { trace, context, isSpanContextValid } from '@opentelemetry/api';
-
-class OpenTelemetryProcessor {
-  /** Field name for trace ID */
-  #traceIdField;
-  /** Field name for span ID */
-  #spanIdField;
-  /** Field name for trace flags */
-  #traceFlagsField;
-  /** Optional field name to nest all trace fields under */
-  #traceFieldName;
-  /**
-   * Creates a new OpenTelemetryProcessor instance.
-   * @param options Configuration options for field names and nesting
-   */
-  constructor(options = {}) {
-    this.#traceIdField = options.traceIdFieldName || "trace_id";
-    this.#spanIdField = options.spanIdFieldName || "span_id";
-    this.#traceFlagsField = options.traceFlagsFieldName || "trace_flags";
-    this.#traceFieldName = options.traceFieldName;
-  }
-  /**
-   * Processes log metadata to add OpenTelemetry trace context.
-   *
-   * Extracts trace information from the active OpenTelemetry span and adds it
-   * to the log context. If no valid span is found, the metadata is returned unchanged.
-   * @param meta The log metadata to process
-   * @returns The processed metadata with trace context added
-   */
-  process(meta) {
-    const span = trace.getSpan(context.active());
-    if (!span) {
-      return meta;
-    }
-    const spanContext = span.spanContext();
-    if (!isSpanContextValid(spanContext)) {
-      return meta;
-    }
-    const fields = {
-      [this.#spanIdField]: spanContext.spanId,
-      [this.#traceFlagsField]: `0${spanContext.traceFlags.toString(16)}`,
-      [this.#traceIdField]: spanContext.traceId
-    };
-    const traceData = this.#traceFieldName ? {
-      [this.#traceFieldName]: fields
-    } : fields;
-    meta.context = [...meta.context || [], traceData];
-    return meta;
-  }
-}
-
-export { OpenTelemetryProcessor };
+import{trace as i,context as c,isSpanContextValid as n}from"@opentelemetry/api";class l{#s;#e;#r;#t;constructor(t={}){this.#s=t.traceIdFieldName??"trace_id",this.#e=t.spanIdFieldName??"span_id",this.#r=t.traceFlagsFieldName??"trace_flags",this.#t=t.traceFieldName}process(t){const e=i.getSpan(c.active());if(!e)return t;const s=e.spanContext();if(!n(s))return t;const r={[this.#e]:s.spanId,[this.#r]:`0${s.traceFlags.toString(16)}`,[this.#s]:s.traceId},a=this.#t?{[this.#t]:r}:r;return t.context=[...t.context??[],a],t}}export{l as OpenTelemetryProcessor};

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

@@ -1,44 +1,102 @@
-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-bWnqHJKL.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'type-fest';
 /**
- * Redact Processor.
- *
- * A processor that redacts sensitive information from log messages and metadata.
- * Uses the {@link https://www.visulima.com/docs/package/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
- * });
- * ```
- */
+* A censor function receives the original value being redacted plus the dot-path
+* identifier of where it was found, and returns the value to store in its place.
+*
+* Use it for partial masking — e.g. keep the last four digits of a card number, or
+* mask the local part of an email — instead of a static replacement string.
+* @example
+* ```ts
+* const keepLast4: Censor = (value) =>
+*     typeof value === "string" ? "****" + value.slice(-4) : value;
+* ```
+* @param value The original value matched by the rule.
+* @param path The dot-path of the matched key (e.g. `user.card`), or `undefined`
+* for matches that have no key path (string-anonymizer / array-index matches).
+*/
+type Censor = (value: unknown, path: string | undefined) => unknown;
+type StringAnonymize = {
+  key: string;
+  pattern: RegExp | string;
+  replacement?: Censor | string;
+};
+type Anonymize = {
+  /**
+  * When `true`, the rule is also applied to nested string values (NLP / regex based),
+  * not just to matching object keys.
+  */
+  deep?: boolean;
+  /** The key (or wildcard pattern, or NLP type) to match. Case-insensitive. */
+  key: string;
+  /** Optional regular expression matched against nested string values. */
+  pattern?: RegExp | string;
+  /**
+  * When `true`, the matching key is deleted from the output object instead of being
+  * replaced with `replacement`. Ignored for array elements and string-anonymizer matches.
+  */
+  remove?: boolean;
+  /**
+  * The value (or {@link Censor} function) to put in place of a match. Defaults to
+  * the `<KEY>` placeholder when omitted.
+  */
+  replacement?: unknown;
+};
+type Rules = (Anonymize | StringAnonymize | number | string)[];
+type RedactOptions = {
+  exclude?: (number | string)[];
+  logger?: {
+    debug: (message?: unknown, ...optionalParameters: unknown[]) => void;
+  };
+};
+/**
+* Credential / secret rules: API keys, AWS keys, bearer/JWT/Slack tokens, crypto wallets,
+* basic-auth strings, and the broad key-name rules (`auth`, `password`, `secret`, ...).
+*
+* These are the safest default rules — they target high-entropy or unambiguous shapes — and are
+* what most logger-scrubbing use cases need.
+*/
+/**
+* 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/redact-processor.js

@@ -1,30 +1 @@
-import { redact, standardRules } from '@visulima/redact';
-
-class RedactProcessor {
-  /** The redact function configured with custom rules and options */
-  #redact;
-  /**
-   * Creates a new RedactProcessor instance.
-   * @param rules Custom redaction rules (uses standardRules if not provided)
-   * @param options Additional redaction options
-   */
-  constructor(rules, options) {
-    this.#redact = (input) => redact(input, rules || standardRules, options);
-  }
-  /**
-   * 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.message = this.#redact(meta.message);
-    meta.context = this.#redact(meta.context);
-    meta.error = this.#redact(meta.error);
-    return meta;
-  }
-}
-
-export { RedactProcessor as default };
+import{redact as e,standardRules as a}from"@visulima/redact";class n{#t;constructor(t,s){const r=t??a;this.#t=o=>e(o,r,s)}process(t){return t.message=this.#t(t.message),t.context=this.#t(t.context),t.error=this.#t(t.error),t}}export{n as default};

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

@@ -1,111 +1,113 @@
-import type { Meta, Processor } from "../types.d.ts";
+import { M as Meta, P as Processor } from "../packem_shared/types.d-bWnqHJKL.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'type-fest';
 /**
- * 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/processor/sampling-processor.js

@@ -1,59 +1 @@
-class SamplingProcessor {
-  #headRates;
-  #tailConditions;
-  /**
-   * Creates a new SamplingProcessor instance.
-   * @param options Sampling configuration options
-   */
-  constructor(options = {}) {
-    this.#headRates = options.head ?? {};
-    this.#tailConditions = options.tail ?? [];
-  }
-  /**
-   * 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) {
-    const level = meta.type.level;
-    if (this.#shouldDrop(level) && !this.#shouldForceKeep(meta)) {
-      return { ...meta, dropped: true };
-    }
-    return meta;
-  }
-  /**
-   * Evaluates head sampling for the given log level.
-   * @returns true if the log should be dropped
-   */
-  #shouldDrop(level) {
-    const rate = this.#headRates[level];
-    if (rate === void 0) {
-      return false;
-    }
-    if (rate <= 0) {
-      return true;
-    }
-    if (rate >= 100) {
-      return false;
-    }
-    return Math.random() * 100 >= rate;
-  }
-  /**
-   * Evaluates tail sampling conditions.
-   * @returns true if any condition forces keeping the log
-   */
-  #shouldForceKeep(meta) {
-    for (const condition of this.#tailConditions) {
-      if (condition(meta)) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-
-export { SamplingProcessor as default };
+class e{#r;#t;constructor(t={}){this.#r=t.head??{},this.#t=t.tail??[]}process(t){const r=t.type.level;return this.#s(r)&&!this.#e(t)?{...t,dropped:!0}:t}#s(t){const r=this.#r[t];return r===void 0?!1:r<=0?!0:r>=100?!1:Math.random()*100>=r}#e(t){for(let r=0;r<this.#t.length;r+=1)if(this.#t[r](t))return!0;return!1}}export{e as default};