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>
78 lines
3.0 KiB
TypeScript
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();
|
|
});
|
|
});
|