logquill 0.1.1 → 0.2.0

package/dist/index.mjs

@@ -1,6 +1,1416 @@
+import { gzipSync } from 'zlib';
+import { mkdirSync, openSync, writeSync, fstatSync, closeSync, existsSync, unlinkSync, renameSync } from 'fs';
+import { dirname } from 'path';
+
+// src/core/levels.ts
+var Level = /* @__PURE__ */ ((Level2) => {
+  Level2[Level2["TRACE"] = 5] = "TRACE";
+  Level2[Level2["DEBUG"] = 10] = "DEBUG";
+  Level2[Level2["INFO"] = 20] = "INFO";
+  Level2[Level2["WARN"] = 30] = "WARN";
+  Level2[Level2["ERROR"] = 40] = "ERROR";
+  Level2[Level2["FATAL"] = 50] = "FATAL";
+  return Level2;
+})(Level || {});
+var NAME_TO_LEVEL = {
+  TRACE: 5 /* TRACE */,
+  DEBUG: 10 /* DEBUG */,
+  INFO: 20 /* INFO */,
+  WARN: 30 /* WARN */,
+  ERROR: 40 /* ERROR */,
+  FATAL: 50 /* FATAL */
+};
+function levelName(level) {
+  return Level[level];
+}
+function parseLevel(level) {
+  if (typeof level === "string") {
+    const parsed = NAME_TO_LEVEL[level.toUpperCase()];
+    if (parsed === void 0) {
+      throw new Error(`Unknown log level: ${level}`);
+    }
+    return parsed;
+  }
+  if (Level[level] === void 0) {
+    throw new Error(`Unknown log level: ${String(level)}`);
+  }
+  return level;
+}
+
+// src/core/records.ts
+function utcTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createRecord(params) {
+  return {
+    timestamp: utcTimestamp(),
+    level: levelName(params.level),
+    logger: params.logger,
+    message: params.message,
+    meta: params.meta
+  };
+}
+
+// src/core/formatter.ts
+var JSONFormatter = class {
+  format(record) {
+    return JSON.stringify(record);
+  }
+};
+
+// src/plugins/context-plugin.ts
+var ContextPlugin = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  beforeLog(record) {
+    return { ...record, meta: { ...this.context, ...record.meta } };
+  }
+};
+
+// src/plugins/redact-plugin.ts
+var DEFAULT_REDACTED_KEYS = ["password", "token", "secret", "api_key", "authorization"];
+var RedactPlugin = class {
+  keys;
+  replacement;
+  constructor(options = {}) {
+    this.keys = new Set((options.keys ?? DEFAULT_REDACTED_KEYS).map((key) => key.toLowerCase()));
+    this.replacement = options.replacement ?? "***";
+  }
+  beforeLog(record) {
+    const meta = {};
+    for (const [key, value] of Object.entries(record.meta)) {
+      meta[key] = this.keys.has(key.toLowerCase()) ? this.replacement : value;
+    }
+    return { ...record, meta };
+  }
+};
+
+// src/plugins/sampling-plugin.ts
+var SamplingPlugin = class {
+  rate;
+  rng;
+  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;
+  }
+  beforeLog(record) {
+    return this.rng() < this.rate ? record : null;
+  }
+};
+
+// src/transports/transport.ts
+var Transport = class {
+  formatter;
+  constructor(formatter = new JSONFormatter()) {
+    this.formatter = formatter;
+  }
+  format(record) {
+    return this.formatter.format(record);
+  }
+  /** Flush/release resources on shutdown. No-op unless a transport overrides it. */
+  close() {
+  }
+};
+var CollectingTransport = class extends Transport {
+  formatted = [];
+  records = [];
+  closed = false;
+  write(formatted, record) {
+    this.formatted.push(formatted);
+    this.records.push(record);
+  }
+  close() {
+    this.closed = true;
+  }
+};
+
+// 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 = 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
+  [10 /* DEBUG */]: "\x1B[36m",
+  // cyan
+  [20 /* INFO */]: "\x1B[32m",
+  // green
+  [30 /* WARN */]: "\x1B[33m",
+  // yellow
+  [40 /* ERROR */]: "\x1B[31m",
+  // red
+  [50 /* FATAL */]: "\x1B[35m"
+  // magenta
+};
+var RESET = "\x1B[0m";
+function defaultColorize() {
+  const env = typeof process === "undefined" ? void 0 : process.env;
+  return env?.NO_COLOR === void 0;
+}
+var ConsoleTransport = class extends Transport {
+  colorize;
+  out;
+  constructor(options = {}) {
+    super(options.formatter);
+    this.colorize = options.colorize ?? defaultColorize();
+    this.out = options.console ?? console;
+  }
+  write(formatted, record) {
+    const level = parseLevel(record.level);
+    const line = this.colorize ? this.applyColor(formatted, level) : formatted;
+    if (level >= 40 /* ERROR */) {
+      this.out.error(line);
+    } else {
+      this.out.log(line);
+    }
+  }
+  applyColor(formatted, level) {
+    return `${COLORS[level]}${formatted}${RESET}`;
+  }
+};
+var FileTransport = class extends Transport {
+  path;
+  maxBytes;
+  backupCount;
+  fd;
+  constructor(path, options = {}) {
+    super(options.formatter);
+    this.path = path;
+    this.maxBytes = options.maxBytes ?? 10 * 1024 * 1024;
+    this.backupCount = options.backupCount ?? 5;
+    mkdirSync(dirname(path), { recursive: true });
+    this.fd = openSync(this.path, "a");
+  }
+  write(formatted) {
+    writeSync(this.fd, formatted + "\n");
+    if (this.maxBytes > 0 && fstatSync(this.fd).size >= this.maxBytes) {
+      this.rotate();
+    }
+  }
+  rotate() {
+    closeSync(this.fd);
+    if (this.backupCount > 0) {
+      for (let index = this.backupCount - 1; index > 0; index--) {
+        const src = `${this.path}.${String(index)}`;
+        const dst = `${this.path}.${String(index + 1)}`;
+        if (existsSync(src)) {
+          if (existsSync(dst)) {
+            unlinkSync(dst);
+          }
+          renameSync(src, dst);
+        }
+      }
+      const backup = `${this.path}.1`;
+      if (existsSync(backup)) {
+        unlinkSync(backup);
+      }
+      renameSync(this.path, backup);
+    } else {
+      unlinkSync(this.path);
+    }
+    this.fd = openSync(this.path, "a");
+  }
+  close() {
+    closeSync(this.fd);
+  }
+};
+
+// src/transports/http-transport.ts
+async function fetchSender(url, batch) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-ndjson" },
+    body: batch.join("\n")
+  });
+  if (!response.ok) {
+    throw new Error(`HTTPTransport: request to ${url} failed with status ${String(response.status)}`);
+  }
+}
+var HTTPTransport = class extends Transport {
+  url;
+  batchSize;
+  sender;
+  batch = [];
+  constructor(url, options = {}) {
+    super(options.formatter);
+    this.url = url;
+    this.batchSize = options.batchSize ?? 50;
+    this.sender = options.sender ?? fetchSender;
+  }
+  write(formatted) {
+    this.batch.push(formatted);
+    if (this.batch.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+  /** Send the current batch now, even if it hasn't reached `batchSize`. */
+  flush() {
+    if (this.batch.length === 0) {
+      return;
+    }
+    const batch = this.batch;
+    this.batch = [];
+    const result = this.sender(this.url, batch);
+    if (result) {
+      result.catch((error) => {
+        console.error("HTTPTransport: failed to send log batch", error);
+      });
+    }
+  }
+  close() {
+    this.flush();
+  }
+};
+
+// src/core/logger.ts
+var Logger = class _Logger {
+  name;
+  transports;
+  plugins;
+  currentLevel;
+  baseMeta;
+  constructor(name, options = {}) {
+    this.name = name;
+    this.currentLevel = parseLevel(options.level ?? 20 /* INFO */);
+    this.transports = options.transports ? [...options.transports] : [];
+    this.plugins = options.plugins ? [...options.plugins] : [];
+    this.baseMeta = options.meta ? { ...options.meta } : {};
+  }
+  get level() {
+    return this.currentLevel;
+  }
+  setLevel(level) {
+    this.currentLevel = parseLevel(level);
+  }
+  /** Register a plugin. Returns `this` so calls can be chained. */
+  use(plugin) {
+    this.plugins.push(plugin);
+    return this;
+  }
+  /** Close every attached transport. Call on shutdown to flush buffered writes. */
+  close() {
+    for (const transport of this.transports) {
+      transport.close();
+    }
+  }
+  /** A logger scoped under this one, inheriting its level, transports, and plugins. */
+  child(name, meta = {}) {
+    return new _Logger(`${this.name}.${name}`, {
+      level: this.currentLevel,
+      transports: this.transports,
+      plugins: this.plugins,
+      meta: { ...this.baseMeta, ...meta }
+    });
+  }
+  notifyError(plugin, error, record) {
+    try {
+      plugin.onError?.(error, record);
+    } catch {
+    }
+  }
+  dispatch(level, message, meta) {
+    if (level < this.currentLevel) {
+      return null;
+    }
+    let record = createRecord({
+      level,
+      logger: this.name,
+      message,
+      meta: { ...this.baseMeta, ...meta }
+    });
+    for (const plugin of this.plugins) {
+      let result;
+      try {
+        result = plugin.beforeLog ? plugin.beforeLog(record) : record;
+      } catch (error) {
+        this.notifyError(plugin, error, record);
+        continue;
+      }
+      if (result === null) {
+        return null;
+      }
+      record = result;
+    }
+    for (const transport of this.transports) {
+      transport.write(transport.format(record), record);
+    }
+    for (const plugin of this.plugins) {
+      try {
+        plugin.afterLog?.(record);
+      } catch (error) {
+        this.notifyError(plugin, error, record);
+      }
+    }
+    return record;
+  }
+  trace(message, meta = {}) {
+    return this.dispatch(5 /* TRACE */, message, meta);
+  }
+  debug(message, meta = {}) {
+    return this.dispatch(10 /* DEBUG */, message, meta);
+  }
+  info(message, meta = {}) {
+    return this.dispatch(20 /* INFO */, message, meta);
+  }
+  warn(message, meta = {}) {
+    return this.dispatch(30 /* WARN */, message, meta);
+  }
+  error(message, meta = {}) {
+    return this.dispatch(40 /* ERROR */, message, meta);
+  }
+  fatal(message, meta = {}) {
+    return this.dispatch(50 /* FATAL */, message, meta);
+  }
+};
+
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 
-export { VERSION };
+export { AppInsightsTransport, BaseQueueTransport, BaseSQLTransport, BatchingTransport, CloudLoggingTransport, CloudWatchTransport, CollectingTransport, ConsoleTransport, ContextPlugin, DEFAULT_REDACTED_KEYS, DatadogTransport, DynamoDBTransport, ElasticsearchTransport, FileTransport, HTTPTransport, JSONFormatter, KafkaTransport, Level, Logger, MongoDBTransport, MySQLTransport, NewRelicTransport, PostgresTransport, PubSubTransport, RabbitMQTransport, RedactPlugin, RedisTransport, SQLiteTransport, SQSTransport, SamplingPlugin, Transport, VERSION, createRecord, levelName, parseLevel, utcTimestamp };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map