@visulima/pail 4.0.0-alpha.6 → 4.0.0-alpha.7

package/dist/packem_shared/{PrettyReporter-BjXCFQlo.js → PrettyReporter-CvBn-hxP.js}

@@ -1252,7 +1252,8 @@ class AbstractPrettyReporter {
   }
 }
 
-const pailFileFilter = (line) => !/[\\/]pail[\\/]dist/.test(line);
+const PAIL_DIST_REGEX = /[\\/]pail[\\/]dist/;
+const pailFileFilter = (line) => !PAIL_DIST_REGEX.test(line);
 class PrettyReporter extends AbstractPrettyReporter {
   #stdout;
   #stderr;

package/dist/packem_shared/createPailError-B11aRfrT.js

@@ -0,0 +1,76 @@
+class PailError extends Error {
+  /** HTTP status code (defaults to 500) */
+  status;
+  /** Explanation of what caused the failure */
+  why;
+  /** Suggested resolution steps */
+  fix;
+  /** Link to relevant documentation */
+  link;
+  constructor(options) {
+    const resolvedOptions = typeof options === "string" ? { message: options } : options;
+    super(resolvedOptions.message, resolvedOptions.cause === void 0 ? void 0 : { cause: resolvedOptions.cause });
+    this.name = "PailError";
+    this.status = resolvedOptions.status ?? 500;
+    this.why = resolvedOptions.why;
+    this.fix = resolvedOptions.fix;
+    this.link = resolvedOptions.link;
+  }
+  /**
+   * Converts the error to a JSON-serializable object.
+   *
+   * Includes all self-documenting fields in the output for structured logging.
+   * @returns A plain object representation of the error
+   */
+  toJSON() {
+    const json = {
+      message: this.message,
+      name: this.name,
+      status: this.status
+    };
+    if (this.why) {
+      json.why = this.why;
+    }
+    if (this.fix) {
+      json.fix = this.fix;
+    }
+    if (this.link) {
+      json.link = this.link;
+    }
+    if (this.stack) {
+      json.stack = this.stack;
+    }
+    if (this.cause !== void 0) {
+      json.cause = this.cause instanceof Error ? { message: this.cause.message, name: this.cause.name, stack: this.cause.stack } : this.cause;
+    }
+    return json;
+  }
+  /**
+   * Returns a formatted string representation including self-documenting fields.
+   * @returns Formatted error string with why/fix/link context
+   */
+  toString() {
+    let output = `${this.name} [${this.status}]: ${this.message}`;
+    if (this.why) {
+      output += `
+  Why: ${this.why}`;
+    }
+    if (this.fix) {
+      output += `
+  Fix: ${this.fix}`;
+    }
+    if (this.link) {
+      output += `
+  Link: ${this.link}`;
+    }
+    if (this.cause !== void 0) {
+      const causeMessage = this.cause instanceof Error ? this.cause.message : String(this.cause);
+      output += `
+  Cause: ${causeMessage}`;
+    }
+    return output;
+  }
+}
+const createPailError = (options) => new PailError(options);
+
+export { PailError, createPailError };

package/dist/packem_shared/headers-Cp4uLtr4.js

@@ -0,0 +1,123 @@
+import { WideEvent } from '../wide-event.js';
+
+const patternToRegex = (pattern) => {
+  let regex = "^";
+  let index = 0;
+  while (index < pattern.length) {
+    const char = pattern[index];
+    if (char === "*" && pattern[index + 1] === "*") {
+      index += 2;
+      if (pattern[index] === "/") {
+        index += 1;
+      }
+      if (index >= pattern.length && regex.endsWith("/")) {
+        regex = `${regex.slice(0, -1)}(/.*)?`;
+      } else if (index >= pattern.length) {
+        regex += ".*";
+      } else {
+        regex += "(.*/)?";
+      }
+    } else {
+      switch (char) {
+        case "*": {
+          regex += "[^/]*";
+          index += 1;
+          break;
+        }
+        case ".": {
+          regex += String.raw`\.`;
+          index += 1;
+          break;
+        }
+        case "?": {
+          regex += "[^/]";
+          index += 1;
+          break;
+        }
+        default: {
+          regex += char;
+          index += 1;
+        }
+      }
+    }
+  }
+  regex += "$";
+  return new RegExp(regex);
+};
+const matchesPattern = (path, pattern) => patternToRegex(pattern).test(path);
+const shouldLog = (path, include, exclude) => {
+  if (exclude?.some((pattern) => matchesPattern(path, pattern))) {
+    return false;
+  }
+  if (!include?.length) {
+    return true;
+  }
+  return include.some((pattern) => matchesPattern(path, pattern));
+};
+const getServiceForPath = (path, routes) => {
+  if (!routes) {
+    return void 0;
+  }
+  for (const [pattern, config] of Object.entries(routes)) {
+    if (matchesPattern(path, pattern)) {
+      return config.service;
+    }
+  }
+  return void 0;
+};
+
+const createMiddlewareLogger = (options, request) => {
+  const { exclude, include, pail, routes, service } = options;
+  const { headers, method, path, requestId } = request;
+  if (!shouldLog(path, include, exclude)) {
+    const noopLogger = new WideEvent({ autoEmit: false, name: `${method} ${path}`, pail });
+    return {
+      finish: () => {
+      },
+      logger: noopLogger,
+      skipped: true
+    };
+  }
+  const routeService = getServiceForPath(path, routes) ?? service;
+  const logger = new WideEvent({
+    name: `${method} ${path}`,
+    pail,
+    service: routeService
+  });
+  logger.set({
+    method,
+    path,
+    requestId,
+    ...headers ? { headers } : {}
+  });
+  const finish = (finishOptions) => {
+    logger.finish(finishOptions);
+  };
+  return {
+    finish,
+    logger,
+    skipped: false
+  };
+};
+
+const SENSITIVE_HEADERS = /* @__PURE__ */ new Set(["authorization", "cookie", "proxy-authorization", "set-cookie", "x-api-key", "x-auth-token"]);
+const extractSafeHeaders = (headers) => {
+  const safe = {};
+  headers.forEach((value, key) => {
+    if (!SENSITIVE_HEADERS.has(key.toLowerCase())) {
+      safe[key.toLowerCase()] = value;
+    }
+  });
+  return safe;
+};
+const extractSafeNodeHeaders = (headers) => {
+  const safe = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (!SENSITIVE_HEADERS.has(key.toLowerCase()) && value !== void 0) {
+      safe[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+    }
+  }
+  return safe;
+};
+
+export { extractSafeHeaders as a, createMiddlewareLogger as c, extractSafeNodeHeaders as e };

package/dist/packem_shared/pailMiddleware-Ci88geIF.js

@@ -0,0 +1,24 @@
+const GLOB_STRIP_RE = /\*+/g;
+const pailMiddleware = (NextResponseClass, options) => {
+  const { exclude, include } = options ?? {};
+  return (request) => {
+    const path = request.nextUrl.pathname;
+    if (exclude?.some((p) => path.startsWith(p.replaceAll(GLOB_STRIP_RE, "")))) {
+      return NextResponseClass.next();
+    }
+    if (include?.length && !include.some((p) => path.startsWith(p.replaceAll(GLOB_STRIP_RE, "")))) {
+      return NextResponseClass.next();
+    }
+    const requestId = request.headers.get("x-request-id") ?? crypto.randomUUID();
+    const requestHeaders = new Headers(request.headers);
+    requestHeaders.set("x-request-id", requestId);
+    requestHeaders.set("x-pail-start", String(Date.now()));
+    const response = NextResponseClass.next({
+      request: { headers: requestHeaders }
+    });
+    response.headers.set("x-request-id", requestId);
+    return response;
+  };
+};
+
+export { pailMiddleware };

package/dist/packem_shared/storage-D0vqz8OX.js

@@ -0,0 +1,36 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  AsyncLocalStorage
+} = __cjs_getBuiltinModule("node:async_hooks");
+
+const createLoggerStorage = (contextHint) => {
+  const storage = new AsyncLocalStorage();
+  const useLogger = () => {
+    const logger = storage.getStore();
+    if (!logger) {
+      throw new Error(`[pail] useLogger() called outside of ${contextHint}`);
+    }
+    return logger;
+  };
+  return { storage, useLogger };
+};
+
+export { createLoggerStorage as c };

