Files
DongHyeonkaandClaude Opus 5.5 6f2e97d482 fix(telemetry): deliver deduplicated occurrences to the collector (R-9.2)
With the default queueMicrotask scheduler the first event of a burst was
sent at once with occurrences=1, and every duplicate inside the 60s dedup
window only bumped counters.deduplicated, so 1000 identical errors reached
the collector as occurrences=1. An event dropped from the buffer also left
its fingerprint in the dedup table, suppressing that event for 60s.

Per D-6 the pipeline now holds duplicate counts per fingerprint. Held
counts are folded into a buffered item of the same fingerprint or ride as
summary items in the next batch; they get a batch of their own only on an
explicit flush() or when the dedup window closes (one window timer), so a
duplicate never triggers a send by itself. The held table is bounded by
maxFingerprints. A rejected or evicted event (new buffer onEvict hook) and
a sampled-out event forget their fingerprint (new
TelemetryDeduplicator.forget), so the next occurrence is admitted again
and a sampled-out event is never reported through a summary. Existing
signatures are unchanged; onEvict and forget are additive.

Test changes:
- tests/features/reference-feature/reference-telemetry.test.ts expected
  exactly one send for a 500-failure storm, which encoded the lost count;
  it now expects 2 sends whose occurrences sum to 500.
- telemetry-pipeline.test.ts:93 (auto flush off, 25 in one item) is kept
  as is and still passes.

RED before fix:
- "delivers every duplicate as occurrences with the default microtask
  scheduler" (sum was 1, expected 1000)
- "reports held duplicates when the dedup window closes without another
  flush" (no window timer armed)
- "does not let a rejected or evicted event suppress its fingerprint"
  (re-emitted event was deduplicated, not buffered)
- "never reports a sampled-out event through a duplicate summary"
  (sampledOut 1, expected 3)

Gates: check:architecture, check:types:app, check:types:test, lint,
test:component, check:release-coherence, test:platform pass; also
tests/scale/telemetry, tests/scale/session, tests/features/reference-feature
pass. test:unit passes except tests/unit/removal-fixture.test.ts, which
needs generated release evidence under artifacts/ that a fresh worktree
does not have (unrelated to this change).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-24 12:18:23 +09:00

78 lines
3.0 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import { createReferenceFeatureInput } from "../../../src/features/reference-feature/application/reference-feature-api.ts";
import { createFailure } from "../../../src/contracts/errors.ts";
import type { TelemetryPort } from "../../../src/platform/telemetry/telemetry-port.ts";
import {
createTelemetryPipeline,
type TelemetryTransport,
} from "../../../src/platform/telemetry/telemetry-pipeline.ts";
import { REFERENCE_FEATURE_ADAPTER_CONTRIBUTION } from "../../../src/features/reference-feature/adapters/create-reference-feature-input.ts";
function failingGateway() {
const failure = Object.freeze({
ok: false as const,
error: createFailure("REQUEST_TIMEOUT", "LIST_REFERENCE_RESOURCES", 0),
});
return Object.freeze({
list: vi.fn(async () => failure),
get: vi.fn(async () => failure),
create: vi.fn(async () => failure),
});
}
describe("reference feature telemetry through the platform port", () => {
it("declares the provider-neutral telemetry capability", () => {
expect(REFERENCE_FEATURE_ADAPTER_CONTRIBUTION.needs).toContain("telemetry");
});
it("emits a feature-owned event with a bounded payload on load failure", async () => {
const emit = vi.fn<TelemetryPort["emit"]>();
const input = createReferenceFeatureInput(failingGateway(), { telemetry: { emit } });
const result = await input.listResources({ limit: 20 });
expect(result.ok).toBe(false);
expect(emit).toHaveBeenCalledWith({
kind: "reference.load.failed",
severity: "warning",
featureId: "reference-feature",
payload: { operation: "list", reason: "REQUEST_TIMEOUT" },
});
});
it("returns the business result even when the port throws or rejects", async () => {
const throwing = createReferenceFeatureInput(failingGateway(), {
telemetry: {
emit() {
throw new Error("port broken");
},
},
});
const rejecting = createReferenceFeatureInput(failingGateway(), {
telemetry: { emit: () => Promise.reject(new Error("collector down")) },
});
await expect(throwing.getResource("id-1")).resolves.toMatchObject({ ok: false });
await expect(rejecting.getResource("id-1")).resolves.toMatchObject({ ok: false });
});
it("collapses a failure storm into bounded sends via the pipeline", async () => {
const send = vi.fn<TelemetryTransport["send"]>();
const pipeline = createTelemetryPipeline({ transport: { send } });
const input = createReferenceFeatureInput(failingGateway(), { telemetry: pipeline });
for (let i = 0; i < 500; i += 1) await input.listResources({ limit: 20 });
await pipeline.flush();
// The first failure goes out at once; the 499 duplicates ride on the flush.
expect(send).toHaveBeenCalledTimes(2);
const occurrences = send.mock.calls
.flatMap(([batch]) => batch)
.reduce((sum, item) => sum + item.occurrences, 0);
expect(occurrences).toBe(500);
expect(pipeline.stats().deduplicated).toBe(499);
pipeline.dispose();
});
});