@richardmcquiston01/error-log-adapter 0.6.0 → 0.8.0

package/dist/index.d.cts

@@ -1022,4 +1022,157 @@ declare class EventEmitterErrorAdapter<TCode extends string = string> implements
     log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
 }
 
-export { type CollectionLike, CompositeErrorAdapter, type CompositeErrorOptions, ConsoleErrorAdapter, type ConsoleErrorOptions, type EmitterLike, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, EventEmitterErrorAdapter, type EventEmitterErrorOptions, type EventEmitterErrorRecord, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbRequestLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, type LockManagerLike, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, 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, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildMySqlWidenColumnsSql, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };
+/**
+ * The only things this adapter needs from a socket: `send` and `readyState`. The
+ * browser `WebSocket`, Node's global `WebSocket`, Deno, Bun, and the `ws` package
+ * all fit as they are.
+ */
+interface WebSocketLike {
+    send(data: string): unknown;
+    readonly readyState: number;
+}
+interface WebSocketErrorOptions {
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Sends each entry as one JSON text message (the serialized entry plus its UUID
+ * `id`) over a socket you own. You connect, and reconnect, the socket; this
+ * adapter never opens one and keeps no buffer. If the socket is not open when
+ * `log` is called, the entry is not sent and `log` returns `ok: false`, so
+ * combine it with a durable adapter in a `CompositeErrorAdapter` when entries
+ * must not be lost while the socket is down.
+ *
+ * `ok: true` means the socket accepted the message, not that the server
+ * received it: a WebSocket gives no acknowledgement, and a connection that
+ * drops after `send` loses the message.
+ *
+ * ```ts
+ * const socket = new WebSocket('wss://logs.example.com/errors');
+ * const adapter = new WebSocketErrorAdapter(socket);
+ * ```
+ */
+declare class WebSocketErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly socket;
+    private readonly prefix;
+    constructor(socket: WebSocketLike, options?: WebSocketErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+
+/** One event as `PutLogEvents` takes it. */
+interface CloudWatchLogEvent {
+    /** Milliseconds since the epoch. */
+    timestamp: number;
+    message: string;
+}
+/** The parameters this adapter passes to `putLogEvents`. */
+interface CloudWatchPutLogEventsInput {
+    logGroupName: string;
+    logStreamName: string;
+    logEvents: CloudWatchLogEvent[];
+}
+/**
+ * What an AWS SDK client needs to offer. The AWS SDK v3 aggregated client
+ * (`new CloudWatchLogs({ ... })` from `@aws-sdk/client-cloudwatch-logs`) fits as
+ * it is. `createLogGroup` and `createLogStream` are only used when
+ * `createMissing` is on (the default); leave them out of a hand-written client
+ * that cannot create them.
+ */
+interface CloudWatchLogsClientLike {
+    putLogEvents(input: CloudWatchPutLogEventsInput): Promise<unknown>;
+    createLogGroup?(input: {
+        logGroupName: string;
+    }): Promise<unknown>;
+    createLogStream?(input: {
+        logGroupName: string;
+        logStreamName: string;
+    }): Promise<unknown>;
+}
+interface CloudWatchBatchOptions {
+    /** Send once this many events are buffered. */
+    batchSize: number;
+    /**
+     * Also send when the oldest buffered event has waited this long (ms). The
+     * timer does not keep the process alive, so call `flush()` before exiting.
+     */
+    maxWaitMs?: number;
+}
+interface CloudWatchLogsErrorOptions {
+    /**
+     * Create the log stream, and the log group if that is missing too, when
+     * `PutLogEvents` says they do not exist, then try again once. This needs the
+     * `logs:CreateLogStream` (and `logs:CreateLogGroup`) permissions and only runs
+     * after a "not found" answer, so a stream that exists costs nothing. A group
+     * created this way never expires its logs; set a retention policy on it.
+     * Defaults to `true`.
+     */
+    createMissing?: boolean;
+    /**
+     * Buffer events and send them together, up to the 10,000 events and 1 MiB
+     * that one request allows. Off by default: one request per entry.
+     */
+    batch?: CloudWatchBatchOptions;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+    /**
+     * How long a request may take before `log` (or `flush`) gives up waiting, in
+     * milliseconds. Defaults to 10000. Pass `Infinity` to wait without limit. The
+     * request cannot be cancelled, so it may still finish afterwards; in batch
+     * mode the events stay buffered and are sent again by the next flush.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Sends entries to one CloudWatch Logs stream through `PutLogEvents`, each as a
+ * JSON event (the serialized entry plus its UUID `id`) stamped with the entry's
+ * time, so Logs Insights can query its fields. AWS no longer asks for sequence
+ * tokens, so none are tracked.
+ *
+ * By default each entry is its own request and `log` resolves once CloudWatch
+ * accepts it. With `batch`, events are buffered and sent together; `log` then
+ * resolves ok as soon as the event is buffered (it is not stored yet), except
+ * for the call that fills the batch, which resolves with the send result. Call
+ * `flush()` before shutting down.
+ *
+ * CloudWatch can answer ok and still reject events it considers too old (over
+ * 14 days) or too new (over 2 hours ahead); that is reported as `ok: false`. An
+ * event over 256 KiB is refused before sending, since CloudWatch would reject
+ * the whole request.
+ *
+ * In AWS Lambda, ECS and similar runtimes, anything written to stdout already
+ * reaches CloudWatch; this adapter is for apps running elsewhere.
+ */
+declare class CloudWatchLogsErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly client;
+    private readonly logGroupName;
+    private readonly logStreamName;
+    private readonly createMissing;
+    private readonly batch;
+    private readonly logPrefix;
+    private readonly timeoutMs;
+    private buffer;
+    private timer;
+    private readonly flushQueue;
+    /** @throws {RangeError} if a name is empty, the batch or timeout options are invalid, or `createMissing` is on but the client cannot create streams. */
+    constructor(client: CloudWatchLogsClientLike, logGroupName: string, logStreamName: string, options?: CloudWatchLogsErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+    /**
+     * Sends any buffered events now. Resolves ok when nothing is buffered. Events
+     * from a failed send stay buffered and are retried by the next flush.
+     */
+    flush(): Promise<ErrorLogResult>;
+    private addToBatch;
+    private scheduleFlush;
+    private sendBuffered;
+    /**
+     * Sends one request, creating the stream first if CloudWatch says it is
+     * missing. Resolves to a description of any events CloudWatch refused, or
+     * undefined when it took them all.
+     */
+    private send;
+    private putLogEvents;
+    private createStream;
+    private fail;
+}
+
+export { type CloudWatchBatchOptions, type CloudWatchLogEvent, type CloudWatchLogsClientLike, CloudWatchLogsErrorAdapter, type CloudWatchLogsErrorOptions, type CloudWatchPutLogEventsInput, type CollectionLike, CompositeErrorAdapter, type CompositeErrorOptions, ConsoleErrorAdapter, type ConsoleErrorOptions, type EmitterLike, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, EventEmitterErrorAdapter, type EventEmitterErrorOptions, type EventEmitterErrorRecord, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbRequestLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, type LockManagerLike, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, 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, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebSocketErrorAdapter, type WebSocketErrorOptions, type WebSocketLike, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildMySqlWidenColumnsSql, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };

package/dist/index.d.ts

@@ -1022,4 +1022,157 @@ declare class EventEmitterErrorAdapter<TCode extends string = string> implements
     log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
 }
 
-export { type CollectionLike, CompositeErrorAdapter, type CompositeErrorOptions, ConsoleErrorAdapter, type ConsoleErrorOptions, type EmitterLike, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, EventEmitterErrorAdapter, type EventEmitterErrorOptions, type EventEmitterErrorRecord, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbRequestLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, type LockManagerLike, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, 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, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildMySqlWidenColumnsSql, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };
+/**
+ * The only things this adapter needs from a socket: `send` and `readyState`. The
+ * browser `WebSocket`, Node's global `WebSocket`, Deno, Bun, and the `ws` package
+ * all fit as they are.
+ */
+interface WebSocketLike {
+    send(data: string): unknown;
+    readonly readyState: number;
+}
+interface WebSocketErrorOptions {
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+}
+/**
+ * Sends each entry as one JSON text message (the serialized entry plus its UUID
+ * `id`) over a socket you own. You connect, and reconnect, the socket; this
+ * adapter never opens one and keeps no buffer. If the socket is not open when
+ * `log` is called, the entry is not sent and `log` returns `ok: false`, so
+ * combine it with a durable adapter in a `CompositeErrorAdapter` when entries
+ * must not be lost while the socket is down.
+ *
+ * `ok: true` means the socket accepted the message, not that the server
+ * received it: a WebSocket gives no acknowledgement, and a connection that
+ * drops after `send` loses the message.
+ *
+ * ```ts
+ * const socket = new WebSocket('wss://logs.example.com/errors');
+ * const adapter = new WebSocketErrorAdapter(socket);
+ * ```
+ */
+declare class WebSocketErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly socket;
+    private readonly prefix;
+    constructor(socket: WebSocketLike, options?: WebSocketErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+}
+
+/** One event as `PutLogEvents` takes it. */
+interface CloudWatchLogEvent {
+    /** Milliseconds since the epoch. */
+    timestamp: number;
+    message: string;
+}
+/** The parameters this adapter passes to `putLogEvents`. */
+interface CloudWatchPutLogEventsInput {
+    logGroupName: string;
+    logStreamName: string;
+    logEvents: CloudWatchLogEvent[];
+}
+/**
+ * What an AWS SDK client needs to offer. The AWS SDK v3 aggregated client
+ * (`new CloudWatchLogs({ ... })` from `@aws-sdk/client-cloudwatch-logs`) fits as
+ * it is. `createLogGroup` and `createLogStream` are only used when
+ * `createMissing` is on (the default); leave them out of a hand-written client
+ * that cannot create them.
+ */
+interface CloudWatchLogsClientLike {
+    putLogEvents(input: CloudWatchPutLogEventsInput): Promise<unknown>;
+    createLogGroup?(input: {
+        logGroupName: string;
+    }): Promise<unknown>;
+    createLogStream?(input: {
+        logGroupName: string;
+        logStreamName: string;
+    }): Promise<unknown>;
+}
+interface CloudWatchBatchOptions {
+    /** Send once this many events are buffered. */
+    batchSize: number;
+    /**
+     * Also send when the oldest buffered event has waited this long (ms). The
+     * timer does not keep the process alive, so call `flush()` before exiting.
+     */
+    maxWaitMs?: number;
+}
+interface CloudWatchLogsErrorOptions {
+    /**
+     * Create the log stream, and the log group if that is missing too, when
+     * `PutLogEvents` says they do not exist, then try again once. This needs the
+     * `logs:CreateLogStream` (and `logs:CreateLogGroup`) permissions and only runs
+     * after a "not found" answer, so a stream that exists costs nothing. A group
+     * created this way never expires its logs; set a retention policy on it.
+     * Defaults to `true`.
+     */
+    createMissing?: boolean;
+    /**
+     * Buffer events and send them together, up to the 10,000 events and 1 MiB
+     * that one request allows. Off by default: one request per entry.
+     */
+    batch?: CloudWatchBatchOptions;
+    /** Text printed before failure messages. Defaults to `[error-log-adapter]`. */
+    prefix?: string;
+    /**
+     * How long a request may take before `log` (or `flush`) gives up waiting, in
+     * milliseconds. Defaults to 10000. Pass `Infinity` to wait without limit. The
+     * request cannot be cancelled, so it may still finish afterwards; in batch
+     * mode the events stay buffered and are sent again by the next flush.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Sends entries to one CloudWatch Logs stream through `PutLogEvents`, each as a
+ * JSON event (the serialized entry plus its UUID `id`) stamped with the entry's
+ * time, so Logs Insights can query its fields. AWS no longer asks for sequence
+ * tokens, so none are tracked.
+ *
+ * By default each entry is its own request and `log` resolves once CloudWatch
+ * accepts it. With `batch`, events are buffered and sent together; `log` then
+ * resolves ok as soon as the event is buffered (it is not stored yet), except
+ * for the call that fills the batch, which resolves with the send result. Call
+ * `flush()` before shutting down.
+ *
+ * CloudWatch can answer ok and still reject events it considers too old (over
+ * 14 days) or too new (over 2 hours ahead); that is reported as `ok: false`. An
+ * event over 256 KiB is refused before sending, since CloudWatch would reject
+ * the whole request.
+ *
+ * In AWS Lambda, ECS and similar runtimes, anything written to stdout already
+ * reaches CloudWatch; this adapter is for apps running elsewhere.
+ */
+declare class CloudWatchLogsErrorAdapter<TCode extends string = string> implements ErrorLogAdapter<TCode> {
+    private readonly client;
+    private readonly logGroupName;
+    private readonly logStreamName;
+    private readonly createMissing;
+    private readonly batch;
+    private readonly logPrefix;
+    private readonly timeoutMs;
+    private buffer;
+    private timer;
+    private readonly flushQueue;
+    /** @throws {RangeError} if a name is empty, the batch or timeout options are invalid, or `createMissing` is on but the client cannot create streams. */
+    constructor(client: CloudWatchLogsClientLike, logGroupName: string, logStreamName: string, options?: CloudWatchLogsErrorOptions);
+    log(entry: ErrorLogEntry<TCode>): Promise<ErrorLogResult>;
+    /**
+     * Sends any buffered events now. Resolves ok when nothing is buffered. Events
+     * from a failed send stay buffered and are retried by the next flush.
+     */
+    flush(): Promise<ErrorLogResult>;
+    private addToBatch;
+    private scheduleFlush;
+    private sendBuffered;
+    /**
+     * Sends one request, creating the stream first if CloudWatch says it is
+     * missing. Resolves to a description of any events CloudWatch refused, or
+     * undefined when it took them all.
+     */
+    private send;
+    private putLogEvents;
+    private createStream;
+    private fail;
+}
+
+export { type CloudWatchBatchOptions, type CloudWatchLogEvent, type CloudWatchLogsClientLike, CloudWatchLogsErrorAdapter, type CloudWatchLogsErrorOptions, type CloudWatchPutLogEventsInput, type CollectionLike, CompositeErrorAdapter, type CompositeErrorOptions, ConsoleErrorAdapter, type ConsoleErrorOptions, type EmitterLike, type ErrorLogAdapter, type ErrorLogEntry, type ErrorLogResult, EventEmitterErrorAdapter, type EventEmitterErrorOptions, type EventEmitterErrorRecord, type FileSystemLike, type FirebaseErrorOptions, type FirebaseErrorRecord, type FirestoreCollectionLike, FirestoreErrorAdapter, FlatFileErrorAdapter, type FlatFileErrorOptions, type IdbDatabaseLike, type IdbObjectStoreLike, type IdbRequestLike, type IdbTransactionLike, type IdbUpgradeDatabaseLike, IndexedDbErrorAdapter, type IndexedDbErrorOptions, type IndexedDbErrorRecord, JsonFileErrorAdapter, type JsonFileErrorOptions, type JsonFileErrorRecord, type LockManagerLike, MongoDbErrorAdapter, type MongoDbErrorOptions, MySqlErrorAdapter, PostgresErrorAdapter, type ReadWriteFileSystemLike, RealtimeDatabaseErrorAdapter, type RealtimeDatabaseRefLike, 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, type SupabaseClientLike, SupabaseErrorAdapter, type SupabaseErrorLike, type SupabaseErrorOptions, type SupabaseErrorRow, type SupabaseInsertResult, type SupabaseSetupOptions, WebSocketErrorAdapter, type WebSocketErrorOptions, type WebSocketLike, WebStorageErrorAdapter, type WebStorageErrorOptions, type WebStorageErrorRecord, WebhookErrorAdapter, type WebhookErrorOptions, buildCreateErrorLogTableSql, buildErrorLogTableDdl, buildMySqlWidenColumnsSql, buildSupabaseSetupSql, createErrorLogStore, formatErrorLogLine, serializeCause, serializeEntry };

package/dist/index.mjs

@@ -241,10 +241,10 @@ async function hmacSha256Hex(secret, message) {
       "signingSecret needs Web Crypto (crypto.subtle), which this runtime does not provide, so the entry was not sent unsigned"
     );
   }
-  const encoder = new TextEncoder();
+  const encoder2 = new TextEncoder();
   const key = await subtle.importKey(
     "raw",
-    encoder.encode(secret),
+    encoder2.encode(secret),
     { name: "HMAC", hash: "SHA-256" },
     false,
     ["sign"]
@@ -252,7 +252,7 @@ async function hmacSha256Hex(secret, message) {
   const signature = await subtle.sign(
     "HMAC",
     key,
-    encoder.encode(message)
+    encoder2.encode(message)
   );
   return Array.from(
     new Uint8Array(signature),
@@ -1770,7 +1770,332 @@ var EventEmitterErrorAdapter = class {
     }
   }
 };
+
+// src/adapters/websocket-error-adapter.ts
+var OPEN = 1;
+var STATE_NAMES = {
+  0: "still connecting",
+  1: "open",
+  2: "closing",
+  3: "closed"
+};
+var WebSocketErrorAdapter = class {
+  constructor(socket, options = {}) {
+    this.socket = socket;
+    this.prefix = options.prefix ?? DEFAULT_PREFIX;
+  }
+  async log(entry) {
+    try {
+      const state = this.socket.readyState;
+      if (state !== OPEN) {
+        throw new Error(
+          `the socket is ${STATE_NAMES[state] ?? `in unknown state ${String(state)}`} (readyState ${String(state)}), so the entry was not sent; connect or reconnect it first`
+        );
+      }
+      this.socket.send(
+        JSON.stringify({ id: resolveEntryId(entry), ...serializeEntry(entry) })
+      );
+      return { ok: true };
+    } catch (error) {
+      return reportFailure({
+        adapterName: "WebSocketErrorAdapter",
+        prefix: this.prefix,
+        action: "to send over the socket",
+        error
+      });
+    }
+  }
+};
+
+// src/adapters/cloudwatch-logs-error-adapter.ts
+var MAX_EVENT_BYTES = 262144;
+var EVENT_OVERHEAD_BYTES = 26;
+var MAX_BATCH_BYTES = 1048576;
+var MAX_BATCH_EVENTS = 1e4;
+var MAX_BATCH_SPAN_MS = 24 * 60 * 60 * 1e3;
+var BUFFER_LIMIT_MULTIPLIER2 = 10;
+var encoder = new TextEncoder();
+function eventBytes(message) {
+  return encoder.encode(message).length + EVENT_OVERHEAD_BYTES;
+}
+function errorName(error) {
+  return typeof error === "object" && error !== null ? error.name : void 0;
+}
+function splitIntoRequests(events) {
+  const requests = [];
+  let current = [];
+  let bytes = 0;
+  for (const event of events) {
+    const size = eventBytes(event.message);
+    const first = current[0];
+    if (first !== void 0 && (current.length >= MAX_BATCH_EVENTS || bytes + size > MAX_BATCH_BYTES || event.timestamp - first.timestamp > MAX_BATCH_SPAN_MS)) {
+      requests.push(current);
+      current = [];
+      bytes = 0;
+    }
+    current.push(event);
+    bytes += size;
+  }
+  if (current.length > 0) {
+    requests.push(current);
+  }
+  return requests;
+}
+var CloudWatchLogsErrorAdapter = class {
+  /** @throws {RangeError} if a name is empty, the batch or timeout options are invalid, or `createMissing` is on but the client cannot create streams. */
+  constructor(client, logGroupName, logStreamName, options = {}) {
+    this.client = client;
+    this.logGroupName = logGroupName;
+    this.logStreamName = logStreamName;
+    this.buffer = [];
+    this.timer = null;
+    this.flushQueue = new SerialQueue();
+    this.createMissing = options.createMissing ?? true;
+    this.batch = options.batch;
+    this.logPrefix = options.prefix ?? DEFAULT_PREFIX;
+    this.timeoutMs = resolveTimeoutMs(
+      options.timeoutMs,
+      "CloudWatchLogsErrorAdapter"
+    );
+    if (logGroupName === "") {
+      throw new RangeError(
+        "CloudWatchLogsErrorAdapter: logGroupName must not be empty."
+      );
+    }
+    if (logStreamName === "") {
+      throw new RangeError(
+        "CloudWatchLogsErrorAdapter: logStreamName must not be empty."
+      );
+    }
+    if (this.createMissing && typeof client.createLogStream !== "function") {
+      throw new RangeError(
+        "CloudWatchLogsErrorAdapter: createMissing is on, but the client has no createLogStream method. Pass createMissing: false, or use an AWS SDK CloudWatchLogs client."
+      );
+    }
+    if (this.batch !== void 0) {
+      if (!Number.isInteger(this.batch.batchSize) || this.batch.batchSize < 1) {
+        throw new RangeError(
+          `CloudWatchLogsErrorAdapter: 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(
+          `CloudWatchLogsErrorAdapter: batch.maxWaitMs must be a positive number, received ${String(this.batch.maxWaitMs)}.`
+        );
+      }
+    }
+  }
+  async log(entry) {
+    try {
+      const id = resolveEntryId(entry);
+      const record = { id, ...serializeEntry(entry) };
+      const timestamp = Date.parse(record.timestamp);
+      if (Number.isNaN(timestamp)) {
+        throw new RangeError(
+          `timestamp "${record.timestamp}" is not a valid ISO 8601 date`
+        );
+      }
+      const message = JSON.stringify(record);
+      const size = eventBytes(message);
+      if (size > MAX_EVENT_BYTES) {
+        throw new RangeError(
+          `the event is ${size} bytes, over the ${MAX_EVENT_BYTES} byte limit CloudWatch Logs puts on one event, so it was not sent; shorten the message or cause`
+        );
+      }
+      const event = { id, timestamp, message };
+      if (this.batch === void 0) {
+        const rejection = await this.send([event]);
+        if (rejection !== void 0) {
+          throw new Error(rejection);
+        }
+        return { ok: true };
+      }
+      return await this.addToBatch(event, this.batch);
+    } catch (error) {
+      return this.fail(error);
+    }
+  }
+  /**
+   * Sends any buffered events now. Resolves ok when nothing is buffered. Events
+   * from a failed send stay buffered and are retried by the next flush.
+   */
+  flush() {
+    return this.flushQueue.run(
+      () => this.sendBuffered()
+    );
+  }
+  async addToBatch(event, batch) {
+    this.buffer.push(event);
+    const limit = batch.batchSize * BUFFER_LIMIT_MULTIPLIER2;
+    if (this.buffer.length > limit) {
+      const dropped = this.buffer.length - limit;
+      this.buffer = this.buffer.slice(dropped);
+      console.error(
+        `${this.logPrefix} CloudWatchLogsErrorAdapter: dropped the ${dropped} oldest buffered events because sends to log stream "${this.logStreamName}" keep failing and the buffer is full (${limit} events).`
+      );
+    }
+    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 sendBuffered() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const pending = this.buffer.slice();
+    if (pending.length === 0) {
+      return { ok: true };
+    }
+    pending.sort(
+      (a, b) => a.timestamp - b.timestamp
+    );
+    let rejectedTotal = 0;
+    let lastRejection = "";
+    try {
+      for (const request of splitIntoRequests(pending)) {
+        const rejection = await this.send(request);
+        const sent = new Set(request);
+        this.buffer = this.buffer.filter(
+          (event) => !sent.has(event)
+        );
+        if (rejection !== void 0) {
+          rejectedTotal += request.length;
+          lastRejection = rejection;
+        }
+      }
+    } catch (error) {
+      if (this.batch !== void 0) {
+        this.scheduleFlush(this.batch);
+      }
+      return this.fail(error, this.buffer.length);
+    }
+    if (rejectedTotal > 0) {
+      return this.fail(new Error(lastRejection), rejectedTotal);
+    }
+    return { ok: true };
+  }
+  /**
+   * Sends one request, creating the stream first if CloudWatch says it is
+   * missing. Resolves to a description of any events CloudWatch refused, or
+   * undefined when it took them all.
+   */
+  async send(events) {
+    let output;
+    try {
+      output = await this.putLogEvents(events);
+    } catch (error) {
+      if (!this.createMissing || errorName(error) !== "ResourceNotFoundException") {
+        throw error;
+      }
+      await this.createStream();
+      output = await this.putLogEvents(events);
+    }
+    return describeRejection(output, events.length);
+  }
+  putLogEvents(events) {
+    return withTimeout(
+      () => this.client.putLogEvents({
+        logGroupName: this.logGroupName,
+        logStreamName: this.logStreamName,
+        logEvents: events.map(
+          ({ timestamp, message }) => ({
+            timestamp,
+            message
+          })
+        )
+      }),
+      this.timeoutMs,
+      timeoutMessage("CloudWatch Logs", this.timeoutMs)
+    );
+  }
+  async createStream() {
+    const createStream = () => withTimeout(
+      () => this.client.createLogStream({
+        logGroupName: this.logGroupName,
+        logStreamName: this.logStreamName
+      }),
+      this.timeoutMs,
+      timeoutMessage("CloudWatch Logs", this.timeoutMs, "create the stream")
+    );
+    try {
+      await createStream();
+    } catch (error) {
+      const name = errorName(error);
+      if (name === "ResourceAlreadyExistsException") {
+        return;
+      }
+      if (name !== "ResourceNotFoundException" || typeof this.client.createLogGroup !== "function") {
+        throw error;
+      }
+      const createGroup = this.client.createLogGroup.bind(this.client);
+      try {
+        await withTimeout(
+          () => createGroup({ logGroupName: this.logGroupName }),
+          this.timeoutMs,
+          timeoutMessage("CloudWatch Logs", this.timeoutMs, "create the group")
+        );
+      } catch (groupError) {
+        if (errorName(groupError) !== "ResourceAlreadyExistsException") {
+          throw groupError;
+        }
+      }
+      try {
+        await createStream();
+      } catch (retryError) {
+        if (errorName(retryError) !== "ResourceAlreadyExistsException") {
+          throw retryError;
+        }
+      }
+    }
+  }
+  fail(error, count) {
+    return reportFailure({
+      adapterName: "CloudWatchLogsErrorAdapter",
+      prefix: this.logPrefix,
+      action: `to send to log stream "${this.logStreamName}" in log group "${this.logGroupName}"${count === void 0 ? "" : ` (${count} event${count === 1 ? "" : "s"} affected)`}`,
+      error
+    });
+  }
+};
+function describeRejection(output, eventCount) {
+  const info = typeof output === "object" && output !== null ? output.rejectedLogEventsInfo : void 0;
+  if (info === void 0 || info === null) {
+    return void 0;
+  }
+  const reasons = [];
+  if (info.tooOldLogEventEndIndex !== void 0) {
+    reasons.push(
+      `${info.tooOldLogEventEndIndex} event(s) were older than the 14 days CloudWatch accepts`
+    );
+  }
+  if (info.expiredLogEventEndIndex !== void 0) {
+    reasons.push(
+      `${info.expiredLogEventEndIndex} event(s) were older than the log group's retention period`
+    );
+  }
+  if (info.tooNewLogEventStartIndex !== void 0) {
+    reasons.push(
+      `${Math.max(0, eventCount - info.tooNewLogEventStartIndex)} event(s) were more than 2 hours ahead of the current time`
+    );
+  }
+  return reasons.length === 0 ? void 0 : `CloudWatch Logs accepted the request but rejected events: ${reasons.join("; ")}`;
+}
 export {
+  CloudWatchLogsErrorAdapter,
   CompositeErrorAdapter,
   ConsoleErrorAdapter,
   EventEmitterErrorAdapter,
@@ -1786,6 +2111,7 @@ export {
   S3ErrorAdapter,
   SqliteErrorAdapter,
   SupabaseErrorAdapter,
+  WebSocketErrorAdapter,
   WebStorageErrorAdapter,
   WebhookErrorAdapter,
   buildCreateErrorLogTableSql,