@checkstack/healthcheck-backend 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @checkstack/healthcheck-backend
 
+## 0.8.0
+
+### Minor Changes
+
+- d6f7449: Add availability statistics display to HealthCheckSystemOverview
+
+  - New `getAvailabilityStats` RPC endpoint that calculates availability percentages for 31-day and 365-day periods
+  - Availability is calculated as `(healthyRuns / totalRuns) * 100`
+  - Data is sourced from both daily aggregates and recent raw runs to include the most up-to-date information
+  - Frontend displays availability stats with color-coded badges (green ≥99.9%, yellow ≥99%, red <99%)
+  - Shows total run counts for each period
+
+### Patch Changes
+
+- Updated dependencies [d6f7449]
+  - @checkstack/healthcheck-common@0.8.0
+
 ## 0.7.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-backend",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
@@ -33,6 +33,7 @@
     "@checkstack/tsconfig": "workspace:*",
     "@orpc/server": "^1.13.2",
     "@types/bun": "^1.0.0",
+    "date-fns": "^4.1.0",
     "drizzle-kit": "^0.31.8",
     "typescript": "^5.0.0"
   }

package/src/availability.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect, mock, beforeEach } from "bun:test";
+import { HealthCheckService } from "./service";
+import { subDays } from "date-fns";
+
+describe("HealthCheckService.getAvailabilityStats", () => {
+  // Mock database
+  let mockDb: ReturnType<typeof createMockDb>;
+  let service: HealthCheckService;
+
+  // Store mock data for different queries
+  let mockDailyAggregates: Array<{
+    bucketStart: Date;
+    runCount: number;
+    healthyCount: number;
+  }> = [];
+  let mockRawRuns: Array<{
+    status: "healthy" | "unhealthy" | "degraded";
+    timestamp: Date;
+  }> = [];
+  let selectCallCount = 0;
+
+  function createMockDb() {
+    // Reset call counter on creation
+    selectCallCount = 0;
+
+    // Create a mock that handles:
+    // 1. First select: daily aggregates
+    // 2. Second select: raw runs
+    const createSelectChain = () => {
+      const currentCall = selectCallCount++;
+
+      return {
+        from: mock(() => ({
+          where: mock(() => {
+            // First call: daily aggregates, Second call: raw runs
+            if (currentCall === 0) return Promise.resolve(mockDailyAggregates);
+            return Promise.resolve(mockRawRuns);
+          }),
+        })),
+      };
+    };
+
+    return {
+      select: mock(createSelectChain),
+    };
+  }
+
+  beforeEach(() => {
+    // Reset mock data
+    mockDailyAggregates = [];
+    mockRawRuns = [];
+    mockDb = createMockDb();
+    service = new HealthCheckService(mockDb as never);
+  });
+
+  describe("with no data", () => {
+    it("returns null availability when no aggregates or runs exist", async () => {
+      const result = await service.getAvailabilityStats({
+        systemId: "sys-1",
+        configurationId: "config-1",
+      });
+
+      expect(result.availability31Days).toBeNull();
+      expect(result.availability365Days).toBeNull();
+      expect(result.totalRuns31Days).toBe(0);
+      expect(result.totalRuns365Days).toBe(0);
+    });
+  });
+
+  describe("with only daily aggregates", () => {
+    it("calculates 100% availability when all runs are healthy", async () => {
+      const now = new Date();
+
+      mockDailyAggregates = [
+        { bucketStart: subDays(now, 10), runCount: 100, healthyCount: 100 },
+        { bucketStart: subDays(now, 20), runCount: 100, healthyCount: 100 },
+      ];
+
+      const result = await service.getAvailabilityStats({
+        systemId: "sys-1",
+        configurationId: "config-1",
+      });
+
+      expect(result.availability31Days).toBe(100);
+      expect(result.availability365Days).toBe(100);
+      expect(result.totalRuns31Days).toBe(200);
+      expect(result.totalRuns365Days).toBe(200);
+    });
+
+    it("calculates correct availability with mixed results", async () => {
+      const now = new Date();
+
+      mockDailyAggregates = [
+        { bucketStart: subDays(now, 10), runCount: 100, healthyCount: 90 }, // 90%
+        { bucketStart: subDays(now, 20), runCount: 100, healthyCount: 80 }, // 80%
+      ];
+
+      const result = await service.getAvailabilityStats({
+        systemId: "sys-1",
+        configurationId: "config-1",
+      });
+
+      // 170 healthy / 200 total = 85%
+      expect(result.availability31Days).toBe(85);
+      expect(result.availability365Days).toBe(85);
+      expect(result.totalRuns31Days).toBe(200);
+      expect(result.totalRuns365Days).toBe(200);
+    });
+
+    it("separates 31-day and 365-day data correctly", async () => {
+      const now = new Date();
+
+      mockDailyAggregates = [
+        // Within 31 days
+        { bucketStart: subDays(now, 10), runCount: 100, healthyCount: 99 },
+        // Outside 31 days, but within 365 days
+        { bucketStart: subDays(now, 60), runCount: 100, healthyCount: 50 },
+      ];
+
+      const result = await service.getAvailabilityStats({
+        systemId: "sys-1",
+        configurationId: "config-1",
+      });
+
+      // 31 days: 99/100 = 99%
+      expect(result.availability31Days).toBe(99);
+      expect(result.totalRuns31Days).toBe(100);
+
+      // 365 days: (99+50)/200 = 74.5%
+      expect(result.availability365Days).toBe(74.5);
+      expect(result.totalRuns365Days).toBe(200);
+    });
+  });
+
+  describe("with raw runs (recent data not yet aggregated)", () => {
+    it("includes raw runs that are not in any aggregate bucket", async () => {
+      const now = new Date();
+
+      // No daily aggregates
+      mockDailyAggregates = [];
+
+      // Recent raw runs
+      mockRawRuns = [
+        { status: "healthy", timestamp: subDays(now, 1) },
+        { status: "healthy", timestamp: subDays(now, 2) },
+        { status: "unhealthy", timestamp: subDays(now, 3) },
+      ];
+
+      const result = await service.getAvailabilityStats({
+        systemId: "sys-1",
+        configurationId: "config-1",
+      });
+
+      // 2 healthy / 3 total = 66.67%
+      expect(result.availability31Days).toBeCloseTo(66.67, 1);
+      expect(result.availability365Days).toBeCloseTo(66.67, 1);
+      expect(result.totalRuns31Days).toBe(3);
+      expect(result.totalRuns365Days).toBe(3);
+    });
+
+    it("deduplicates raw runs when aggregate bucket exists", async () => {
+      const now = new Date();
+      const bucketDate = subDays(now, 5);
+      bucketDate.setUTCHours(0, 0, 0, 0);
+
+      // Aggregate bucket for that day
+      mockDailyAggregates = [
+        { bucketStart: bucketDate, runCount: 10, healthyCount: 9 },
+      ];
+
+      // Raw runs on the same day (should be deduplicated)
+      const runTimestamp = new Date(bucketDate);
+      runTimestamp.setUTCHours(12, 0, 0, 0); // Same day, different time
+      mockRawRuns = [
+        { status: "healthy", timestamp: runTimestamp },
+        { status: "healthy", timestamp: runTimestamp },
+      ];
+
+      const result = await service.getAvailabilityStats({
+        systemId: "sys-1",
+        configurationId: "config-1",
+      });
+
+      // Should only count the aggregate bucket, not the raw runs
+      expect(result.totalRuns31Days).toBe(10);
+      expect(result.totalRuns365Days).toBe(10);
+      expect(result.availability31Days).toBe(90);
+    });
+  });
+
+  describe("99.9% availability calculation", () => {
+    it("calculates precise availability for SLA tracking", async () => {
+      const now = new Date();
+
+      // Simulate a month with 1 failure out of 1000 runs
+      mockDailyAggregates = [
+        { bucketStart: subDays(now, 15), runCount: 1000, healthyCount: 999 },
+      ];
+
+      const result = await service.getAvailabilityStats({
+        systemId: "sys-1",
+        configurationId: "config-1",
+      });
+
+      expect(result.availability31Days).toBe(99.9);
+      expect(result.availability365Days).toBe(99.9);
+    });
+
+    it("calculates very high availability correctly", async () => {
+      const now = new Date();
+
+      // 99.99% availability
+      mockDailyAggregates = [
+        { bucketStart: subDays(now, 15), runCount: 10_000, healthyCount: 9999 },
+      ];
+
+      const result = await service.getAvailabilityStats({
+        systemId: "sys-1",
+        configurationId: "config-1",
+      });
+
+      expect(result.availability31Days).toBe(99.99);
+    });
+  });
+});

package/src/router.ts

@@ -224,6 +224,10 @@ export const createHealthCheckRouter = (
         return service.getSystemHealthOverview(input.systemId);
       },
     ),
+
+    getAvailabilityStats: os.getAvailabilityStats.handler(async ({ input }) => {
+      return service.getAvailabilityStats(input);
+    }),
   });
 };
 

package/src/service.ts

@@ -917,6 +917,120 @@ export class HealthCheckService {
    * Calculate bucket start time for dynamic interval sizing.
    * Aligns buckets to the query start time.
    */
+  /**
+   * Get availability statistics for a health check over 31-day and 365-day periods.
+   * Availability is calculated as (healthyCount / totalRunCount) * 100.
+   */
+  async getAvailabilityStats(props: {
+    systemId: string;
+    configurationId: string;
+  }): Promise<{
+    availability31Days: number | null;
+    availability365Days: number | null;
+    totalRuns31Days: number;
+    totalRuns365Days: number;
+  }> {
+    const { systemId, configurationId } = props;
+    const now = new Date();
+
+    // Calculate cutoff dates
+    const cutoff31Days = new Date(now.getTime() - 31 * 24 * 60 * 60 * 1000);
+    const cutoff365Days = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000);
+
+    // Query daily aggregates for the full 365-day period
+    const dailyAggregates = await this.db
+      .select({
+        bucketStart: healthCheckAggregates.bucketStart,
+        runCount: healthCheckAggregates.runCount,
+        healthyCount: healthCheckAggregates.healthyCount,
+      })
+      .from(healthCheckAggregates)
+      .where(
+        and(
+          eq(healthCheckAggregates.systemId, systemId),
+          eq(healthCheckAggregates.configurationId, configurationId),
+          eq(healthCheckAggregates.bucketSize, "daily"),
+          gte(healthCheckAggregates.bucketStart, cutoff365Days),
+        ),
+      );
+
+    // Also query raw runs for the recent period not yet aggregated (typically last 7 days)
+    const recentRuns = await this.db
+      .select({
+        status: healthCheckRuns.status,
+        timestamp: healthCheckRuns.timestamp,
+      })
+      .from(healthCheckRuns)
+      .where(
+        and(
+          eq(healthCheckRuns.systemId, systemId),
+          eq(healthCheckRuns.configurationId, configurationId),
+          gte(healthCheckRuns.timestamp, cutoff365Days),
+        ),
+      );
+
+    // Separate data by period
+    let totalRuns31Days = 0;
+    let healthyRuns31Days = 0;
+    let totalRuns365Days = 0;
+    let healthyRuns365Days = 0;
+
+    // Process daily aggregates
+    for (const agg of dailyAggregates) {
+      totalRuns365Days += agg.runCount;
+      healthyRuns365Days += agg.healthyCount;
+
+      if (agg.bucketStart >= cutoff31Days) {
+        totalRuns31Days += agg.runCount;
+        healthyRuns31Days += agg.healthyCount;
+      }
+    }
+
+    // Process recent raw runs (to include data not yet aggregated)
+    // Deduplicate by checking if a run's timestamp falls within an already-counted aggregate bucket
+    const aggregateBucketStarts = new Set(
+      dailyAggregates.map((a) => a.bucketStart.getTime()),
+    );
+
+    for (const run of recentRuns) {
+      // Calculate which daily bucket this run would belong to
+      const runBucketStart = new Date(run.timestamp);
+      runBucketStart.setUTCHours(0, 0, 0, 0);
+
+      // Only count if this bucket isn't already in aggregates
+      if (!aggregateBucketStarts.has(runBucketStart.getTime())) {
+        totalRuns365Days += 1;
+        if (run.status === "healthy") {
+          healthyRuns365Days += 1;
+        }
+
+        if (run.timestamp >= cutoff31Days) {
+          totalRuns31Days += 1;
+          if (run.status === "healthy") {
+            healthyRuns31Days += 1;
+          }
+        }
+      }
+    }
+
+    // Calculate availability percentages
+    const availability31Days =
+      // eslint-disable-next-line unicorn/no-null -- RPC contract uses nullable()
+      totalRuns31Days > 0 ? (healthyRuns31Days / totalRuns31Days) * 100 : null;
+    const availability365Days =
+      totalRuns365Days > 0
+        ? (healthyRuns365Days / totalRuns365Days) * 100
+        : // eslint-disable-next-line unicorn/no-null -- RPC contract uses nullable()
+          null;
+
+    return {
+      availability31Days,
+      availability365Days,
+      totalRuns31Days,
+      totalRuns365Days,
+    };
+  }
+
   private getBucketStartDynamic(
     timestamp: Date,
     rangeStart: Date,