@oneuptime/common 12.0.5 → 12.0.7

package/Tests/Server/Utils/Telemetry/TelemetryFanInWriter.test.ts

@@ -828,6 +828,134 @@ describe("TelemetryFanInWriter", () => {
       expect(target.insertJsonRows).toHaveBeenCalledTimes(1);
       expect(callOptions(target, 0).clickhouseSettings).toBe(settingsFirst);
     });
+
+    /*
+     * The production shape after the batched-inserts change: one table can
+     * receive tokened submissions (low-volume signals like syslog, still
+     * inside runWithInsertDedup) and untokened ones (traces/logs/metrics)
+     * in the same flush window. Tokened submissions must keep per-job
+     * statement granularity; the untokened remainder must collapse into
+     * one minted-token statement.
+     */
+    test("mixed tokened/untokened batch: tokened submissions insert individually under their tokens, the untokened remainder merges under one minted token", async () => {
+      const target: TestTarget = makeTarget();
+      const writer: TelemetryFanInWriter = new TelemetryFanInWriter(
+        makeOptions({ maxBatchRows: 8, maxWaitMs: 60_000 }),
+      );
+
+      const tokenedFirst: FanInSubmitResult = await runWithInsertDedup(
+        "job-a",
+        () => {
+          return writer.submit(target, makeRows(2));
+        },
+      );
+      /*
+       * TWO untokened submissions, not one: merging a single-element group is
+       * indistinguishable from inserting it alone, so one would make the
+       * "merges" half of this assertion vacuous — a regression to
+       * one-statement-per-submission would still produce the same call count.
+       */
+      const untokenedFirst: FanInSubmitResult = await writer.submit(
+        target,
+        makeRows(2, 2),
+      );
+      const untokenedSecond: FanInSubmitResult = await writer.submit(
+        target,
+        makeRows(2, 4),
+      );
+      // Reaching maxBatchRows (8) cuts and dispatches the batch.
+      const tokenedSecond: FanInSubmitResult = await runWithInsertDedup(
+        "job-b",
+        () => {
+          return writer.submit(target, makeRows(2, 6));
+        },
+      );
+
+      await Promise.all([
+        tokenedFirst.flushed,
+        untokenedFirst.flushed,
+        untokenedSecond.flushed,
+        tokenedSecond.flushed,
+      ]);
+
+      /*
+       * Exactly three statements for four submissions: each tokened
+       * submission alone under its deterministic per-job token (in batch
+       * order), then BOTH untokened submissions collapsed into one statement
+       * under a single minted fanin: token.
+       */
+      expect(target.insertJsonRows).toHaveBeenCalledTimes(3);
+
+      expect(callOptions(target, 0).dedupToken).toBe("job-a:TestTable:0");
+      expect(rowSeqs(callRows(target, 0))).toEqual([0, 1]);
+
+      expect(callOptions(target, 1).dedupToken).toBe("job-b:TestTable:0");
+      expect(rowSeqs(callRows(target, 1))).toEqual([6, 7]);
+
+      expect(callOptions(target, 2).dedupToken).toMatch(/^fanin:TestTable:/);
+      expect(rowSeqs(callRows(target, 2))).toEqual([2, 3, 4, 5]);
+    });
+
+    test("mixed batch failure isolation: the merged untokened statement failing rejects ALL its submissions with one shared error; tokened ones in the same batch still succeed", async () => {
+      const target: TestTarget = makeTarget({
+        impl: async (
+          _rows: Array<JSONObject>,
+          options?: InsertRowsOptions,
+        ): Promise<void> => {
+          if (options?.dedupToken?.startsWith("fanin:")) {
+            // Non-retryable: plain error with no recognized code/message.
+            throw new Error("merged statement rejected");
+          }
+        },
+      });
+      const writer: TelemetryFanInWriter = new TelemetryFanInWriter(
+        makeOptions({ maxBatchRows: 6, maxWaitMs: 60_000 }),
+      );
+
+      const tokened: FanInSubmitResult = await runWithInsertDedup(
+        "job-a",
+        () => {
+          return writer.submit(target, makeRows(2));
+        },
+      );
+      const untokenedFirst: FanInSubmitResult = await writer.submit(
+        target,
+        makeRows(2, 2),
+      );
+      const untokenedSecond: FanInSubmitResult = await writer.submit(
+        target,
+        makeRows(2, 4),
+      );
+
+      // The tokened submission's ack resolves even though its batch-mate failed.
+      await tokened.flushed;
+
+      const errFirst: Error = await captureRejection(untokenedFirst.flushed);
+      const errSecond: Error = await captureRejection(untokenedSecond.flushed);
+
+      expect(errFirst).toBeInstanceOf(FanInInsertError);
+      expect(errFirst.message).toContain("merged statement rejected");
+      expect(errFirst.message).toContain("after 1 attempt(s)");
+      /*
+       * The SAME error instance reaches both untokened acks — that identity
+       * is what proves they shared one merged statement rather than each
+       * failing its own.
+       */
+      expect(errSecond).toBe(errFirst);
+
+      // Two statements: the tokened one (ok) and the merged untokened one (failed).
+      expect(target.insertJsonRows).toHaveBeenCalledTimes(2);
+      expect(callOptions(target, 0).dedupToken).toBe("job-a:TestTable:0");
+      expect(callOptions(target, 1).dedupToken).toMatch(/^fanin:TestTable:/);
+      expect(rowSeqs(callRows(target, 1))).toEqual([2, 3, 4, 5]);
+
+      // Failure still drains the writer's accounting.
+      expect(writer.getStats()).toEqual({
+        bufferedRows: 0,
+        pendingRows: 0,
+        activeInserts: 0,
+      });
+    });
   });
 });
 