package/dist/packem_shared/useLogger-D0rU3lcX.js

@@ -0,0 +1,33 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  AsyncLocalStorage
+} = __cjs_getBuiltinModule("node:async_hooks");
+
+const pailStorage = new AsyncLocalStorage();
+const useLogger = () => {
+  const logger = pailStorage.getStore();
+  if (!logger) {
+    throw new Error("[pail] useLogger() called outside of withPail() context. Wrap your route handler or server action with withPail().");
+  }
+  return logger;
+};
+
+export { pailStorage, useLogger };

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

@@ -0,0 +1,124 @@
+import type { Meta, Processor } from "../types.d.ts";
+/**
+ * Detected environment information.
+ *
+ * Contains runtime environment details that are automatically detected
+ * from environment variables and process information.
+ */
+interface EnvironmentInfo {
+    /** Git commit hash or short SHA */
+    commit?: string;
+    /** Runtime environment (e.g., "production", "development", "test") */
+    environment?: string;
+    /** Hostname of the machine */
+    hostname?: string;
+    /** Process ID */
+    pid?: number;
+    /** Cloud region (e.g., "us-east-1") */
+    region?: string;
+    /** Application/service name */
+    service?: string;
+    /** Application version */
+    version?: string;
+}
+/**
+ * Environment processor configuration options.
+ */
+interface EnvironmentProcessorOptions {
+    /**
+     * Whether to include the hostname. Defaults to false.
+     */
+    includeHostname?: boolean;
+    /**
+     * Whether to include the process ID. Defaults to false.
+     */
+    includePid?: boolean;
+    /**
+     * Static environment info to use instead of or in addition to auto-detection.
+     * Values provided here take precedence over auto-detected values.
+     */
+    overrides?: Partial<EnvironmentInfo>;
+}
+/**
+ * Detects the runtime environment from environment variables.
+ *
+ * Checks common environment variable patterns used by various hosting
+ * platforms (Vercel, AWS, GCP, Heroku, Railway, Fly.io, Render, etc.)
+ * to automatically determine service name, version, environment, region,
+ * and commit hash.
+ * @returns Detected environment information
+ */
+declare const detectEnvironment: () => EnvironmentInfo;
+/**
+ * Environment Enrichment Processor.
+ *
+ * Inspired by evlog's automatic environment detection, this processor
+ * enriches log metadata with runtime environment information. It auto-detects
+ * details like service name, version, environment, region, and commit hash
+ * from common environment variables used by popular hosting platforms.
+ *
+ * The detected info is added to the log's context, making it easier to
+ * correlate logs across services and deployments in production.
+ * @template L - The log level type
+ * @example
+ * ```typescript
+ * import { createPail } from "@visulima/pail";
+ * import EnvironmentProcessor from "@visulima/pail/processor/environment";
+ *
+ * const logger = createPail({
+ *   processors: [
+ *     new EnvironmentProcessor({
+ *       overrides: { service: "my-api" },
+ *       includePid: true,
+ *     }),
+ *   ],
+ * });
+ *
+ * logger.info("Server started");
+ * // Log metadata will include: { __env: { service: "my-api", environment: "production", ... } }
+ * ```
+ * @example
+ * ```typescript
+ * // With static configuration only (no auto-detection)
+ * new EnvironmentProcessor({
+ *   overrides: {
+ *     service: "payment-service",
+ *     version: "2.1.0",
+ *     environment: "staging",
+ *   },
+ * });
+ * ```
+ */
+declare class EnvironmentProcessor<L extends string = string> implements Processor<L> {
+    #private;
+    /**
+     * Creates a new EnvironmentProcessor instance.
+     *
+     * Auto-detects environment information on construction and merges
+     * with any provided overrides. Undefined values in overrides are
+     * filtered out so they don't overwrite detected values.
+     * @param options Processor configuration options
+     */
+    constructor(options?: EnvironmentProcessorOptions);
+    /**
+     * Processes log metadata to add environment information.
+     *
+     * Adds a `__env` property to the meta containing detected and
+     * configured environment details. Each call receives a shallow
+     * clone of the environment info to prevent cross-record mutation.
+     * @param meta The log metadata to process
+     * @returns The processed metadata with environment info added
+     */
+    process(meta: Meta<L>): Meta<L>;
+    /**
+     * Returns the detected environment information.
+     *
+     * Useful for inspecting what environment details were auto-detected.
+     * Returns a shallow clone to prevent external mutation.
+     * @returns The environment information object
+     */
+    getEnvironmentInfo(): Readonly<EnvironmentInfo>;
+}
+export { detectEnvironment };
+export default EnvironmentProcessor;
+export type { EnvironmentInfo, EnvironmentProcessorOptions };

