@oneuptime/common 11.6.0 → 11.6.1

package/Tests/Server/Utils/AnalyticsDatabase/StatementGenerator.test.ts

@@ -1102,6 +1102,105 @@ describe("StatementGenerator", () => {
       );
     });
 
+    test("emits AggregateFunction and scalar SimpleAggregateFunction measures", () => {
+      const statement: Statement = generator.toColumnsCreateStatement([
+        new AnalyticsTableColumn({
+          key: "retentionDate",
+          title: "<title>",
+          description: "<description>",
+          required: false,
+          type: TableColumnType.Date,
+          simpleAggregateFunction: "max",
+        }),
+        new AnalyticsTableColumn({
+          key: "valueState",
+          title: "<title>",
+          description: "<description>",
+          required: true,
+          type: TableColumnType.AggregateFunction,
+          aggregateFunctionDefinition: "sum, Float64",
+        }),
+      ]);
+
+      expectStatement(
+        statement,
+        SQL`retentionDate SimpleAggregateFunction(max, DateTime), valueState AggregateFunction(sum, Float64)`,
+      );
+    });
+
+    test("supports SimpleAggregateFunction on non-DateTime scalar types and codecs", () => {
+      const statement: Statement = generator.toColumnsCreateStatement([
+        new AnalyticsTableColumn({
+          key: "sampleCount",
+          title: "<title>",
+          description: "<description>",
+          required: true,
+          type: TableColumnType.UInt64,
+          simpleAggregateFunction: "sum",
+          codec: { codec: "ZSTD", level: 1 },
+        }),
+      ]);
+
+      expectStatement(
+        statement,
+        SQL`sampleCount SimpleAggregateFunction(sum, UInt64) CODEC(ZSTD(1))`,
+      );
+    });
+
+    test("rejects a column that declares both aggregate representations", () => {
+      expect(() => {
+        return generator.toColumnsCreateStatement([
+          new AnalyticsTableColumn({
+            key: "ambiguousState",
+            title: "<title>",
+            description: "<description>",
+            required: true,
+            type: TableColumnType.AggregateFunction,
+            aggregateFunctionDefinition: "sum, Float64",
+            simpleAggregateFunction: "sum",
+          }),
+        ]);
+      }).toThrow(
+        "Column ambiguousState cannot declare both AggregateFunction and SimpleAggregateFunction",
+      );
+    });
+
+    test.each(["", " max", "max ", "max)", "max, DateTime"])(
+      "rejects unsafe SimpleAggregateFunction name %p",
+      (functionName: string) => {
+        expect(() => {
+          return generator.toColumnsCreateStatement([
+            new AnalyticsTableColumn({
+              key: "invalidMeasure",
+              title: "<title>",
+              description: "<description>",
+              required: true,
+              type: TableColumnType.Date,
+              simpleAggregateFunction: functionName,
+            }),
+          ]);
+        }).toThrow(
+          `Column invalidMeasure has invalid simpleAggregateFunction "${functionName}"`,
+        );
+      },
+    );
+
+    test("rejects AggregateFunction without its state definition", () => {
+      expect(() => {
+        return generator.toColumnsCreateStatement([
+          new AnalyticsTableColumn({
+            key: "missingStateDefinition",
+            title: "<title>",
+            description: "<description>",
+            required: true,
+            type: TableColumnType.AggregateFunction,
+          }),
+        ]);
+      }).toThrow(
+        "Column missingStateDefinition is AggregateFunction but missing aggregateFunctionDefinition",
+      );
+    });
+
     test("emits single and pipelined CODEC clauses", () => {
       const statement: Statement = generator.toColumnsCreateStatement([
         new AnalyticsTableColumn({

package/Tests/Types/HashCode.test.ts

@@ -0,0 +1,41 @@
+import HashCode from "../../Types/HashCode";
+
+describe("HashCode", () => {
+  describe("fromString", () => {
+    test("returns 0 for an empty string", () => {
+      expect(HashCode.fromString("")).toBe(0);
+    });
+
+    test("is deterministic for the same input", () => {
+      expect(HashCode.fromString("oneuptime")).toBe(
+        HashCode.fromString("oneuptime"),
+      );
+    });
+
+    test("produces different hashes for different inputs", () => {
+      expect(HashCode.fromString("abc")).not.toBe(HashCode.fromString("abd"));
+    });
+
+    test("is order-sensitive", () => {
+      expect(HashCode.fromString("ab")).not.toBe(HashCode.fromString("ba"));
+    });
+
+    test("returns a 32-bit signed integer", () => {
+      const hash: number = HashCode.fromString(
+        "a fairly long string to exercise the shift/overflow path",
+      );
+      expect(Number.isInteger(hash)).toBe(true);
+      expect(hash).toBeGreaterThanOrEqual(-(2 ** 31));
+      expect(hash).toBeLessThanOrEqual(2 ** 31 - 1);
+    });
+
+    test("matches the known Java-style hashCode value", () => {
+      // "hello".hashCode() in Java is 99162322.
+      expect(HashCode.fromString("hello")).toBe(99162322);
+    });
+
+    test("single character equals its char code", () => {
+      expect(HashCode.fromString("A")).toBe("A".charCodeAt(0));
+    });
+  });
+});

package/Tests/Types/Log/LogQueryParser.test.ts

@@ -0,0 +1,186 @@
+import parseLogQuery, {
+  FilterOperator,
+  ParsedToken,
+  TokenType,
+  tokensToDisplayString,
+} from "../../../Types/Log/LogQueryParser";
+
+describe("LogQueryParser", () => {
+  describe("parseLogQuery - empty and free text", () => {
+    test("returns an empty array for empty / whitespace input", () => {
+      expect(parseLogQuery("")).toEqual([]);
+      expect(parseLogQuery("   ")).toEqual([]);
+    });
+
+    test("combines free text words into a single Contains token", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("connection refused");
+      expect(tokens).toHaveLength(1);
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.FreeText,
+        operator: FilterOperator.Contains,
+        value: "connection refused",
+        negated: false,
+      });
+    });
+
+    test("strips quotes from a quoted phrase", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery('"connection refused"');
+      expect(tokens).toHaveLength(1);
+      expect(tokens[0]!.value).toBe("connection refused");
+      expect(tokens[0]!.type).toBe(TokenType.FreeText);
+    });
+  });
+
+  describe("parseLogQuery - field filters and aliases", () => {
+    test("resolves the severity alias to severityText", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("severity:error");
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.FieldFilter,
+        field: "severityText",
+        operator: FilterOperator.Equals,
+        value: "error",
+        negated: false,
+      });
+    });
+
+    test("resolves the service alias to primaryEntityId", () => {
+      expect(parseLogQuery("service:api")[0]!.field).toBe("primaryEntityId");
+    });
+
+    test("resolves level, message, and trace aliases", () => {
+      expect(parseLogQuery("level:warn")[0]!.field).toBe("severityText");
+      expect(parseLogQuery("message:hello")[0]!.field).toBe("body");
+      expect(parseLogQuery("trace:abc")[0]!.field).toBe("traceId");
+    });
+
+    test("keeps unknown field names as-is", () => {
+      expect(parseLogQuery("customfield:x")[0]!.field).toBe("customfield");
+    });
+  });
+
+  describe("parseLogQuery - attribute filters", () => {
+    test("parses @-prefixed attribute access", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("@http.status_code:500");
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.AttributeFilter,
+        field: "http.status_code",
+        operator: FilterOperator.Equals,
+        value: "500",
+      });
+    });
+
+    test("does not run aliasing on attribute field names", () => {
+      // "service" is an alias for field filters but must stay literal as an attribute.
+      expect(parseLogQuery("@service:api")[0]!.field).toBe("service");
+    });
+  });
+
+  describe("parseLogQuery - negation", () => {
+    test("negated equals becomes NotEquals", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("-severity:debug");
+      expect(tokens[0]).toMatchObject({
+        field: "severityText",
+        operator: FilterOperator.NotEquals,
+        value: "debug",
+        negated: true,
+      });
+    });
+
+    test("negated attribute filter", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("-@http.method:GET");
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.AttributeFilter,
+        field: "http.method",
+        operator: FilterOperator.NotEquals,
+        negated: true,
+      });
+    });
+  });
+
+  describe("parseLogQuery - operators", () => {
+    test("detects wildcard values", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery("service:api-*");
+      expect(tokens[0]).toMatchObject({
+        operator: FilterOperator.Wildcard,
+        value: "api-*",
+      });
+    });
+
+    test("detects numeric comparison operators", () => {
+      expect(parseLogQuery("@duration:>1000")[0]).toMatchObject({
+        operator: FilterOperator.GreaterThan,
+        value: "1000",
+      });
+      expect(parseLogQuery("@duration:>=1000")[0]).toMatchObject({
+        operator: FilterOperator.GreaterThanOrEqual,
+        value: "1000",
+      });
+      expect(parseLogQuery("@duration:<50")[0]).toMatchObject({
+        operator: FilterOperator.LessThan,
+        value: "50",
+      });
+      expect(parseLogQuery("@duration:<=50")[0]).toMatchObject({
+        operator: FilterOperator.LessThanOrEqual,
+        value: "50",
+      });
+    });
+  });
+
+  describe("parseLogQuery - boolean keywords and mixed queries", () => {
+    test("skips bare AND/OR/NOT keywords", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery(
+        "severity:error AND service:api",
+      );
+      expect(tokens).toHaveLength(2);
+      expect(tokens[0]!.field).toBe("severityText");
+      expect(tokens[1]!.field).toBe("primaryEntityId");
+    });
+
+    test("splits free text around a field filter", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery(
+        "connection severity:error refused",
+      );
+      expect(tokens).toHaveLength(3);
+      expect(tokens[0]).toMatchObject({
+        type: TokenType.FreeText,
+        value: "connection",
+      });
+      expect(tokens[1]).toMatchObject({
+        type: TokenType.FieldFilter,
+        field: "severityText",
+      });
+      expect(tokens[2]).toMatchObject({
+        type: TokenType.FreeText,
+        value: "refused",
+      });
+    });
+
+    test("does not split a quoted phrase containing spaces", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery(
+        '"connection refused" severity:error',
+      );
+      expect(tokens).toHaveLength(2);
+      expect(tokens[0]!.value).toBe("connection refused");
+      expect(tokens[1]!.field).toBe("severityText");
+    });
+
+    test("strips quotes from field values", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery('message:"a b c"');
+      expect(tokens[0]!.value).toBe("a b c");
+      expect(tokens[0]!.field).toBe("body");
+    });
+  });
+
+  describe("tokensToDisplayString", () => {
+    test("rejoins tokens using their raw representation", () => {
+      const tokens: Array<ParsedToken> = parseLogQuery(
+        "severity:error service:api",
+      );
+      expect(tokensToDisplayString(tokens)).toBe("severity:error service:api");
+    });
+
+    test("returns an empty string for no tokens", () => {
+      expect(tokensToDisplayString([])).toBe("");
+    });
+  });
+});

