@oneuptime/common 11.5.8 → 11.5.10

package/Tests/Utils/Metrics/MetricFormulaEvaluator.test.ts

@@ -26,6 +26,20 @@ const buildQueryConfig: BuildQueryConfigFunction = (
   };
 };
 
+type BuildGroupedQueryConfigFunction = (
+  variable: string,
+  groupByAttributeKeys: Array<string>,
+) => MetricQueryConfigData;
+
+const buildGroupedQueryConfig: BuildGroupedQueryConfigFunction = (
+  variable: string,
+  groupByAttributeKeys: Array<string>,
+): MetricQueryConfigData => {
+  const config: MetricQueryConfigData = buildQueryConfig(variable);
+  config.metricQueryData.groupByAttributeKeys = groupByAttributeKeys;
+  return config;
+};
+
 type BuildResultFunction = (
   points: Array<{ timestamp: string; value: number }>,
 ) => AggregatedResult;
@@ -43,6 +57,38 @@ const buildResult: BuildResultFunction = (
   };
 };
 
+type BuildGroupedResultFunction = (
+  points: Array<{
+    timestamp: string;
+    value: number;
+    attributes: Record<string, string>;
+  }>,
+) => AggregatedResult;
+
+const buildGroupedResult: BuildGroupedResultFunction = (
+  points: Array<{
+    timestamp: string;
+    value: number;
+    attributes: Record<string, string>;
+  }>,
+): AggregatedResult => {
+  return {
+    data: points.map(
+      (point: {
+        timestamp: string;
+        value: number;
+        attributes: Record<string, string>;
+      }) => {
+        return {
+          timestamp: new Date(point.timestamp),
+          value: point.value,
+          attributes: point.attributes,
+        };
+      },
+    ),
+  };
+};
+
 describe("MetricFormulaEvaluator", () => {
   describe("evaluateFormula", () => {
     test("adds two series point-by-point", () => {
@@ -230,6 +276,402 @@ describe("MetricFormulaEvaluator", () => {
         });
       }).toThrow(/unknown variable/i);
     });
+
+    test("throws a structural error for malformed formulas like a**b", () => {
+      expect(() => {
+        MetricFormulaEvaluator.evaluateFormula({
+          formula: "a ** b",
+          queryConfigs: [buildQueryConfig("a"), buildQueryConfig("b")],
+          formulaConfigs: [],
+          results: [
+            buildResult([{ timestamp: "2024-01-01T00:00:00.000Z", value: 2 }]),
+            buildResult([{ timestamp: "2024-01-01T00:00:00.000Z", value: 3 }]),
+          ],
+        });
+      }).toThrow(/missing an operand/i);
+    });
+  });
+
+  describe("group-aware evaluation", () => {
+    const timestamps: Array<string> = [
+      "2024-01-01T00:00:00.000Z",
+      "2024-01-01T00:01:00.000Z",
+    ];
+
+    test("evaluates grouped formulas once per group and stamps group attributes", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildGroupedQueryConfig("a", ["host.name"]),
+        buildGroupedQueryConfig("b", ["host.name"]),
+      ];
+
+      const results: Array<AggregatedResult> = [
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 10,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[0]!,
+            value: 40,
+            attributes: { "host.name": "web-2" },
+          },
+          {
+            timestamp: timestamps[1]!,
+            value: 20,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[1]!,
+            value: 80,
+            attributes: { "host.name": "web-2" },
+          },
+        ]),
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 2,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[0]!,
+            value: 4,
+            attributes: { "host.name": "web-2" },
+          },
+          {
+            timestamp: timestamps[1]!,
+            value: 2,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[1]!,
+            value: 4,
+            attributes: { "host.name": "web-2" },
+          },
+        ]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "a / b",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      // Groups are ordered by canonical label key: web-1 first, then web-2.
+      expect(output.data).toEqual([
+        {
+          timestamp: new Date(timestamps[0]!),
+          value: 5,
+          attributes: { "host.name": "web-1" },
+        },
+        {
+          timestamp: new Date(timestamps[1]!),
+          value: 10,
+          attributes: { "host.name": "web-1" },
+        },
+        {
+          timestamp: new Date(timestamps[0]!),
+          value: 10,
+          attributes: { "host.name": "web-2" },
+        },
+        {
+          timestamp: new Date(timestamps[1]!),
+          value: 20,
+          attributes: { "host.name": "web-2" },
+        },
+      ]);
+    });
+
+    test("broadcasts an ungrouped variable across groups", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildGroupedQueryConfig("a", ["host.name"]),
+        buildQueryConfig("b"),
+      ];
+
+      const results: Array<AggregatedResult> = [
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 10,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[0]!,
+            value: 30,
+            attributes: { "host.name": "web-2" },
+          },
+        ]),
+        buildResult([{ timestamp: timestamps[0]!, value: 2 }]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "a / b",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      expect(output.data).toEqual([
+        {
+          timestamp: new Date(timestamps[0]!),
+          value: 5,
+          attributes: { "host.name": "web-1" },
+        },
+        {
+          timestamp: new Date(timestamps[0]!),
+          value: 15,
+          attributes: { "host.name": "web-2" },
+        },
+      ]);
+    });
+
+    test("throws a structural error when grouped variables share no groups", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildGroupedQueryConfig("a", ["host.name"]),
+        buildGroupedQueryConfig("b", ["region"]),
+      ];
+
+      const results: Array<AggregatedResult> = [
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 1,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[0]!,
+            value: 2,
+            attributes: { "host.name": "web-2" },
+          },
+        ]),
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 3,
+            attributes: { region: "us-east" },
+          },
+          {
+            timestamp: timestamps[0]!,
+            value: 4,
+            attributes: { region: "eu-west" },
+          },
+        ]),
+      ];
+
+      expect(() => {
+        MetricFormulaEvaluator.evaluateFormula({
+          formula: "a + b",
+          queryConfigs,
+          formulaConfigs: [],
+          results,
+        });
+      }).toThrow(/no series groups in common/i);
+    });
+
+    test("joins a grouped variable that collapsed to a single series by group key (no cross-group broadcast)", () => {
+      /*
+       * Regression: $a and $b are both grouped by host.name, but in the
+       * charted window $b only returned rows for web-1 (web-2's
+       * denominator metric is missing). $b must NOT be treated as
+       * ungrouped-and-broadcast — that would compute a(web-2)/b(web-1)
+       * and stamp it as the web-2 series. Per the documented "groups
+       * present in ALL grouped variables" semantics, web-2 is dropped.
+       */
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildGroupedQueryConfig("a", ["host.name"]),
+        buildGroupedQueryConfig("b", ["host.name"]),
+      ];
+
+      const results: Array<AggregatedResult> = [
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 10,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[0]!,
+            value: 40,
+            attributes: { "host.name": "web-2" },
+          },
+        ]),
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 2,
+            attributes: { "host.name": "web-1" },
+          },
+        ]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "a / b",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      // Only web-1 (the common group) is emitted — and with web-1 math.
+      expect(output.data).toEqual([
+        {
+          timestamp: new Date(timestamps[0]!),
+          value: 5,
+          attributes: { "host.name": "web-1" },
+        },
+      ]);
+    });
+
+    test("still broadcasts a config-grouped variable whose result is EMPTY (degrades to gaps, not a structural error)", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildGroupedQueryConfig("a", ["host.name"]),
+        buildGroupedQueryConfig("b", ["host.name"]),
+      ];
+
+      const results: Array<AggregatedResult> = [
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 10,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[0]!,
+            value: 40,
+            attributes: { "host.name": "web-2" },
+          },
+        ]),
+        buildGroupedResult([]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "a / b",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      // Every point misses $b, so every point is skipped silently.
+      expect(output.data).toEqual([]);
+    });
+
+    test("single-series inputs stay byte-identical to ungrouped behavior", () => {
+      /*
+       * The metric-monitor worker pre-buckets per series fingerprint and
+       * calls the evaluator with one series per variable — even though
+       * the query configs still carry groupByAttributeKeys and the rows
+       * still carry full attributes. Output must be exactly the legacy
+       * shape: unstamped {timestamp, value} rows.
+       */
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildGroupedQueryConfig("a", ["host.name"]),
+        buildGroupedQueryConfig("b", ["host.name"]),
+      ];
+
+      const results: Array<AggregatedResult> = [
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 10,
+            attributes: { "host.name": "web-1", "process.pid": "42" },
+          },
+        ]),
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 4,
+            attributes: { "host.name": "web-1", "process.pid": "43" },
+          },
+        ]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "a - b",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      expect(output.data).toEqual([
+        { timestamp: new Date(timestamps[0]!), value: 6 },
+      ]);
+      expect(Object.keys(output.data[0]!)).toEqual(["timestamp", "value"]);
+    });
+
+    test("skips per-point gaps within a group silently", () => {
+      const queryConfigs: Array<MetricQueryConfigData> = [
+        buildGroupedQueryConfig("a", ["host.name"]),
+        buildGroupedQueryConfig("b", ["host.name"]),
+      ];
+
+      const results: Array<AggregatedResult> = [
+        buildGroupedResult([
+          {
+            timestamp: timestamps[0]!,
+            value: 10,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[1]!,
+            value: 20,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[0]!,
+            value: 30,
+            attributes: { "host.name": "web-2" },
+          },
+          {
+            timestamp: timestamps[1]!,
+            value: 40,
+            attributes: { "host.name": "web-2" },
+          },
+        ]),
+        buildGroupedResult([
+          // web-1 is missing the first timestamp for "b".
+          {
+            timestamp: timestamps[1]!,
+            value: 2,
+            attributes: { "host.name": "web-1" },
+          },
+          {
+            timestamp: timestamps[0]!,
+            value: 3,
+            attributes: { "host.name": "web-2" },
+          },
+          {
+            timestamp: timestamps[1]!,
+            value: 4,
+            attributes: { "host.name": "web-2" },
+          },
+        ]),
+      ];
+
+      const output: AggregatedResult = MetricFormulaEvaluator.evaluateFormula({
+        formula: "a / b",
+        queryConfigs,
+        formulaConfigs: [],
+        results,
+      });
+
+      expect(output.data).toEqual([
+        {
+          timestamp: new Date(timestamps[1]!),
+          value: 10,
+          attributes: { "host.name": "web-1" },
+        },
+        {
+          timestamp: new Date(timestamps[0]!),
+          value: 10,
+          attributes: { "host.name": "web-2" },
+        },
+        {
+          timestamp: new Date(timestamps[1]!),
+          value: 10,
+          attributes: { "host.name": "web-2" },
+        },
+      ]);
+    });
   });
 
   describe("validateFormula", () => {
@@ -265,5 +707,37 @@ describe("MetricFormulaEvaluator", () => {
       });
       expect(message).toMatch(/required/i);
     });
+
+    test("rejects doubled binary operators like a**b", () => {
+      const message: string | null = MetricFormulaEvaluator.validateFormula({
+        formula: "a ** b",
+        availableVariables: ["a", "b"],
+      });
+      expect(message).toMatch(/missing an operand/i);
+    });
+
+    test("rejects trailing operators like a+", () => {
+      const message: string | null = MetricFormulaEvaluator.validateFormula({
+        formula: "a +",
+        availableVariables: ["a"],
+      });
+      expect(message).toMatch(/missing an operand/i);
+    });
+
+    test("rejects empty parentheses", () => {
+      const message: string | null = MetricFormulaEvaluator.validateFormula({
+        formula: "()",
+        availableVariables: ["a"],
+      });
+      expect(message).toMatch(/empty/i);
+    });
+
+    test("rejects adjacent values with no operator", () => {
+      const message: string | null = MetricFormulaEvaluator.validateFormula({
+        formula: "a b",
+        availableVariables: ["a", "b"],
+      });
+      expect(message).toMatch(/single value/i);
+    });
   });
 });

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

@@ -234,13 +234,61 @@ describe("HeartbeatAvailabilityUtil.buildAvailabilitySeries", () => {
     expect(downPoints(result).length).toBeGreaterThanOrEqual(2);
   });
 
