@richardmcquiston01/error-log-adapter 0.6.0 → 0.8.0

package/README.md

@@ -70,25 +70,27 @@ Constructor options are checked when the adapter is created and throw a descript
 
 Every adapter takes an optional `prefix` (default `[error-log-adapter]`) that is printed before its failure messages.
 
-| Adapter                             | Sink                                                      | Runs in       | Main options                                                        |
-| ----------------------------------- | --------------------------------------------------------- | ------------- | ------------------------------------------------------------------- |
-| `ConsoleErrorAdapter`               | `console.error`                                           | Anywhere      |                                                                     |
-| `WebhookErrorAdapter(url)`          | HTTP `POST` of the entry as JSON                          | Anywhere      | `headers`, `timeoutMs`, `retries`, `signingSecret`, `allowInsecure` |
-| `MongoDbErrorAdapter(collection)`   | Anything with `insertOne`, such as a MongoDB `Collection` | Node          | `timeoutMs`                                                         |
-| `PostgresErrorAdapter(client)`      | A Postgres table, through `pg`                            | Node          | `tableName`, `createTable`, `timeoutMs`                             |
-| `MySqlErrorAdapter(client)`         | A MySQL / MariaDB table, through `mysql2/promise`         | Node          | `tableName`, `createTable`, `timeoutMs`                             |
-| `SqliteErrorAdapter(client)`        | A SQLite table, through any driver                        | Node, Bun     | `tableName`, `createTable`, `timeoutMs`                             |
-| `SupabaseErrorAdapter(client)`      | A Supabase table, through `supabase-js`                   | Anywhere      | `tableName`, `timeoutMs`                                            |
-| `RedisErrorAdapter(client)`         | A Redis list or stream                                    | Node          | `mode`, `key`, `maxEntries`, `side`, `timeoutMs`                    |
-| `S3ErrorAdapter(client, bucket)`    | S3, DigitalOcean Spaces, R2, MinIO objects                | Node          | `keyPrefix`, `batch`, `contentType`, `timeoutMs`                    |
-| `FirestoreErrorAdapter(collection)` | A Firestore collection                                    | Node, browser | `timeoutMs`                                                         |
-| `RealtimeDatabaseErrorAdapter(ref)` | A Realtime Database reference                             | Node, browser | `timeoutMs`                                                         |
-| `FlatFileErrorAdapter(path)`        | One text line per entry                                   | Node, Bun     | `formatLine`, `maxBytes`, `maxFiles`                                |
-| `JsonFileErrorAdapter(path)`        | NDJSON lines or one JSON array                            | Node, Bun     | `mode`, `maxEntries`, `indent`                                      |
-| `IndexedDbErrorAdapter(database)`   | An IndexedDB object store                                 | Browser       | `storeName`, `timeoutMs`                                            |
-| `WebStorageErrorAdapter(storage)`   | `sessionStorage` or `localStorage`, as one capped array   | Browser       | `key`, `maxEntries`, `locks`                                        |
-| `EventEmitterErrorAdapter(emitter)` | An event on an emitter you own (in-process hooks)         | Anywhere      | `eventName`, `requireListener`                                      |
-| `CompositeErrorAdapter([...])`      | Several adapters at once; succeeds only if all succeed    | Anywhere      | `timeoutMs`                                                         |
+| Adapter                                             | Sink                                                      | Runs in       | Main options                                                        |
+| --------------------------------------------------- | --------------------------------------------------------- | ------------- | ------------------------------------------------------------------- |
+| `ConsoleErrorAdapter`                               | `console.error`                                           | Anywhere      |                                                                     |
+| `WebhookErrorAdapter(url)`                          | HTTP `POST` of the entry as JSON                          | Anywhere      | `headers`, `timeoutMs`, `retries`, `signingSecret`, `allowInsecure` |
+| `MongoDbErrorAdapter(collection)`                   | Anything with `insertOne`, such as a MongoDB `Collection` | Node          | `timeoutMs`                                                         |
+| `PostgresErrorAdapter(client)`                      | A Postgres table, through `pg`                            | Node          | `tableName`, `createTable`, `timeoutMs`                             |
+| `MySqlErrorAdapter(client)`                         | A MySQL / MariaDB table, through `mysql2/promise`         | Node          | `tableName`, `createTable`, `timeoutMs`                             |
+| `SqliteErrorAdapter(client)`                        | A SQLite table, through any driver                        | Node, Bun     | `tableName`, `createTable`, `timeoutMs`                             |
+| `SupabaseErrorAdapter(client)`                      | A Supabase table, through `supabase-js`                   | Anywhere      | `tableName`, `timeoutMs`                                            |
+| `RedisErrorAdapter(client)`                         | A Redis list or stream                                    | Node          | `mode`, `key`, `maxEntries`, `side`, `timeoutMs`                    |
+| `S3ErrorAdapter(client, bucket)`                    | S3, DigitalOcean Spaces, R2, MinIO objects                | Node          | `keyPrefix`, `batch`, `contentType`, `timeoutMs`                    |
+| `FirestoreErrorAdapter(collection)`                 | A Firestore collection                                    | Node, browser | `timeoutMs`                                                         |
+| `RealtimeDatabaseErrorAdapter(ref)`                 | A Realtime Database reference                             | Node, browser | `timeoutMs`                                                         |
+| `FlatFileErrorAdapter(path)`                        | One text line per entry                                   | Node, Bun     | `formatLine`, `maxBytes`, `maxFiles`                                |
+| `JsonFileErrorAdapter(path)`                        | NDJSON lines or one JSON array                            | Node, Bun     | `mode`, `maxEntries`, `indent`                                      |
+| `IndexedDbErrorAdapter(database)`                   | An IndexedDB object store                                 | Browser       | `storeName`, `timeoutMs`                                            |
+| `WebStorageErrorAdapter(storage)`                   | `sessionStorage` or `localStorage`, as one capped array   | Browser       | `key`, `maxEntries`, `locks`                                        |
+| `EventEmitterErrorAdapter(emitter)`                 | An event on an emitter you own (in-process hooks)         | Anywhere      | `eventName`, `requireListener`                                      |
+| `WebSocketErrorAdapter(socket)`                     | One JSON message over a socket you own                    | Anywhere      | (none)                                                              |
+| `CloudWatchLogsErrorAdapter(client, group, stream)` | AWS CloudWatch Logs events                                | Node          | `batch`, `createMissing`, `timeoutMs`                               |
+| `CompositeErrorAdapter([...])`                      | Several adapters at once; succeeds only if all succeed    | Anywhere      | `timeoutMs`                                                         |
 
 Every stored record has the same shape: a UUID `id`, `code`, `message`, `timestamp` (ISO 8601), and optional `source` and `cause`. An `Error` cause is stored as `{ name, message, stack }`. `serializeEntry` and `serializeCause` are exported if you build your own sink.
 