package/Tests/Server/Utils/Telemetry/TelemetryUtilAttributeKeys.test.ts

@@ -0,0 +1,381 @@
+/*
+ * These tests exercise pure attribute-key helpers only — nothing here
+ * touches Postgres. Stub the DatabaseService base class out before
+ * TelemetryUtil's import graph (MetricTypeService -> DatabaseService ->
+ * PasswordHash, which has a known TS5.9 compile failure under ts-jest)
+ * drags the whole server-side service layer into the suite. Mirrors
+ * App/Tests/Telemetry/MetricRowIngestionStamp.test.ts.
+ */
+jest.mock("../../../../Server/Services/DatabaseService", () => {
+  /*
+   * Service constructors touch a little base-class API before any database
+   * work happens, so the stub has to answer it. `hardDeleteItemsOlderThanInDays`
+   * is the one that bites: ~100 services call it from their constructor, but
+   * only `if (IsBillingEnabled)` — which is off in a plain local checkout and
+   * ON in CI (Common/test-setup.sh writes BILLING_ENABLED=true). A bare
+   * `class {}` therefore passes locally and dies in CI the moment this test's
+   * import graph reaches one of those services, with a suite-level
+   * "hardDeleteItemsOlderThanInDays is not a function" and no failing test to
+   * point at. Anything genuinely used by the code under test belongs in the
+   * test's own mocks, not here.
+   */
+  return {
+    __esModule: true,
+    default: class DatabaseServiceStub {
+      public hardDeleteItemsOlderThanInDays(): void {
+        // no-op: retention config, nothing for a pure unit test to do.
+      }
+
+      public setDoNotAllowDelete(): void {
+        // no-op: delete-permission config, same.
+      }
+    },
+  };
+});
+
+import TelemetryUtil, {
+  AttributeType,
+} from "../../../../Server/Utils/Telemetry/Telemetry";
+import Dictionary from "../../../../Types/Dictionary";
+import { JSONObject } from "../../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The two helpers the OTel ingest hot-path restructure leans on:
+ *
+ *   1. mergeAttributeKeysWithSortedBase — the per-datapoint replacement for
+ *      `Object.keys(mergedAttributes).sort()`. Its whole contract is ORDER
+ *      IDENTITY with the full sort: metric rows store attributeKeys sorted,
+ *      and the pipeline rule engine re-sorts after attribute mutations, so
+ *      any divergence between "merge of two sorted lists" and "sort of the
+ *      union" would make rule-touched and untouched rows disagree. Every
+ *      test here therefore asserts against the reference derivation
+ *      (`Object.keys(Object.assign({}, base, extra)).sort()`), not against
+ *      hand-written expectations that could encode the same mistake twice.
+ *
+ *   2. getPrefixedScopeAttributes — the once-per-scope replacement for the
+ *      per-record `scope.` prefix loop the three ingest services carried.
+ */
+
+type MergeInput = {
+  sortedBaseAttributeKeys: Array<string>;
+  additionalAttributeKeys: Array<string>;
+};
+
+function referenceSortedUnion(
+  baseKeys: Array<string>,
+  additionalKeys: Array<string>,
+): Array<string> {
+  const union: Record<string, boolean> = {};
+  for (const key of baseKeys) {
+    union[key] = true;
+  }
+  for (const key of additionalKeys) {
+    union[key] = true;
+  }
+  return Object.keys(union).sort();
+}
+
+function merge(data: MergeInput): Array<string> {
+  return TelemetryUtil.mergeAttributeKeysWithSortedBase(data);
+}
+
+describe("TelemetryUtil.mergeAttributeKeysWithSortedBase", () => {
+  test("empty additional keys returns the base list content unchanged", () => {
+    const base: Array<string> = ["a", "b", "c"];
+
+    expect(
+      merge({ sortedBaseAttributeKeys: base, additionalAttributeKeys: [] }),
+    ).toEqual(["a", "b", "c"]);
+  });
+
+  test("empty additional keys returns a FRESH array, never the base reference", () => {
+    /*
+     * Rows must not share an attributeKeys array: pipeline rules replace a
+     * row's key list independently of its siblings, and the base list is
+     * reused for every datapoint of a metric.
+     */
+    const base: Array<string> = ["a", "b"];
+    const merged: Array<string> = merge({
+      sortedBaseAttributeKeys: base,
+      additionalAttributeKeys: [],
+    });
+
+    expect(merged).not.toBe(base);
+    merged.push("mutated");
+    expect(base).toEqual(["a", "b"]);
+  });
+
+  test("does not mutate either input list", () => {
+    const base: Array<string> = ["a", "m", "z"];
+    const additional: Array<string> = ["c", "b"];
+
+    merge({
+      sortedBaseAttributeKeys: base,
+      additionalAttributeKeys: additional,
+    });
+
+    expect(base).toEqual(["a", "m", "z"]);
+    // In particular the internal sort must run on a copy.
+    expect(additional).toEqual(["c", "b"]);
+  });
+
+  test("interleaved keys merge into the exact full-sort order", () => {
+    const base: Array<string> = ["alpha", "gamma", "omega"];
+    const additional: Array<string> = ["zeta", "beta", "delta"];
+
+    expect(
+      merge({
+        sortedBaseAttributeKeys: base,
+        additionalAttributeKeys: additional,
+      }),
+    ).toEqual(referenceSortedUnion(base, additional));
+  });
+
+  test("a per-row key overriding a base key appears exactly once", () => {
+    const base: Array<string> = ["resource.service.name", "shared.key"];
+    const additional: Array<string> = ["shared.key", "datapoint.only"];
+
+    const merged: Array<string> = merge({
+      sortedBaseAttributeKeys: base,
+      additionalAttributeKeys: additional,
+    });
+
+    expect(merged).toEqual(referenceSortedUnion(base, additional));
+    expect(
+      merged.filter((key: string) => {
+        return key === "shared.key";
+      }),
+    ).toHaveLength(1);
+  });
+
+  test("all additional keys sorting before the base keys", () => {
+    const base: Array<string> = ["x", "y", "z"];
+    const additional: Array<string> = ["c", "a", "b"];
+
+    expect(
+      merge({
+        sortedBaseAttributeKeys: base,
+        additionalAttributeKeys: additional,
+      }),
+    ).toEqual(["a", "b", "c", "x", "y", "z"]);
+  });
+
+  test("all additional keys sorting after the base keys", () => {
+    const base: Array<string> = ["a", "b"];
+    const additional: Array<string> = ["z", "y"];
+
+    expect(
+      merge({
+        sortedBaseAttributeKeys: base,
+        additionalAttributeKeys: additional,
+      }),
+    ).toEqual(["a", "b", "y", "z"]);
+  });
+
+  test("empty base list yields the sorted additional keys", () => {
+    expect(
+      merge({
+        sortedBaseAttributeKeys: [],
+        additionalAttributeKeys: ["b", "a"],
+      }),
+    ).toEqual(["a", "b"]);
+  });
+
+  test("both lists empty yields an empty list", () => {
+    expect(
+      merge({ sortedBaseAttributeKeys: [], additionalAttributeKeys: [] }),
+    ).toEqual([]);
+  });
+
+  test("UTF-16 code-unit ordering matches the default sort (uppercase before lowercase, multibyte last)", () => {
+    /*
+     * The default Array.prototype.sort comparator orders by UTF-16 code
+     * units: "Z" (0x5A) < "a" (0x61) < "é" (0xE9) < "日" (0x65E5). The
+     * merge relies on `<`/`>` applying the same ordering — this test fails
+     * if anyone "fixes" either side to use localeCompare.
+     */
+    const base: Array<string> = ["Zebra", "apple"].sort();
+    const additional: Array<string> = ["日本語", "é-accent", "Banana"];
+
+    expect(
+      merge({
+        sortedBaseAttributeKeys: base,
+        additionalAttributeKeys: additional,
+      }),
+    ).toEqual(referenceSortedUnion(base, additional));
+  });
+
+  test("integer-like keys follow string sort order, not the Object.keys numeric-first order", () => {
+    /*
+     * Object.keys lists integer-like keys first in ascending numeric order
+     * ("2" before "10"), but the stored attributeKeys was always the
+     * SORTED list, where "10" < "2" lexicographically. The merge must
+     * reproduce the sorted view.
+     */
+    const attributes: Dictionary<AttributeType> = {
+      "10": "ten",
+      "2": "two",
+      name: "x",
+    };
+    const base: Array<string> = Object.keys(attributes).sort();
+    const additional: Array<string> = ["11", "1"];
+
+    expect(
+      merge({
+        sortedBaseAttributeKeys: base,
+        additionalAttributeKeys: additional,
+      }),
+    ).toEqual(referenceSortedUnion(base, additional));
+  });
+
+  test("randomized inputs always equal the reference full sort (order included)", () => {
+    /*
+     * Deterministic pseudo-random sweep: many shapes of overlap, sizes and
+     * key alphabets, each checked element-for-element against the
+     * reference derivation the old per-datapoint code used.
+     */
+    let seed: number = 42;
+    const nextRandom: () => number = (): number => {
+      // Park-Miller minimal standard PRNG — deterministic across runs.
+      seed = (seed * 16807) % 2147483647;
+      return seed / 2147483647;
+    };
+
+    const alphabet: Array<string> = [
+      "a",
+      "B",
+      "resource.service.name",
+      "scope.name",
+      "http.status_code",
+      "0",
+      "10",
+      "2",
+      "é",
+      "日本",
+      "_underscore",
+      "UPPER",
+      "shared.key",
+      "z.last",
+    ];
+
+    for (let round: number = 0; round < 200; round++) {
+      const baseSet: Record<string, boolean> = {};
+      const additionalSet: Record<string, boolean> = {};
+
+      for (const key of alphabet) {
+        if (nextRandom() < 0.5) {
+          baseSet[key] = true;
+        }
+        if (nextRandom() < 0.3) {
+          additionalSet[key] = true;
+        }
+      }
+
+      const base: Array<string> = Object.keys(baseSet).sort();
+      const additional: Array<string> = Object.keys(additionalSet);
+
+      expect(
+        merge({
+          sortedBaseAttributeKeys: base,
+          additionalAttributeKeys: additional,
+        }),
+      ).toEqual(referenceSortedUnion(base, additional));
+    }
+  });
+});
+
+describe("TelemetryUtil.getPrefixedScopeAttributes", () => {
+  test("prefixes every scope key with 'scope.'", () => {
+    const scope: JSONObject = {
+      name: "my-instrumentation",
+      version: "1.2.3",
+    };
+
+    expect(TelemetryUtil.getPrefixedScopeAttributes(scope)).toEqual({
+      "scope.name": "my-instrumentation",
+      "scope.version": "1.2.3",
+    });
+  });
+
+  test("preserves values verbatim, including non-string ones", () => {
+    /*
+     * The historical inline loop cast whatever the scope object carried
+     * (`scopeAttributes[key] as AttributeType`) without transforming it —
+     * the helper must not start coercing.
+     */
+    const nested: JSONObject = { droppedAttributesCount: 0 };
+    const scope: JSONObject = {
+      name: "scope-with-odd-values",
+      attributes: nested,
+      flag: true,
+      count: 7,
+    };
+
+    const prefixed: Dictionary<AttributeType | Array<AttributeType>> =
+      TelemetryUtil.getPrefixedScopeAttributes(scope);
+
+    expect(prefixed["scope.name"]).toBe("scope-with-odd-values");
+    expect(prefixed["scope.attributes"]).toBe(
+      nested as unknown as AttributeType,
+    );
+    expect(prefixed["scope.flag"]).toBe(true);
+    expect(prefixed["scope.count"]).toBe(7);
+  });
+
+  test("undefined, null and empty scopes all produce an empty map", () => {
+    expect(TelemetryUtil.getPrefixedScopeAttributes(undefined)).toEqual({});
+    expect(TelemetryUtil.getPrefixedScopeAttributes(null)).toEqual({});
+    expect(TelemetryUtil.getPrefixedScopeAttributes({})).toEqual({});
+  });
+
+  test("returns a fresh object per call (scopes must not share prefixed maps)", () => {
+    const first: Dictionary<AttributeType | Array<AttributeType>> =
+      TelemetryUtil.getPrefixedScopeAttributes({});
+    const second: Dictionary<AttributeType | Array<AttributeType>> =
+      TelemetryUtil.getPrefixedScopeAttributes({});
+
+    expect(first).not.toBe(second);
+  });
+
+  test("merging the prefixed map last reproduces the historical per-record loop", () => {
+    /*
+     * The ingest services replaced `spread resource+record attrs, then loop
+     * scope keys in` with `Object.assign({}, resource, record, prefixed)`.
+     * Equivalence proof at the helper level: same winners on collision and
+     * same key insertion order as the loop-based construction.
+     */
+    const resourceAttributes: Dictionary<AttributeType> = {
+      "resource.service.name": "svc",
+      "scope.name": "resource-level-collision",
+    };
+    const recordAttributes: Dictionary<AttributeType> = {
+      "http.method": "GET",
+      "scope.name": "record-level-collision",
+    };
+    const scope: JSONObject = { name: "the-scope", version: "9" };
+
+    // Historical construction.
+    const legacy: Dictionary<AttributeType> = {
+      ...resourceAttributes,
+      ...recordAttributes,
+    };
+    for (const key of Object.keys(scope)) {
+      legacy[`scope.${key}`] = scope[key] as AttributeType;
+    }
+
+    // New construction.
+    const merged: Dictionary<AttributeType | Array<AttributeType>> =
+      Object.assign(
+        {},
+        resourceAttributes,
+        recordAttributes,
+        TelemetryUtil.getPrefixedScopeAttributes(scope),
+      );
+
+    expect(merged).toEqual(legacy);
+    expect(Object.keys(merged)).toEqual(Object.keys(legacy));
+    // Scope wins the collision, exactly as the loop-based code had it.
+    expect(merged["scope.name"]).toBe("the-scope");
+  });
+});

