logquill 0.1.2 → 0.2.0

package/dist/index.cjs

@@ -1,9 +1,10 @@
 'use strict';
 
+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 +39,7 @@ function parseLevel(level) {
   return level;
 }
 
-// src/records.ts
+// src/core/records.ts
 function utcTimestamp() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -52,14 +53,14 @@ function createRecord(params) {
   };
 }
 
-// src/formatter.ts
+// src/core/formatter.ts
 var JSONFormatter = class {
   format(record) {
     return JSON.stringify(record);
   }
 };
 
-// src/context-plugin.ts
+// src/plugins/context-plugin.ts
 var ContextPlugin = class {
   context;
   constructor(context) {
@@ -70,7 +71,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,7 +89,7 @@ var RedactPlugin = class {
   }
 };
 
-// src/sampling-plugin.ts
+// src/plugins/sampling-plugin.ts
 var SamplingPlugin = class {
   rate;
   rng;
@@ -104,7 +105,7 @@ var SamplingPlugin = class {
   }
 };
 
-// src/transport.ts
+// src/transports/transport.ts
 var Transport = class {
   formatter;
   constructor(formatter = new JSONFormatter()) {
@@ -130,7 +131,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 +1262,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 +1309,7 @@ var HTTPTransport = class extends Transport {
   }
 };
 
-// src/logger.ts
+// src/core/logger.ts
 var Logger = class _Logger {
   name;
   transports;
@@ -367,18 +1411,37 @@ var Logger = class _Logger {
 };
 
 // src/index.ts
-var VERSION = "0.1.2";
+var VERSION = "0.2.0";
 
+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_REDACTED_KEYS = DEFAULT_REDACTED_KEYS;
+exports.DatadogTransport = DatadogTransport;
+exports.DynamoDBTransport = DynamoDBTransport;
+exports.ElasticsearchTransport = ElasticsearchTransport;
 exports.FileTransport = FileTransport;
 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.PostgresTransport = PostgresTransport;
+exports.PubSubTransport = PubSubTransport;
+exports.RabbitMQTransport = RabbitMQTransport;
 exports.RedactPlugin = RedactPlugin;
+exports.RedisTransport = RedisTransport;
+exports.SQLiteTransport = SQLiteTransport;
+exports.SQSTransport = SQSTransport;
 exports.SamplingPlugin = SamplingPlugin;
 exports.Transport = Transport;
 exports.VERSION = VERSION;