@checkstack/healthcheck-backend 0.6.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,82 @@
 # @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
+
+- 1f81b60: ### Clickable Run History with Deep Linking
+
+  **Backend (`healthcheck-backend`):**
+
+  - Added `getRunById` service method to fetch a single health check run by ID
+
+  **Schema (`healthcheck-common`):**
+
+  - Added `getRunById` RPC procedure for fetching individual runs
+  - Added `historyRun` route for deep linking to specific runs (`/history/:systemId/:configurationId/:runId`)
+
+  **Frontend (`healthcheck-frontend`):**
+
+  - Table rows in Recent Runs and Run History now navigate to detailed view instead of expanding inline
+  - Added "Selected Run" card that displays when navigating to a specific run
+  - Extracted `ExpandedResultView` into reusable component
+  - Fixed layout shift during table pagination by preserving previous data while loading
+  - Removed accordion expansion in favor of consistent navigation UX
+
+### Patch Changes
+
+- 090143b: ### Health Check Aggregation & UI Fixes
+
+  **Backend (`healthcheck-backend`):**
+
+  - Fixed tail-end bucket truncation where the last aggregated bucket was cut off at the interval boundary instead of extending to the query end date
+  - Added `rangeEnd` parameter to `reaggregateBuckets()` to properly extend the last bucket
+  - Fixed cross-tier merge logic (`mergeTieredBuckets`) to prevent hourly aggregates from blocking fresh raw data
+
+  **Schema (`healthcheck-common`):**
+
+  - Added `bucketEnd` field to `AggregatedBucketBaseSchema` so frontends know the actual end time of each bucket
+
+  **Frontend (`healthcheck-frontend`):**
+
+  - Updated all components to use `bucket.bucketEnd` instead of calculating from `bucketIntervalSeconds`
+  - Fixed aggregation mode detection: changed `>` to `>=` so 7-day queries use aggregated data when `rawRetentionDays` is 7
+  - Added ref-based memoization in `useHealthCheckData` to prevent layout shift during signal-triggered refetches
+  - Exposed `isFetching` state to show loading spinner during background refetches
+  - Added debounced custom date range with Apply button to prevent fetching on every field change
+  - Added validation preventing start date >= end date in custom ranges
+  - Added sparkline downsampling: when there are 60+ data points, they are aggregated into buckets with informative tooltips
+
+  **UI (`ui`):**
+
+  - Fixed `DateRangeFilter` presets to use true sliding windows (removed `startOfDay` from 7-day and 30-day ranges)
+  - Added `disabled` prop to `DateRangeFilter` and `DateTimePicker` components
+  - Added `onCustomChange` prop to `DateRangeFilter` for debounced custom date handling
+  - Improved layout: custom date pickers now inline with preset buttons on desktop
+  - Added responsive mobile layout: date pickers stack vertically with down arrow
+  - Added validation error display for invalid date ranges
+
+- Updated dependencies [1f81b60]
+- Updated dependencies [090143b]
+  - @checkstack/healthcheck-common@0.7.0
+
 ## 0.6.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-backend",
-  "version": "0.6.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/aggregation-utils.test.ts

@@ -342,6 +342,66 @@ describe("aggregation-utils", () => {
       expect(result[1].sourceTier).toBe("hourly");
       expect(result[2].sourceTier).toBe("raw");
     });
