logquill 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,68 +1,113 @@
-/** Log levels, shared by name and numeric weight with the logquill-python contract. */
-declare enum Level {
-    TRACE = 5,
-    DEBUG = 10,
-    INFO = 20,
-    WARN = 30,
-    ERROR = 40,
-    FATAL = 50
-}
-/** A level given as a `Level`, a level name (any case), or its numeric weight. */
-type LevelInput = Level | number | string;
-/** The level's name, e.g. `levelName(Level.INFO) === "INFO"`. */
-declare function levelName(level: Level): string;
-/** Normalize a level given as a `Level`, level name, or numeric weight. Throws if unknown. */
-declare function parseLevel(level: LevelInput): Level;
-
-/** The cross-language record shape shared with logquill-python. */
-interface LogRecord {
-    timestamp: string;
-    level: string;
-    logger: string;
-    message: string;
-    meta: Record<string, unknown>;
+import { P as Plugin, L as LogRecord, a as Level, T as Transport, b as LevelInput, F as Formatter } from './logger-D1_THnBJ.js';
+export { C as CollectingTransport, c as FunctionPlugin, J as JSONFormatter, d as Logger, e as LoggerOptions, M as MiddlewareFunc, S as SpanOptions, f as createRecord, l as levelName, p as parseLevel, u as utcTimestamp } from './logger-D1_THnBJ.js';
+
+/**
+ * Injects fixed key/value pairs into every record's `meta`.
+ * A value already present in a record's own `meta` wins over the fixed context.
+ */
+declare class ContextPlugin implements Plugin {
+    readonly context: Record<string, unknown>;
+    constructor(context: Record<string, unknown>);
+    beforeLog(record: LogRecord): LogRecord;
 }
-/** ISO8601 UTC timestamp with millisecond precision, matching Python's `utc_timestamp()`. */
-declare function utcTimestamp(): string;
-declare function createRecord(params: {
-    level: Level;
-    logger: string;
-    message: string;
-    meta: Record<string, unknown>;
-}): LogRecord;
 
-/** `format(record) -> string`, per the transport contract shared with logquill-python. */
-interface Formatter {
-    format(record: LogRecord): string;
+interface RunPluginOptions {
+    runId?: string;
 }
-/** Serializes a record to the canonical JSON line shape. */
-declare class JSONFormatter implements Formatter {
-    format(record: LogRecord): string;
+/**
+ * Stamps `meta.runId` — a stable id grouping every record from one agent
+ * run — plus an incrementing `meta.step` counter, one per record processed
+ * through this plugin instance.
+ *
+ * Distinct from `TraceContextPlugin`'s `traceId`: `runId` scopes one agent
+ * run, `traceId` follows one request across services. A run can span
+ * multiple traces (e.g. an agent that calls several downstream services);
+ * the two ids are independent.
+ *
+ * One instance is one run: attach a fresh `RunPlugin()` per run (typically
+ * via `logger.child("agent").use(new RunPlugin())`), never a process-wide
+ * singleton shared across runs — otherwise concurrent runs would share both
+ * the run id and the step counter.
+ *
+ * A record that already carries `meta.runId` (e.g. propagated from an
+ * upstream call) keeps its existing value; `meta.step` is always set from
+ * this instance's own counter.
+ */
+declare class RunPlugin implements Plugin {
+    readonly runId: string;
+    private step;
+    constructor(options?: RunPluginOptions);
+    beforeLog(record: LogRecord): LogRecord;
 }
 
 /**
- * The plugin pipeline hooks, matching the Python hook names: `beforeLog`,
- * `afterLog`, `onError`. All hooks are optional — implement only what you need.
- * A hook that throws cannot crash logging: the pipeline catches it, routes it
- * to `onError`, and moves on.
+ * Sets the inbound trace header for the current execution context (e.g.
+ * request-scoped HTTP middleware, before the handler runs) — the
+ * propagation mechanism framework middleware uses to hand `TraceContextPlugin`
+ * an inbound header without threading it through every log call. Backed by
+ * `AsyncLocalStorage`, so it's isolated per concurrent request. Returns a
+ * function that restores the previous value; call it (typically in a
+ * `finally` block) once the request is done.
  */
-interface Plugin {
-    /** Return a (possibly modified) record, or `null` to drop it. */
-    beforeLog?(record: LogRecord): LogRecord | null;
-    /** Called after the record has been dispatched to every transport. */
-    afterLog?(record: LogRecord): void;
-    /** Called when one of this plugin's own hooks throws. */
-    onError?(error: unknown, record: LogRecord): void;
+declare function setTraceparent(value: string | undefined): () => void;
+/** The header most recently set via `setTraceparent()` for this execution context. */
+declare function getTraceparent(): string | undefined;
+/** A fresh 32-hex-char id, matching the shape of an OTel/W3C trace id. */
+declare function generateTraceId(): string;
+/**
+ * Extracts a 32-hex-char trace id from a W3C `traceparent`, AWS X-Ray
+ * `X-Amzn-Trace-Id`, or GCP `X-Cloud-Trace-Context` header value. Returns
+ * `undefined` if `header` doesn't match any of the three shapes.
+ */
+declare function parseTraceHeader(header: string): string | undefined;
+/**
+ * Best-effort, synchronous lookup of the active OpenTelemetry span's trace
+ * id via a plain `require("@opentelemetry/api")` — `@opentelemetry/api` is
+ * never a declared dependency of this package (matching `logquill-python`'s
+ * lazy `import opentelemetry`); this returns `undefined` whenever it isn't
+ * installed, or no span is currently active, rather than throwing.
+ *
+ * A `require()` (via `createRequire`) rather than a dynamic `import()` is
+ * deliberate: `Plugin.beforeLog` is synchronous, so this has to be too.
+ */
+declare function defaultResolveActiveOtelTraceId(): string | undefined;
+interface TraceContextPluginOptions {
+    /** `meta` key the trace id is written to. Default `"traceId"`. */
+    traceKey?: string;
+    /** An inbound trace header to resolve on every record, bypassing `setTraceparent()`. */
+    traceparent?: string;
+    /** Override for testing, or to plug in a non-Node OTel API surface. Defaults to `defaultResolveActiveOtelTraceId`. */
+    resolveActiveOtelTraceId?: () => string | undefined;
 }
-
 /**
- * Injects fixed key/value pairs into every record's `meta`.
- * A value already present in a record's own `meta` wins over the fixed context.
+ * Stamps `meta.traceId` for cross-service correlation — distinct from
+ * `RunPlugin`'s `runId`: `traceId` follows one request across services,
+ * `runId` scopes one agent run.
+ *
+ * A record that already carries `meta[traceKey]` (e.g. because
+ * `SamplingPlugin`'s tail-based elevation, or an upstream plugin, already
+ * set one) is left alone. Otherwise resolves a trace id in priority order:
+ *
+ * 1. An active OpenTelemetry span's trace id, if `@opentelemetry/api` is
+ *    installed and a span is current — read directly, not just inbound
+ *    headers.
+ * 2. The `traceparent` constructor option, if given.
+ * 3. Whatever `setTraceparent()` most recently set for the current
+ *    execution context.
+ * 4. A freshly generated trace id, if none of the above produced one.
+ *
+ * Header parsing understands W3C `traceparent`, AWS X-Ray
+ * `X-Amzn-Trace-Id`, and GCP `X-Cloud-Trace-Context` — see
+ * `parseTraceHeader`. A header that doesn't parse is treated the same as no
+ * header: falls through to generating a new trace id.
  */
-declare class ContextPlugin implements Plugin {
-    readonly context: Record<string, unknown>;
-    constructor(context: Record<string, unknown>);
+declare class TraceContextPlugin implements Plugin {
+    readonly traceKey: string;
+    private readonly explicitTraceparent;
+    private readonly resolveActiveOtelTraceId;
+    constructor(options?: TraceContextPluginOptions);
     beforeLog(record: LogRecord): LogRecord;
+    private resolveTraceId;
 }
 
 declare const DEFAULT_REDACTED_KEYS: readonly string[];
@@ -78,38 +123,292 @@ declare class RedactPlugin implements Plugin {
     beforeLog(record: LogRecord): LogRecord;
 }
 
+/**
+ * Syntactic (not semantic) patterns — matched on shape, so both false
+ * positives (a random 9-digit number) and false negatives (anything that
+ * doesn't look like these shapes) are expected. Override via `patterns`
+ * for anything stricter.
+ */
+declare const DEFAULT_PII_PATTERNS: Readonly<Record<string, RegExp>>;
+interface PIIRedactPluginOptions {
+    patterns?: Readonly<Record<string, RegExp>>;
+    replacement?: string;
+}
+/**
+ * Regex-based PII redaction over `meta` **values**, not just keys.
+ *
+ * Complements `RedactPlugin`, which redacts by exact key match —
+ * `PIIRedactPlugin` scans string values (recursively through nested
+ * objects/arrays) for emails, SSNs, credit-card numbers, and phone
+ * numbers, and redacts matches wherever they appear, regardless of which
+ * key holds them (a `notes` field containing a stray SSN is still caught).
+ *
+ * Detection is pattern-based: fast and dependency-free, but it matches on
+ * syntactic shape, not meaning — a random 9-digit number can false-positive
+ * as an SSN, and anything that doesn't fit these shapes (a name, a street
+ * address) is a false negative. Pass your own `patterns` to extend or
+ * replace the defaults.
+ *
+ * Recursion into nested `meta` structures is depth- and cycle-bounded, so a
+ * circular reference or a pathologically deep structure can't hang or
+ * crash the caller — it's left unredacted past the bound rather than
+ * throwing.
+ */
+declare class PIIRedactPlugin implements Plugin {
+    readonly patterns: Readonly<Record<string, RegExp>>;
+    readonly replacement: string;
+    constructor(options?: PIIRedactPluginOptions);
+    beforeLog(record: LogRecord): LogRecord;
+    private redactValue;
+    private redactText;
+}
+
 interface SamplingPluginOptions {
     rng?: () => number;
+    /** `meta` key holding the trace/run id used to group buffered records. Default `"traceId"`. */
+    traceKey?: string;
+    /** A record at or above this level elevates its whole trace. Default `Level.ERROR`. */
+    elevateAt?: LevelInput;
+    /** Enables tail-based elevation, writing straight to these transports on elevation. Omit to disable and get plain rate-based sampling. */
+    transports?: Transport[];
+    /** Total buffered records allowed across every trace before the oldest trace is evicted. Default 1000. */
+    maxBufferedRecords?: number;
+    /** Distinct trace ids held at once before the oldest is evicted. Default 200. */
+    maxTraces?: number;
 }
-/** Keeps roughly `rate` of records (0.0-1.0), dropping the rest. */
+/**
+ * Keeps roughly `rate` of records (0.0-1.0), dropping the rest.
+ *
+ * With `transports` set, sampling becomes tail-based per trace: a record
+ * that would otherwise be dropped is buffered under its `meta[traceKey]`
+ * value instead of discarded outright. If any later record sharing that
+ * trace id reaches `elevateAt` or above, the whole trace is "elevated" —
+ * every buffered record for that trace id is flushed straight to
+ * `transports`, and every subsequent record for that trace id ships
+ * unconditionally. This is what lets a sampled-out request still produce a
+ * complete trace once it turns out to matter (it errored).
+ *
+ * Flushing writes buffered records directly to `transports` — pass the
+ * same array given to the `Logger`. This bypasses `beforeLog`/`afterLog`/
+ * `onError` for any plugin *after* `SamplingPlugin` in the pipeline (the
+ * plugins before it already ran, since that's how the buffered record was
+ * built); put `SamplingPlugin` last if that matters for your pipeline.
+ *
+ * Without `transports`, tail-based elevation is inactive and this behaves
+ * exactly like plain rate-based sampling (the original behavior) — a
+ * record without `meta[traceKey]` is also just rate-sampled, since there's
+ * no trace to buffer it under.
+ *
+ * Buffering is bounded: at most `maxBufferedRecords` records total and
+ * `maxTraces` distinct trace ids are held at once. Once either limit is
+ * hit, the oldest buffered trace is evicted (and its records are lost, not
+ * flushed) — a deliberate bounded-memory trade-off, not a bug: an
+ * unbounded per-trace buffer would let a single pathologically long-lived
+ * or high-cardinality trace grow memory without limit.
+ */
 declare class SamplingPlugin implements Plugin {
     readonly rate: number;
+    readonly traceKey: string;
+    readonly elevateAt: Level;
+    readonly transports: Transport[] | undefined;
+    readonly maxBufferedRecords: number;
+    readonly maxTraces: number;
     private readonly rng;
+    private readonly buffer;
+    private bufferedCount;
+    private readonly elevated;
     constructor(rate: number, options?: SamplingPluginOptions);
     beforeLog(record: LogRecord): LogRecord | null;
+    private elevate;
+    private bufferRecord;
+    private evictOldestTrace;
 }
 
+declare const GENESIS_HASH: string;
+interface TamperEvidentPluginOptions {
+    genesisHash?: string;
+}
 /**
- * Sink for log records, per the cross-language transport contract:
- * `format(record) -> string`, `write(formatted, record)`, `close()` on shutdown.
+ * Hash-chains every record so tampering with a written log can be
+ * detected after the fact.
+ *
+ * Each record gets `meta.hash` — a SHA-256 hex digest over the record's
+ * own content plus the previous record's hash (`meta.prevHash`) — the same
+ * hash-chain construction used by tamper-evident/append-only logs: editing
+ * or deleting any one line breaks every hash after it in the chain, even
+ * if the tamperer edits the file directly and not through this plugin.
+ * Opt-in — hashing every record has a real, measurable CPU cost, so it
+ * isn't part of the default pipeline.
+ *
+ * Verify a previously-written log with `TamperEvidentPlugin.verifyChain`,
+ * which re-derives each record's hash from its content and confirms it
+ * matches both the stored `meta.hash` and the chain built from the records
+ * before it, in order.
  */
-declare abstract class Transport {
-    formatter: Formatter;
-    constructor(formatter?: Formatter);
-    format(record: LogRecord): string;
-    abstract write(formatted: string, record: LogRecord): void;
-    /** Flush/release resources on shutdown. No-op unless a transport overrides it. */
-    close(): void;
+declare class TamperEvidentPlugin implements Plugin {
+    private readonly genesisHash;
+    private lastHash;
+    constructor(options?: TamperEvidentPluginOptions);
+    beforeLog(record: LogRecord): LogRecord;
+    /**
+     * Returns `true` iff every record's hash matches its content plus the
+     * previous record's hash, in the given order. Returns `false` at the
+     * first break in the chain (an edited, removed, or reordered record).
+     */
+    static verifyChain(records: Iterable<Pick<LogRecord, "timestamp" | "level" | "logger" | "message" | "meta">>, options?: TamperEvidentPluginOptions): boolean;
 }
-/** In-memory transport for tests: collects every (formatted, record) pair written to it. */
-declare class CollectingTransport extends Transport {
-    readonly formatted: string[];
-    readonly records: LogRecord[];
-    closed: boolean;
-    write(formatted: string, record: LogRecord): void;
+
+interface AlertingPluginOptions {
+    /** A record at or above this level fires an alert. Default `Level.ERROR`. */
+    threshold?: LevelInput;
+    /** How long a dedupe window stays open before a collapsed follow-up alert (if any) fires. Default 300_000 (5 minutes). */
+    dedupeWindowMs?: number;
+    /** Groups records into the same dedupe window. Default: `level:logger:message`. */
+    dedupeKey?: (record: LogRecord) => string;
+    /** Distinct concurrent dedupe keys tracked at once; beyond this, new keys are dropped rather than tracked. Default 500. */
+    maxTrackedKeys?: number;
+}
+/**
+ * Base class for plugins that fire an external alert on ERROR/FATAL (or any
+ * configurable `threshold`).
+ *
+ * A concrete subclass implements only `sendAlert(record, occurrences)` —
+ * everything else (thresholding, deduplication, never blocking the caller,
+ * never letting a broken destination crash logging) lives here.
+ *
+ * The first record at or above `threshold` for a given dedupe key (by
+ * default: level + logger + message) fires `sendAlert` right away, without
+ * awaiting it — so the log call that triggered it is never blocked on a
+ * webhook, SMTP handshake, or any other I/O, even if the destination is
+ * slow or unreachable. This stands in for the shared async dispatch queue
+ * a later phase will introduce; once that queue exists, `AlertingPlugin`
+ * can route through it instead of firing its own unawaited call per alert.
+ *
+ * Any further record matching the same dedupe key within
+ * `dedupeWindowMs` of the first is *not* sent again — it just increments a
+ * counter. When the window closes, if more than one record matched,
+ * exactly one follow-up alert is sent with the total occurrence count,
+ * instead of spamming the destination once per record. Tracking is bounded
+ * to `maxTrackedKeys` distinct concurrent dedupe keys; beyond that, new
+ * keys are dropped rather than tracked (alerting degrades under extreme
+ * cardinality, logging itself never does).
+ *
+ * `sendAlert` is always called without being awaited, and any rejection is
+ * routed to this plugin's own `onError`, the same as any other plugin hook
+ * that throws.
+ */
+declare abstract class AlertingPlugin implements Plugin {
+    readonly threshold: Level;
+    readonly dedupeWindowMs: number;
+    readonly maxTrackedKeys: number;
+    private readonly dedupeKeyFn;
+    private readonly windows;
+    constructor(options?: AlertingPluginOptions);
+    afterLog(record: LogRecord): void;
+    private flush;
+    private safeSend;
+    /**
+     * Send one alert for `record`, representing `occurrences` collapsed
+     * duplicates (1 on first occurrence; the deduped total on a follow-up
+     * flush). Override in a concrete subclass — never call this directly,
+     * `AlertingPlugin` calls it without awaiting it.
+     */
+    protected abstract sendAlert(record: LogRecord, occurrences: number): void | Promise<void>;
+    onError?(error: unknown, record: LogRecord): void;
+    /** Cancel any pending dedupe-window timers. Call on logger shutdown. */
     close(): void;
 }
 
+/** Posts one alert body to a Slack incoming webhook URL. Swap in a fake for tests. */
+type SlackSender = (webhookUrl: string, body: string) => Promise<void> | void;
+interface SlackAlertPluginOptions extends AlertingPluginOptions {
+    sender?: SlackSender;
+}
+/**
+ * Sends deduplicated `AlertingPlugin` alerts to a Slack incoming webhook.
+ *
+ * `webhookUrl` is the full "Incoming Webhook" URL from Slack's app config.
+ * Uses `fetch` — no extra dependency required. Pass `sender` to swap in a
+ * fake for tests or an alternate backend.
+ */
+declare class SlackAlertPlugin extends AlertingPlugin {
+    readonly webhookUrl: string;
+    private readonly sender;
+    constructor(webhookUrl: string, options?: SlackAlertPluginOptions);
+    protected sendAlert(record: LogRecord, occurrences: number): Promise<void>;
+}
+
+/** POSTs one PagerDuty Events API v2 payload. Swap in a fake for tests. */
+type PagerDutySender = (body: string) => Promise<void> | void;
+interface PagerDutyAlertPluginOptions extends AlertingPluginOptions {
+    sender?: PagerDutySender;
+}
+/**
+ * Sends deduplicated `AlertingPlugin` alerts to PagerDuty via the Events
+ * API v2 (`POST https://events.pagerduty.com/v2/enqueue`).
+ *
+ * `routingKey` is an Events API v2 integration key from a PagerDuty
+ * service. Uses `fetch` — no extra dependency required. Pass `sender` to
+ * swap in a fake for tests or an alternate backend.
+ */
+declare class PagerDutyAlertPlugin extends AlertingPlugin {
+    readonly routingKey: string;
+    private readonly sender;
+    constructor(routingKey: string, options?: PagerDutyAlertPluginOptions);
+    protected sendAlert(record: LogRecord, occurrences: number): Promise<void>;
+}
+
+interface EmailMessage {
+    from: string;
+    to: string[];
+    subject: string;
+    text: string;
+}
+/** Sends one email message. Swap in a fake for tests. */
+type EmailSender = (message: EmailMessage) => Promise<void> | void;
+/** The subset of a `nodemailer` transporter that `EmailAlertPlugin` needs. */
+interface NodemailerTransporterLike {
+    sendMail(message: {
+        from: string;
+        to: string;
+        subject: string;
+        text: string;
+    }): Promise<unknown>;
+}
+interface EmailAlertPluginOptions extends AlertingPluginOptions {
+    smtpHost: string;
+    smtpPort: number;
+    fromAddr: string;
+    toAddrs: string[];
+    username?: string;
+    password?: string;
+    /** `false` for an SMTP server that doesn't support STARTTLS (e.g. a local relay). Default `true`. */
+    useTls?: boolean;
+    /** Pre-built sender, e.g. for tests. Skips the `nodemailer` auto-import entirely. */
+    sender?: EmailSender;
+}
+/**
+ * Sends deduplicated `AlertingPlugin` alerts by email over SMTP.
+ *
+ * `nodemailer` is an optional peer dependency: install it yourself, or
+ * pass `sender` to swap in a fake for tests or an alternate backend —
+ * `username`/`password` are only used if both are set.
+ */
+declare class EmailAlertPlugin extends AlertingPlugin {
+    readonly smtpHost: string;
+    readonly smtpPort: number;
+    readonly fromAddr: string;
+    readonly toAddrs: string[];
+    private readonly username;
+    private readonly password;
+    private readonly useTls;
+    private readonly injectedSender;
+    private transporter;
+    constructor(options: EmailAlertPluginOptions);
+    protected sendAlert(record: LogRecord, occurrences: number): Promise<void>;
+    private importTransporter;
+}
+
 interface BatchingTransportOptions {
     formatter?: Formatter;
     /** Flush once the buffer holds this many items. Default 100. */
@@ -943,37 +1242,6 @@ declare class HTTPTransport extends Transport {
     close(): void;
 }
 
-interface LoggerOptions {
-    level?: LevelInput;
-    transports?: Transport[];
-    plugins?: Plugin[];
-    meta?: Record<string, unknown>;
-}
-declare class Logger {
-    readonly name: string;
-    readonly transports: Transport[];
-    readonly plugins: Plugin[];
-    private currentLevel;
-    private readonly baseMeta;
-    constructor(name: string, options?: LoggerOptions);
-    get level(): Level;
-    setLevel(level: LevelInput): void;
-    /** Register a plugin. Returns `this` so calls can be chained. */
-    use(plugin: Plugin): this;
-    /** Close every attached transport. Call on shutdown to flush buffered writes. */
-    close(): void;
-    /** A logger scoped under this one, inheriting its level, transports, and plugins. */
-    child(name: string, meta?: Record<string, unknown>): Logger;
-    private notifyError;
-    private dispatch;
-    trace(message: string, meta?: Record<string, unknown>): LogRecord | null;
-    debug(message: string, meta?: Record<string, unknown>): LogRecord | null;
-    info(message: string, meta?: Record<string, unknown>): LogRecord | null;
-    warn(message: string, meta?: Record<string, unknown>): LogRecord | null;
-    error(message: string, meta?: Record<string, unknown>): LogRecord | null;
-    fatal(message: string, meta?: Record<string, unknown>): LogRecord | null;
-}
-
-declare const VERSION = "0.2.0";
+declare const VERSION = "0.3.0";
 
-export { type AmqpChannelLike, type AppInsightsClientLike, type AppInsightsTrace, AppInsightsTransport, type AppInsightsTransportOptions, BaseQueueTransport, type BaseQueueTransportOptions, BaseSQLTransport, type BaseSQLTransportOptions, BatchingTransport, type BatchingTransportOptions, type CloudLoggingClientLike, type CloudLoggingEntry, CloudLoggingTransport, type CloudLoggingTransportOptions, type CloudWatchClientLike, type CloudWatchLogEvent, CloudWatchTransport, type CloudWatchTransportOptions, CollectingTransport, type ConsoleLike, ConsoleTransport, type ConsoleTransportOptions, ContextPlugin, DEFAULT_REDACTED_KEYS, type DatadogSender, DatadogTransport, type DatadogTransportOptions, type DynamoClientLike, DynamoDBTransport, type DynamoDBTransportOptions, type DynamoLogItem, type ElasticsearchSender, ElasticsearchTransport, type ElasticsearchTransportOptions, FileTransport, type FileTransportOptions, type Formatter, HTTPTransport, type HTTPTransportOptions, JSONFormatter, type KafkaProducerLike, KafkaTransport, type KafkaTransportOptions, Level, type LevelInput, type LogRecord, Logger, type LoggerOptions, type MongoClientLike, type MongoCollectionLike, MongoDBTransport, type MongoDBTransportOptions, type MySQLClientLike, MySQLTransport, type MySQLTransportOptions, type NewRelicRegion, type NewRelicSender, type NewRelicSenderResult, NewRelicTransport, type NewRelicTransportOptions, type PgClientLike, type Plugin, PostgresTransport, type PostgresTransportOptions, type PubSubTopicLike, PubSubTransport, type PubSubTransportOptions, RabbitMQTransport, type RabbitMQTransportOptions, RedactPlugin, type RedactPluginOptions, type RedisClientLike, RedisTransport, type RedisTransportOptions, type SQLLogRow, type SQLiteClientLike, type SQLiteStatementLike, SQLiteTransport, type SQLiteTransportOptions, type SQSClientLike, SQSTransport, type SQSTransportOptions, SamplingPlugin, type SamplingPluginOptions, type Sender, Transport, VERSION, createRecord, levelName, parseLevel, utcTimestamp };
+export { AlertingPlugin, type AlertingPluginOptions, type AmqpChannelLike, type AppInsightsClientLike, type AppInsightsTrace, AppInsightsTransport, type AppInsightsTransportOptions, BaseQueueTransport, type BaseQueueTransportOptions, BaseSQLTransport, type BaseSQLTransportOptions, BatchingTransport, type BatchingTransportOptions, type CloudLoggingClientLike, type CloudLoggingEntry, CloudLoggingTransport, type CloudLoggingTransportOptions, type CloudWatchClientLike, type CloudWatchLogEvent, CloudWatchTransport, type CloudWatchTransportOptions, type ConsoleLike, ConsoleTransport, type ConsoleTransportOptions, ContextPlugin, DEFAULT_PII_PATTERNS, DEFAULT_REDACTED_KEYS, type DatadogSender, DatadogTransport, type DatadogTransportOptions, type DynamoClientLike, DynamoDBTransport, type DynamoDBTransportOptions, type DynamoLogItem, type ElasticsearchSender, ElasticsearchTransport, type ElasticsearchTransportOptions, EmailAlertPlugin, type EmailAlertPluginOptions, type EmailMessage, type EmailSender, FileTransport, type FileTransportOptions, Formatter, GENESIS_HASH, HTTPTransport, type HTTPTransportOptions, type KafkaProducerLike, KafkaTransport, type KafkaTransportOptions, Level, LevelInput, LogRecord, type MongoClientLike, type MongoCollectionLike, MongoDBTransport, type MongoDBTransportOptions, type MySQLClientLike, MySQLTransport, type MySQLTransportOptions, type NewRelicRegion, type NewRelicSender, type NewRelicSenderResult, NewRelicTransport, type NewRelicTransportOptions, type NodemailerTransporterLike, PIIRedactPlugin, type PIIRedactPluginOptions, PagerDutyAlertPlugin, type PagerDutyAlertPluginOptions, type PagerDutySender, type PgClientLike, Plugin, PostgresTransport, type PostgresTransportOptions, type PubSubTopicLike, PubSubTransport, type PubSubTransportOptions, RabbitMQTransport, type RabbitMQTransportOptions, RedactPlugin, type RedactPluginOptions, type RedisClientLike, RedisTransport, type RedisTransportOptions, RunPlugin, type RunPluginOptions, type SQLLogRow, type SQLiteClientLike, type SQLiteStatementLike, SQLiteTransport, type SQLiteTransportOptions, type SQSClientLike, SQSTransport, type SQSTransportOptions, SamplingPlugin, type SamplingPluginOptions, type Sender, SlackAlertPlugin, type SlackAlertPluginOptions, type SlackSender, TamperEvidentPlugin, type TamperEvidentPluginOptions, TraceContextPlugin, type TraceContextPluginOptions, Transport, VERSION, defaultResolveActiveOtelTraceId, generateTraceId, getTraceparent, parseTraceHeader, setTraceparent };