package/dist/processor/environment-processor.js

@@ -0,0 +1,78 @@
+const detectEnvironment = () => {
+  if (!process.env) {
+    return {};
+  }
+  const { env } = process;
+  const info = {
+    // Commit hash
+    commit: env.COMMIT_SHA || env.GIT_COMMIT || env.VERCEL_GIT_COMMIT_SHA?.slice(0, 7) || env.RAILWAY_GIT_COMMIT_SHA?.slice(0, 7) || env.RENDER_GIT_COMMIT?.slice(0, 7) || env.HEROKU_SLUG_COMMIT?.slice(0, 7) || env.CF_PAGES_COMMIT_SHA?.slice(0, 7) || void 0,
+    // Environment / Node env
+    environment: env.NODE_ENV || env.ENVIRONMENT || env.APP_ENV || void 0,
+    // Hostname
+    hostname: env.HOSTNAME || env.HOST || void 0,
+    // PID
+    pid: process.pid,
+    // Region (including GCP Cloud Functions FUNCTION_REGION and GOOGLE_CLOUD_REGION)
+    region: env.AWS_REGION || env.VERCEL_REGION || env.FLY_REGION || env.RENDER_REGION || env.CF_REGION || env.GOOGLE_CLOUD_REGION || env.FUNCTION_REGION || void 0,
+    // Service name - check common platform variables (including GCP Cloud Run / App Engine)
+    service: env.SERVICE_NAME || env.APP_NAME || env.K_SERVICE || env.GAE_SERVICE || env.FUNCTION_TARGET || env.VERCEL_PROJECT_PRODUCTION_URL || env.FLY_APP_NAME || env.RAILWAY_SERVICE_NAME || env.RENDER_SERVICE_NAME || env.HEROKU_APP_NAME || void 0,
+    // Version (including GCP Cloud Run K_REVISION and App Engine GAE_VERSION)
+    version: env.APP_VERSION || env.npm_package_version || env.K_REVISION || env.GAE_VERSION || env.RAILWAY_GIT_COMMIT_SHA?.slice(0, 7) || env.RENDER_GIT_COMMIT?.slice(0, 7) || void 0
+  };
+  return Object.fromEntries(Object.entries(info).filter(([, v]) => v !== void 0));
+};
+class EnvironmentProcessor {
+  #envInfo;
+  /**
+   * Creates a new EnvironmentProcessor instance.
+   *
+   * Auto-detects environment information on construction and merges
+   * with any provided overrides. Undefined values in overrides are
+   * filtered out so they don't overwrite detected values.
+   * @param options Processor configuration options
+   */
+  constructor(options = {}) {
+    const detected = detectEnvironment();
+    const cleanOverrides = {};
+    if (options.overrides) {
+      for (const [key, value] of Object.entries(options.overrides)) {
+        if (value !== void 0) {
+          cleanOverrides[key] = value;
+        }
+      }
+    }
+    const merged = { ...detected, ...cleanOverrides };
+    if (!options.includePid && cleanOverrides.pid === void 0) {
+      delete merged.pid;
+    }
+    if (!options.includeHostname && cleanOverrides.hostname === void 0) {
+      delete merged.hostname;
+    }
+    this.#envInfo = merged;
+  }
+  /**
+   * Processes log metadata to add environment information.
+   *
+   * Adds a `__env` property to the meta containing detected and
+   * configured environment details. Each call receives a shallow
+   * clone of the environment info to prevent cross-record mutation.
+   * @param meta The log metadata to process
+   * @returns The processed metadata with environment info added
+   */
+  process(meta) {
+    const enriched = { ...meta, envStorage: { ...this.#envInfo } };
+    return enriched;
+  }
+  /**
+   * Returns the detected environment information.
+   *
+   * Useful for inspecting what environment details were auto-detected.
+   * Returns a shallow clone to prevent external mutation.
+   * @returns The environment information object
+   */
+  getEnvironmentInfo() {
+    return { ...this.#envInfo };
+  }
+}
+
+export { EnvironmentProcessor as default, detectEnvironment };

package/dist/processor/message-formatter-processor.d.ts

@@ -1,5 +1,4 @@
 import type { FormatterFunction } from "@visulima/fmt";
-import type { stringify } from "safe-stable-stringify";
 import type { Meta, StringifyAwareProcessor } from "../types.d.ts";
 /**
  * Message Formatter Processor.
@@ -39,7 +38,7 @@ declare class MessageFormatterProcessor<L extends string = string> implements St
      * Sets the stringify function for object serialization.
      * @param function_ The stringify function to use for serializing objects
      */
-    setStringify(function_: typeof stringify): void;
+    setStringify(function_: typeof JSON.stringify): void;
     /**
      * Processes log metadata to format messages.
      *

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

@@ -0,0 +1,111 @@
+import type { Meta, Processor } from "../types.d.ts";
+/**
+ * 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
+ */
+type TailSamplingCondition<L extends string = string> = (meta: Readonly<Meta<L>>) => boolean;
+/**
+ * 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>[];
+}
+/**
+ * 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>;
+}
+export default SamplingProcessor;
+export type { HeadSamplingConfig, SamplingProcessorOptions, TailSamplingCondition };

package/dist/processor/sampling-processor.js

@@ -0,0 +1,59 @@
+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 };