@logtape/logtape 1.1.0-dev.338 → 1.1.0

package/src/sink.test.ts

@@ -11,6 +11,7 @@ import type { LogLevel } from "./level.ts";
 import type { LogRecord } from "./record.ts";
 import {
   type AsyncSink,
+  fingersCrossed,
   fromAsyncSink,
   getConsoleSink,
   getStreamSink,
@@ -873,3 +874,835 @@ test("fromAsyncSink() - empty async sink", async () => {
   // Test passes if no errors thrown
   assert(true);
 });
+
+test("fingersCrossed() - basic functionality", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer));
+
+  // Add debug and info logs - should be buffered
+  sink(trace);
+  sink(debug);
+  sink(info);
+  assertEquals(buffer.length, 0); // Not flushed yet
+
+  // Add warning - still buffered (default trigger is error)
+  sink(warning);
+  assertEquals(buffer.length, 0);
+
+  // Add error - should trigger flush
+  sink(error);
+  assertEquals(buffer, [trace, debug, info, warning, error]);
+
+  // After trigger, logs pass through directly
+  sink(fatal);
+  assertEquals(buffer, [trace, debug, info, warning, error, fatal]);
+});
+
+test("fingersCrossed() - custom trigger level", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    triggerLevel: "warning",
+  });
+
+  // Add logs below warning
+  sink(trace);
+  sink(debug);
+  sink(info);
+  assertEquals(buffer.length, 0);
+
+  // Warning should trigger flush
+  sink(warning);
+  assertEquals(buffer, [trace, debug, info, warning]);
+
+  // Subsequent logs pass through
+  sink(error);
+  assertEquals(buffer, [trace, debug, info, warning, error]);
+});
+
+test("fingersCrossed() - buffer overflow protection", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    maxBufferSize: 3,
+  });
+
+  // Add more logs than buffer size
+  sink(trace);
+  sink(debug);
+  sink(info);
+  sink(warning); // Should drop trace
+  assertEquals(buffer.length, 0); // Still buffered
+
+  // Trigger flush
+  sink(error);
+  // Should only have last 3 records + error
+  assertEquals(buffer, [debug, info, warning, error]);
+});
+
+test("fingersCrossed() - multiple trigger events", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer));
+
+  // First batch
+  sink(debug);
+  sink(info);
+  sink(error); // Trigger
+  assertEquals(buffer, [debug, info, error]);
+
+  // After trigger, everything passes through
+  sink(debug);
+  assertEquals(buffer, [debug, info, error, debug]);
+
+  sink(error); // Another error
+  assertEquals(buffer, [debug, info, error, debug, error]);
+});
+
+test("fingersCrossed() - trigger includes fatal", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    triggerLevel: "error",
+  });
+
+  sink(debug);
+  sink(info);
+  assertEquals(buffer.length, 0);
+
+  // Fatal should also trigger (since it's >= error)
+  sink(fatal);
+  assertEquals(buffer, [debug, info, fatal]);
+});
+
+test("fingersCrossed() - category isolation descendant mode", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "descendant",
+  });
+
+  // Create test records with different categories
+  const appDebug: LogRecord = {
+    ...debug,
+    category: ["app"],
+  };
+  const appModuleDebug: LogRecord = {
+    ...debug,
+    category: ["app", "module"],
+  };
+  const appModuleSubDebug: LogRecord = {
+    ...debug,
+    category: ["app", "module", "sub"],
+  };
+  const otherDebug: LogRecord = {
+    ...debug,
+    category: ["other"],
+  };
+  const appError: LogRecord = {
+    ...error,
+    category: ["app"],
+  };
+
+  // Buffer logs in different categories
+  sink(appDebug);
+  sink(appModuleDebug);
+  sink(appModuleSubDebug);
+  sink(otherDebug);
+  assertEquals(buffer.length, 0);
+
+  // Trigger in parent category
+  sink(appError);
+
+  // Should flush parent and all descendants, but not other
+  assertEquals(buffer.length, 4); // app, app.module, app.module.sub, and trigger
+  assert(buffer.includes(appDebug));
+  assert(buffer.includes(appModuleDebug));
+  assert(buffer.includes(appModuleSubDebug));
+  assert(buffer.includes(appError));
+  assert(!buffer.includes(otherDebug));
+});
+
+test("fingersCrossed() - category isolation ancestor mode", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "ancestor",
+  });
+
+  // Create test records
+  const appDebug: LogRecord = {
+    ...debug,
+    category: ["app"],
+  };
+  const appModuleDebug: LogRecord = {
+    ...debug,
+    category: ["app", "module"],
+  };
+  const appModuleSubDebug: LogRecord = {
+    ...debug,
+    category: ["app", "module", "sub"],
+  };
+  const appModuleSubError: LogRecord = {
+    ...error,
+    category: ["app", "module", "sub"],
+  };
+
+  // Buffer logs
+  sink(appDebug);
+  sink(appModuleDebug);
+  sink(appModuleSubDebug);
+  assertEquals(buffer.length, 0);
+
+  // Trigger in child category
+  sink(appModuleSubError);
+
+  // Should flush child and all ancestors
+  assertEquals(buffer.length, 4);
+  assert(buffer.includes(appDebug));
+  assert(buffer.includes(appModuleDebug));
+  assert(buffer.includes(appModuleSubDebug));
+  assert(buffer.includes(appModuleSubError));
+});
+
+test("fingersCrossed() - category isolation both mode", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "both",
+  });
+
+  // Create test records
+  const rootDebug: LogRecord = {
+    ...debug,
+    category: ["app"],
+  };
+  const parentDebug: LogRecord = {
+    ...debug,
+    category: ["app", "parent"],
+  };
+  const siblingDebug: LogRecord = {
+    ...debug,
+    category: ["app", "sibling"],
+  };
+  const childDebug: LogRecord = {
+    ...debug,
+    category: ["app", "parent", "child"],
+  };
+  const unrelatedDebug: LogRecord = {
+    ...debug,
+    category: ["other"],
+  };
+  const parentError: LogRecord = {
+    ...error,
+    category: ["app", "parent"],
+  };
+
+  // Buffer logs
+  sink(rootDebug);
+  sink(parentDebug);
+  sink(siblingDebug);
+  sink(childDebug);
+  sink(unrelatedDebug);
+  assertEquals(buffer.length, 0);
+
+  // Trigger in middle category
+  sink(parentError);
+
+  // Should flush ancestors and descendants, but not siblings or unrelated
+  assertEquals(buffer.length, 4);
+  assert(buffer.includes(rootDebug)); // Ancestor
+  assert(buffer.includes(parentDebug)); // Same
+  assert(buffer.includes(childDebug)); // Descendant
+  assert(buffer.includes(parentError)); // Trigger
+  assert(!buffer.includes(siblingDebug)); // Sibling
+  assert(!buffer.includes(unrelatedDebug)); // Unrelated
+});
+
+test("fingersCrossed() - custom category matcher", () => {
+  const buffer: LogRecord[] = [];
+
+  // Custom matcher: only flush if categories share first element
+  const customMatcher = (
+    trigger: readonly string[],
+    buffered: readonly string[],
+  ): boolean => {
+    return trigger[0] === buffered[0];
+  };
+
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: customMatcher,
+  });
+
+  // Create test records
+  const app1Debug: LogRecord = {
+    ...debug,
+    category: ["app", "module1"],
+  };
+  const app2Debug: LogRecord = {
+    ...debug,
+    category: ["app", "module2"],
+  };
+  const otherDebug: LogRecord = {
+    ...debug,
+    category: ["other", "module"],
+  };
+  const appError: LogRecord = {
+    ...error,
+    category: ["app", "module3"],
+  };
+
+  // Buffer logs
+  sink(app1Debug);
+  sink(app2Debug);
+  sink(otherDebug);
+  assertEquals(buffer.length, 0);
+
+  // Trigger
+  sink(appError);
+
+  // Should flush all with same first category element
+  assertEquals(buffer.length, 3);
+  assert(buffer.includes(app1Debug));
+  assert(buffer.includes(app2Debug));
+  assert(buffer.includes(appError));
+  assert(!buffer.includes(otherDebug));
+});
+
+test("fingersCrossed() - isolated buffers maintain separate states", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "descendant",
+  });
+
+  // Create test records
+  const app1Debug: LogRecord = {
+    ...debug,
+    category: ["app1"],
+  };
+  const app1Error: LogRecord = {
+    ...error,
+    category: ["app1"],
+  };
+  const app2Debug: LogRecord = {
+    ...debug,
+    category: ["app2"],
+  };
+  const app2Info: LogRecord = {
+    ...info,
+    category: ["app2"],
+  };
+
+  // Buffer in app1
+  sink(app1Debug);
+
+  // Trigger app1
+  sink(app1Error);
+  assertEquals(buffer, [app1Debug, app1Error]);
+
+  // Buffer in app2 (should still be buffering)
+  sink(app2Debug);
+  assertEquals(buffer, [app1Debug, app1Error]); // app2 still buffered
+
+  // Add more to triggered app1 (should pass through)
+  sink(app1Debug);
+  assertEquals(buffer, [app1Debug, app1Error, app1Debug]);
+
+  // app2 still buffering
+  sink(app2Info);
+  assertEquals(buffer, [app1Debug, app1Error, app1Debug]); // app2 still buffered
+});
+
+test("fingersCrossed() - chronological order in category isolation", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "both",
+  });
+
+  // Create test records with different timestamps
+  const app1: LogRecord = {
+    ...debug,
+    category: ["app"],
+    timestamp: 1000,
+  };
+  const app2: LogRecord = {
+    ...debug,
+    category: ["app", "sub"],
+    timestamp: 2000,
+  };
+  const app3: LogRecord = {
+    ...info,
+    category: ["app"],
+    timestamp: 3000,
+  };
+  const app4: LogRecord = {
+    ...debug,
+    category: ["app", "sub"],
+    timestamp: 4000,
+  };
+  const appError: LogRecord = {
+    ...error,
+    category: ["app"],
+    timestamp: 5000,
+  };
+
+  // Add out of order
+  sink(app3);
+  sink(app1);
+  sink(app4);
+  sink(app2);
+
+  // Trigger
+  sink(appError);
+
+  // Should be sorted by timestamp
+  assertEquals(buffer, [app1, app2, app3, app4, appError]);
+});
+
+test("fingersCrossed() - empty buffer trigger", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer));
+
+  // Trigger immediately without any buffered logs
+  sink(error);
+  assertEquals(buffer, [error]);
+
+  // Continue to pass through
+  sink(debug);
+  assertEquals(buffer, [error, debug]);
+});
+
+test("fingersCrossed() - buffer size per category in isolation mode", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    maxBufferSize: 2,
+    isolateByCategory: "descendant",
+  });
+
+  // Create records for different categories
+  const app1Trace: LogRecord = { ...trace, category: ["app1"] };
+  const app1Debug: LogRecord = { ...debug, category: ["app1"] };
+  const app1Info: LogRecord = { ...info, category: ["app1"] };
+  const app2Trace: LogRecord = { ...trace, category: ["app2"] };
+  const app2Debug: LogRecord = { ...debug, category: ["app2"] };
+  const app1Error: LogRecord = { ...error, category: ["app1"] };
+
+  // Fill app1 buffer beyond max
+  sink(app1Trace);
+  sink(app1Debug);
+  sink(app1Info); // Should drop app1Trace
+
+  // Fill app2 buffer
+  sink(app2Trace);
+  sink(app2Debug);
+
+  // Trigger app1
+  sink(app1Error);
+
+  // Should only have last 2 from app1 + error
+  assertEquals(buffer.length, 3);
+  assert(!buffer.some((r) => r === app1Trace)); // Dropped
+  assert(buffer.includes(app1Debug));
+  assert(buffer.includes(app1Info));
+  assert(buffer.includes(app1Error));
+  // app2 records should not be flushed
+  assert(!buffer.includes(app2Trace));
+  assert(!buffer.includes(app2Debug));
+});
+
+test("fingersCrossed() - edge case: trigger level not in severity order", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    triggerLevel: "trace", // Lowest level triggers immediately
+  });
+
+  // Everything should pass through immediately
+  sink(trace);
+  assertEquals(buffer, [trace]);
+
+  sink(debug);
+  assertEquals(buffer, [trace, debug]);
+});
+
+test("fingersCrossed() - edge case: invalid trigger level", () => {
+  const buffer: LogRecord[] = [];
+
+  // Should throw TypeError during sink creation
+  assertThrows(
+    () => {
+      fingersCrossed(buffer.push.bind(buffer), {
+        triggerLevel: "invalid" as LogLevel,
+      });
+    },
+    TypeError,
+    "Invalid triggerLevel",
+  );
+});
+
+test("fingersCrossed() - edge case: very large buffer size", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    maxBufferSize: Number.MAX_SAFE_INTEGER,
+  });
+
+  // Add many records
+  for (let i = 0; i < 1000; i++) {
+    sink(debug);
+  }
+  assertEquals(buffer.length, 0); // Still buffered
+
+  sink(error);
+  assertEquals(buffer.length, 1001); // All 1000 + error
+});
+
+test("fingersCrossed() - edge case: zero buffer size", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    maxBufferSize: 0,
+  });
+
+  // Nothing should be buffered
+  sink(debug);
+  sink(info);
+  assertEquals(buffer.length, 0);
+
+  // Trigger should still work
+  sink(error);
+  assertEquals(buffer, [error]); // Only the trigger
+});
+
+test("fingersCrossed() - edge case: negative buffer size", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    maxBufferSize: -1,
+  });
+
+  // Should behave like zero
+  sink(debug);
+  sink(info);
+  assertEquals(buffer.length, 0);
+
+  sink(error);
+  assertEquals(buffer, [error]);
+});
+
+test("fingersCrossed() - edge case: same record logged multiple times", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer));
+
+  // Log same record multiple times
+  sink(debug);
+  sink(debug);
+  sink(debug);
+  assertEquals(buffer.length, 0);
+
+  sink(error);
+  // All instances should be preserved
+  assertEquals(buffer.length, 4);
+  assertEquals(buffer, [debug, debug, debug, error]);
+});
+
+test("fingersCrossed() - edge case: empty category array", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "both",
+  });
+
+  const emptyCategory: LogRecord = {
+    ...debug,
+    category: [],
+  };
+
+  const normalCategory: LogRecord = {
+    ...info,
+    category: ["app"],
+  };
+
+  const emptyError: LogRecord = {
+    ...error,
+    category: [],
+  };
+
+  sink(emptyCategory);
+  sink(normalCategory);
+  assertEquals(buffer.length, 0);
+
+  // Trigger with empty category
+  sink(emptyError);
+
+  // Only empty category should flush (no ancestors/descendants)
+  assertEquals(buffer.length, 2);
+  assert(buffer.includes(emptyCategory));
+  assert(buffer.includes(emptyError));
+  assert(!buffer.includes(normalCategory));
+});
+
+test("fingersCrossed() - edge case: category with special characters", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "descendant",
+  });
+
+  // Category with null character (our separator)
+  const specialCategory: LogRecord = {
+    ...debug,
+    category: ["app\0special", "sub"],
+  };
+
+  const normalCategory: LogRecord = {
+    ...info,
+    category: ["app"],
+  };
+
+  const specialError: LogRecord = {
+    ...error,
+    category: ["app\0special"],
+  };
+
+  sink(specialCategory);
+  sink(normalCategory);
+  assertEquals(buffer.length, 0);
+
+  // Should still work correctly despite special characters
+  sink(specialError);
+
+  assertEquals(buffer.length, 2);
+  assert(buffer.includes(specialCategory));
+  assert(buffer.includes(specialError));
+  assert(!buffer.includes(normalCategory));
+});
+
+test("fingersCrossed() - edge case: rapid alternating triggers", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "both",
+  });
+
+  const app1Debug: LogRecord = { ...debug, category: ["app1"] };
+  const app2Debug: LogRecord = { ...debug, category: ["app2"] };
+  const app1Error: LogRecord = { ...error, category: ["app1"] };
+  const app2Error: LogRecord = { ...error, category: ["app2"] };
+
+  // Rapidly alternate between categories and triggers
+  sink(app1Debug);
+  sink(app2Debug);
+  sink(app1Error); // Trigger app1
+  assertEquals(buffer.length, 2); // app1Debug + app1Error
+
+  sink(app2Error); // Trigger app2
+  assertEquals(buffer.length, 4); // Previous + app2Debug + app2Error
+
+  // After both triggered, everything passes through
+  sink(app1Debug);
+  sink(app2Debug);
+  assertEquals(buffer.length, 6);
+});
+
+test("fingersCrossed() - edge case: custom matcher throws error", () => {
+  const buffer: LogRecord[] = [];
+
+  const errorMatcher = (): boolean => {
+    throw new Error("Matcher error");
+  };
+
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: errorMatcher,
+  });
+
+  const app1Debug: LogRecord = { ...debug, category: ["app1"] };
+  const app2Debug: LogRecord = { ...debug, category: ["app2"] };
+  const app1Error: LogRecord = { ...error, category: ["app1"] };
+
+  sink(app1Debug);
+  sink(app2Debug);
+
+  // Should handle error gracefully and still trigger
+  try {
+    sink(app1Error);
+  } catch {
+    // Should not throw to caller
+  }
+
+  // At minimum, trigger record should be sent
+  assert(buffer.includes(app1Error));
+});
+
+test("fingersCrossed() - edge case: circular category references", () => {
+  const buffer: LogRecord[] = [];
+
+  // Custom matcher that creates circular logic
+  const circularMatcher = (
+    _trigger: readonly string[],
+    _buffered: readonly string[],
+  ): boolean => {
+    // Always return true, creating a circular flush
+    return true;
+  };
+
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: circularMatcher,
+  });
+
+  const app1: LogRecord = { ...debug, category: ["app1"] };
+  const app2: LogRecord = { ...debug, category: ["app2"] };
+  const app3: LogRecord = { ...debug, category: ["app3"] };
+  const trigger: LogRecord = { ...error, category: ["trigger"] };
+
+  sink(app1);
+  sink(app2);
+  sink(app3);
+  assertEquals(buffer.length, 0);
+
+  // Should flush all despite circular logic
+  sink(trigger);
+  assertEquals(buffer.length, 4);
+
+  // All buffers should be cleared after flush
+  const newDebug: LogRecord = { ...debug, category: ["new"] };
+  sink(newDebug);
+  assertEquals(buffer.length, 4); // New category should be buffered
+});
+
+test("fingersCrossed() - edge case: timestamps in wrong order", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "both",
+  });
+
+  const future: LogRecord = {
+    ...debug,
+    category: ["app"],
+    timestamp: Date.now() + 10000, // Future
+  };
+
+  const past: LogRecord = {
+    ...info,
+    category: ["app", "sub"],
+    timestamp: Date.now() - 10000, // Past
+  };
+
+  const present: LogRecord = {
+    ...warning,
+    category: ["app"],
+    timestamp: Date.now(),
+  };
+
+  const trigger: LogRecord = {
+    ...error,
+    category: ["app"],
+    timestamp: Date.now() + 5000,
+  };
+
+  // Add in random order
+  sink(future);
+  sink(past);
+  sink(present);
+
+  // Trigger
+  sink(trigger);
+
+  // Should be sorted by timestamp
+  assertEquals(buffer[0], past);
+  assertEquals(buffer[1], present);
+  assertEquals(buffer[2], future);
+  assertEquals(buffer[3], trigger);
+});
+
+test("fingersCrossed() - edge case: NaN and Infinity in timestamps", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "both",
+  });
+
+  const nanTime: LogRecord = {
+    ...debug,
+    category: ["app"],
+    timestamp: NaN,
+  };
+
+  const infinityTime: LogRecord = {
+    ...info,
+    category: ["app"],
+    timestamp: Infinity,
+  };
+
+  const negInfinityTime: LogRecord = {
+    ...warning,
+    category: ["app"],
+    timestamp: -Infinity,
+  };
+
+  const normalTime: LogRecord = {
+    ...error,
+    category: ["app"],
+    timestamp: 1000,
+  };
+
+  sink(nanTime);
+  sink(infinityTime);
+  sink(negInfinityTime);
+
+  // Should handle special values without crashing
+  sink(normalTime);
+
+  // Check all records are present (order might vary with NaN)
+  assertEquals(buffer.length, 4);
+  assert(buffer.includes(nanTime));
+  assert(buffer.includes(infinityTime));
+  assert(buffer.includes(negInfinityTime));
+  assert(buffer.includes(normalTime));
+});
+
+test("fingersCrossed() - edge case: undefined properties in record", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer));
+
+  const weirdRecord: LogRecord = {
+    ...debug,
+    properties: {
+      normal: "value",
+      undef: undefined,
+      nullish: null,
+      nan: NaN,
+      inf: Infinity,
+    },
+  };
+
+  sink(weirdRecord);
+  sink(error);
+
+  // Should preserve all properties as-is
+  assertEquals(buffer[0].properties, weirdRecord.properties);
+});
+
+test("fingersCrossed() - edge case: very deep category hierarchy", () => {
+  const buffer: LogRecord[] = [];
+  const sink = fingersCrossed(buffer.push.bind(buffer), {
+    isolateByCategory: "both",
+  });
+
+  // Create very deep hierarchy
+  const deepCategory = Array.from({ length: 100 }, (_, i) => `level${i}`);
+  const parentCategory = deepCategory.slice(0, 50);
+
+  const deepRecord: LogRecord = {
+    ...debug,
+    category: deepCategory,
+  };
+
+  const parentRecord: LogRecord = {
+    ...info,
+    category: parentCategory,
+  };
+
+  const deepError: LogRecord = {
+    ...error,
+    category: deepCategory,
+  };
+
+  sink(deepRecord);
+  sink(parentRecord);
+  assertEquals(buffer.length, 0);
+
+  // Should handle deep hierarchies
+  sink(deepError);
+
+  // Both should flush (ancestor relationship)
+  assertEquals(buffer.length, 3);
+  assert(buffer.includes(deepRecord));
+  assert(buffer.includes(parentRecord));
+  assert(buffer.includes(deepError));
+});