@richardmcquiston01/error-log-adapter 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -355,4 +355,208 @@ declare class JsonFileErrorAdapter<TCode extends string = string> implements Err
     private readRecords;
 }
 
-export { type CollectionLike, CompositeErrorAdapter, ConsoleErrorAdapter, type ConsoleErrorOptions, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, type FileSystemLike, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, MongoDbErrorAdapter, type MongoDbErrorOptions, type ReadWriteFileSystemLike, type SerializedErrorLogEntry, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };
+type SqlDialect = 'postgres' | 'mysql';
+/**
+ * The only thing these adapters need from a database driver: run one
+ * parameterized statement. `pg` (`Pool` / `Client`) and `mysql2/promise`
+ * (`Pool` / `Connection`) both fit as they are.
+ */
+interface SqlClientLike {
+    query(sql: string, params: unknown[]): Promise<unknown>;
+}
+interface SqlErrorOptions {
+    /** Table to write to. Defaults to `error_log`. Letters, digits and `_` only, up to 47 characters. */
+    tableName?: string;
+    /** Create the table (and index) on first use. Defaults to `true`. */
+    createTable?: boolean;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Returns the statements that create the error log table and its index for a
+ * dialect. Use this to run your own migration when `createTable` is disabled.
+ *
+ * Postgres gets a native `UUID` key, `JSONB` for the cause, and `TIMESTAMPTZ`
+ * columns. MySQL gets a `CHAR(36)` UUID key (it has no UUID type), a `JSON`
+ * cause, and `DATETIME(3)` columns holding UTC times.
+ */
+declare function buildErrorLogTableDdl(dialect: SqlDialect, tableName?: string): string[];
+/** Shared by the Postgres and MySQL adapters: only the SQL text and time format differ. */
+declare abstract class SqlErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly client;
+    private readonly dialect;
+    private readonly adapterName;
+    private readonly tableName;
+    private readonly createTable;
+    private readonly prefix;
+    private tableReady;
+    protected constructor(client: SqlClientLike, dialect: SqlDialect, adapterName: string, options: SqlErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+    private insertSql;
+    /** Creates the table once. A failed attempt is retried on the next log call. */
+    private ensureTable;
+    private runCreateStatements;
+}
+/**
+ * Writes entries to Postgres. Pass a `pg` `Pool` or `Client`.
+ *
+ * ```ts
+ * const adapter = new PostgresErrorAdapter(new Pool({ connectionString }));
+ * ```
+ */
+declare class PostgresErrorAdapter<TCode extends string = string> extends SqlErrorAdapter<TCode> {
+    /** @throws {RangeError} if `options.tableName` is not a plain identifier of 47 characters or fewer. */
+    constructor(client: SqlClientLike, options?: SqlErrorOptions);
+}
+/**
+ * Writes entries to MySQL or MariaDB. Pass a `mysql2/promise` `Pool` or `Connection`.
+ *
+ * ```ts
+ * const adapter = new MySqlErrorAdapter(mysql.createPool(connectionUri));
+ * ```
+ */
+declare class MySqlErrorAdapter<TCode extends string = string> extends SqlErrorAdapter<TCode> {
+    /** @throws {RangeError} if `options.tableName` is not a plain identifier of 47 characters or fewer. */
+    constructor(client: SqlClientLike, options?: SqlErrorOptions);
+}
+
+/**
+ * The only thing this adapter needs from a Redis client: send one raw command
+ * as an array of strings. node-redis (`client.sendCommand`) already matches.
+ * ioredis needs a one-line wrapper:
+ *
+ * ```ts
+ * const client: RedisClientLike = {
+ *   sendCommand: (args) => redis.call(args[0] as string, ...args.slice(1)),
+ * };
+ * ```
+ */
+interface RedisClientLike {
+    sendCommand(args: string[]): Promise<unknown>;
+}
+interface RedisErrorOptions {
+    /**
+     * `list` (default) pushes each entry onto a Redis list as one JSON string.
+     * `stream` appends each entry to a Redis stream (`XADD`) as separate fields.
+     */
+    mode?: 'list' | 'stream';
+    /** Key to write to. Defaults to `error_log`. */
+    key?: string;
+    /**
+     * Most entries to keep. The oldest are dropped first. Unlimited by default.
+     * Lists are trimmed with `LTRIM` after the push; streams use an exact `MAXLEN`.
+     */
+    maxEntries?: number;
+    /**
+     * List mode only: which end to push onto. `right` (default, `RPUSH`) keeps
+     * the newest entry last; `left` (`LPUSH`) keeps the newest entry first.
+     */
+    side?: 'left' | 'right';
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Writes entries to Redis, either as a capped list of JSON strings or as a
+ * stream. Each record holds a UUID `id` plus the serialized entry. In stream
+ * mode `cause` and `source` fields are left out when the entry has none.
+ */
+declare class RedisErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly client;
+    private readonly mode;
+    private readonly key;
+    private readonly maxEntries;
+    private readonly side;
+    private readonly prefix;
+    /** @throws {RangeError} if `key` is empty, `maxEntries` is not a positive integer, or `mode` / `side` is unknown. */
+    constructor(client: RedisClientLike, options?: RedisErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+    private buildStreamCommand;
+    /**
+     * Drops the oldest list entries beyond `maxEntries`. The entry is already
+     * stored by now, so a trim failure is reported but does not fail the call;
+     * the next successful write trims the list again.
+     */
+    private trimList;
+}
+
+/** The parameters this adapter passes to `putObject`. */
+interface S3PutObjectInput {
+    Bucket: string;
+    Key: string;
+    Body: string;
+    ContentType: string;
+}
+/**
+ * The only thing this adapter needs from an S3 client: `putObject`. The AWS
+ * SDK v3 aggregated client (`new S3({ ... })` from `@aws-sdk/client-s3`) fits as
+ * it is, and so does anything else that follows the S3 API, including
+ * DigitalOcean Spaces, Cloudflare R2 and MinIO when you point the client at
+ * their endpoint.
+ */
+interface S3ClientLike {
+    putObject(input: S3PutObjectInput): Promise<unknown>;
+}
+interface S3BatchOptions {
+    /** Upload once this many entries are buffered. */
+    batchSize: number;
+    /**
+     * Also upload when the oldest buffered entry has waited this long (ms). The
+     * timer does not keep the process alive, so call `flush()` before exiting.
+     */
+    maxWaitMs?: number;
+}
+interface S3ErrorOptions {
+    /**
+     * Key prefix, for example `logs/app/`. A trailing slash is added if missing.
+     * Defaults to `error_log/`. Use `''` for no prefix.
+     */
+    keyPrefix?: string;
+    /**
+     * Content type of the uploaded objects. Defaults to `application/json`, or
+     * `application/x-ndjson` when batching.
+     */
+    contentType?: string;
+    /**
+     * Buffer entries and upload them together as one newline-delimited JSON
+     * object. Off by default: one object per entry.
+     */
+    batch?: S3BatchOptions;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Stores entries as objects in an S3-compatible bucket, keyed by date and UUID:
+ * `error_log/2026/01/02/20260102T030405678Z-<uuid>.json`.
+ *
+ * By default each entry becomes its own JSON object and `log` resolves once the
+ * upload succeeds. With `batch`, entries are buffered and uploaded together as
+ * one `.ndjson` object; `log` then resolves ok as soon as the entry is
+ * buffered (it is not stored yet), except for the call that fills the batch,
+ * which resolves with the upload result. Call `flush()` before shutting down.
+ */
+declare class S3ErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly client;
+    private readonly bucket;
+    private readonly keyPrefix;
+    private readonly contentType;
+    private readonly batch;
+    private readonly logPrefix;
+    private buffer;
+    private timer;
+    private flushQueue;
+    /** @throws {RangeError} if `bucket` is empty or the batch options are invalid. */
+    constructor(client: S3ClientLike, bucket: string, options?: S3ErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+    /**
+     * Uploads any buffered entries now. Resolves ok when nothing is buffered.
+     * Entries from a failed upload stay buffered and are retried by the next flush.
+     */
+    flush(): Promise<ErrorLogResult>;
+    private addToBatch;
+    private scheduleFlush;
+    private uploadBuffered;
+    private upload;
+    private fail;
+}
+
+export { type CollectionLike, CompositeErrorAdapter, ConsoleErrorAdapter, type ConsoleErrorOptions, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, type FileSystemLike, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, type RedisClientLike, RedisErrorAdapter, type RedisErrorOptions, type S3BatchOptions, type S3ClientLike, S3ErrorAdapter, type S3ErrorOptions, type S3PutObjectInput, type SerializedErrorLogEntry, type SqlClientLike, type SqlDialect, type SqlErrorOptions, type SqliteClientLike, SqliteErrorAdapter, type SqliteErrorOptions, type StorageLike, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };

package/dist/index.mjs

@@ -628,6 +628,363 @@ var JsonFileErrorAdapter = class {
     return [];
   }
 };
+
+// src/adapters/sql-error-adapter.ts
+var DEFAULT_TABLE_NAME2 = "error_log";
+var MAX_TABLE_NAME_LENGTH = 47;
+var IDENTIFIER_PATTERN2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertValidTableName2(tableName, adapterName) {
+  if (!IDENTIFIER_PATTERN2.test(tableName)) {
+    throw new RangeError(
+      `${adapterName}: invalid table name "${tableName}". Use only letters, digits and underscores, and do not start with a digit.`
+    );
+  }
+  if (tableName.length > MAX_TABLE_NAME_LENGTH) {
+    throw new RangeError(
+      `${adapterName}: table name "${tableName}" is ${tableName.length} characters long, but the limit is ${MAX_TABLE_NAME_LENGTH}.`
+    );
+  }
+}
+function quoteIdentifier(dialect, identifier) {
+  return dialect === "postgres" ? `"${identifier}"` : `\`${identifier}\``;
+}
+function buildErrorLogTableDdl(dialect, tableName = DEFAULT_TABLE_NAME2) {
+  assertValidTableName2(tableName, "buildErrorLogTableDdl");
+  const table = quoteIdentifier(dialect, tableName);
+  const index = quoteIdentifier(
+    dialect,
+    `${tableName}_occurred_at_idx`
+  );
+  if (dialect === "postgres") {
+    return [
+      `CREATE TABLE IF NOT EXISTS ${table} (id UUID PRIMARY KEY, code TEXT NOT NULL, message TEXT NOT NULL, cause JSONB, source TEXT, occurred_at TIMESTAMPTZ NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now())`,
+      `CREATE INDEX IF NOT EXISTS ${index} ON ${table} (occurred_at)`
+    ];
+  }
+  return [
+    `CREATE TABLE IF NOT EXISTS ${table} (id CHAR(36) NOT NULL PRIMARY KEY, code VARCHAR(255) NOT NULL, message TEXT NOT NULL, cause JSON NULL, source VARCHAR(255) NULL, occurred_at DATETIME(3) NOT NULL, created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3), INDEX ${index} (occurred_at))`
+  ];
+}
+function toMysqlDateTime(date) {
+  return date.toISOString().replace("T", " ").replace("Z", "");
+}
+var SqlErrorAdapter = class {
+  constructor(client, dialect, adapterName, options) {
+    this.client = client;
+    this.dialect = dialect;
+    this.adapterName = adapterName;
+    this.tableReady = null;
+    this.tableName = options.tableName ?? DEFAULT_TABLE_NAME2;
+    assertValidTableName2(this.tableName, adapterName);
+    this.createTable = options.createTable ?? true;
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+  }
+  async log(entry) {
+    try {
+      const serialized = serializeEntry(entry);
+      const occurredAt = new Date(serialized.timestamp);
+      if (Number.isNaN(occurredAt.getTime())) {
+        throw new RangeError(
+          `timestamp "${serialized.timestamp}" is not a valid ISO 8601 date`
+        );
+      }
+      const params = [
+        crypto.randomUUID(),
+        serialized.code,
+        serialized.message,
+        serialized.cause === void 0 ? null : JSON.stringify(serialized.cause),
+        serialized.source ?? null,
+        this.dialect === "postgres" ? occurredAt.toISOString() : toMysqlDateTime(occurredAt)
+      ];
+      await this.ensureTable();
+      await this.client.query(this.insertSql(), params);
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} ${this.adapterName}:`, error);
+      return {
+        ok: false,
+        error: `${this.adapterName} failed to write to table "${this.tableName}": ${describeError(error)}`
+      };
+    }
+  }
+  insertSql() {
+    const placeholders = this.dialect === "postgres" ? "$1, $2, $3, $4, $5, $6" : "?, ?, ?, ?, ?, ?";
+    return `INSERT INTO ${quoteIdentifier(this.dialect, this.tableName)} (id, code, message, cause, source, occurred_at) VALUES (${placeholders})`;
+  }
+  /** Creates the table once. A failed attempt is retried on the next log call. */
+  ensureTable() {
+    if (!this.createTable) {
+      return Promise.resolve();
+    }
+    if (this.tableReady === null) {
+      this.tableReady = this.runCreateStatements().catch(
+        (error) => {
+          this.tableReady = null;
+          throw error;
+        }
+      );
+    }
+    return this.tableReady;
+  }
+  async runCreateStatements() {
+    for (const sql of buildErrorLogTableDdl(this.dialect, this.tableName)) {
+      await this.client.query(sql, []);
+    }
+  }
+};
+var PostgresErrorAdapter = class extends SqlErrorAdapter {
+  /** @throws {RangeError} if `options.tableName` is not a plain identifier of 47 characters or fewer. */
+  constructor(client, options = {}) {
+    super(client, "postgres", "PostgresErrorAdapter", options);
+  }
+};
+var MySqlErrorAdapter = class extends SqlErrorAdapter {
+  /** @throws {RangeError} if `options.tableName` is not a plain identifier of 47 characters or fewer. */
+  constructor(client, options = {}) {
+    super(client, "mysql", "MySqlErrorAdapter", options);
+  }
+};
+
+// src/adapters/redis-error-adapter.ts
+var DEFAULT_REDIS_KEY = "error_log";
+var RedisErrorAdapter = class {
+  /** @throws {RangeError} if `key` is empty, `maxEntries` is not a positive integer, or `mode` / `side` is unknown. */
+  constructor(client, options = {}) {
+    this.client = client;
+    this.mode = options.mode ?? "list";
+    this.key = options.key ?? DEFAULT_REDIS_KEY;
+    this.maxEntries = options.maxEntries;
+    this.side = options.side ?? "right";
+    this.prefix = options.prefix ?? "[error-log-adapter]";
+    if (this.mode !== "list" && this.mode !== "stream") {
+      throw new RangeError(
+        `RedisErrorAdapter: mode must be "list" or "stream", received "${String(options.mode)}".`
+      );
+    }
+    if (this.side !== "left" && this.side !== "right") {
+      throw new RangeError(
+        `RedisErrorAdapter: side must be "left" or "right", received "${String(options.side)}".`
+      );
+    }
+    if (this.key === "") {
+      throw new RangeError("RedisErrorAdapter: key must not be empty.");
+    }
+    if (this.maxEntries !== void 0 && (!Number.isInteger(this.maxEntries) || this.maxEntries < 1)) {
+      throw new RangeError(
+        `RedisErrorAdapter: maxEntries must be a positive integer, received ${String(this.maxEntries)}.`
+      );
+    }
+  }
+  async log(entry) {
+    try {
+      const record = { id: crypto.randomUUID(), ...serializeEntry(entry) };
+      if (this.mode === "stream") {
+        await this.client.sendCommand(this.buildStreamCommand(record));
+      } else {
+        await this.client.sendCommand([
+          this.side === "left" ? "LPUSH" : "RPUSH",
+          this.key,
+          JSON.stringify(record)
+        ]);
+        await this.trimList();
+      }
+      return { ok: true };
+    } catch (error) {
+      console.error(`${this.prefix} RedisErrorAdapter:`, error);
+      return {
+        ok: false,
+        error: `RedisErrorAdapter failed to write to ${this.mode} "${this.key}": ${describeError(error)}`
+      };
+    }
+  }
+  buildStreamCommand(record) {
+    const command = ["XADD", this.key];
+    if (this.maxEntries !== void 0) {
+      command.push("MAXLEN", "=", String(this.maxEntries));
+    }
+    command.push(
+      "*",
+      "id",
+      record.id,
+      "code",
+      record.code,
+      "message",
+      record.message,
+      "timestamp",
+      record.timestamp
+    );
+    if (record.cause !== void 0) {
+      command.push("cause", JSON.stringify(record.cause));
+    }
+    if (record.source !== void 0) {
+      command.push("source", record.source);
+    }
+    return command;
+  }
+  /**
+   * Drops the oldest list entries beyond `maxEntries`. The entry is already
+   * stored by now, so a trim failure is reported but does not fail the call;
+   * the next successful write trims the list again.
+   */
+  async trimList() {
+    if (this.maxEntries === void 0) {
+      return;
+    }
+    const keep = this.maxEntries;
+    const [start, stop] = this.side === "right" ? [String(-keep), "-1"] : ["0", String(keep - 1)];
+    try {
+      await this.client.sendCommand(["LTRIM", this.key, start, stop]);
+    } catch (error) {
+      console.error(
+        `${this.prefix} RedisErrorAdapter: stored the entry but could not trim list "${this.key}" to ${keep} entries: ${describeError(error)}`
+      );
+    }
+  }
+};
+
+// src/adapters/s3-error-adapter.ts
+var DEFAULT_S3_PREFIX = "error_log/";
+var BUFFER_LIMIT_MULTIPLIER = 10;
+function datePath(date) {
+  const compact = date.toISOString().replace(/[-:.]/g, "");
+  return `${compact.slice(0, 4)}/${compact.slice(4, 6)}/${compact.slice(6, 8)}/${compact}`;
+}
+function normalizePrefix(prefix) {
+  const trimmed = prefix.replace(/^\/+/, "");
+  return trimmed === "" || trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+}
+var S3ErrorAdapter = class {
+  /** @throws {RangeError} if `bucket` is empty or the batch options are invalid. */
+  constructor(client, bucket, options = {}) {
+    this.client = client;
+    this.bucket = bucket;
+    this.buffer = [];
+    this.timer = null;
+    this.flushQueue = Promise.resolve();
+    this.keyPrefix = normalizePrefix(options.keyPrefix ?? DEFAULT_S3_PREFIX);
+    this.batch = options.batch;
+    this.contentType = options.contentType ?? (this.batch === void 0 ? "application/json" : "application/x-ndjson");
+    this.logPrefix = options.prefix ?? "[error-log-adapter]";
+    if (bucket === "") {
+      throw new RangeError("S3ErrorAdapter: bucket must not be empty.");
+    }
+    if (this.batch !== void 0) {
+      if (!Number.isInteger(this.batch.batchSize) || this.batch.batchSize < 1) {
+        throw new RangeError(
+          `S3ErrorAdapter: batch.batchSize must be a positive integer, received ${String(this.batch.batchSize)}.`
+        );
+      }
+      if (this.batch.maxWaitMs !== void 0 && (!Number.isFinite(this.batch.maxWaitMs) || this.batch.maxWaitMs <= 0)) {
+        throw new RangeError(
+          `S3ErrorAdapter: batch.maxWaitMs must be a positive number, received ${String(this.batch.maxWaitMs)}.`
+        );
+      }
+    }
+  }
+  async log(entry) {
+    try {
+      const record = {
+        id: crypto.randomUUID(),
+        ...serializeEntry(entry)
+      };
+      const occurredAt = new Date(record.timestamp);
+      if (Number.isNaN(occurredAt.getTime())) {
+        throw new RangeError(
+          `timestamp "${record.timestamp}" is not a valid ISO 8601 date`
+        );
+      }
+      if (this.batch === void 0) {
+        const key = `${this.keyPrefix}${datePath(occurredAt)}-${record.id}.json`;
+        await this.upload(key, `${JSON.stringify(record)}
+`);
+        return { ok: true };
+      }
+      return await this.addToBatch(record, this.batch);
+    } catch (error) {
+      return this.fail(error);
+    }
+  }
+  /**
+   * Uploads any buffered entries now. Resolves ok when nothing is buffered.
+   * Entries from a failed upload stay buffered and are retried by the next flush.
+   */
+  flush() {
+    const result = this.flushQueue.then(
+      () => this.uploadBuffered()
+    );
+    this.flushQueue = result.catch(() => void 0);
+    return result;
+  }
+  async addToBatch(record, batch) {
+    this.buffer.push(record);
+    const limit = batch.batchSize * BUFFER_LIMIT_MULTIPLIER;
+    if (this.buffer.length > limit) {
+      const dropped = this.buffer.length - limit;
+      this.buffer = this.buffer.slice(dropped);
+      console.error(
+        `${this.logPrefix} S3ErrorAdapter: dropped the ${dropped} oldest buffered entries because uploads to bucket "${this.bucket}" keep failing and the buffer is full (${limit} entries).`
+      );
+    }
+    if (this.buffer.length >= batch.batchSize) {
+      return this.flush();
+    }
+    this.scheduleFlush(batch);
+    return { ok: true };
+  }
+  scheduleFlush(batch) {
+    if (batch.maxWaitMs === void 0 || this.timer !== null) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, batch.maxWaitMs);
+    timer.unref?.();
+    this.timer = timer;
+  }
+  async uploadBuffered() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const pending = this.buffer.slice();
+    if (pending.length === 0) {
+      return { ok: true };
+    }
+    try {
+      const key = `${this.keyPrefix}${datePath(/* @__PURE__ */ new Date())}-${crypto.randomUUID()}.ndjson`;
+      const body = pending.map((record) => JSON.stringify(record)).join("\n");
+      await this.upload(key, `${body}
+`);
+      const uploaded = new Set(pending);
+      this.buffer = this.buffer.filter(
+        (record) => !uploaded.has(record)
+      );
+      return { ok: true };
+    } catch (error) {
+      if (this.batch !== void 0) {
+        this.scheduleFlush(this.batch);
+      }
+      return this.fail(error, pending.length);
+    }
+  }
+  upload(key, body) {
+    return this.client.putObject({
+      Bucket: this.bucket,
+      Key: key,
+      Body: body,
+      ContentType: this.contentType
+    });
+  }
+  fail(error, bufferedCount) {
+    console.error(`${this.logPrefix} S3ErrorAdapter:`, error);
+    const retry = bufferedCount === void 0 ? "" : ` (${bufferedCount} buffered ${bufferedCount === 1 ? "entry was" : "entries were"} kept for the next flush)`;
+    return {
+      ok: false,
+      error: `S3ErrorAdapter failed to upload to bucket "${this.bucket}": ${describeError(error)}${retry}`
+    };
+  }
+};
 export {
   CompositeErrorAdapter,
   ConsoleErrorAdapter,
@@ -635,10 +992,15 @@ export {
   IndexedDbErrorAdapter,
   JsonFileErrorAdapter,
   MongoDbErrorAdapter,
+  MySqlErrorAdapter,
+  PostgresErrorAdapter,
+  RedisErrorAdapter,
+  S3ErrorAdapter,
   SqliteErrorAdapter,
   WebStorageErrorAdapter,
   WebhookErrorAdapter,
   buildCreateErrorLogTableSql,
+  buildErrorLogTableDdl,
   createErrorLogStore,
   formatErrorLogLine,
   serializeCause,