logquill 0.1.2 → 0.3.0

package/dist/index.cjs

@@ -1,9 +1,11 @@
 'use strict';
 
+var crypto = require('crypto');
+var zlib = require('zlib');
 var fs = require('fs');
 var path = require('path');
 
-// src/levels.ts
+// src/core/levels.ts
 var Level = /* @__PURE__ */ ((Level2) => {
   Level2[Level2["TRACE"] = 5] = "TRACE";
   Level2[Level2["DEBUG"] = 10] = "DEBUG";
@@ -38,7 +40,7 @@ function parseLevel(level) {
   return level;
 }
 
-// src/records.ts
+// src/core/records.ts
 function utcTimestamp() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -52,14 +54,25 @@ function createRecord(params) {
   };
 }
 
-// src/formatter.ts
+// src/core/formatter.ts
 var JSONFormatter = class {
   format(record) {
     return JSON.stringify(record);
   }
 };
 
-// src/context-plugin.ts
+// src/core/plugin.ts
+var FunctionPlugin = class {
+  func;
+  constructor(func) {
+    this.func = func;
+  }
+  beforeLog(record) {
+    return this.func(record);
+  }
+};
+
+// src/plugins/context-plugin.ts
 var ContextPlugin = class {
   context;
   constructor(context) {
@@ -70,7 +83,7 @@ var ContextPlugin = class {
   }
 };
 
-// src/redact-plugin.ts
+// src/plugins/redact-plugin.ts
 var DEFAULT_REDACTED_KEYS = ["password", "token", "secret", "api_key", "authorization"];
 var RedactPlugin = class {
   keys;
@@ -88,23 +101,413 @@ var RedactPlugin = class {
   }
 };
 
-// src/sampling-plugin.ts
+// src/plugins/pii-redact-plugin.ts
+var DEFAULT_PII_PATTERNS = {
+  email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+  ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
+  creditCard: /\b(?:\d[ -]?){13,16}\b/g,
+  phone: /\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g
+};
+var MAX_DEPTH = 50;
+var PIIRedactPlugin = class {
+  patterns;
+  replacement;
+  constructor(options = {}) {
+    this.patterns = options.patterns ?? DEFAULT_PII_PATTERNS;
+    this.replacement = options.replacement ?? "***";
+  }
+  beforeLog(record) {
+    return { ...record, meta: this.redactValue(record.meta, /* @__PURE__ */ new Set(), 0) };
+  }
+  redactValue(value, seen, depth) {
+    if (depth > MAX_DEPTH) {
+      return value;
+    }
+    if (typeof value === "string") {
+      return this.redactText(value);
+    }
+    if (Array.isArray(value)) {
+      if (seen.has(value)) {
+        return value;
+      }
+      const nextSeen = new Set(seen).add(value);
+      return value.map((entry) => this.redactValue(entry, nextSeen, depth + 1));
+    }
+    if (value !== null && typeof value === "object") {
+      if (seen.has(value)) {
+        return value;
+      }
+      const nextSeen = new Set(seen).add(value);
+      const result = {};
+      for (const [key, entryValue] of Object.entries(value)) {
+        result[key] = this.redactValue(entryValue, nextSeen, depth + 1);
+      }
+      return result;
+    }
+    return value;
+  }
+  redactText(text) {
+    let redacted = text;
+    for (const pattern of Object.values(this.patterns)) {
+      const global = pattern.global ? pattern : new RegExp(pattern.source, `${pattern.flags}g`);
+      redacted = redacted.replace(global, this.replacement);
+    }
+    return redacted;
+  }
+};
+
+// src/plugins/sampling-plugin.ts
 var SamplingPlugin = class {
   rate;
+  traceKey;
+  elevateAt;
+  transports;
+  maxBufferedRecords;
+  maxTraces;
   rng;
+  buffer = /* @__PURE__ */ new Map();
+  bufferedCount = 0;
+  elevated = /* @__PURE__ */ new Set();
   constructor(rate, options = {}) {
     if (rate < 0 || rate > 1) {
       throw new Error(`rate must be between 0 and 1, got ${String(rate)}`);
     }
     this.rate = rate;
     this.rng = options.rng ?? Math.random;
+    this.traceKey = options.traceKey ?? "traceId";
+    this.elevateAt = parseLevel(options.elevateAt ?? 40 /* ERROR */);
+    this.transports = options.transports;
+    this.maxBufferedRecords = options.maxBufferedRecords ?? 1e3;
+    this.maxTraces = options.maxTraces ?? 200;
   }
   beforeLog(record) {
-    return this.rng() < this.rate ? record : null;
+    const transports = this.transports;
+    if (transports === void 0) {
+      return this.rng() < this.rate ? record : null;
+    }
+    const traceId = record.meta[this.traceKey];
+    if (traceId !== void 0 && this.elevated.has(traceId)) {
+      return record;
+    }
+    const keep = this.rng() < this.rate;
+    const reachedElevateLevel = parseLevel(record.level) >= this.elevateAt;
+    if (traceId !== void 0 && reachedElevateLevel) {
+      this.elevate(traceId, transports);
+      return record;
+    }
+    if (keep) {
+      return record;
+    }
+    if (traceId !== void 0) {
+      this.bufferRecord(traceId, record);
+    }
+    return null;
+  }
+  elevate(traceId, transports) {
+    this.elevated.add(traceId);
+    const buffered = this.buffer.get(traceId) ?? [];
+    this.buffer.delete(traceId);
+    this.bufferedCount -= buffered.length;
+    for (const bufferedRecord of buffered) {
+      for (const transport of transports) {
+        transport.write(transport.format(bufferedRecord), bufferedRecord);
+      }
+    }
+  }
+  bufferRecord(traceId, record) {
+    let records = this.buffer.get(traceId);
+    if (records) {
+      this.buffer.delete(traceId);
+      this.buffer.set(traceId, records);
+    } else {
+      if (this.buffer.size >= this.maxTraces) {
+        this.evictOldestTrace();
+      }
+      records = [];
+      this.buffer.set(traceId, records);
+    }
+    records.push(record);
+    this.bufferedCount += 1;
+    while (this.bufferedCount > this.maxBufferedRecords && this.buffer.size > 0) {
+      this.evictOldestTrace();
+    }
+  }
+  evictOldestTrace() {
+    const oldest = this.buffer.entries().next();
+    if (oldest.done) {
+      return;
+    }
+    const [oldestKey, oldestRecords] = oldest.value;
+    this.buffer.delete(oldestKey);
+    this.bufferedCount -= oldestRecords.length;
+  }
+};
+var GENESIS_HASH = "0".repeat(64);
+function canonicalStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => canonicalStringify(entry)).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${canonicalStringify(entryValue)}`).join(",")}}`;
+  }
+  if (value === void 0) {
+    return "null";
+  }
+  return JSON.stringify(value);
+}
+function computeHash(record, prevHash) {
+  const restMeta = Object.fromEntries(Object.entries(record.meta).filter(([key]) => key !== "hash" && key !== "prevHash"));
+  const payload = canonicalStringify({
+    timestamp: record.timestamp,
+    level: record.level,
+    logger: record.logger,
+    message: record.message,
+    meta: restMeta
+  });
+  return crypto.createHash("sha256").update(`${prevHash}${payload}`).digest("hex");
+}
+var TamperEvidentPlugin = class {
+  genesisHash;
+  lastHash;
+  constructor(options = {}) {
+    this.genesisHash = options.genesisHash ?? GENESIS_HASH;
+    this.lastHash = this.genesisHash;
+  }
+  beforeLog(record) {
+    const prevHash = this.lastHash;
+    const digest = computeHash(record, prevHash);
+    const next = { ...record, meta: { ...record.meta, prevHash, hash: digest } };
+    this.lastHash = digest;
+    return next;
+  }
+  /**
+   * 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, options = {}) {
+    let prevHash = options.genesisHash ?? GENESIS_HASH;
+    for (const record of records) {
+      const storedHash = record.meta.hash;
+      const storedPrevHash = record.meta.prevHash;
+      if (typeof storedHash !== "string" || storedPrevHash !== prevHash) {
+        return false;
+      }
+      if (computeHash(record, prevHash) !== storedHash) {
+        return false;
+      }
+      prevHash = storedHash;
+    }
+    return true;
+  }
+};
+
+// src/plugins/alerting-plugin.ts
+function defaultDedupeKey(record) {
+  return `${record.level}:${record.logger}:${record.message}`;
+}
+var AlertingPlugin = class {
+  threshold;
+  dedupeWindowMs;
+  maxTrackedKeys;
+  dedupeKeyFn;
+  windows = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.threshold = parseLevel(options.threshold ?? 40 /* ERROR */);
+    this.dedupeWindowMs = options.dedupeWindowMs ?? 3e5;
+    this.dedupeKeyFn = options.dedupeKey ?? defaultDedupeKey;
+    this.maxTrackedKeys = options.maxTrackedKeys ?? 500;
+  }
+  afterLog(record) {
+    if (parseLevel(record.level) < this.threshold) {
+      return;
+    }
+    const key = this.dedupeKeyFn(record);
+    const existing = this.windows.get(key);
+    if (existing) {
+      existing.count += 1;
+      return;
+    }
+    if (this.windows.size >= this.maxTrackedKeys) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      this.flush(key);
+    }, this.dedupeWindowMs);
+    timer.unref();
+    this.windows.set(key, { record, count: 1, timer });
+    this.safeSend(record, 1);
+  }
+  flush(key) {
+    const window = this.windows.get(key);
+    this.windows.delete(key);
+    if (!window || window.count <= 1) {
+      return;
+    }
+    this.safeSend(window.record, window.count);
+  }
+  safeSend(record, occurrences) {
+    Promise.resolve().then(() => this.sendAlert(record, occurrences)).catch((error) => {
+      try {
+        this.onError?.(error, record);
+      } catch {
+      }
+    });
+  }
+  /** Cancel any pending dedupe-window timers. Call on logger shutdown. */
+  close() {
+    const windows = [...this.windows.values()];
+    this.windows.clear();
+    for (const window of windows) {
+      clearTimeout(window.timer);
+    }
+  }
+};
+
+// src/plugins/slack-alert-plugin.ts
+async function fetchSlackSender(webhookUrl, body) {
+  const response = await fetch(webhookUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body
+  });
+  if (!response.ok) {
+    throw new Error(
+      `SlackAlertPlugin: webhook returned HTTP ${String(response.status)} \u2014 check the webhook URL is still valid in Slack's app config`
+    );
+  }
+}
+function formatMessage(record, occurrences) {
+  const suffix = occurrences > 1 ? ` (x${String(occurrences)})` : "";
+  return `[${record.level}] ${record.logger}: ${record.message}${suffix}`;
+}
+var SlackAlertPlugin = class extends AlertingPlugin {
+  webhookUrl;
+  sender;
+  constructor(webhookUrl, options = {}) {
+    super(options);
+    this.webhookUrl = webhookUrl;
+    this.sender = options.sender ?? fetchSlackSender;
+  }
+  async sendAlert(record, occurrences) {
+    const body = JSON.stringify({ text: formatMessage(record, occurrences) });
+    await this.sender(this.webhookUrl, body);
+  }
+};
+
+// src/plugins/pagerduty-alert-plugin.ts
+var ENDPOINT = "https://events.pagerduty.com/v2/enqueue";
+var SEVERITY = { ERROR: "error", FATAL: "critical" };
+async function fetchPagerDutySender(body) {
+  const response = await fetch(ENDPOINT, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body
+  });
+  if (!response.ok) {
+    throw new Error(
+      `PagerDutyAlertPlugin: Events API returned HTTP ${String(response.status)} \u2014 check the routing key is a valid Events API v2 integration key`
+    );
+  }
+}
+var PagerDutyAlertPlugin = class extends AlertingPlugin {
+  routingKey;
+  sender;
+  constructor(routingKey, options = {}) {
+    super(options);
+    this.routingKey = routingKey;
+    this.sender = options.sender ?? fetchPagerDutySender;
+  }
+  async sendAlert(record, occurrences) {
+    let summary = `${record.logger}: ${record.message}`;
+    if (occurrences > 1) {
+      summary += ` (x${String(occurrences)})`;
+    }
+    const body = JSON.stringify({
+      routing_key: this.routingKey,
+      event_action: "trigger",
+      payload: {
+        summary,
+        severity: SEVERITY[record.level] ?? "error",
+        source: record.logger,
+        timestamp: record.timestamp,
+        custom_details: { occurrences, ...record.meta }
+      }
+    });
+    await this.sender(body);
+  }
+};
+
+// src/plugins/email-alert-plugin.ts
+var EmailAlertPlugin = class extends AlertingPlugin {
+  smtpHost;
+  smtpPort;
+  fromAddr;
+  toAddrs;
+  username;
+  password;
+  useTls;
+  injectedSender;
+  transporter;
+  constructor(options) {
+    super(options);
+    this.smtpHost = options.smtpHost;
+    this.smtpPort = options.smtpPort;
+    this.fromAddr = options.fromAddr;
+    this.toAddrs = options.toAddrs;
+    this.username = options.username;
+    this.password = options.password;
+    this.useTls = options.useTls ?? true;
+    this.injectedSender = options.sender;
+  }
+  async sendAlert(record, occurrences) {
+    let subject = `[${record.level}] ${record.logger}`;
+    if (occurrences > 1) {
+      subject += ` (x${String(occurrences)})`;
+    }
+    const text = [
+      record.message,
+      "",
+      `occurrences: ${String(occurrences)}`,
+      `timestamp: ${record.timestamp}`,
+      `meta: ${JSON.stringify(record.meta)}`
+    ].join("\n");
+    const message = { from: this.fromAddr, to: this.toAddrs, subject, text };
+    if (this.injectedSender) {
+      await this.injectedSender(message);
+      return;
+    }
+    const transporter = this.transporter ?? await this.importTransporter();
+    await transporter.sendMail({ from: message.from, to: message.to.join(", "), subject: message.subject, text: message.text });
+  }
+  async importTransporter() {
+    let createTransport;
+    try {
+      const moduleName = "nodemailer";
+      const mod = await import(moduleName);
+      const resolved = mod.default?.createTransport ?? mod.createTransport;
+      if (!resolved) {
+        throw new Error("no createTransport export found");
+      }
+      createTransport = resolved;
+    } catch {
+      throw new Error(
+        "EmailAlertPlugin: install `nodemailer` to use this plugin without providing a `sender` \u2014 `npm install nodemailer`"
+      );
+    }
+    this.transporter = createTransport({
+      host: this.smtpHost,
+      port: this.smtpPort,
+      secure: false,
+      requireTLS: this.useTls,
+      auth: this.username && this.password ? { user: this.username, pass: this.password } : void 0
+    });
+    return this.transporter;
   }
 };
 
