deepdebug-local-agent 1.6.0 → 1.8.0

package/test/incident-detector/parity.test.js

@@ -0,0 +1,66 @@
+/**
+ * F3-11b: the Node detector against vectors generated from the Java code (scripts/incident-parity/gen.sh).
+ * Every field of every case must match byte for byte: errorHash (group hash), group key, fingerprint, errorType, first user
+ * frame, normalised message/frame, significance, noise class; and the natural-key dedup (LogEntryDedup).
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+    computeGroupHash, normalizeGroupKey, computeFingerprint, extractErrorType, extractFirstUserFrame, normaliseMessage, normaliseFrame,
+    isSignificant, classifyNoise, naturalKey,
+} from "../../src/incident-detector/normalize.js";
+
+const VECTORS = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), "parity.vectors.json"), "utf8"));
+const nl = (v) => (v === undefined ? null : v);
+
+test("the vector file says where it came from and is big enough to mean something", () => {
+    assert.equal(VECTORS.schema, "incident-parity-vectors/1");
+    assert.match(VECTORS.source.commit, /^[0-9a-f]{40}$/);
+    assert.ok(Object.keys(VECTORS.source.files).length >= 5);
+    assert.ok(VECTORS.cases.length >= 100, `${VECTORS.cases.length} cases`);
+    assert.ok(VECTORS.dedup.length >= 5);
+});
+
+for (const c of VECTORS.cases) {
+    test(`parity: ${c.name}`, () => {
+        const e = c.expect;
+        const message = nl(c.message);
+        const stack = nl(c.stack);
+        assert.equal(isSignificant({ severity: c.severity, message, stacktrace: stack }), e.significant, "significant");
+        assert.equal(normalizeGroupKey(message == null ? "" : message.split("\n")[0]), e.groupKey, "groupKey");
+        assert.equal(computeGroupHash(message), e.groupHash, "errorHash");
+        assert.equal(extractErrorType(message, stack), e.errorType, "errorType");
+        assert.equal(extractFirstUserFrame(stack), e.firstFrame, "firstFrame");
+        assert.equal(normaliseMessage(message), e.normalisedMessage, "normalisedMessage");
+        assert.equal(normaliseFrame(e.firstFrame), e.normalisedFrame, "normalisedFrame");
+        assert.equal(computeFingerprint(message, stack), e.fingerprint, "fingerprint");
+        assert.equal(classifyNoise(message), e.noiseClass, "noiseClass");
+    });
+}
+
+for (const d of VECTORS.dedup) {
+    test(`parity dedup: ${d.name}`, () => {
+        const nanos = (iso) => {
+            if (iso == null) return null;
+            const m = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?Z$/.exec(iso);
+            assert.ok(m, iso);
+            return BigInt(Date.parse(`${m[1]}Z`)) * 1_000_000n + BigInt((m[2] || "").padEnd(9, "0"));
+        };
+        const keys = d.entries.map((x) => naturalKey(x.service, nanos(x.ts), x.message));
+        assert.deepEqual(keys, d.keys, "natural keys");
+        // filterNew: drop what is known or repeated inside the batch; an entry without a key is always kept
+        const known = new Set(d.known);
+        const seen = new Set();
+        const kept = [];
+        keys.forEach((k, i) => {
+            if (k == null) { kept.push(i); return; }
+            if (known.has(k) || seen.has(k)) return;
+            seen.add(k);
+            kept.push(i);
+        });
+        assert.deepEqual(kept, d.kept, "kept entries");
+    });
+}