package/Tests/Server/Utils/Telemetry.test.ts

@@ -74,6 +74,55 @@ describe("Telemetry.getExceptionAttributes", () => {
     expect(typeof attributes["exception.stacktrace"]).toBe("string");
   });
 
+  /*
+   * exception.type is the exception's identity downstream: it is hashed into
+   * the TelemetryException group fingerprint and it is what the Issues list
+   * and the AI insight titles show. An Error subclass that never assigns
+   * `this.name` inherits the generic "Error" from Error.prototype — which is
+   * every exception OneUptime raises — so the constructor name is the one
+   * that carries information.
+   */
+  test("a subclass that never sets `name` is typed by its constructor, not 'Error'", () => {
+    class NotAuthenticatedException extends Error {
+      public code: number = 401;
+    }
+
+    const attributes: ExceptionAttributes = getAttributes(
+      new NotAuthenticatedException("Authenticated user is needed"),
+    );
+
+    expect(attributes["exception.type"]).toBe("NotAuthenticatedException");
+  });
+
+  test("an explicit name still wins over the constructor", () => {
+    const error: Error = new Error("boom");
+    error.name = "ValidationError";
+
+    expect(getAttributes(error)["exception.type"]).toBe("ValidationError");
+  });
+
+  /*
+   * Node system errors carry a descriptive string code; HTTP statuses and
+   * Postgres SQLSTATEs carry a numeric one that says less than the class.
+   */
+  test("a descriptive string code is used, a numeric one is not", () => {
+    const systemError: Error = Object.assign(new Error("connect failed"), {
+      code: "ECONNREFUSED",
+    });
+    expect(getAttributes(systemError)["exception.type"]).toBe("ECONNREFUSED");
+
+    class ServerException extends Error {
+      public code: number = 500;
+    }
+    expect(getAttributes(new ServerException("boom"))["exception.type"]).toBe(
+      "ServerException",
+    );
+    // The numeric code is not lost — it keeps its own attribute.
+    expect(getAttributes(new ServerException("boom"))["exception.code"]).toBe(
+      "500",
+    );
+  });
+
   test("handles a thrown string", () => {
     const attributes: ExceptionAttributes = getAttributes("kaboom");
 
@@ -229,6 +278,44 @@ describe("Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan", () => {
     expect((state.attributes || {})["exception.message"]).toBe("kaboom");
   });
 
+  /*
+   * THE REGRESSION THIS GUARDS. The OTel SDK reads `exception.code` BEFORE
+   * `exception.name` when it derives the exception event's `exception.type`,
+   * and OneUptime's Exception base exposes an HTTP STATUS as `code`. Handing
+   * the raw thrown value to recordException therefore typed every exception
+   * this platform raises "401"/"400"/"500" — which is hashed into the
+   * TelemetryException group fingerprint and rendered as the AI insight
+   * title, collapsing a service's unrelated failures into one indistinct row.
+   * A normalized {name, message, stack} has no `code` for the SDK to prefer.
+   */
+  test("records a normalized exception so the SDK cannot type it by an HTTP status", () => {
+    class NotAuthenticatedException extends Error {
+      public code: number = 401;
+    }
+
+    const state: FakeSpanState = {
+      attributes: null,
+      status: null,
+      recorded: null,
+      ended: 0,
+    };
+
+    Telemetry.recordExceptionMarkSpanAsErrorAndEndSpan({
+      span: makeFakeSpan(state),
+      exception: new NotAuthenticatedException("needs an API key"),
+    });
+
+    const recorded: Record<string, unknown> = state.recorded as Record<
+      string,
+      unknown
+    >;
+
+    expect(recorded["code"]).toBeUndefined();
+    expect(recorded["name"]).toBe("NotAuthenticatedException");
+    expect(recorded["message"]).toBe("needs an API key");
+    expect(typeof recorded["stack"]).toBe("string");
+  });
+
   test("still ends and flags the span even if a span write throws", () => {
     const state: FakeSpanState = {
       attributes: null,