-// src/transport.ts
+// src/transports/transport.ts
 var Transport = class {
   formatter;
   constructor(formatter = new JSONFormatter()) {
@@ -130,7 +533,1050 @@ var CollectingTransport = class extends Transport {
   }
 };
 
-// src/console-transport.ts
+// src/transports/batching-transport.ts
+var BatchingTransport = class extends Transport {
+  maxRecords;
+  maxBytes;
+  buffer = [];
+  bufferBytes = 0;
+  constructor(options = {}) {
+    super(options.formatter);
+    this.maxRecords = options.maxRecords ?? 100;
+    this.maxBytes = options.maxBytes ?? 1e6;
+  }
+  /** Converts a written record into the buffered item type. Defaults to the record itself. */
+  toItem(formatted, record) {
+    return record;
+  }
+  /** Estimated byte size of one buffered item, used for the `maxBytes` bound. */
+  sizeOf(item) {
+    return JSON.stringify(item).length;
+  }
+  write(formatted, record) {
+    const item = this.toItem(formatted, record);
+    this.buffer.push(item);
+    this.bufferBytes += this.sizeOf(item);
+    if (this.buffer.length >= this.maxRecords || this.bufferBytes >= this.maxBytes) {
+      this.flush();
+    }
+  }
+  /** Send the current batch now, even if it hasn't reached a bound. */
+  flush() {
+    if (this.buffer.length === 0) {
+      return;
+    }
+    const batch = this.buffer;
+    this.buffer = [];
+    this.bufferBytes = 0;
+    const result = this.sendBatch(batch);
+    if (result) {
+      result.catch((error) => {
+        console.error(`${this.constructor.name}: failed to send log batch`, error);
+      });
+    }
+  }
+  close() {
+    this.flush();
+  }
+};
+
+// src/transports/sql/base-sql-transport.ts
+function metaString(meta, key) {
+  const value = meta[key];
+  return typeof value === "string" ? value : null;
+}
+var BaseSQLTransport = class extends BatchingTransport {
+  tableName;
+  ensureSchema;
+  schemaEnsured = false;
+  constructor(options = {}) {
+    super(options);
+    this.tableName = options.tableName ?? "logs";
+    this.ensureSchema = options.ensureSchema ?? false;
+  }
+  toItem(_formatted, record) {
+    return {
+      timestamp: record.timestamp,
+      level: record.level,
+      logger: record.logger,
+      message: record.message,
+      meta: JSON.stringify(record.meta),
+      runId: metaString(record.meta, "runId"),
+      spanId: metaString(record.meta, "spanId"),
+      parentSpanId: metaString(record.meta, "parentSpanId"),
+      traceId: metaString(record.meta, "traceId")
+    };
+  }
+  sizeOf(row) {
+    return row.message.length + row.meta.length + 96;
+  }
+  /**
+   * Minimal, dialect-generic `CREATE TABLE IF NOT EXISTS` for dev/test use via
+   * `ensureSchema: true`. Production deployments should manage this table with
+   * a real migration instead — override in a subclass for dialect-correct
+   * column types (e.g. `JSONB` on Postgres).
+   */
+  createTableSQL() {
+    return `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp TEXT NOT NULL,
+  level TEXT NOT NULL,
+  logger TEXT NOT NULL,
+  message TEXT NOT NULL,
+  meta TEXT NOT NULL,
+  runId TEXT,
+  spanId TEXT,
+  parentSpanId TEXT,
+  traceId TEXT
+)`;
+  }
+  async sendBatch(rows) {
+    if (this.ensureSchema && !this.schemaEnsured) {
+      this.schemaEnsured = true;
+      await this.ensureTable();
+    }
+    await this.insertRows(rows);
+  }
+};
+
+// src/transports/sql/sqlite-transport.ts
+var SQLiteTransport = class extends BaseSQLTransport {
+  injectedClient;
+  filename;
+  client;
+  constructor(options = {}) {
+    super(options);
+    this.injectedClient = options.client;
+    this.filename = options.filename ?? ":memory:";
+  }
+  /** Synchronously available client, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let DatabaseCtor;
+    try {
+      const moduleName = "better-sqlite3";
+      const mod = await import(moduleName);
+      DatabaseCtor = mod.default;
+    } catch {
+      throw new Error(
+        "SQLiteTransport: install `better-sqlite3` to use this transport without providing a client \u2014 `npm install better-sqlite3`"
+      );
+    }
+    this.client = new DatabaseCtor(this.filename);
+    return this.client;
+  }
+  async ensureTable() {
+    const client = this.resolvedClient() ?? await this.importClient();
+    client.exec(this.createTableSQL());
+  }
+  async insertRows(rows) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    const stmt = client.prepare(
+      `INSERT INTO ${this.tableName} (timestamp, level, logger, message, meta, runId, spanId, parentSpanId, traceId) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const insertMany = client.transaction((batch) => {
+      for (const row of batch) {
+        stmt.run(
+          row.timestamp,
+          row.level,
+          row.logger,
+          row.message,
+          row.meta,
+          row.runId,
+          row.spanId,
+          row.parentSpanId,
+          row.traceId
+        );
+      }
+    });
+    insertMany(rows);
+  }
+};
+
+// src/transports/sql/postgres-transport.ts
+var PostgresTransport = class extends BaseSQLTransport {
+  injectedClient;
+  connectionString;
+  connectionConfig;
+  client;
+  constructor(options = {}) {
+    super(options);
+    this.injectedClient = options.client;
+    this.connectionString = options.connectionString;
+    this.connectionConfig = options.connectionConfig;
+  }
+  /** Synchronously available client, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let PoolCtor;
+    try {
+      const moduleName = "pg";
+      const mod = await import(moduleName);
+      const resolved = mod.default?.Pool ?? mod.Pool;
+      if (!resolved) {
+        throw new Error("no Pool export found");
+      }
+      PoolCtor = resolved;
+    } catch {
+      throw new Error(
+        "PostgresTransport: install `pg` to use this transport without providing a client \u2014 `npm install pg`"
+      );
+    }
+    const config = this.connectionString ? { connectionString: this.connectionString } : this.connectionConfig ?? {};
+    this.client = new PoolCtor(config);
+    return this.client;
+  }
+  /** Postgres-correct `CREATE TABLE IF NOT EXISTS`: `SERIAL` primary key, `JSONB` for `meta`. */
+  createTableSQL() {
+    return `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+  id SERIAL PRIMARY KEY,
+  timestamp TEXT NOT NULL,
+  level TEXT NOT NULL,
+  logger TEXT NOT NULL,
+  message TEXT NOT NULL,
+  meta JSONB NOT NULL,
+  "runId" TEXT,
+  "spanId" TEXT,
+  "parentSpanId" TEXT,
+  "traceId" TEXT
+)`;
+  }
+  async ensureTable() {
+    const client = this.resolvedClient() ?? await this.importClient();
+    await client.query(this.createTableSQL(), []);
+  }
+  async insertRows(rows) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    const columns = 9;
+    const values = [];
+    const placeholders = [];
+    rows.forEach((row, rowIndex) => {
+      const base = rowIndex * columns;
+      placeholders.push(
+        `(${Array.from({ length: columns }, (_, col) => `$${String(base + col + 1)}`).join(", ")})`
+      );
+      values.push(
+        row.timestamp,
+        row.level,
+        row.logger,
+        row.message,
+        row.meta,
+        row.runId,
+        row.spanId,
+        row.parentSpanId,
+        row.traceId
+      );
+    });
+    const sql = `INSERT INTO ${this.tableName} (timestamp, level, logger, message, meta, "runId", "spanId", "parentSpanId", "traceId") VALUES ${placeholders.join(", ")}`;
+    await client.query(sql, values);
+  }
+};
+
+// src/transports/sql/mysql-transport.ts
+var MySQLTransport = class extends BaseSQLTransport {
+  injectedClient;
+  connectionString;
+  connectionConfig;
+  client;
+  constructor(options = {}) {
+    super(options);
+    this.injectedClient = options.client;
+    this.connectionString = options.connectionString;
+    this.connectionConfig = options.connectionConfig;
+  }
+  /** Synchronously available client, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let createPool;
+    try {
+      const moduleName = "mysql2/promise";
+      const mod = await import(moduleName);
+      const resolved = mod.default?.createPool ?? mod.createPool;
+      if (!resolved) {
+        throw new Error("no createPool export found");
+      }
+      createPool = resolved;
+    } catch {
+      throw new Error(
+        "MySQLTransport: install `mysql2` to use this transport without providing a client \u2014 `npm install mysql2`"
+      );
+    }
+    const target = this.connectionString ?? this.connectionConfig ?? {};
+    this.client = createPool(target);
+    return this.client;
+  }
+  /** MySQL-correct `CREATE TABLE IF NOT EXISTS`: `AUTO_INCREMENT` primary key, `JSON` column type for `meta`. */
+  createTableSQL() {
+    return `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+  timestamp VARCHAR(64) NOT NULL,
+  level VARCHAR(16) NOT NULL,
+  logger VARCHAR(255) NOT NULL,
+  message TEXT NOT NULL,
+  meta JSON NOT NULL,
+  runId VARCHAR(255),
+  spanId VARCHAR(255),
+  parentSpanId VARCHAR(255),
+  traceId VARCHAR(255)
+)`;
+  }
+  async ensureTable() {
+    const client = this.resolvedClient() ?? await this.importClient();
+    await client.execute(this.createTableSQL(), []);
+  }
+  async insertRows(rows) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    const columns = 9;
+    const values = [];
+    const placeholders = [];
+    for (const row of rows) {
+      placeholders.push(`(${Array.from({ length: columns }, () => "?").join(", ")})`);
+      values.push(
+        row.timestamp,
+        row.level,
+        row.logger,
+        row.message,
+        row.meta,
+        row.runId,
+        row.spanId,
+        row.parentSpanId,
+        row.traceId
+      );
+    }
+    const sql = `INSERT INTO ${this.tableName} (timestamp, level, logger, message, meta, runId, spanId, parentSpanId, traceId) VALUES ${placeholders.join(", ")}`;
+    await client.execute(sql, values);
+  }
+};
+
+// src/transports/nosql/mongodb-transport.ts
+var MongoDBTransport = class extends BatchingTransport {
+  injectedCollection;
+  connectionString;
+  database;
+  collectionName;
+  collection;
+  constructor(options = {}) {
+    super(options);
+    this.injectedCollection = options.collection;
+    this.connectionString = options.connectionString;
+    this.database = options.database ?? "logquill";
+    this.collectionName = options.collectionName ?? "logs";
+  }
+  /** Synchronously available collection, if one was injected or already connected — avoids an unnecessary microtask hop on the hot path. */
+  resolvedCollection() {
+    return this.injectedCollection ?? this.collection;
+  }
+  async importCollection() {
+    if (!this.connectionString) {
+      throw new Error(
+        "MongoDBTransport: provide either a `collection` or a `connectionString` to connect with \u2014 neither was given"
+      );
+    }
+    let MongoClientCtor;
+    try {
+      const moduleName = "mongodb";
+      const mod = await import(moduleName);
+      MongoClientCtor = mod.MongoClient;
+    } catch {
+      throw new Error(
+        "MongoDBTransport: install `mongodb` to use this transport without providing a client \u2014 `npm install mongodb`"
+      );
+    }
+    const client = new MongoClientCtor(this.connectionString);
+    await client.connect();
+    this.collection = client.db(this.database).collection(this.collectionName);
+    return this.collection;
+  }
+  async sendBatch(batch) {
+    const collection = this.resolvedCollection() ?? await this.importCollection();
+    await collection.insertMany(batch.map((record) => ({ ...record })));
+  }
+};
+
+// src/transports/nosql/dynamodb-transport.ts
+var DYNAMO_BATCH_LIMIT = 25;
+function toAttributeValue(value) {
+  if (value === null || value === void 0) {
+    return { NULL: true };
+  }
+  if (typeof value === "string") {
+    return { S: value };
+  }
+  if (typeof value === "number") {
+    return { N: String(value) };
+  }
+  if (typeof value === "boolean") {
+    return { BOOL: value };
+  }
+  if (typeof value === "bigint") {
+    return { N: value.toString() };
+  }
+  if (Array.isArray(value)) {
+    return { L: value.map((entry) => toAttributeValue(entry)) };
+  }
+  if (typeof value === "object") {
+    const m = {};
+    for (const [key, entryValue] of Object.entries(value)) {
+      m[key] = toAttributeValue(entryValue);
+    }
+    return { M: m };
+  }
+  return { NULL: true };
+}
+function marshallItem(item) {
+  return toAttributeValue({ ...item }).M;
+}
+var DynamoDBTransport = class extends BatchingTransport {
+  injectedClient;
+  tableName;
+  region;
+  client;
+  constructor(options = {}) {
+    super(options);
+    this.injectedClient = options.client;
+    this.tableName = options.tableName ?? "logs";
+    this.region = options.region;
+  }
+  /** Synchronously available client, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let DynamoDBClientCtor;
+    let BatchWriteItemCommandCtor;
+    try {
+      const moduleName = "@aws-sdk/client-dynamodb";
+      const mod = await import(moduleName);
+      DynamoDBClientCtor = mod.DynamoDBClient;
+      BatchWriteItemCommandCtor = mod.BatchWriteItemCommand;
+    } catch {
+      throw new Error(
+        "DynamoDBTransport: install `@aws-sdk/client-dynamodb` to use this transport without providing a client \u2014 `npm install @aws-sdk/client-dynamodb`"
+      );
+    }
+    const sdkClient = new DynamoDBClientCtor(this.region ? { region: this.region } : {});
+    this.client = {
+      async batchWriteItems(tableName, items) {
+        const requestItems = {
+          [tableName]: items.map((item) => ({ PutRequest: { Item: marshallItem(item) } }))
+        };
+        return sdkClient.send(new BatchWriteItemCommandCtor({ RequestItems: requestItems }));
+      }
+    };
+    return this.client;
+  }
+  /** `meta.runId`, else `meta.traceId`, else the logger name — see the class doc for why. */
+  partitionKey(record) {
+    const runId = record.meta.runId;
+    if (typeof runId === "string" && runId.length > 0) {
+      return runId;
+    }
+    const traceId = record.meta.traceId;
+    if (typeof traceId === "string" && traceId.length > 0) {
+      return traceId;
+    }
+    return record.logger;
+  }
+  toDynamoItem(record) {
+    const spanId = record.meta.spanId;
+    const parentSpanId = record.meta.parentSpanId;
+    const traceId = record.meta.traceId;
+    return {
+      runId: this.partitionKey(record),
+      timestamp: record.timestamp,
+      level: record.level,
+      logger: record.logger,
+      message: record.message,
+      meta: record.meta,
+      ...typeof spanId === "string" ? { spanId } : {},
+      ...typeof parentSpanId === "string" ? { parentSpanId } : {},
+      ...typeof traceId === "string" ? { traceId } : {}
+    };
+  }
+  async sendBatch(batch) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    const items = batch.map((record) => this.toDynamoItem(record));
+    const chunks = [];
+    for (let offset = 0; offset < items.length; offset += DYNAMO_BATCH_LIMIT) {
+      chunks.push(items.slice(offset, offset + DYNAMO_BATCH_LIMIT));
+    }
+    await Promise.all(chunks.map((chunk) => client.batchWriteItems(this.tableName, chunk)));
+  }
+};
+
+// src/transports/nosql/redis-transport.ts
+var RedisTransport = class extends BatchingTransport {
+  injectedClient;
+  url;
+  stream;
+  client;
+  constructor(options = {}) {
+    super(options);
+    this.injectedClient = options.client;
+    this.url = options.url ?? "redis://localhost:6379";
+    this.stream = options.stream ?? "logquill:logs";
+  }
+  /** Synchronously available client, if one was injected or already connected — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let createClient;
+    try {
+      const moduleName = "redis";
+      const mod = await import(moduleName);
+      createClient = mod.createClient;
+    } catch {
+      throw new Error(
+        "RedisTransport: install `redis` to use this transport without providing a client \u2014 `npm install redis`"
+      );
+    }
+    const client = createClient({ url: this.url });
+    await client.connect();
+    this.client = client;
+    return client;
+  }
+  toFields(record) {
+    return {
+      timestamp: record.timestamp,
+      level: record.level,
+      logger: record.logger,
+      message: record.message,
+      meta: JSON.stringify(record.meta)
+    };
+  }
+  async sendBatch(batch) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    await Promise.all(batch.map((record) => client.xAdd(this.stream, "*", this.toFields(record))));
+  }
+};
+
+// src/transports/queue/base-queue-transport.ts
+var BaseQueueTransport = class extends BatchingTransport {
+  topic;
+  constructor(options) {
+    super(options);
+    this.topic = options.topic;
+  }
+  sendBatch(batch) {
+    return this.publishBatch(batch);
+  }
+};
+
+// src/transports/queue/kafka-transport.ts
+function metaKey(meta, key) {
+  const value = meta[key];
+  return typeof value === "string" ? value : void 0;
+}
+var KafkaTransport = class extends BaseQueueTransport {
+  injectedClient;
+  brokers;
+  client;
+  constructor(options) {
+    super(options);
+    this.injectedClient = options.client;
+    this.brokers = options.brokers ?? ["localhost:9092"];
+  }
+  /** Synchronously available producer, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  /**
+   * Builds the real `kafkajs` producer and connects it. Connection happens
+   * here, once, as part of acquiring the driver — not on every
+   * `publishBatch()` call — so an injected `client` (tests, or a caller's
+   * own already-connected producer) is trusted to already be ready and is
+   * never re-connected.
+   */
+  async importClient() {
+    let producer;
+    try {
+      const moduleName = "kafkajs";
+      const mod = await import(moduleName);
+      producer = new mod.Kafka({ brokers: this.brokers }).producer();
+      await producer.connect?.();
+    } catch {
+      throw new Error(
+        "KafkaTransport: install `kafkajs` to use this transport without providing a client \u2014 `npm install kafkajs`"
+      );
+    }
+    this.client = producer;
+    return producer;
+  }
+  async publishBatch(records) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    await client.send({
+      topic: this.topic,
+      messages: records.map((record) => ({
+        key: metaKey(record.meta, "runId") ?? metaKey(record.meta, "traceId") ?? null,
+        value: JSON.stringify(record)
+      }))
+    });
+  }
+};
+
+// src/transports/queue/rabbitmq-transport.ts
+var RabbitMQTransport = class extends BaseQueueTransport {
+  injectedClient;
+  url;
+  client;
+  constructor(options) {
+    super(options);
+    this.injectedClient = options.client;
+    this.url = options.url ?? "amqp://localhost";
+  }
+  /** Synchronously available channel, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  /**
+   * Opens the real `amqplib` connection/channel and asserts the queue
+   * exists. Both happen here, once, as part of acquiring the driver — not on
+   * every `publishBatch()` call — so an injected `client` (tests, or a
+   * caller's own already-open channel) is trusted to already have its queue
+   * set up and is never re-asserted.
+   */
+  async importClient() {
+    let channel;
+    try {
+      const moduleName = "amqplib";
+      const mod = await import(moduleName);
+      const connection = await mod.connect(this.url);
+      channel = await connection.createChannel();
+      await channel.assertQueue?.(this.topic);
+    } catch {
+      throw new Error(
+        "RabbitMQTransport: install `amqplib` to use this transport without providing a client \u2014 `npm install amqplib`"
+      );
+    }
+    this.client = channel;
+    return channel;
+  }
+  async publishBatch(records) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    for (const record of records) {
+      client.sendToQueue(this.topic, Buffer.from(JSON.stringify(record)));
+    }
+  }
+};
+
+// src/transports/queue/sqs-transport.ts
+var SQS_BATCH_LIMIT = 10;
+var SQSTransport = class extends BaseQueueTransport {
+  injectedClient;
+  region;
+  client;
+  constructor(options) {
+    super(options);
+    this.injectedClient = options.client;
+    this.region = options.region;
+  }
+  /** Synchronously available client, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let client;
+    try {
+      const moduleName = "@aws-sdk/client-sqs";
+      const mod = await import(moduleName);
+      const sdkClient = new mod.SQSClient({ region: this.region });
+      const CommandCtor = mod.SendMessageBatchCommand;
+      client = {
+        sendMessageBatch: (queueUrl, entries) => sdkClient.send(
+          new CommandCtor({
+            QueueUrl: queueUrl,
+            Entries: entries.map((entry) => ({ Id: entry.id, MessageBody: entry.body }))
+          })
+        )
+      };
+    } catch {
+      throw new Error(
+        "SQSTransport: install `@aws-sdk/client-sqs` to use this transport without providing a client \u2014 `npm install @aws-sdk/client-sqs`"
+      );
+    }
+    this.client = client;
+    return client;
+  }
+  async publishBatch(records) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    const chunks = [];
+    for (let start = 0; start < records.length; start += SQS_BATCH_LIMIT) {
+      chunks.push(records.slice(start, start + SQS_BATCH_LIMIT));
+    }
+    await Promise.all(
+      chunks.map(
+        (chunk) => client.sendMessageBatch(
+          this.topic,
+          chunk.map((record, index) => ({ id: String(index), body: JSON.stringify(record) }))
+        )
+      )
+    );
+  }
+};
+
+// src/transports/queue/pubsub-transport.ts
+var PubSubTransport = class extends BaseQueueTransport {
+  injectedClient;
+  projectId;
+  client;
+  constructor(options) {
+    super(options);
+    this.injectedClient = options.client;
+    this.projectId = options.projectId;
+  }
+  /** Synchronously available topic reference, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let topic;
+    try {
+      const moduleName = "@google-cloud/pubsub";
+      const mod = await import(moduleName);
+      topic = new mod.PubSub({ projectId: this.projectId }).topic(this.topic);
+    } catch {
+      throw new Error(
+        "PubSubTransport: install `@google-cloud/pubsub` to use this transport without providing a client \u2014 `npm install @google-cloud/pubsub`"
+      );
+    }
+    this.client = topic;
+    return topic;
+  }
+  async publishBatch(records) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    await Promise.all(records.map((record) => client.publishMessage({ data: Buffer.from(JSON.stringify(record)) })));
+  }
+};
+
+// src/transports/cloud/cloudwatch-transport.ts
+var CloudWatchTransport = class extends BatchingTransport {
+  logGroupName;
+  logStreamName;
+  region;
+  injectedClient;
+  client;
+  constructor(options) {
+    super(options);
+    this.logGroupName = options.logGroupName;
+    this.logStreamName = options.logStreamName;
+    this.region = options.region;
+    this.injectedClient = options.client;
+  }
+  /** Synchronously available client, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let ClientCtor;
+    let PutLogEventsCommandCtor;
+    try {
+      const moduleName = "@aws-sdk/client-cloudwatch-logs";
+      const mod = await import(moduleName);
+      ClientCtor = mod.CloudWatchLogsClient;
+      PutLogEventsCommandCtor = mod.PutLogEventsCommand;
+    } catch {
+      throw new Error(
+        "CloudWatchTransport: install `@aws-sdk/client-cloudwatch-logs` to use this transport without providing a client \u2014 `npm install @aws-sdk/client-cloudwatch-logs`"
+      );
+    }
+    const sdkClient = new ClientCtor({ region: this.region });
+    this.client = {
+      putLogEvents: (logGroupName, logStreamName, events) => sdkClient.send(
+        new PutLogEventsCommandCtor({
+          logGroupName,
+          logStreamName,
+          logEvents: events
+        })
+      )
+    };
+    return this.client;
+  }
+  async sendBatch(batch) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    const events = batch.map((record) => ({
+      timestamp: Date.parse(record.timestamp),
+      message: this.format(record)
+    })).sort((a, b) => a.timestamp - b.timestamp);
+    await client.putLogEvents(this.logGroupName, this.logStreamName, events);
+  }
+};
+
+// src/transports/cloud/cloud-logging-transport.ts
+function gcpSeverity(levelValue) {
+  const level = parseLevel(levelValue);
+  switch (level) {
+    case 5 /* TRACE */:
+    case 10 /* DEBUG */:
+      return "DEBUG";
+    case 20 /* INFO */:
+      return "INFO";
+    case 30 /* WARN */:
+      return "WARNING";
+    case 40 /* ERROR */:
+      return "ERROR";
+    case 50 /* FATAL */:
+      return "CRITICAL";
+  }
+}
+var CloudLoggingTransport = class extends BatchingTransport {
+  logName;
+  projectId;
+  injectedClient;
+  client;
+  constructor(options = {}) {
+    super(options);
+    this.logName = options.logName ?? "logquill";
+    this.projectId = options.projectId;
+    this.injectedClient = options.client;
+  }
+  /** Synchronously available client, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let LoggingCtor;
+    try {
+      const moduleName = "@google-cloud/logging";
+      const mod = await import(moduleName);
+      LoggingCtor = mod.Logging;
+    } catch {
+      throw new Error(
+        "CloudLoggingTransport: install `@google-cloud/logging` to use this transport without providing a client \u2014 `npm install @google-cloud/logging`"
+      );
+    }
+    const logging = new LoggingCtor({ projectId: this.projectId });
+    const log = logging.log(this.logName);
+    this.client = {
+      writeLogEntries: (entries) => log.write(entries)
+    };
+    return this.client;
+  }
+  async sendBatch(batch) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    const entries = batch.map((record) => ({
+      severity: gcpSeverity(record.level),
+      timestamp: record.timestamp,
+      jsonPayload: JSON.parse(this.format(record))
+    }));
+    await client.writeLogEntries(entries);
+  }
+};
+
+// src/transports/cloud/app-insights-transport.ts
+function appInsightsSeverity(levelValue) {
+  const level = parseLevel(levelValue);
+  switch (level) {
+    case 5 /* TRACE */:
+    case 10 /* DEBUG */:
+      return 0;
+    // Verbose
+    case 20 /* INFO */:
+      return 1;
+    // Information
+    case 30 /* WARN */:
+      return 2;
+    // Warning
+    case 40 /* ERROR */:
+      return 3;
+    // Error
+    case 50 /* FATAL */:
+      return 4;
+  }
+}
+var AppInsightsTransport = class extends BatchingTransport {
+  connectionString;
+  injectedClient;
+  client;
+  constructor(options = {}) {
+    super(options);
+    this.connectionString = options.connectionString;
+    this.injectedClient = options.client;
+  }
+  /** Synchronously available client, if one was injected or already imported — avoids an unnecessary microtask hop on the hot path. */
+  resolvedClient() {
+    return this.injectedClient ?? this.client;
+  }
+  async importClient() {
+    let TelemetryClientCtor;
+    try {
+      const moduleName = "applicationinsights";
+      const mod = await import(moduleName);
+      TelemetryClientCtor = mod.TelemetryClient;
+    } catch {
+      throw new Error(
+        "AppInsightsTransport: install `applicationinsights` to use this transport without providing a client \u2014 `npm install applicationinsights`"
+      );
+    }
+    const telemetryClient = new TelemetryClientCtor(this.connectionString);
+    this.client = {
+      trackTraceBatch: (traces) => {
+        for (const trace of traces) {
+          telemetryClient.trackTrace(trace);
+        }
+        telemetryClient.flush();
+        return Promise.resolve();
+      }
+    };
+    return this.client;
+  }
+  async sendBatch(batch) {
+    const client = this.resolvedClient() ?? await this.importClient();
+    const traces = batch.map((record) => ({
+      message: this.format(record),
+      severity: appInsightsSeverity(record.level)
+    }));
+    await client.trackTraceBatch(traces);
+  }
+};
+
+// src/transports/cloud/datadog-transport.ts
+async function fetchDatadogSender(url, apiKey, batch) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "DD-API-KEY": apiKey },
+    body: `[${batch.join(",")}]`
+  });
+  if (!response.ok) {
+    throw new Error(
+      `DatadogTransport: request to ${url} failed with status ${String(response.status)} \u2014 check the API key and site region`
+    );
+  }
+}
+var DatadogTransport = class extends BatchingTransport {
+  url;
+  apiKey;
+  site;
+  sender;
+  constructor(options) {
+    super(options);
+    this.apiKey = options.apiKey;
+    this.site = options.site ?? "datadoghq.com";
+    this.url = `https://http-intake.logs.${this.site}/api/v2/logs`;
+    this.sender = options.sender ?? fetchDatadogSender;
+  }
+  sendBatch(batch) {
+    const formatted = batch.map((record) => this.format(record));
+    return this.sender(this.url, this.apiKey, formatted);
+  }
+};
+
+// src/transports/cloud/elasticsearch-transport.ts
+async function fetchElasticsearchSender(url, headers, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/x-ndjson" },
+    body
+  });
+  if (!response.ok) {
+    throw new Error(`ElasticsearchTransport: request to ${url} failed with status ${String(response.status)}`);
+  }
+}
+var ElasticsearchTransport = class extends BatchingTransport {
+  url;
+  index;
+  apiKey;
+  sender;
+  constructor(options) {
+    super(options);
+    this.index = options.index ?? "logs";
+    this.url = `${options.node.replace(/\/+$/, "")}/_bulk`;
+    this.apiKey = options.apiKey;
+    this.sender = options.sender ?? fetchElasticsearchSender;
+  }
+  sendBatch(batch) {
+    const lines = [];
+    for (const record of batch) {
+      lines.push(JSON.stringify({ index: { _index: this.index } }));
+      lines.push(this.format(record));
+    }
+    const body = `${lines.join("\n")}
+`;
+    const headers = {};
+    if (this.apiKey !== void 0) {
+      headers.Authorization = `ApiKey ${this.apiKey}`;
+    }
+    return this.sender(this.url, headers, body);
+  }
+};
+async function fetchNewRelicSender(url, headers, body) {
+  const response = await fetch(url, { method: "POST", headers, body });
+  return {
+    ok: response.ok,
+    status: response.status,
+    retryAfter: response.headers.get("retry-after")
+  };
+}
+function withoutEventType(record) {
+  const meta = { ...record.meta };
+  delete meta.eventType;
+  return { ...record, meta };
+}
+function resumeTimestamp(retryAfter, now) {
+  if (retryAfter === null) {
+    return now + 6e4;
+  }
+  const seconds = Number(retryAfter);
+  if (Number.isFinite(seconds)) {
+    return now + seconds * 1e3;
+  }
+  const dateMs = Date.parse(retryAfter);
+  return Number.isNaN(dateMs) ? now + 6e4 : dateMs;
+}
+var NewRelicTransport = class extends BatchingTransport {
+  url;
+  region;
+  licenseKey;
+  sender;
+  clock;
+  pausedUntil = null;
+  constructor(options) {
+    super(options);
+    this.licenseKey = options.licenseKey;
+    this.region = options.region ?? "US";
+    this.url = this.region === "EU" ? "https://log-api.eu.newrelic.com/log/v1" : "https://log-api.newrelic.com/log/v1";
+    this.sender = options.sender ?? fetchNewRelicSender;
+    this.clock = options.clock ?? Date.now;
+  }
+  async sendBatch(batch) {
+    const now = this.clock();
+    if (this.pausedUntil !== null && now < this.pausedUntil) {
+      console.error(
+        `NewRelicTransport: sends paused until ${new Date(this.pausedUntil).toISOString()} after a 429 rate-limit response \u2014 skipping this batch rather than making a doomed request`
+      );
+      return;
+    }
+    this.pausedUntil = null;
+    const records = batch.map((record) => withoutEventType(record));
+    const body = zlib.gzipSync(Buffer.from(JSON.stringify(records)));
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Encoding": "gzip",
+      "Api-Key": this.licenseKey
+    };
+    const result = await this.sender(this.url, headers, body);
+    if (result.status === 429) {
+      this.pausedUntil = resumeTimestamp(result.retryAfter, now);
+      console.error(
+        `NewRelicTransport: received 429 from New Relic \u2014 pausing sends until ${new Date(this.pausedUntil).toISOString()}. Reduce log volume or increase batching to stay under the rate limit.`
+      );
+      return;
+    }
+    if (!result.ok) {
+      throw new Error(
+        `NewRelicTransport: request to ${this.url} failed with status ${String(result.status)} \u2014 check the license key and region`
+      );
+    }
+  }
+};
+
+// src/transports/console-transport.ts
 var COLORS = {
   [5 /* TRACE */]: "\x1B[90m",
   // gray
@@ -218,7 +1664,7 @@ var FileTransport = class extends Transport {
   }
 };
 
