code/core/src/manager/utils/prepareForTelemetry.ts (2)

28-33: Make skip matching robust (substring + case-insensitive).

React/DevTools messages often vary slightly. Use a case-insensitive substring match so variants are also filtered.

Apply this diff:

-export const shouldSkipError = (error: Error) => errorMessages.includes(error?.message);
+export const shouldSkipError = (error: Error) => {
+  const msg = error?.message?.toLowerCase?.();
+  return !!msg && errorMessages.some((m) => msg.includes(m.toLowerCase()));
+};

---

32-32: Optional: accept unknown and normalize to a message.

This makes the filter resilient to strings/objects passed from unhandledrejection.

Example (outside the changed hunk):

export const shouldSkipError = (err: unknown) => {
  const msg =
    err instanceof Error
      ? err.message
      : typeof err === 'string'
      ? err
      : typeof (err as any)?.message === 'string'
      ? (err as any).message
      : '';
  const lower = msg.toLowerCase();
  return lower && errorMessages.some((m) => lower.includes(m.toLowerCase()));
};

code/core/src/manager/globals-runtime.ts (4)

13-14: Bound the queue to prevent unbounded memory growth.

If the channel is unavailable for a while, the queue can grow without limit.

Apply this diff:

-const queuedErrors: Error[] = [];
+const queuedErrors: Error[] = [];
+const MAX_QUEUED_ERRORS = 200; // drop oldest beyond this

---

15-22: Normalize input to Error before filtering and preparing.

Unhandled rejections can be strings/objects. Normalize first so skip logic and preparation are reliable.

Apply this diff:

-globalThis.sendTelemetryError = (error) => {
-  if (shouldSkipError(error)) {
+globalThis.sendTelemetryError = (raw) => {
+  const error =
+    raw instanceof Error
+      ? raw
+      : new Error(String((raw as any)?.message ?? raw));
+  if (shouldSkipError(error)) {
     return;
   }
 
-  const channel = globalThis.__STORYBOOK_ADDONS_CHANNEL__;
-  const preparedError = prepareForTelemetry(error);
+  const channel = globalThis.__STORYBOOK_ADDONS_CHANNEL__;
+  const preparedError = prepareForTelemetry(error);

---

23-26: Drop oldest when queue is full.

Prevents runaway memory while preserving the most recent context.

Apply this diff:

-  if (!channel) {
-    queuedErrors.push(preparedError);
+  if (!channel) {
+    if (queuedErrors.length >= MAX_QUEUED_ERRORS) queuedErrors.shift();
+    queuedErrors.push(preparedError);
     return;
   }

---

28-33: Flush without O(n) shift and guard against emit failures.

Use splice to drain in one shot and try/catch so one bad emit doesn’t stop the rest.

Apply this diff:

-  // Flush any queued errors first
-  while (queuedErrors.length > 0) {
-    const queuedError = queuedErrors.shift();
-    channel.emit(TELEMETRY_ERROR, queuedError);
-  }
+  // Flush any queued errors first
+  const toFlush = queuedErrors.splice(0, queuedErrors.length);
+  for (const queuedError of toFlush) {
+    try {
+      channel.emit(TELEMETRY_ERROR, queuedError);
+    } catch {
+      // swallow to avoid cascading failures
+    }
+  }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro