@oneuptime/common 11.7.2 → 11.7.4

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

@@ -0,0 +1,269 @@
+import {
+  DropFilterCandidate,
+  DropFilterValidationOptions,
+  isSqlExpressionValue,
+  SAMPLE_ACTION,
+  validateDropFilter,
+  validateDropFilterFilterQuery,
+  validateDropFilterSamplePercentage,
+} from "../../../Server/Utils/DropFilterValidation";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import {
+  MAX_SAMPLE_PERCENTAGE,
+  MIN_SAMPLE_PERCENTAGE,
+} from "../../../Types/Telemetry/DropFilterSampling";
+import LogDropFilterAction from "../../../Types/Log/LogDropFilterAction";
+import TraceDropFilterAction from "../../../Types/Trace/TraceDropFilterAction";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test — the save-time gate on drop filters.
+ *
+ * Both drop-filter models used to accept configurations the ingest engine
+ * could not honour, and both failed silently AND destructively:
+ *
+ *   - A blank `filterQuery` compiles to "match every record", so saving a
+ *     drop filter with an empty query discarded 100% of a project's
+ *     telemetry with nothing to notice it by.
+ *   - `action = "sample"` could be saved with no percentage, which the engine
+ *     read as "throw away half".
+ *
+ * The API boundary is the only place a human is present to read the error,
+ * which is why this runs on create and on update rather than only in the
+ * dashboard form.
+ */
+
+const LOGS: DropFilterValidationOptions = { recordNoun: "logs" };
+const SPANS: DropFilterValidationOptions = { recordNoun: "spans" };
+
+function candidate(
+  overrides: Partial<DropFilterCandidate>,
+): DropFilterCandidate {
+  return {
+    action: "drop",
+    samplePercentage: null,
+    filterQuery: "severityText = 'Error'",
+    ...overrides,
+  };
+}
+
+describe("drop filter action vocabulary", () => {
+  /*
+   * The validator compares a raw string so one implementation can serve both
+   * services. If either enum ever renames its member, this fails instead of
+   * silently skipping sample validation.
+   */
+  it("matches the literal both action enums use for sampling", () => {
+    expect(LogDropFilterAction.Sample).toBe(SAMPLE_ACTION);
+    expect(TraceDropFilterAction.Sample).toBe(SAMPLE_ACTION);
+  });
+});
+
+describe("validateDropFilterFilterQuery", () => {
+  it("accepts a query with an actual condition", () => {
+    expect(() => {
+      return validateDropFilterFilterQuery("body CONTAINS 'debug'", LOGS);
+    }).not.toThrow();
+  });
+
+  /*
+   * The destructive case: empty means match-all, and match-all plus a drop
+   * action means the project loses everything.
+   */
+  it("rejects an empty query", () => {
+    expect(() => {
+      return validateDropFilterFilterQuery("", LOGS);
+    }).toThrow(BadDataException);
+  });
+
+  it("rejects a whitespace-only query", () => {
+    for (const blank of [" ", "   ", "\t", "\n", " \t\n "]) {
+      expect(() => {
+        return validateDropFilterFilterQuery(blank, LOGS);
+      }).toThrow(BadDataException);
+    }
+  });
+
+  it("rejects a missing query", () => {
+    expect(() => {
+      return validateDropFilterFilterQuery(undefined, LOGS);
+    }).toThrow(BadDataException);
+    expect(() => {
+      return validateDropFilterFilterQuery(null, LOGS);
+    }).toThrow(BadDataException);
+  });
+
+  /*
+   * The message has to explain the consequence, not just name the field —
+   * "Filter query is required" alone does not tell someone that saving it
+   * blank would have deleted all their logs.
+   */
+  it("explains the consequence in the message, in the caller's vocabulary", () => {
+    expect(() => {
+      return validateDropFilterFilterQuery("", LOGS);
+    }).toThrow(/discard all of this project's logs/);
+
+    expect(() => {
+      return validateDropFilterFilterQuery("", SPANS);
+    }).toThrow(/discard all of this project's spans/);
+  });
+});
+
+describe("validateDropFilterSamplePercentage", () => {
+  it("ignores the percentage entirely for a drop-action filter", () => {
+    for (const percentage of [null, undefined, 0, -5, 100, 1000]) {
+      expect(() => {
+        return validateDropFilterSamplePercentage(
+          candidate({ action: "drop", samplePercentage: percentage }),
+          LOGS,
+        );
+      }).not.toThrow();
+    }
+  });
+
+  it("accepts a sample filter inside the usable range", () => {
+    for (const percentage of [
+      MIN_SAMPLE_PERCENTAGE,
+      10,
+      50,
+      MAX_SAMPLE_PERCENTAGE,
+    ]) {
+      expect(() => {
+        return validateDropFilterSamplePercentage(
+          candidate({ action: SAMPLE_ACTION, samplePercentage: percentage }),
+          LOGS,
+        );
+      }).not.toThrow();
+    }
+  });
+
+  it("rejects a sample filter with no percentage at all", () => {
+    for (const missing of [null, undefined]) {
+      expect(() => {
+        return validateDropFilterSamplePercentage(
+          candidate({ action: SAMPLE_ACTION, samplePercentage: missing }),
+          LOGS,
+        );
+      }).toThrow(BadDataException);
+    }
+  });
+
+  it("rejects a sample filter with a non-finite percentage", () => {
+    for (const bad of [NaN, Infinity, -Infinity]) {
+      expect(() => {
+        return validateDropFilterSamplePercentage(
+          candidate({ action: SAMPLE_ACTION, samplePercentage: bad }),
+          LOGS,
+        );
+      }).toThrow(BadDataException);
+    }
+  });
+
+  /*
+   * 0 and 100 are the two values a user reaches for when they mean something
+   * else. Point them at the tool that actually does it rather than accepting
+   * a filter the engine will treat as a no-op.
+   */
+  it("rejects 0 and points at the Drop action instead", () => {
+    expect(() => {
+      return validateDropFilterSamplePercentage(
+        candidate({ action: SAMPLE_ACTION, samplePercentage: 0 }),
+        LOGS,
+      );
+    }).toThrow(/"Drop" action/);
+  });
+
+  it("rejects 100 and points at disabling the filter instead", () => {
+    expect(() => {
+      return validateDropFilterSamplePercentage(
+        candidate({ action: SAMPLE_ACTION, samplePercentage: 100 }),
+        LOGS,
+      );
+    }).toThrow(/disable the filter/);
+  });
+
+  it("rejects percentages outside the range on both sides", () => {
+    for (const outOfRange of [-1, 0, 100, 101, 1000]) {
+      expect(() => {
+        return validateDropFilterSamplePercentage(
+          candidate({ action: SAMPLE_ACTION, samplePercentage: outOfRange }),
+          LOGS,
+        );
+      }).toThrow(BadDataException);
+    }
+  });
+
+  it("names the allowed range in the message so the fix is obvious", () => {
+    expect(() => {
+      return validateDropFilterSamplePercentage(
+        candidate({ action: SAMPLE_ACTION, samplePercentage: null }),
+        LOGS,
+      );
+    }).toThrow(
+      new RegExp(`${MIN_SAMPLE_PERCENTAGE} and ${MAX_SAMPLE_PERCENTAGE}`),
+    );
+  });
+});
+
+describe("validateDropFilter", () => {
+  it("accepts a well-formed drop filter", () => {
+    expect(() => {
+      return validateDropFilter(
+        candidate({ action: "drop", filterQuery: "severityText = 'Debug'" }),
+        LOGS,
+      );
+    }).not.toThrow();
+  });
+
+  it("accepts a well-formed sample filter", () => {
+    expect(() => {
+      return validateDropFilter(
+        candidate({
+          action: SAMPLE_ACTION,
+          samplePercentage: 10,
+          filterQuery: "severityText = 'Debug'",
+        }),
+        LOGS,
+      );
+    }).not.toThrow();
+  });
+
+  /*
+   * The query check runs first on purpose. A row that is broken both ways
+   * should surface the more destructive problem, because a match-all drop
+   * filter deletes everything while a bad percentage only samples.
+   */
+  it("reports the empty query first when a candidate is broken both ways", () => {
+    expect(() => {
+      return validateDropFilter(
+        candidate({
+          action: SAMPLE_ACTION,
+          samplePercentage: null,
+          filterQuery: "",
+        }),
+        LOGS,
+      );
+    }).toThrow(/Filter query is required/);
+  });
+});
+
+describe("isSqlExpressionValue", () => {
+  /*
+   * `PartialEntity` values may be raw SQL expressions. We cannot evaluate one
+   * to validate it, and stringifying a function to compare it would be worse
+   * than skipping — so the update hook detects and skips.
+   */
+  it("detects a raw SQL expression value", () => {
+    expect(
+      isSqlExpressionValue(() => {
+        return "NOW()";
+      }),
+    ).toBe(true);
+  });
+
+  it("treats every ordinary literal as a plain value", () => {
+    for (const literal of ["sample", "", 0, 50, null, undefined, {}, []]) {
+      expect(isSqlExpressionValue(literal)).toBe(false);
+    }
+  });
+});

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

@@ -0,0 +1,94 @@
+import SpanUtil, {
+  SpanAttributes,
+} from "../../../../Server/Utils/Telemetry/SpanUtil";
+import { describe, expect, it, jest } from "@jest/globals";
+
+/*
+ * SpanUtil.addAttributesToSpan copies telemetry attributes onto a span, but it
+ * must drop undefined/null values - OpenTelemetry rejects those and throwing
+ * mid-request would break the traced operation. This pins the filtering so a
+ * partially-populated SpanAttributes object stays safe to pass in.
+ */
+
+// A stand-in Span that just records what setAttribute was called with.
+function fakeSpan(): {
+  span: { setAttribute: (key: string, value: unknown) => void };
+  calls: Array<[string, unknown]>;
+} {
+  const calls: Array<[string, unknown]> = [];
+  const setAttribute: (key: string, value: unknown) => void = jest.fn(
+    (key: string, value: unknown): void => {
+      calls.push([key, value]);
+    },
+  );
+  return { span: { setAttribute }, calls };
+}
+
+describe("SpanUtil.addAttributesToSpan", () => {
+  it("sets every defined attribute on the span", () => {
+    const { span, calls } = fakeSpan();
+
+    const attributes: SpanAttributes = {
+      userId: "user-1",
+      projectId: "project-1",
+    };
+
+    SpanUtil.addAttributesToSpan({
+      span: span as never,
+      attributes,
+    });
+
+    expect(calls).toContainEqual(["userId", "user-1"]);
+    expect(calls).toContainEqual(["projectId", "project-1"]);
+    expect(calls).toHaveLength(2);
+  });
+
+  it("skips undefined and null values (OpenTelemetry rejects them)", () => {
+    const { span, calls } = fakeSpan();
+
+    const attributes: SpanAttributes = {
+      userId: "user-1",
+      projectId: undefined,
+      // null is not part of the typed surface but can arrive at runtime.
+      monitorId: null as unknown as string,
+    };
+
+    SpanUtil.addAttributesToSpan({
+      span: span as never,
+      attributes,
+    });
+
+    expect(calls).toEqual([["userId", "user-1"]]);
+  });
+
+  it("preserves falsy-but-defined values like empty string, 0 and false", () => {
+    const { span, calls } = fakeSpan();
+
+    const attributes: SpanAttributes = {
+      channelId: "",
+      retryCount: 0,
+      isRetry: false,
+    };
+
+    SpanUtil.addAttributesToSpan({
+      span: span as never,
+      attributes,
+    });
+
+    expect(calls).toContainEqual(["channelId", ""]);
+    expect(calls).toContainEqual(["retryCount", 0]);
+    expect(calls).toContainEqual(["isRetry", false]);
+    expect(calls).toHaveLength(3);
+  });
+
+  it("does nothing for an empty attribute object", () => {
+    const { span, calls } = fakeSpan();
+
+    SpanUtil.addAttributesToSpan({
+      span: span as never,
+      attributes: {},
+    });
+
+    expect(calls).toHaveLength(0);
+  });
+});

package/Tests/Types/DateUserTimezone.test.ts

@@ -139,6 +139,58 @@ describe("OneUptimeDate user timezone", () => {
       expect(formatted).toContain("EDT");
     });
 
+    it("names the abbreviation in effect on the formatted date, not today's", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      /*
+       * The abbreviation used to be looked up for "now", so all summer every
+       * winter timestamp read "EDT" — and 13:00 EDT is a different instant
+       * than the 13:00 EST that was actually stored.
+       */
+      const winter: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-01-15T18:00:00Z"),
+      );
+      const summer: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-07-15T18:00:00Z"),
+      );
+
+      expect(winter).toContain("13:00");
+      expect(winter).toContain("EST");
+      expect(winter).not.toContain("EDT");
+
+      expect(summer).toContain("14:00");
+      expect(summer).toContain("EDT");
+    });
+
+    it("labels each pass of a folded fall-back hour with its own abbreviation", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // 01:30 local happens twice on 2026-11-01 — once EDT, once EST.
+      const firstPass: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-11-01T05:30:00Z"),
+      );
+      const secondPass: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-11-01T06:30:00Z"),
+      );
+
+      expect(firstPass).toContain("01:30");
+      expect(secondPass).toContain("01:30");
+      // Identical wall clocks; the abbreviation is what tells them apart.
+      expect(firstPass).toContain("EDT");
+      expect(secondPass).toContain("EST");
+    });
+
+    it("still omits the abbreviation when only the date is shown", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const dateOnly: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-01-15T18:00:00Z"),
+        true,
+      );
+
+      expect(dateOnly).toBe("Jan 15, 2026");
+    });
+
     it("reads the hour and minute of an instant in the user timezone", () => {
       OneUptimeDate.setUserTimezone(KOLKATA);
 

package/Tests/Types/JSONFunctions.test.ts

@@ -1,4 +1,4 @@
-import { JSONArray, JSONObject } from "../../Types/JSON";
+import { JSONArray, JSONObject, ObjectType } from "../../Types/JSON";
 import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import JSONFunctions from "../../Types/JSONFunctions";
 
@@ -262,4 +262,106 @@ describe("JSONFunctions Class", () => {
       expect(size).toBeGreaterThanOrEqual(0);
     });
   });
