Files
DongHyeonkaandClaude Opus 5.5 b2f37f05b0 fix(telemetry): evict buffered events only when that makes room (Q-6.9-11)
The buffer evicted lower-severity events one by one and only then found
the incoming event still did not fit, so both were lost (maxBytes 300,
info 50 + error 240, incoming warning 100: info evicted, warning
dropped). It now plans the evictions first (severity no higher than the
incoming one, lowest first, oldest first within a severity) and evicts
only if the plan frees enough room. The header comment now matches the
code: an event of the same severity is evicted, not only a lower one.

Verified: tests/platform/telemetry/telemetry-buffer.test.ts — the
review scenario RED before (info evicted), green after; same-severity
oldest-first eviction pinned. All gates PASS.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-24 13:58:35 +09:00

121 lines
4.5 KiB
TypeScript

import { describe, expect, it } from "vitest";
import { createTelemetryBuffer } from "../../../src/platform/telemetry/telemetry-buffer.ts";
import type { TelemetryEvent } from "../../../src/platform/telemetry/telemetry-event.ts";
import { createDeterministicSampler } from "../../../src/platform/telemetry/telemetry-sampler.ts";
const infoEvent = (id: string): TelemetryEvent<unknown> => ({
kind: "test.info",
severity: "info",
payload: { id },
});
const criticalEvent = (id: string): TelemetryEvent<unknown> => ({
kind: "test.critical",
severity: "critical",
payload: { id },
});
describe("createDeterministicSampler", () => {
it("makes the same sampling decision for the same stable key", () => {
const sampler = createDeterministicSampler({ rate: 0.1 });
expect(sampler.keep("interaction-123")).toBe(sampler.keep("interaction-123"));
});
it("approximates the configured rate over many keys", () => {
const sampler = createDeterministicSampler({ rate: 0.1 });
let kept = 0;
for (let i = 0; i < 10_000; i += 1) if (sampler.keep(`interaction-${i}`)) kept += 1;
expect(kept).toBeGreaterThan(700);
expect(kept).toBeLessThan(1_300);
});
it("is exact at the edges and rejects invalid rates", () => {
expect(createDeterministicSampler({ rate: 1 }).keep("x")).toBe(true);
expect(createDeterministicSampler({ rate: 0 }).keep("x")).toBe(false);
expect(() => createDeterministicSampler({ rate: 1.5 })).toThrow(TypeError);
expect(() => createDeterministicSampler({ rate: Number.NaN })).toThrow(TypeError);
});
});
describe("createTelemetryBuffer", () => {
it("never exceeds event or byte ceilings", () => {
const buffer = createTelemetryBuffer({
maxEvents: 2,
maxBytes: 1_024,
});
buffer.push(infoEvent("a"));
buffer.push(infoEvent("b"));
buffer.push(criticalEvent("c"));
expect(buffer.size).toBeLessThanOrEqual(2);
expect(buffer.bytes).toBeLessThanOrEqual(1_024);
expect(buffer.items.some((item) => item.severity === "critical")).toBe(true);
});
it("drops an incoming low-severity event rather than evicting a severe one", () => {
const buffer = createTelemetryBuffer({ maxEvents: 1, maxBytes: 1_024 });
buffer.push(criticalEvent("keep"));
expect(buffer.push(infoEvent("late"))).toBe(false);
expect(buffer.items).toEqual([criticalEvent("keep")]);
expect(buffer.dropped).toBe(1);
});
it("evicts nothing when eviction cannot make room for the incoming event (Q-6.9-11)", () => {
const at = (severity: TelemetryEvent<unknown>["severity"]) => ({
kind: `test.${severity}`,
severity,
});
const evicted: string[] = [];
const buffer = createTelemetryBuffer({
maxEvents: 10,
maxBytes: 300,
onEvict: (entry) => evicted.push(entry.event.severity),
});
buffer.push(at("info"), 50);
buffer.push(at("error"), 240);
// Dropping the info event frees 50 bytes; the warning needs 100.
expect(buffer.push(at("warning"), 100)).toBe(false);
expect(buffer.items.map((item) => item.severity)).toEqual(["info", "error"]);
expect(buffer.bytes).toBe(290);
expect(buffer.dropped).toBe(1);
expect(evicted).toEqual([]);
});
it("evicts the oldest event of the same severity to admit a new one", () => {
const buffer = createTelemetryBuffer({ maxEvents: 2, maxBytes: 1_024 });
buffer.push(infoEvent("a"));
buffer.push(infoEvent("b"));
expect(buffer.push(infoEvent("c"))).toBe(true);
expect(buffer.items).toEqual([infoEvent("b"), infoEvent("c")]);
expect(buffer.dropped).toBe(1);
});
it("enforces the byte ceiling independently of the event count", () => {
const buffer = createTelemetryBuffer({ maxEvents: 100, maxBytes: 200 });
for (let i = 0; i < 50; i += 1) buffer.push(infoEvent(`event-${i}`));
expect(buffer.bytes).toBeLessThanOrEqual(200);
expect(buffer.size).toBeLessThan(50);
});
it("rejects a single event larger than the byte ceiling", () => {
const buffer = createTelemetryBuffer({ maxEvents: 10, maxBytes: 64 });
expect(buffer.push(infoEvent("x".repeat(100)))).toBe(false);
expect(buffer.size).toBe(0);
});
it("hands batches out in FIFO order and releases their bytes", () => {
const buffer = createTelemetryBuffer({ maxEvents: 10, maxBytes: 10_000 });
buffer.push(infoEvent("a"));
buffer.push(infoEvent("b"));
buffer.push(infoEvent("c"));
const batch = buffer.take(2);
expect(batch.map((entry) => entry.event)).toEqual([infoEvent("a"), infoEvent("b")]);
expect(buffer.size).toBe(1);
buffer.take(10);
expect(buffer.bytes).toBe(0);
});
});