@@ -101,6 +103,8 @@ What changes durability or size, by adapter:
 - **Redis and Web Storage** (`maxEntries`): the oldest entries are dropped past the cap.
 - **Browser storage**: `sessionStorage` belongs to one tab. `localStorage` is shared by every tab and has no atomic update, so two tabs logging at the same instant can overwrite each other's entry. `WebStorageErrorAdapter` takes a `navigator.locks` lock around each write, which reduces the loss but cannot remove it, since tabs in separate processes can still read a stale copy. Use `IndexedDbErrorAdapter` when every entry matters. Create its object store from your `onupgradeneeded` handler with `createErrorLogStore`. A stored value the adapter cannot read is copied to `<key>.corrupt` before it is replaced.
 - **Event emitter**: each entry is emitted as an `error-log` event whose payload is the stored record, for in-process hooks such as a toast, a metrics counter or a test assertion. Listeners run synchronously, so one that throws makes `log()` return `ok: false` with its message. Node's `EventEmitter` and mitt work as they are; a browser `EventTarget` needs a one-line wrapper (shown in the example below). Don't name the event `error` on a Node `EventEmitter`: it throws when nobody listens. Node's `emit` returns `false` when there are no listeners; pass `requireListener: true` to report that as a failure instead of letting the entry vanish.
+- **WebSocket**: each entry is sent as one JSON text message (the serialized entry plus its UUID `id`) over a socket you own; the adapter never connects, reconnects or buffers. If the socket's `readyState` is not open (connecting, closing or closed), `log()` returns `ok: false` and says which. `ok: true` means the socket accepted the message, not that the server got it, since a WebSocket has no acknowledgement. Browsers, Node's global `WebSocket`, Deno, Bun and `ws` all fit. Pair it with a durable adapter in a `CompositeErrorAdapter` if entries must survive the socket being down.
+- **CloudWatch Logs**: each entry is sent through `PutLogEvents` as a JSON event (the serialized entry plus its UUID `id`) stamped with the entry's time, so Logs Insights can query its fields. Pass an AWS SDK v3 `CloudWatchLogs` client. AWS no longer needs sequence tokens, so none are tracked. If the stream (or group) does not exist, the adapter creates it and tries again once (`createMissing`, on by default; it needs `logs:CreateLogStream` and `logs:CreateLogGroup`, and a group created this way never expires its logs, so set a retention policy). CloudWatch can answer ok and still refuse events older than 14 days or more than 2 hours ahead; that is reported as `ok: false`. An event over 256 KiB is refused before sending. With `batch: { batchSize, maxWaitMs }`, events are buffered and sent together (up to 10,000 events and 1 MiB per request, oldest first), `log()` returns `ok` as soon as the event is buffered, and you should call `flush()` before the process exits. In Lambda and ECS, stdout already reaches CloudWatch; this is for apps running elsewhere.
 - **Webhook**: the URL must be `https://` (or `http://localhost`, `127.0.0.1`, `[::1]`) unless you pass `allowInsecure: true`, because entries carry messages and stack traces. Redirects are not followed, since a redirect would turn the `POST` into a body-less `GET` or re-send the entry and your headers to another host; a redirect is reported as `ok: false`. Failure messages contain only the origin, never the path or query, because webhook URLs often hold a secret. Set `retries` to try again after a network error, a timeout, HTTP 408, 425, 429 or 5xx (exponential backoff with jitter from `retryDelayMs`, capped by `maxRetryDelayMs`, honoring `Retry-After`; other 4xx answers are never retried). With `retries` set, every attempt sends the same body including an `id`, so the receiver can drop a repeat. Set `signingSecret` to add `X-Signature-Timestamp` and `X-Signature-256` (`sha256=` + hex HMAC-SHA256 of `<timestamp>.<body>`); the receiver recomputes it and rejects old timestamps.
 
 ### When a sink is slow or down
