@oneuptime/common 12.0.12 → 12.0.14

package/Tests/Types/Service/ServiceLanguage.test.ts

@@ -0,0 +1,255 @@
+import {
+  SERVICE_LANGUAGE_DISPLAY_NAMES,
+  ServiceLanguage,
+  detectServiceLanguage,
+} from "../../../Types/Service/ServiceLanguage";
+import TechStack from "../../../Types/Service/TechStack";
+
+/*
+ * Which runtime a service is written in, decided from three sources of
+ * evidence of decreasing trustworthiness.
+ *
+ * This used to only pick which charts to draw on the service overview, where
+ * a wrong answer is a chart with no data in it. It now also picks which
+ * monitors OneUptime recommends, where a wrong answer is a monitor that
+ * queries a metric the service never emits and therefore never fires — a
+ * silent gap that reads as coverage. Every case below is about the difference
+ * between "we know" and "we are guessing".
+ */
+
+const ALL_LANGUAGES: Array<ServiceLanguage> = Object.keys(
+  SERVICE_LANGUAGE_DISPLAY_NAMES,
+) as Array<ServiceLanguage>;
+
+describe("detectServiceLanguage", () => {
+  describe("precedence between the three sources", () => {
+    /*
+     * The order is not arbitrary. `telemetry.sdk.language` is stamped by the
+     * SDK inside the process, so it describes what the process actually runs
+     * on. `process.runtime.name` is the same information one hop later.
+     * The tech stack is a human's answer typed into a form, which can be
+     * months out of date. Each test below sets up a deliberate disagreement
+     * so the winner is unambiguous.
+     */
+    it("prefers the SDK language over the runtime name", () => {
+      expect(
+        detectServiceLanguage({
+          telemetrySdkLanguage: "go",
+          runtimeName: "OpenJDK Runtime Environment",
+        }),
+      ).toBe("go");
+    });
+
+    it("prefers the SDK language over the tech stack", () => {
+      expect(
+        detectServiceLanguage({
+          telemetrySdkLanguage: "python",
+          techStack: [TechStack.Java],
+        }),
+      ).toBe("python");
+    });
+
+    it("prefers the runtime name over the tech stack", () => {
+      expect(
+        detectServiceLanguage({
+          runtimeName: "node",
+          techStack: [TechStack.Java],
+        }),
+      ).toBe("nodejs");
+    });
+
+    it("falls through to the tech stack when telemetry says nothing", () => {
+      expect(
+        detectServiceLanguage({
+          techStack: [TechStack.Rust],
+        }),
+      ).toBe("rust");
+    });
+  });
+
+  describe("the SDK language attribute", () => {
+    it.each(ALL_LANGUAGES)("recognises %s", (language: ServiceLanguage) => {
+      expect(detectServiceLanguage({ telemetrySdkLanguage: language })).toBe(
+        language,
+      );
+    });
+
+    it("is matched case-insensitively and ignores surrounding whitespace", () => {
+      expect(
+        detectServiceLanguage({ telemetrySdkLanguage: "  DotNet  " }),
+      ).toBe("dotnet");
+    });
+
+    /*
+     * The important negative case. An unrecognised value must NOT be returned
+     * verbatim — it would be a string that looks like a `ServiceLanguage` to
+     * every consumer and matches no template set, so the recommendations page
+     * would show nothing at all rather than the language-agnostic set.
+     */
+    it("does not pass an unrecognised SDK language through", () => {
+      expect(
+        detectServiceLanguage({ telemetrySdkLanguage: "cobol" }),
+      ).toBeNull();
+    });
+
+    it("falls through to the other sources when the SDK language is unknown", () => {
+      expect(
+        detectServiceLanguage({
+          telemetrySdkLanguage: "cobol",
+          techStack: [TechStack.Go],
+        }),
+      ).toBe("go");
+    });
+  });
+
+  describe("the runtime name markers", () => {
+    it.each([
+      ["OpenJDK 64-Bit Server VM", "java"],
+      ["GraalVM CE", "java"],
+      ["Java HotSpot(TM) 64-Bit Server VM", "java"],
+      [".NET 9.0.0", "dotnet"],
+      ["dotnet", "dotnet"],
+      ["node", "nodejs"],
+      ["Deno", "nodejs"],
+      ["bun", "nodejs"],
+      ["CPython", "python"],
+      ["PyPy", "python"],
+      ["BEAM", "erlang"],
+      ["Erlang/OTP 26", "erlang"],
+      ["ruby", "ruby"],
+      ["PHP 8.3", "php"],
+      ["rustc", "rust"],
+      ["swift", "swift"],
+      ["go", "go"],
+    ])(
+      "maps runtime name %s to %s",
+      (runtimeName: string, expected: string) => {
+        expect(detectServiceLanguage({ runtimeName: runtimeName })).toBe(
+          expected,
+        );
+      },
+    );
+
+    /*
+     * `go` is a two-letter substring, so it appears inside plenty of words —
+     * "GraalVM" does not contain it, but the ordering still matters and this
+     * pins it: the JVM markers are checked first, so a runtime string that
+     * contains both loses to the more specific one.
+     */
+    it("checks specific markers before the two-letter go marker", () => {
+      expect(
+        detectServiceLanguage({ runtimeName: "GraalVM for Go interop" }),
+      ).toBe("java");
+    });
+
+    it("returns null for a runtime name it does not recognise", () => {
+      expect(detectServiceLanguage({ runtimeName: "SomeVM 1.0" })).toBeNull();
+    });
+  });
+
+  describe("the tech stack fallback", () => {
+    it("maps Kotlin to java, because the runtime is what matters", () => {
+      expect(detectServiceLanguage({ techStack: [TechStack.Kotlin] })).toBe(
+        "java",
+      );
+    });
+
+    it("maps C# to dotnet", () => {
+      expect(detectServiceLanguage({ techStack: [TechStack.CSharp] })).toBe(
+        "dotnet",
+      );
+    });
+
+    it.each([TechStack.TypeScript, TechStack.JavaScript, TechStack.NodeJS])(
+      "maps %s to nodejs",
+      (techStack: TechStack) => {
+        expect(detectServiceLanguage({ techStack: [techStack] })).toBe(
+          "nodejs",
+        );
+      },
+    );
+
+    it("maps React to webjs rather than to nodejs", () => {
+      expect(detectServiceLanguage({ techStack: [TechStack.React] })).toBe(
+        "webjs",
+      );
+    });
+
+    it("takes the first entry that maps to a runtime", () => {
+      expect(
+        detectServiceLanguage({
+          techStack: [TechStack.Shell, TechStack.Markdown, TechStack.Go],
+        }),
+      ).toBe("go");
+    });
+
+    it.each([TechStack.Shell, TechStack.Markdown, TechStack.Other])(
+      "does not invent a runtime for %s",
+      (techStack: TechStack) => {
+        expect(detectServiceLanguage({ techStack: [techStack] })).toBeNull();
+      },
+    );
+  });
+
+  describe("when nothing identifies the runtime", () => {
+    /*
+     * Null, never a default. A default would hand every unidentified service
+     * one language's recommendations — monitors on metrics it does not emit,
+     * presented as if OneUptime had established what it runs on.
+     */
+    it("returns null for no input at all", () => {
+      expect(detectServiceLanguage({})).toBeNull();
+    });
+
+    it("returns null for empty strings and an empty tech stack", () => {
+      expect(
+        detectServiceLanguage({
+          telemetrySdkLanguage: "",
+          runtimeName: "",
+          techStack: [],
+        }),
+      ).toBeNull();
+    });
+
+    it("returns null for whitespace-only telemetry values", () => {
+      expect(
+        detectServiceLanguage({
+          telemetrySdkLanguage: "   ",
+          runtimeName: "  ",
+        }),
+      ).toBeNull();
+    });
+
+    it("returns null for explicitly undefined fields", () => {
+      expect(
+        detectServiceLanguage({
+          telemetrySdkLanguage: undefined,
+          runtimeName: undefined,
+          techStack: undefined,
+        }),
+      ).toBeNull();
+    });
+  });
+});
+
+describe("SERVICE_LANGUAGE_DISPLAY_NAMES", () => {
+  it("names every language, non-blank", () => {
+    expect(ALL_LANGUAGES.length).toBeGreaterThan(0);
+
+    for (const language of ALL_LANGUAGES) {
+      expect(
+        SERVICE_LANGUAGE_DISPLAY_NAMES[language].trim().length,
+      ).toBeGreaterThan(0);
+    }
+  });
+
+  it("gives each language a distinct display name", () => {
+    const names: Array<string> = ALL_LANGUAGES.map(
+      (language: ServiceLanguage) => {
+        return SERVICE_LANGUAGE_DISPLAY_NAMES[language];
+      },
+    );
+
+    expect(new Set<string>(names).size).toBe(names.length);
+  });
+});

package/Tests/Types/StatusPage/SearchEngineIndexing.test.ts

@@ -0,0 +1,86 @@
+/**
+ * The single place that decides "is this status page indexable?".
+ *
+ * Every renderer feeds this the raw flag off the /seo API response, and the
+ * answer decides whether a <meta name="robots"> and an X-Robots-Tag go out.
+ * The interesting half is what it does with values that are NOT an explicit
+ * off - a missing field, a null, an API that did not answer - because that is
+ * the state the internal HTTP call lands in whenever anything goes wrong, and
+ * it must resolve to "indexable" rather than silently de-indexing pages whose
+ * owners never asked for it.
+ */
+
+import {
+  NOINDEX_ROBOTS_DIRECTIVE,
+  SEARCH_ENGINE_INDEXING_FLAG_NAME,
+  X_ROBOTS_TAG_HEADER_NAME,
+  isSearchEngineIndexingEnabled,
+} from "../../../Types/StatusPage/SearchEngineIndexing";
+import { describe, expect, test } from "@jest/globals";
+
+describe("isSearchEngineIndexingEnabled", () => {
+  test("the owner turning the toggle off is the only thing that blocks indexing", () => {
+    expect(isSearchEngineIndexingEnabled(false)).toBe(false);
+  });
+
+  test("the toggle left on indexes", () => {
+    expect(isSearchEngineIndexingEnabled(true)).toBe(true);
+  });
+
+  test("a JSON round-trip that stringified the boolean still reads as off", () => {
+    /*
+     * The flag crosses an HTTP boundary between the API and the two frontend
+     * servers. A serializer that renders booleans as strings must not turn an
+     * opt-out back into an opt-in.
+     */
+    expect(isSearchEngineIndexingEnabled("false")).toBe(false);
+    expect(isSearchEngineIndexingEnabled("true")).toBe(true);
+  });
+
+  describe("anything that is not an explicit off leaves the page indexable", () => {
+    /*
+     * These are the shapes an unreachable or older /seo API produces. Reading
+     * any of them as "noindex" would take a page out of Google over a blip on
+     * an internal HTTP call - a failure the owner never asked for and would
+     * have no way to see.
+     */
+    const notAnExplicitOff: Array<[string, unknown]> = [
+      ["field absent from the response", undefined],
+      ["field present but null", null],
+      ["empty string", ""],
+      ["zero", 0],
+      ["the string 'no'", "no"],
+      ["the string 'FALSE' in the wrong case", "FALSE"],
+      ["an object", {}],
+    ];
+
+    test.each(notAnExplicitOff)("%s", (_label: string, value: unknown) => {
+      expect(isSearchEngineIndexingEnabled(value)).toBe(true);
+    });
+  });
+});
+
+describe("the directives that go on the wire", () => {
+  /*
+   * Pinned strings. Crawlers parse these literally, so a typo here is a
+   * feature that silently does nothing - the page keeps being indexed and
+   * nothing errors.
+   */
+  test("the robots directive is noindex, nofollow", () => {
+    expect(NOINDEX_ROBOTS_DIRECTIVE).toBe("noindex, nofollow");
+  });
+
+  test("the response header is X-Robots-Tag", () => {
+    expect(X_ROBOTS_TAG_HEADER_NAME).toBe("X-Robots-Tag");
+  });
+
+  test("the API/template flag name matches the model column name", () => {
+    /*
+     * The /seo API keys its response off this constant, and index.ejs reads a
+     * variable of the same name. Renaming the column without renaming this
+     * would leave the template reading undefined - which reads as indexable,
+     * so the toggle would just stop working, quietly.
+     */
+    expect(SEARCH_ENGINE_INDEXING_FLAG_NAME).toBe("enableSearchEngineIndexing");
+  });
+});