-// src/http-transport.ts
+// src/transports/http-transport.ts
 async function fetchSender(url, batch) {
   const response = await fetch(url, {
     method: "POST",
@@ -265,7 +1711,7 @@ var HTTPTransport = class extends Transport {
   }
 };
 
-// src/logger.ts
+// src/core/logger.ts
 var Logger = class _Logger {
   name;
   transports;
@@ -276,7 +1722,10 @@ var Logger = class _Logger {
     this.name = name;
     this.currentLevel = parseLevel(options.level ?? 20 /* INFO */);
     this.transports = options.transports ? [...options.transports] : [];
-    this.plugins = options.plugins ? [...options.plugins] : [];
+    this.plugins = [];
+    for (const plugin of options.plugins ?? []) {
+      this.use(plugin);
+    }
     this.baseMeta = options.meta ? { ...options.meta } : {};
   }
   get level() {
@@ -285,9 +1734,14 @@ var Logger = class _Logger {
   setLevel(level) {
     this.currentLevel = parseLevel(level);
   }
-  /** Register a plugin. Returns `this` so calls can be chained. */
+  /**
+   * Register a plugin, or a plain `beforeLog`-style function. A function is
+   * wrapped internally as an anonymous `Plugin` (`FunctionPlugin`) — the
+   * same middleware ergonomics as Express/Koa, without needing to read the
+   * `Plugin` interface first. Returns `this` so calls can be chained.
+   */
   use(plugin) {
-    this.plugins.push(plugin);
+    this.plugins.push(typeof plugin === "function" ? new FunctionPlugin(plugin) : plugin);
     return this;
   }
   /** Close every attached transport. Call on shutdown to flush buffered writes. */
@@ -367,19 +1821,47 @@ var Logger = class _Logger {
 };
 
 // src/index.ts
-var VERSION = "0.1.2";
+var VERSION = "0.3.0";
 
+exports.AlertingPlugin = AlertingPlugin;
+exports.AppInsightsTransport = AppInsightsTransport;
+exports.BaseQueueTransport = BaseQueueTransport;
+exports.BaseSQLTransport = BaseSQLTransport;
+exports.BatchingTransport = BatchingTransport;
+exports.CloudLoggingTransport = CloudLoggingTransport;
+exports.CloudWatchTransport = CloudWatchTransport;
 exports.CollectingTransport = CollectingTransport;
 exports.ConsoleTransport = ConsoleTransport;
 exports.ContextPlugin = ContextPlugin;
+exports.DEFAULT_PII_PATTERNS = DEFAULT_PII_PATTERNS;
 exports.DEFAULT_REDACTED_KEYS = DEFAULT_REDACTED_KEYS;
+exports.DatadogTransport = DatadogTransport;
+exports.DynamoDBTransport = DynamoDBTransport;
+exports.ElasticsearchTransport = ElasticsearchTransport;
+exports.EmailAlertPlugin = EmailAlertPlugin;
 exports.FileTransport = FileTransport;
+exports.FunctionPlugin = FunctionPlugin;
+exports.GENESIS_HASH = GENESIS_HASH;
 exports.HTTPTransport = HTTPTransport;
 exports.JSONFormatter = JSONFormatter;
+exports.KafkaTransport = KafkaTransport;
 exports.Level = Level;
 exports.Logger = Logger;
+exports.MongoDBTransport = MongoDBTransport;
+exports.MySQLTransport = MySQLTransport;
+exports.NewRelicTransport = NewRelicTransport;
+exports.PIIRedactPlugin = PIIRedactPlugin;
+exports.PagerDutyAlertPlugin = PagerDutyAlertPlugin;
+exports.PostgresTransport = PostgresTransport;
+exports.PubSubTransport = PubSubTransport;
+exports.RabbitMQTransport = RabbitMQTransport;
 exports.RedactPlugin = RedactPlugin;
+exports.RedisTransport = RedisTransport;
+exports.SQLiteTransport = SQLiteTransport;
+exports.SQSTransport = SQSTransport;
 exports.SamplingPlugin = SamplingPlugin;
+exports.SlackAlertPlugin = SlackAlertPlugin;
+exports.TamperEvidentPlugin = TamperEvidentPlugin;
 exports.Transport = Transport;
 exports.VERSION = VERSION;
 exports.createRecord = createRecord;