@oneuptime/common 11.4.0 → 11.5.0

package/Tests/Server/Services/MetricServiceAggregate.test.ts

@@ -0,0 +1,194 @@
+import "../TestingUtils/Init";
+import { MetricService } from "../../../Server/Services/MetricService";
+import Metric from "../../../Models/AnalyticsModels/Metric";
+import AggregateBy from "../../../Server/Types/AnalyticsDatabase/AggregateBy";
+import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+
+describe("MetricService aggregate statement generation", () => {
+  const projectId: ObjectID = ObjectID.generate();
+  const startDate: Date = new Date("2026-07-09T19:08:00.000Z");
+  const endDate: Date = new Date("2026-07-09T19:13:00.000Z");
+
+  let service: MetricService;
+
+  beforeEach(() => {
+    service = new MetricService();
+  });
+
+  type BuildAggregateByFunction = (
+    overrides?: Partial<AggregateBy<Metric>>,
+  ) => AggregateBy<Metric>;
+
+  const buildAggregateBy: BuildAggregateByFunction = (
+    overrides?: Partial<AggregateBy<Metric>>,
+  ): AggregateBy<Metric> => {
+    return {
+      query: {
+        projectId: projectId,
+        name: "http.client.request.duration",
+        time: new InBetween(startDate, endDate),
+      } as AggregateBy<Metric>["query"],
+      aggregationType: AggregationType.Avg,
+      aggregateColumnName: "value",
+      aggregationTimestampColumnName: "time",
+      startTimestamp: startDate,
+      endTimestamp: endDate,
+      limit: 10000,
+      skip: 0,
+      sort: { time: SortOrder.Ascending } as AggregateBy<Metric>["sort"],
+      props: { isRoot: true },
+      ...overrides,
+    };
+  };
+
+  type GetQueryFunction = (aggregateBy: AggregateBy<Metric>) => string;
+
+  const getQuery: GetQueryFunction = (
+    aggregateBy: AggregateBy<Metric>,
+  ): string => {
+    const result: { statement: Statement; columns: Array<string> } =
+      service.toAggregateStatement(aggregateBy);
+    return result.statement.query;
+  };
+
+  describe("scalar aggregations", () => {
+    it("routes plain Avg (no filters, no group-by, no distribution hint) to the minute MV", () => {
+      const query: string = getQuery(buildAggregateBy());
+      expect(query).toContain("MetricItemAggMV1m");
+    });
+
+    it("skips the MVs and uses count-weighted expressions when the metric is a distribution (histogram) metric", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy();
+      (
+        service as unknown as {
+          pointTypeHintByAggregate: WeakMap<AggregateBy<Metric>, string | null>;
+        }
+      ).pointTypeHintByAggregate.set(aggregateBy, "Histogram");
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).not.toContain("MetricItemAggMV1m");
+      /*
+       * Avg must be count-weighted (sum of observation totals divided
+       * by sum of observation counts) — NOT avg(value), which for
+       * histogram rows averages per-export-interval sums.
+       */
+      expect(query).toContain("sum(multiIf(isNotNull(count)");
+      expect(query).toContain("toFloat64(count)");
+      expect(query).not.toContain("avg(value)");
+    });
+
+    it("uses count-weighted expressions on the base table when an attribute filter blocks the MVs", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        query: {
+          projectId: projectId,
+          name: "http.client.request.duration",
+          time: new InBetween(startDate, endDate),
+          attributes: { "oneuptime.service.name": "starship-web" },
+        } as unknown as AggregateBy<Metric>["query"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).not.toContain("MetricItemAggMV1m");
+      expect(query).toContain("sum(multiIf(isNotNull(count)");
+    });
+
+    it("groups by individual attribute keys, not the whole attributes map", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        groupByAttributeKeys: ["oneuptime.service.name"],
+      });
+
+      const result: { statement: Statement; columns: Array<string> } =
+        service.toAggregateStatement(aggregateBy);
+      const query: string = result.statement.query;
+
+      // Key extraction is parameter-bound and aliased...
+      expect(query).toMatch(/attributes\[\{p\d+:String\}\] AS __attr_grp_0/);
+      // ...regrouped rows re-project the selected keys as a compact map...
+      expect(query).toMatch(
+        /map\(\{p\d+:String\}, __attr_grp_0\) AS attributes/,
+      );
+      // ...grouping happens on the extracted key, never the Map column.
+      expect(query).toContain("GROUP BY time, __attr_grp_0");
+      expect(query).not.toContain("GROUP BY time, attributes");
+
+      // The selected key reaches the query only as a bound parameter.
+      const parameterValues: Array<unknown> = Object.values(
+        result.statement.query_params,
+      );
+      expect(
+        parameterValues.filter((value: unknown) => {
+          return value === "oneuptime.service.name";
+        }),
+      ).toHaveLength(2); // extraction + map key
+
+      expect(result.columns).toContain("attributes");
+    });
+
+    it("drops a legacy whole-map attributes group-by when key-scoped grouping is requested", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        groupBy: { attributes: true } as AggregateBy<Metric>["groupBy"],
+        groupByAttributeKeys: ["oneuptime.service.name"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("GROUP BY time, __attr_grp_0");
+      expect(query).not.toContain("GROUP BY time, attributes");
+    });
+
+    it("rejects more than 10 group-by attribute keys", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        groupByAttributeKeys: Array.from(
+          { length: 11 },
+          (_: unknown, i: number) => {
+            return `key.${i}`;
+          },
+        ),
+      });
+
+      expect(() => {
+        return service.toAggregateStatement(aggregateBy);
+      }).toThrow(BadDataException);
+    });
+  });
+
+  describe("percentile aggregations", () => {
+    it("keeps the histogram bucket fanout and pools by selected attribute keys", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationType: AggregationType.P90,
+        groupByAttributeKeys: ["oneuptime.service.name"],
+      });
+
+      const result: { statement: Statement; columns: Array<string> } =
+        service.toAggregateStatement(aggregateBy);
+      const query: string = result.statement.query;
+
+      expect(query).toContain("quantileExactWeighted(0.9)");
+      expect(query).toMatch(/attributes\[\{p\d+:String\}\] AS __attr_grp_0/);
+      expect(query).toMatch(
+        /map\(\{p\d+:String\}, __attr_grp_0\) AS attributes/,
+      );
+      expect(query).toContain("GROUP BY time, __attr_grp_0");
+      expect(result.columns).toContain("attributes");
+    });
+
+    it("does not group when no attribute keys are selected (regression: whole-map fragmentation)", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationType: AggregationType.P90,
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("quantileExactWeighted(0.9)");
+      expect(query).not.toContain("__attr_grp_0");
+      expect(query).toContain("GROUP BY time");
+    });
+  });
+});