package/Tests/Types/Telemetry/ResourceEntityFacet.test.ts

@@ -0,0 +1,254 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  ALL_RESOURCE_FACET_KEYS,
+  MAX_RESOURCE_IDS_PER_FACET,
+  RESOURCE_ENTITY_FACET_KEYS,
+  ResourceEntityFacetSelections,
+  SERVICE_FACET_KEYS,
+  collectResourceEntityFacetSelections,
+  collectServiceFacetSelections,
+  hasResourceEntityFacetSelections,
+  isResourceEntityFacetKey,
+  isResourceFacetKey,
+  isServiceFacetKey,
+  parseResourceEntityFacetSelections,
+} from "../../../Types/Telemetry/ResourceEntityFacet";
+
+/*
+ * The split this module encodes is the whole fix for issue #3216: the
+ * Services facet reads out of `primaryEntityId`, every other resource facet
+ * has to be resolved through the resource's entity key. Getting a key into
+ * the wrong bucket silently reintroduces the bug (a cluster id compared
+ * against a column that only holds Service ids), so the classification is
+ * pinned here rather than left to the call sites.
+ */
+
+const CLUSTER_ID: string = "8c0f2f1e-2e4f-4a8c-9a1a-2f5b6c7d8e9f";
+const OTHER_CLUSTER_ID: string = "1a2b3c4d-5e6f-4071-8293-a4b5c6d7e8f9";
+const HOST_ID: string = "5f4e3d2c-1b0a-4998-8776-655443322110";
+const SERVICE_ID: string = "0d1c2b3a-4958-4867-9776-8574a3b2c1d0";
+
+function facetMap(
+  entries: Record<string, Array<string>>,
+): Map<string, Set<string>> {
+  const map: Map<string, Set<string>> = new Map();
+
+  for (const [key, values] of Object.entries(entries)) {
+    map.set(key, new Set(values));
+  }
+
+  return map;
+}
+
+describe("ResourceEntityFacet", () => {
+  describe("facet classification", () => {
+    test("the Services facet and its pre-rename alias read out of primaryEntityId", () => {
+      expect(isServiceFacetKey("primaryEntityId")).toBe(true);
+      expect(isServiceFacetKey("serviceId")).toBe(true);
+      expect(isResourceEntityFacetKey("primaryEntityId")).toBe(false);
+      expect(isResourceEntityFacetKey("serviceId")).toBe(false);
+    });
+
+    test("every non-Service resource facet needs entity-key resolution", () => {
+      for (const facetKey of [
+        "hostId",
+        "dockerHostId",
+        "podmanHostId",
+        "kubernetesClusterId",
+      ]) {
+        expect(isResourceEntityFacetKey(facetKey)).toBe(true);
+        expect(isServiceFacetKey(facetKey)).toBe(false);
+      }
+    });
+
+    test("non-resource facets belong to neither group", () => {
+      for (const facetKey of [
+        "severityText",
+        "traceId",
+        "spanId",
+        "attributes.k8s.cluster.name",
+        "",
+      ]) {
+        expect(isResourceFacetKey(facetKey)).toBe(false);
+      }
+    });
+
+    test("the combined list is exactly the two groups, with no overlap", () => {
+      expect(ALL_RESOURCE_FACET_KEYS).toEqual([
+        ...SERVICE_FACET_KEYS,
+        ...RESOURCE_ENTITY_FACET_KEYS,
+      ]);
+      expect(new Set(ALL_RESOURCE_FACET_KEYS).size).toBe(
+        ALL_RESOURCE_FACET_KEYS.length,
+      );
+    });
+  });
+
+  describe("collectResourceEntityFacetSelections", () => {
+    test("keeps each facet's ids under its own key", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          facetMap({
+            kubernetesClusterId: [CLUSTER_ID],
+            hostId: [HOST_ID],
+          }).entries(),
+        );
+
+      expect(selections).toEqual({
+        kubernetesClusterId: [CLUSTER_ID],
+        hostId: [HOST_ID],
+      });
+    });
+
+    test("leaves Service selections out — they are not entity-key resolved", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          facetMap({
+            primaryEntityId: [SERVICE_ID],
+            serviceId: [SERVICE_ID],
+            severityText: ["Error"],
+          }).entries(),
+        );
+
+      expect(selections).toEqual({});
+    });
+
+    test("accepts a plain record via Object.entries (the traces explorer's shape)", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          Object.entries({
+            kubernetesClusterId: [CLUSTER_ID, OTHER_CLUSTER_ID],
+          }),
+        );
+
+      expect(selections["kubernetesClusterId"]).toEqual([
+        CLUSTER_ID,
+        OTHER_CLUSTER_ID,
+      ]);
+    });
+
+    test("de-duplicates repeated ids within one facet", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          Object.entries({
+            kubernetesClusterId: [CLUSTER_ID, CLUSTER_ID],
+          }),
+        );
+
+      expect(selections["kubernetesClusterId"]).toEqual([CLUSTER_ID]);
+    });
+
+    test("drops a facet whose last chip was just removed rather than emitting []", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          facetMap({ kubernetesClusterId: [] }).entries(),
+        );
+
+      expect(selections).toEqual({});
+      expect(hasResourceEntityFacetSelections(selections)).toBe(false);
+    });
+
+    test("skips blank values", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          Object.entries({ hostId: ["", HOST_ID] }),
+        );
+
+      expect(selections["hostId"]).toEqual([HOST_ID]);
+    });
+  });
+
+  describe("collectServiceFacetSelections", () => {
+    test("unions the canonical key and its alias", () => {
+      expect(
+        collectServiceFacetSelections(
+          facetMap({
+            primaryEntityId: [SERVICE_ID],
+            serviceId: [SERVICE_ID, HOST_ID],
+          }).entries(),
+        ),
+      ).toEqual([SERVICE_ID, HOST_ID]);
+    });
+
+    test("ignores non-Service resource facets", () => {
+      expect(
+        collectServiceFacetSelections(
+          facetMap({ kubernetesClusterId: [CLUSTER_ID] }).entries(),
+        ),
+      ).toEqual([]);
+    });
+  });
+
+  describe("parseResourceEntityFacetSelections", () => {
+    test("accepts a well-formed selection map", () => {
+      expect(
+        parseResourceEntityFacetSelections({
+          kubernetesClusterId: [CLUSTER_ID],
+        }),
+      ).toEqual({ kubernetesClusterId: [CLUSTER_ID] });
+    });
+
+    test("drops unknown facet keys", () => {
+      expect(
+        parseResourceEntityFacetSelections({
+          kubernetesClusterId: [CLUSTER_ID],
+          primaryEntityId: [SERVICE_ID],
+          somethingElse: [CLUSTER_ID],
+        }),
+      ).toEqual({ kubernetesClusterId: [CLUSTER_ID] });
+    });
+
+    test("drops ids that are not ObjectID strings", () => {
+      expect(
+        parseResourceEntityFacetSelections({
+          kubernetesClusterId: [CLUSTER_ID, "not-an-id", "'; DROP TABLE --"],
+        }),
+      ).toEqual({ kubernetesClusterId: [CLUSTER_ID] });
+    });
+
+    test("a facet left with no valid id is dropped entirely", () => {
+      expect(parseResourceEntityFacetSelections({ hostId: ["nope"] })).toEqual(
+        {},
+      );
+    });
+
+    test("non-array values carry no filter", () => {
+      expect(
+        parseResourceEntityFacetSelections({
+          kubernetesClusterId: CLUSTER_ID,
+        }),
+      ).toEqual({});
+    });
+
+    test("junk input parses to no constraint rather than throwing", () => {
+      for (const junk of [undefined, null, "", 0, [], "string", true]) {
+        expect(parseResourceEntityFacetSelections(junk)).toEqual({});
+      }
+    });
+
+    test("caps the id list so a crafted request cannot send an unbounded IN", () => {
+      const many: Array<string> = Array.from(
+        { length: MAX_RESOURCE_IDS_PER_FACET + 25 },
+        (_unused: unknown, index: number): string => {
+          return `00000000-0000-4000-8000-${String(index).padStart(12, "0")}`;
+        },
+      );
+
+      const parsed: ResourceEntityFacetSelections =
+        parseResourceEntityFacetSelections({ kubernetesClusterId: many });
+
+      expect(parsed["kubernetesClusterId"]).toHaveLength(
+        MAX_RESOURCE_IDS_PER_FACET,
+      );
+    });
+
+    test("de-duplicates before capping", () => {
+      const parsed: ResourceEntityFacetSelections =
+        parseResourceEntityFacetSelections({
+          hostId: [HOST_ID, HOST_ID, HOST_ID],
+        });
+
+      expect(parsed["hostId"]).toEqual([HOST_ID]);
+    });
+  });
+});