package/Tests/Utils/Dashboard/VariableInterpolation.test.ts

@@ -0,0 +1,197 @@
+import Includes from "../../../Types/BaseDatabase/Includes";
+import DashboardVariable, {
+  DashboardVariableType,
+} from "../../../Types/Dashboard/DashboardVariable";
+import DashboardVariableInterpolation from "../../../Utils/Dashboard/VariableInterpolation";
+
+function makeVariable(
+  overrides: Partial<DashboardVariable>,
+): DashboardVariable {
+  return {
+    id: "var-1",
+    name: "cluster",
+    type: DashboardVariableType.TelemetryAttribute,
+    ...overrides,
+  } as DashboardVariable;
+}
+
+describe("DashboardVariableInterpolation", () => {
+  describe("resolveValue", () => {
+    test("returns scalar for a single-select with selectedValue", () => {
+      const variable: DashboardVariable = makeVariable({
+        selectedValue: "prod",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "prod",
+      });
+    });
+
+    test("falls back to defaultValue when selectedValue is unset", () => {
+      const variable: DashboardVariable = makeVariable({
+        defaultValue: "staging",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "staging",
+      });
+    });
+
+    test("prefers selectedValue over defaultValue", () => {
+      const variable: DashboardVariable = makeVariable({
+        selectedValue: "prod",
+        defaultValue: "staging",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "prod",
+      });
+    });
+
+    test("returns undefined when nothing is selected", () => {
+      expect(
+        DashboardVariableInterpolation.resolveValue(makeVariable({})),
+      ).toBeUndefined();
+      expect(
+        DashboardVariableInterpolation.resolveValue(
+          makeVariable({ selectedValue: "" }),
+        ),
+      ).toBeUndefined();
+    });
+
+    test("returns multi for a multi-select with values", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: true,
+        selectedValues: ["a", "b"],
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        multi: ["a", "b"],
+      });
+    });
+
+    test("filters out empty values in multi-select", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: true,
+        selectedValues: ["a", "", "b"],
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        multi: ["a", "b"],
+      });
+    });
+
+    test("multi-select with no picks falls through to scalar default", () => {
+      const variable: DashboardVariable = makeVariable({
+        isMultiSelect: true,
+        selectedValues: [],
+        defaultValue: "d",
+      });
+      expect(DashboardVariableInterpolation.resolveValue(variable)).toEqual({
+        scalar: "d",
+      });
+    });
+  });
+
+  describe("applyToAttributes", () => {
+    test("returns the same reference when there are no variables", () => {
+      const attrs: Record<string, unknown> = { foo: "bar" };
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, undefined),
+      ).toBe(attrs);
+      expect(DashboardVariableInterpolation.applyToAttributes(attrs, [])).toBe(
+        attrs,
+      );
+    });
+
+    test("injects a scalar attribute for a selected variable", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes({}, [variable]);
+      expect(result).toEqual({ "k8s.cluster.name": "prod" });
+    });
+
+    test("emits an Includes operator for multi-select", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        isMultiSelect: true,
+        selectedValues: ["a", "b"],
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes({}, [variable]);
+      const value: unknown = result["k8s.cluster.name"];
+      expect(value).toBeInstanceOf(Includes);
+      expect((value as Includes).values).toEqual(["a", "b"]);
+    });
+
+    test("removes a previously-set filter when selection is cleared (All)", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes(
+          { "k8s.cluster.name": "prod", other: "keep" },
+          [variable],
+        );
+      expect(result).toEqual({ other: "keep" });
+    });
+
+    test("ignores non-TelemetryAttribute variables", () => {
+      const attrs: Record<string, unknown> = { foo: "bar" };
+      const variable: DashboardVariable = makeVariable({
+        type: DashboardVariableType.TextInput,
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("ignores TelemetryAttribute variables without an attributeKey", () => {
+      const attrs: Record<string, unknown> = { foo: "bar" };
+      const variable: DashboardVariable = makeVariable({
+        selectedValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("returns same reference when scalar value is already set", () => {
+      const attrs: Record<string, unknown> = { "k8s.cluster.name": "prod" };
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      expect(
+        DashboardVariableInterpolation.applyToAttributes(attrs, [variable]),
+      ).toBe(attrs);
+    });
+
+    test("handles undefined attributes map", () => {
+      const variable: DashboardVariable = makeVariable({
+        attributeKey: "k8s.cluster.name",
+        selectedValue: "prod",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes(undefined, [variable]);
+      expect(result).toEqual({ "k8s.cluster.name": "prod" });
+    });
+
+    test("applies multiple variables at once", () => {
+      const v1: DashboardVariable = makeVariable({
+        id: "v1",
+        attributeKey: "cluster",
+        selectedValue: "prod",
+      });
+      const v2: DashboardVariable = makeVariable({
+        id: "v2",
+        attributeKey: "namespace",
+        selectedValue: "default",
+      });
+      const result: Record<string, unknown> =
+        DashboardVariableInterpolation.applyToAttributes({}, [v1, v2]);
+      expect(result).toEqual({ cluster: "prod", namespace: "default" });
+    });
+  });
+});