package/Tests/Server/Utils/AI/BaselineAnomalyTool.test.ts

@@ -0,0 +1,253 @@
+import { BaselineAnomalyTool } from "../../../../Server/Utils/AI/Toolbox/MetricTools";
+import { ToolContext } from "../../../../Server/Utils/AI/Toolbox/ToolTypes";
+import MetricBaselineService from "../../../../Server/Services/MetricBaselineService";
+import MetricService from "../../../../Server/Services/MetricService";
+import ModelPermission from "../../../../Server/Types/AnalyticsDatabase/ModelPermission";
+import ObjectID from "../../../../Types/ObjectID";
+import AggregatedResult from "../../../../Types/BaseDatabase/AggregatedResult";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
+
+/*
+ * baseline_anomaly judges a metric's recent average against its learned
+ * hour-of-week baseline band (mean ± sigma·stddev — the same math the anomaly
+ * monitors use via sigmaForSensitivity). These tests mock the baseline and
+ * metric services (no ClickHouse) to lock in:
+ *   (a) missing/unreliable baselines report "insufficient baseline data" and
+ *       never render a normal/anomalous verdict (a missing baseline must not
+ *       read as "not anomalous");
+ *   (b) above-band / below-band / within-band classification at Medium (3σ);
+ *   (c) a metric with no recent data points is flagged as possibly having
+ *       stopped reporting, not judged normal;
+ *   (d) a zero-stddev baseline still classifies (band collapses to the mean).
+ */
+
+const ctx: ToolContext = {
+  projectId: ObjectID.generate(),
+  props: { isRoot: true },
+};
+
+function mockBaseline(data: {
+  mean: number;
+  stddev: number;
+  sampleCount?: number;
+  isReliable?: boolean;
+}): void {
+  jest.spyOn(MetricBaselineService, "getBaseline").mockResolvedValue({
+    sampleCount: data.sampleCount ?? 50,
+    mean: data.mean,
+    stddev: data.stddev,
+    median: data.mean,
+    p95: data.mean + 2 * data.stddev,
+    minObserved: data.mean - 3 * data.stddev,
+    maxObserved: data.mean + 3 * data.stddev,
+    isReliable: data.isReliable ?? true,
+    windowDays: 14,
+    hourOfWeek: 10,
+  });
+}
+
+function mockCurrentValues(values: Array<number>): void {
+  jest.spyOn(MetricService, "aggregateBy").mockResolvedValue({
+    data: values.map((value: number) => {
+      return { timestamp: new Date(), value };
+    }),
+  } as unknown as AggregatedResult);
+}
+
+function mockEmptyBand(): void {
+  jest.spyOn(MetricBaselineService, "getBandSeries").mockResolvedValue([]);
+}
+
+describe("BaselineAnomalyTool", () => {
+  beforeEach(() => {
+    // Default: project-wide telemetry access (null = unrestricted).
+    jest
+      .spyOn(ModelPermission, "getAccessibleServiceIdsForAnalyticsModel")
+      .mockResolvedValue(null);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("requires metricName", async () => {
+    await expect(BaselineAnomalyTool.execute({}, ctx)).rejects.toThrow(
+      "metricName is required",
+    );
+  });
+
+  test("rejects an unparseable atTime", async () => {
+    await expect(
+      BaselineAnomalyTool.execute(
+        { metricName: "cpu.usage", atTime: "yesterday-ish" },
+        ctx,
+      ),
+    ).rejects.toThrow("not a valid ISO 8601 timestamp");
+  });
+
+  test("no baseline reports insufficient data and never queries the metric", async () => {
+    jest.spyOn(MetricBaselineService, "getBaseline").mockResolvedValue(null);
+    jest.spyOn(MetricBaselineService, "getCoverage").mockResolvedValue({
+      totalSamples: 3,
+      oldestDay: new Date(),
+    });
+    const aggregateBy: jest.SpyInstance = jest.spyOn(
+      MetricService,
+      "aggregateBy",
+    );
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("insufficient baseline data");
+    expect(result.dataForLlm).not.toContain("ANOMALOUS");
+    expect(aggregateBy).not.toHaveBeenCalled();
+  });
+
+  test("unreliable baseline (too few samples) also reports insufficient data", async () => {
+    mockBaseline({ mean: 100, stddev: 10, sampleCount: 2, isReliable: false });
+    jest.spyOn(MetricBaselineService, "getCoverage").mockResolvedValue({
+      totalSamples: 2,
+      oldestDay: null,
+    });
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("insufficient baseline data");
+    expect(result.dataForLlm).toContain("only 2 sample(s)");
+  });
+
+  test("value above the 3-sigma band is anomalous (above)", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([150]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("ANOMALOUS — above");
+  });
+
+  test("value below the 3-sigma band is anomalous (below)", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([30]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("ANOMALOUS — below");
+  });
+
+  test("value inside the band is normal", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([120]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("normal — within the expected range");
+  });
+
+  test("High sensitivity (2 sigma) flags what Medium would call normal", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([125]); // z = 2.5: inside 3σ, outside 2σ
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage", sensitivity: "High" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("ANOMALOUS — above");
+  });
+
+  test("no recent data points is flagged as possibly stopped reporting", async () => {
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("STOPPED reporting");
+    expect(result.dataForLlm).not.toContain("normal — within");
+  });
+
+  test("zero-stddev baseline refuses to classify, matching the anomaly monitors", async () => {
+    mockBaseline({ mean: 100, stddev: 0 });
+    mockCurrentValues([101]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage" },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("cannot judge");
+    expect(result.dataForLlm).toContain("zero variance");
+    expect(result.dataForLlm).not.toContain("ANOMALOUS");
+  });
+
+  test("a label-scoped user without entityId is refused (baseline SQL skips the owned-scope filter)", async () => {
+    jest
+      .spyOn(ModelPermission, "getAccessibleServiceIdsForAnalyticsModel")
+      .mockResolvedValue([ObjectID.generate()]);
+    const getBaseline: jest.SpyInstance = jest.spyOn(
+      MetricBaselineService,
+      "getBaseline",
+    );
+
+    await expect(
+      BaselineAnomalyTool.execute({ metricName: "cpu.usage" }, ctx),
+    ).rejects.toThrow("scoped to specific services");
+    expect(getBaseline).not.toHaveBeenCalled();
+  });
+
+  test("a label-scoped user asking about another service's entity is refused", async () => {
+    jest
+      .spyOn(ModelPermission, "getAccessibleServiceIdsForAnalyticsModel")
+      .mockResolvedValue([ObjectID.generate()]);
+
+    await expect(
+      BaselineAnomalyTool.execute(
+        {
+          metricName: "cpu.usage",
+          entityId: ObjectID.generate().toString(),
+        },
+        ctx,
+      ),
+    ).rejects.toThrow("scoped to specific services");
+  });
+
+  test("a label-scoped user pinned to their own service proceeds", async () => {
+    const ownServiceId: ObjectID = ObjectID.generate();
+    jest
+      .spyOn(ModelPermission, "getAccessibleServiceIdsForAnalyticsModel")
+      .mockResolvedValue([ownServiceId]);
+    mockBaseline({ mean: 100, stddev: 10 });
+    mockCurrentValues([120]);
+    mockEmptyBand();
+
+    const result: { dataForLlm: string } = await BaselineAnomalyTool.execute(
+      { metricName: "cpu.usage", entityId: ownServiceId.toString() },
+      ctx,
+    );
+
+    expect(result.dataForLlm).toContain("normal — within the expected range");
+  });
+});

package/Tests/Server/Utils/AI/LLMServiceToolCalling.test.ts

@@ -384,3 +384,47 @@ describe("LLMService — prompt caching", () => {
     expect(response.usage!.totalTokens).toBe(55);
   });
 });