+
+    it("raw buckets take precedence even when hourly starts earlier (regression test)", () => {
+      /**
+       * Regression test for the "Tail-End Stale" bug:
+       * When an hourly aggregate (e.g., 21:00-22:00) exists and raw data
+       * arrives mid-hour (e.g., 21:48), the raw data should take precedence,
+       * not be blocked by the hourly aggregate.
+       *
+       * Bug scenario:
+       * - Hourly aggregate: 21:00 to 22:00
+       * - Raw buckets: 21:48 to 22:11 (fresh data)
+       * - Old buggy behavior: hourly was processed first (earlier start time),
+       *   set coveredUntil=22:00, and raw was skipped
+       * - Correct behavior: raw always takes precedence, hourly is excluded
+       */
+      const baseTime = 21 * HOUR; // 21:00
+
+      // Hourly bucket covering 21:00-22:00 (stale aggregate)
+      const hourlyBuckets = [
+        createBucket({
+          startMs: baseTime,
+          durationMs: HOUR,
+          runCount: 60, // Old stale data
+          sourceTier: "hourly",
+        }),
+      ];
+
+      // Raw buckets at 21:48 and 22:00 (fresh data that should NOT be blocked)
+      const rawBuckets = [
+        createBucket({
+          startMs: baseTime + 48 * MINUTE, // 21:48
+          durationMs: 12 * MINUTE,
+          runCount: 12, // Fresh data
+          sourceTier: "raw",
+        }),
+        createBucket({
+          startMs: baseTime + HOUR, // 22:00
+          durationMs: 11 * MINUTE,
+          runCount: 11, // Fresh data
+          sourceTier: "raw",
+        }),
+      ];
+
+      const result = mergeTieredBuckets({
+        rawBuckets,
+        hourlyBuckets,
+        dailyBuckets: [],
+      });
+
+      // CRITICAL: Both raw buckets should be included
+      expect(result).toHaveLength(2);
+      expect(result[0].sourceTier).toBe("raw");
+      expect(result[1].sourceTier).toBe("raw");
+      expect(result[0].runCount).toBe(12); // 21:48 bucket
+      expect(result[1].runCount).toBe(11); // 22:00 bucket
+
+      // Hourly bucket should be excluded because raw data covers its range
+      const hourlyInResult = result.find((b) => b.sourceTier === "hourly");
+      expect(hourlyInResult).toBeUndefined();
+    });
   });
 
   describe("combineBuckets", () => {
@@ -520,6 +580,7 @@ describe("aggregation-utils", () => {
         sourceBuckets: [],
         targetIntervalMs: HOUR,
         rangeStart: new Date(0),
+        rangeEnd: new Date(HOUR),
       });
 
       expect(result).toEqual([]);
@@ -552,6 +613,7 @@ describe("aggregation-utils", () => {
         sourceBuckets,
         targetIntervalMs: HOUR,
         rangeStart: new Date(0),
+        rangeEnd: new Date(HOUR),
       });
 
       expect(result).toHaveLength(1);
@@ -585,6 +647,7 @@ describe("aggregation-utils", () => {
         sourceBuckets,
         targetIntervalMs: HOUR,
         rangeStart: new Date(0),
+        rangeEnd: new Date(2 * HOUR),
       });
 
       expect(result).toHaveLength(2);
@@ -611,6 +674,7 @@ describe("aggregation-utils", () => {
         sourceBuckets,
         targetIntervalMs: HOUR,
         rangeStart,
+        rangeEnd: new Date(rangeStart.getTime() + HOUR),
       });
 
       expect(result).toHaveLength(1);
@@ -633,6 +697,7 @@ describe("aggregation-utils", () => {
         sourceBuckets,
         targetIntervalMs: HOUR,
         rangeStart: new Date(0),
+        rangeEnd: new Date(3 * HOUR),
       });
 
       expect(result).toHaveLength(3);

package/src/aggregation-utils.ts

@@ -193,6 +193,10 @@ const TIER_PRIORITY: Record<NormalizedBucket["sourceTier"], number> = {
 /**
  * Merge buckets from different tiers, preferring most granular data.
  * For overlapping time periods, uses priority: raw > hourly > daily.
+ *
+ * IMPORTANT: Raw buckets always take precedence over hourly/daily aggregates,
+ * even when the aggregate bucket starts earlier. This ensures fresh raw data
+ * is never blocked by stale pre-computed aggregates.
  */
 export function mergeTieredBuckets(params: {
   rawBuckets: NormalizedBucket[];
@@ -201,42 +205,108 @@ export function mergeTieredBuckets(params: {
 }): NormalizedBucket[] {
   const { rawBuckets, hourlyBuckets, dailyBuckets } = params;
 
-  // Combine all buckets
-  const allBuckets = [...rawBuckets, ...hourlyBuckets, ...dailyBuckets];
-
-  if (allBuckets.length === 0) {
+  if (
+    rawBuckets.length === 0 &&
+    hourlyBuckets.length === 0 &&
+    dailyBuckets.length === 0
+  ) {
     return [];
   }
 
-  // Sort by start time, then by tier priority (most granular first)
-  allBuckets.sort((a, b) => {
-    const timeDiff = a.bucketStart.getTime() - b.bucketStart.getTime();
-    if (timeDiff !== 0) return timeDiff;
-    return TIER_PRIORITY[a.sourceTier] - TIER_PRIORITY[b.sourceTier];
-  });
+  // Two-pass approach:
+  // 1. First, collect all time ranges covered by raw data (highest priority)
+  // 2. Then, add hourly/daily buckets only for gaps not covered by raw data
+
+  // Build a sorted list of raw bucket time ranges for efficient lookup
+  const rawTimeRanges = rawBuckets
+    .map((b) => ({
+      start: b.bucketStart.getTime(),
+      end: b.bucketEndMs,
+    }))
+    .toSorted((a, b) => a.start - b.start);
+
+  // Merge overlapping raw time ranges into continuous coverage
+  const rawCoverage: Array<{ start: number; end: number }> = [];
+  for (const range of rawTimeRanges) {
+    if (rawCoverage.length === 0) {
+      rawCoverage.push({ ...range });
+    } else {
+      const last = rawCoverage.at(-1)!;
+      // If this range overlaps or is adjacent to the last, extend it
+      if (range.start <= last.end) {
+        last.end = Math.max(last.end, range.end);
+      } else {
+        rawCoverage.push({ ...range });
+      }
+    }
+  }
 
-  // Merge overlapping buckets, keeping the most granular tier
-  const result: NormalizedBucket[] = [];
-  let coveredUntil = 0; // Timestamp up to which we have data
-
-  for (const bucket of allBuckets) {
-    const bucketStartMs = bucket.bucketStart.getTime();
-
-    // Skip if this bucket's time range is already covered by higher-priority data
-    if (bucketStartMs < coveredUntil) {
-      // Check if this bucket extends beyond current coverage
-      if (bucket.bucketEndMs > coveredUntil) {
-        // Partial overlap - for simplicity, we skip partially overlapping lower-priority buckets
-        // This is acceptable because we prefer raw data which is more granular
-        continue;
+  // Helper: check if a bucket has ANY overlap with raw data
+  // Two ranges overlap if: start1 < end2 AND start2 < end1
+  const doesBucketOverlapWithRaw = (bucket: NormalizedBucket): boolean => {
+    const bucketStart = bucket.bucketStart.getTime();
+    const bucketEnd = bucket.bucketEndMs;
+
+    for (const range of rawCoverage) {
+      // Check for overlap: ranges overlap if they intersect
+      if (bucketStart < range.end && range.start < bucketEnd) {
+        return true;
+      }
+      // Optimization: if raw range starts after bucket ends, no more overlaps possible
+      if (range.start >= bucketEnd) {
+        break;
       }
-      continue;
     }
+    return false;
+  };
 
-    result.push(bucket);
-    coveredUntil = bucket.bucketEndMs;
+  // Start with all raw buckets (they always take precedence)
+  const result: NormalizedBucket[] = [...rawBuckets];
+
+  // Add hourly buckets that don't overlap with raw data
+  for (const bucket of hourlyBuckets) {
+    if (!doesBucketOverlapWithRaw(bucket)) {
+      result.push(bucket);
+    }
   }
 
+  // Add daily buckets that don't overlap with raw or hourly data
+  // Build hourly coverage to check against
+  const hourlyTimeRanges = hourlyBuckets
+    .map((b) => ({
+      start: b.bucketStart.getTime(),
+      end: b.bucketEndMs,
+    }))
+    .toSorted((a, b) => a.start - b.start);
+
+  // Helper: check if a bucket has ANY overlap with hourly data
+  const doesBucketOverlapWithHourly = (bucket: NormalizedBucket): boolean => {
+    const bucketStart = bucket.bucketStart.getTime();
+    const bucketEnd = bucket.bucketEndMs;
+
+    for (const range of hourlyTimeRanges) {
+      if (bucketStart < range.end && range.start < bucketEnd) {
+        return true;
+      }
+      if (range.start >= bucketEnd) {
+        break;
+      }
+    }
+    return false;
+  };
+
+  for (const bucket of dailyBuckets) {
+    if (
+      !doesBucketOverlapWithRaw(bucket) &&
+      !doesBucketOverlapWithHourly(bucket)
+    ) {
+      result.push(bucket);
+    }
+  }
+
+  // Sort final result by bucket start time
+  result.sort((a, b) => a.bucketStart.getTime() - b.bucketStart.getTime());
+
   return result;
 }
 
@@ -349,19 +419,24 @@ export function combineBuckets(params: {
 /**
  * Re-aggregate a list of normalized buckets into target-sized buckets.
  * Groups source buckets by target bucket boundaries and combines them.
+ *
+ * @param rangeEnd - The end of the query range. The last bucket will extend
+ *   to this time to ensure data is visually represented up to the query end.
  */
 export function reaggregateBuckets(params: {
   sourceBuckets: NormalizedBucket[];
   targetIntervalMs: number;
   rangeStart: Date;
+  rangeEnd: Date;
 }): NormalizedBucket[] {
-  const { sourceBuckets, targetIntervalMs, rangeStart } = params;
+  const { sourceBuckets, targetIntervalMs, rangeStart, rangeEnd } = params;
 
   if (sourceBuckets.length === 0) {
     return [];
   }
 
   const rangeStartMs = rangeStart.getTime();
+  const rangeEndMs = rangeEnd.getTime();
 
   // Group source buckets by target bucket index
   const bucketGroups = new Map<number, NormalizedBucket[]>();
@@ -379,9 +454,16 @@ export function reaggregateBuckets(params: {
   // Combine each group into a single target bucket
   const result: NormalizedBucket[] = [];
 
+  // Find the maximum bucket index to identify the last bucket
+  const maxIndex = Math.max(...bucketGroups.keys());
+
   for (const [index, buckets] of bucketGroups) {
     const targetBucketStart = new Date(rangeStartMs + index * targetIntervalMs);
-    const targetBucketEndMs = targetBucketStart.getTime() + targetIntervalMs;
+    const intervalEndMs = targetBucketStart.getTime() + targetIntervalMs;
+
+    // For the last bucket, extend to rangeEnd to capture all trailing data
+    const targetBucketEndMs =
+      index === maxIndex ? Math.max(intervalEndMs, rangeEndMs) : intervalEndMs;
 
     result.push(
       combineBuckets({