-  test("hour buckets are used for windows over 3 hours", () => {
+  test("5-minute buckets are used for windows over 3 hours", () => {
+    const windowEnd: Date = NOW;
+    const windowStart: Date = new Date(NOW.getTime() - 6 * 60 * MINUTE);
+    const bucketMs: number = 5 * MINUTE;
+    const base: number =
+      Math.floor(windowStart.getTime() / bucketMs) * bucketMs;
+    const rows: Array<AggregatedModel> = Array.from(
+      { length: 74 },
+      (_: unknown, i: number): AggregatedModel => {
+        return row(new Date(base + i * bucketMs));
+      },
+    );
+    const result: HeartbeatAvailabilityResult = build(
+      rows,
+      windowStart,
+      windowEnd,
+      NOW,
+    );
+    expect(result.uptimePercent).toBe(100);
+    // ~72 five-minute buckets, not ~360 minute buckets.
+    expect(result.points.length).toBeLessThanOrEqual(74);
+    expect(result.points.length).toBeGreaterThan(60);
+  });
+
+  test("15-minute buckets are used for a 24-hour window", () => {
     const windowEnd: Date = NOW;
     const windowStart: Date = new Date(NOW.getTime() - 24 * 60 * MINUTE);
+    const bucketMs: number = 15 * MINUTE;
+    const base: number =
+      Math.floor(windowStart.getTime() / bucketMs) * bucketMs;
+    const rows: Array<AggregatedModel> = Array.from(
+      { length: 98 },
+      (_: unknown, i: number): AggregatedModel => {
+        return row(new Date(base + i * bucketMs));
+      },
+    );
+    const result: HeartbeatAvailabilityResult = build(
+      rows,
+      windowStart,
+      windowEnd,
+      NOW,
+    );
+    expect(result.uptimePercent).toBe(100);
+    // ~96 fifteen-minute buckets, not ~1440 minute buckets.
+    expect(result.points.length).toBeLessThanOrEqual(98);
+    expect(result.points.length).toBeGreaterThan(90);
+  });
+
+  test("hour buckets are used for windows over 3 days", () => {
+    const windowEnd: Date = NOW;
+    const windowStart: Date = new Date(NOW.getTime() - 5 * 24 * 60 * MINUTE);
     const hourMs: number = 60 * MINUTE;
     const base: number = Math.floor(windowStart.getTime() / hourMs) * hourMs;
     const rows: Array<AggregatedModel> = Array.from(
-      { length: 25 },
+      { length: 122 },
       (_: unknown, i: number): AggregatedModel => {
         return row(new Date(base + i * hourMs));
       },
@@ -252,8 +300,8 @@ describe("HeartbeatAvailabilityUtil.buildAvailabilitySeries", () => {
       NOW,
     );
     expect(result.uptimePercent).toBe(100);
-    // ~24 hour buckets, not ~1440 minute buckets.
-    expect(result.points.length).toBeLessThanOrEqual(26);
+    // ~120 hour buckets, not ~7200 minute buckets.
+    expect(result.points.length).toBeLessThanOrEqual(122);
   });
 
   test("returns null uptime when nothing is evaluable", () => {

package/Types/AI/AIAgentTaskStatus.ts

@@ -2,6 +2,12 @@ enum AIAgentTaskStatus {
   Scheduled = "Scheduled",
   InProgress = "InProgress",
   Completed = "Completed",
+  /*
+   * The agent finished cleanly but had no fix to propose, so it opened no
+   * pull request. Reported instead of Error so a negative result is not
+   * counted as a failure — see AIRunStatus.NoFixFound, which this maps to.
+   */
+  NoFixFound = "NoFixFound",
   Error = "Error",
 }
 
@@ -32,6 +38,12 @@ export class AIAgentTaskStatusHelper {
         title: "Completed",
         description: "Task has been completed successfully.",
       },
+      {
+        status: AIAgentTaskStatus.NoFixFound,
+        title: "No Fix Found",
+        description:
+          "Task ran successfully but AI did not find a fix to propose.",
+      },
       {
         status: AIAgentTaskStatus.Error,
         title: "Error",
@@ -59,6 +71,7 @@ export class AIAgentTaskStatusHelper {
   public static isTerminalStatus(status: AIAgentTaskStatus): boolean {
     return (
       status === AIAgentTaskStatus.Completed ||
+      status === AIAgentTaskStatus.NoFixFound ||
       status === AIAgentTaskStatus.Error
     );
   }