+
+describe("LLMService — additionalParams (per-provider overrides)", () => {
+  test("merges provider additionalParams into the request body", async () => {
+    const spy: PostSpy = mockPostResponse({
+      choices: [{ message: { content: "OK" } }],
+    });
+
+    await LLMService.getCompletion({
+      llmProviderConfig: { llmType: LlmType.OpenAI, apiKey: "test-key" },
+      messages: [{ role: "user", content: "hi" }],
+      maxTokens: 1024,
+      additionalParams: { temperature: 0.2, top_p: 0.9 },
+    });
+
+    const requestBody: JSONObject = (
+      spy.mock.calls[0]![0] as { data: JSONObject }
+    ).data;
+    // additionalParams override defaults and are added to the body...
+    expect(requestBody["temperature"]).toBe(0.2);
+    expect(requestBody["top_p"]).toBe(0.9);
+    // ...while leaving the default max_tokens intact for legacy providers.
+    expect(requestBody["max_tokens"]).toBe(1024);
+  });
+
+  test("max_completion_tokens in additionalParams drops the legacy max_tokens", async () => {
+    const spy: PostSpy = mockPostResponse({
+      choices: [{ message: { content: "OK" } }],
+    });
+
+    await LLMService.getCompletion({
+      llmProviderConfig: { llmType: LlmType.OpenAI, apiKey: "test-key" },
+      messages: [{ role: "user", content: "hi" }],
+      maxTokens: 1024,
+      // gpt-5 / o1 / o3 reject max_tokens and require max_completion_tokens.
+      additionalParams: { max_completion_tokens: 2048 },
+    });
+
+    const requestBody: JSONObject = (
+      spy.mock.calls[0]![0] as { data: JSONObject }
+    ).data;
+    expect(requestBody["max_completion_tokens"]).toBe(2048);
+    expect(requestBody["max_tokens"]).toBeUndefined();
+  });
+});