@@ -134,6 +138,7 @@ Without an `id`, every call to `log()` gets a new random one, so logging twice s
 | IndexedDB, Web Storage, JSON file (`array` mode)     | Replaces the earlier record                                                                                     |
 | S3                                                   | Overwrites the same object only if the retry also has the same `timestamp` (the key contains both)              |
 | Webhook                                              | The `id` is added to the JSON body so the receiver can drop repeats                                             |
+| CloudWatch Logs                                      | Cannot detect a repeat (the `id` is in the message, so Logs Insights can `dedup id`)                            |
 | Redis, flat file, JSON file (`ndjson` mode), console | Cannot detect a repeat                                                                                          |
 
 `CompositeErrorAdapter` passes the entry through unchanged, so every sink sees the same `id`.
@@ -245,6 +250,31 @@ target.addEventListener('error-log', (event) =>
 const errorLog = new EventEmitterErrorAdapter(emitter);
 ```
 
+Send errors over a socket you manage, with a file as the fallback while it is down:
+
+```ts
+const socket = new WebSocket('wss://logs.example.com/errors');
+const errorLog = new CompositeErrorAdapter([
+  new WebSocketErrorAdapter(socket),
+  new FlatFileErrorAdapter('./errors.log'),
+]);
+```
+
+Send errors to CloudWatch Logs from an app running outside AWS:
+
+```ts
+import { CloudWatchLogs } from '@aws-sdk/client-cloudwatch-logs';
+import { CloudWatchLogsErrorAdapter } from '@richardmcquiston01/error-log-adapter';
+
+const errorLog = new CloudWatchLogsErrorAdapter(
+  new CloudWatchLogs({ region: 'us-east-1' }),
+  '/my-app/errors',
+  `web-${process.pid}`,
+  { batch: { batchSize: 100, maxWaitMs: 5000 } }
+);
+process.on('beforeExit', () => void errorLog.flush());
+```
+
 Write your own adapter by implementing the interface. Catch failures and return them rather than throwing:
 
 ```ts

package/dist/index.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CloudWatchLogsErrorAdapter: () => CloudWatchLogsErrorAdapter,
   CompositeErrorAdapter: () => CompositeErrorAdapter,
   ConsoleErrorAdapter: () => ConsoleErrorAdapter,
   EventEmitterErrorAdapter: () => EventEmitterErrorAdapter,
@@ -35,6 +36,7 @@ __export(index_exports, {
   S3ErrorAdapter: () => S3ErrorAdapter,
   SqliteErrorAdapter: () => SqliteErrorAdapter,
   SupabaseErrorAdapter: () => SupabaseErrorAdapter,
+  WebSocketErrorAdapter: () => WebSocketErrorAdapter,
   WebStorageErrorAdapter: () => WebStorageErrorAdapter,
   WebhookErrorAdapter: () => WebhookErrorAdapter,
   buildCreateErrorLogTableSql: () => buildCreateErrorLogTableSql,
@@ -291,10 +293,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"]
@@ -302,7 +304,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),
@@ -1820,8 +1822,333 @@ 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("; ")}`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CloudWatchLogsErrorAdapter,
   CompositeErrorAdapter,
   ConsoleErrorAdapter,
   EventEmitterErrorAdapter,
@@ -1837,6 +2164,7 @@ var EventEmitterErrorAdapter = class {
   S3ErrorAdapter,
   SqliteErrorAdapter,
   SupabaseErrorAdapter,
+  WebSocketErrorAdapter,
   WebStorageErrorAdapter,
   WebhookErrorAdapter,
   buildCreateErrorLogTableSql,