+
+  describe("serialize and serializeArray Methods", () => {
+    test("Passes primitives and null through, and drops undefined keys", () => {
+      const input: JSONObject = {
+        n: 1,
+        s: "x",
+        b: true,
+        nil: null,
+        gone: undefined,
+      };
+      expect(JSONFunctions.serialize(input)).toEqual({
+        n: 1,
+        s: "x",
+        b: true,
+        nil: null,
+      });
+    });
+
+    test("Tags a Date value with its DateTime object type", () => {
+      const serialized: JSONObject = JSONFunctions.serialize({
+        when: new Date("2023-01-01T00:00:00.000Z"),
+      });
+      const when: JSONObject = serialized["when"] as JSONObject;
+      expect(when["_type"]).toBe(ObjectType.DateTime);
+      expect(typeof when["value"]).toBe("string");
+    });
+
+    test("Serializes nested objects recursively", () => {
+      expect(JSONFunctions.serialize({ a: { b: 2 } })).toEqual({ a: { b: 2 } });
+    });
+
+    test("Serializes each value inside an array", () => {
+      expect(JSONFunctions.serialize({ arr: [1, "x", null] })).toEqual({
+        arr: [1, "x", null],
+      });
+    });
+
+    test("serializeArray serializes each object in the array", () => {
+      const input: JSONArray = [{ a: 1 }, { b: 2 }];
+      expect(JSONFunctions.serializeArray(input)).toEqual([{ a: 1 }, { b: 2 }]);
+    });
+  });
+
+  describe("deserialize and deserializeArray Methods", () => {
+    test("Passes primitives and null through", () => {
+      const input: JSONObject = { n: 1, s: "x", nil: null };
+      expect(JSONFunctions.deserialize(input)).toEqual({
+        n: 1,
+        s: "x",
+        nil: null,
+      });
+    });
+
+    test("Rebuilds a Buffer-tagged value into a Buffer", () => {
+      const input: JSONObject = {
+        payload: {
+          _type: ObjectType.Buffer,
+          value: { type: ObjectType.Buffer, data: [1, 2, 3] },
+        },
+      };
+      const deserialized: JSONObject = JSONFunctions.deserialize(input);
+      expect(Buffer.isBuffer(deserialized["payload"])).toBe(true);
+      expect(deserialized["payload"]).toEqual(Buffer.from([1, 2, 3]));
+    });
+
+    test("deserializeArray deserializes each object in the array", () => {
+      const input: JSONArray = [{ a: 1 }, { b: 2 }];
+      expect(JSONFunctions.deserializeArray(input)).toEqual([
+        { a: 1 },
+        { b: 2 },
+      ]);
+    });
+  });
+
+  describe("serializeValue and deserializeValue Methods", () => {
+    test("Pass numbers and non-empty strings through unchanged", () => {
+      expect(JSONFunctions.serializeValue(5)).toBe(5);
+      expect(JSONFunctions.serializeValue("hi")).toBe("hi");
+      expect(JSONFunctions.deserializeValue(5)).toBe(5);
+      expect(JSONFunctions.deserializeValue("hi")).toBe("hi");
+    });
+
+    test("Pass null through unchanged", () => {
+      expect(JSONFunctions.serializeValue(null)).toBeNull();
+      expect(JSONFunctions.deserializeValue(null)).toBeNull();
+    });
+  });
+
+  describe("serialize and deserialize round trip", () => {
+    test("A plain object survives a serialize -> JSON -> deserialize round trip", () => {
+      const original: JSONObject = {
+        a: 1,
+        b: "x",
+        c: { d: 2 },
+        e: [1, 2, 3],
+      };
+      const roundTripped: JSONObject = JSONFunctions.deserialize(
+        JSON.parse(JSON.stringify(JSONFunctions.serialize(original))),
+      );
+      expect(roundTripped).toEqual(original);
+    });
+  });
 });