@checkstack/healthcheck-backend 0.12.0 → 0.13.0

package/src/service.ts

@@ -5,6 +5,7 @@ import {
   StateThresholds,
   HealthCheckStatus,
   RetentionConfig,
+  type HealthCheckRunResult,
 } from "@checkstack/healthcheck-common";
 import {
   healthCheckConfigurations,
@@ -12,13 +13,13 @@ import {
   healthCheckRuns,
   healthCheckAggregates,
   VersionedStateThresholds,
-  DEFAULT_RETENTION_CONFIG,
 } from "./schema";
 import * as schema from "./schema";
-import { eq, and, InferSelectModel, desc, gte, lte, lt } from "drizzle-orm";
+import { eq, and, InferSelectModel, desc, gte, lte, isNull } from "drizzle-orm";
 import { ORPCError } from "@orpc/server";
 import { evaluateHealthStatus } from "./state-evaluator";
 import { stateThresholds } from "./state-thresholds-migrations";
+import { incrementHourlyAggregate } from "./realtime-aggregation";
 import type {
   HealthCheckRegistry,
   SafeDatabase,
@@ -130,12 +131,16 @@ export class HealthCheckService {
     configurationId: string;
     enabled?: boolean;
     stateThresholds?: StateThresholds;
+    satelliteIds?: string[];
+    includeLocal?: boolean;
   }) {
     const {
       systemId,
       configurationId,
       enabled = true,
       stateThresholds: stateThresholds_,
+      satelliteIds,
+      includeLocal = true,
     } = props;
 
     // Wrap thresholds in versioned config if provided
@@ -149,6 +154,8 @@ export class HealthCheckService {
         configurationId,
         enabled,
         stateThresholds: versionedThresholds,
+        satelliteIds: satelliteIds ?? undefined,
+        includeLocal,
       })
       .onConflictDoUpdate({
         target: [
@@ -158,6 +165,8 @@ export class HealthCheckService {
         set: {
           enabled,
           stateThresholds: versionedThresholds,
+          satelliteIds: satelliteIds ?? undefined,
+          includeLocal,
           updatedAt: new Date(),
         },
       });
@@ -271,6 +280,8 @@ export class HealthCheckService {
         configName: healthCheckConfigurations.name,
         enabled: systemHealthChecks.enabled,
         stateThresholds: systemHealthChecks.stateThresholds,
+        satelliteIds: systemHealthChecks.satelliteIds,
+        includeLocal: systemHealthChecks.includeLocal,
       })
       .from(systemHealthChecks)
       .innerJoin(
@@ -291,6 +302,8 @@ export class HealthCheckService {
         configurationName: row.configName,
         enabled: row.enabled,
         stateThresholds: thresholds,
+        satelliteIds: row.satelliteIds ?? undefined,
+        includeLocal: row.includeLocal,
       });
     }
     return results;
@@ -475,6 +488,7 @@ export class HealthCheckService {
     configurationId?: string;
     startDate?: Date;
     endDate?: Date;
+    sourceFilter?: string;
     limit?: number;
     offset?: number;
     sortOrder: "asc" | "desc";
@@ -484,6 +498,7 @@ export class HealthCheckService {
       configurationId,
       startDate,
       endDate,
+      sourceFilter,
       limit = 10,
       offset = 0,
       sortOrder,
@@ -496,6 +511,13 @@ export class HealthCheckService {
     if (startDate) conditions.push(gte(healthCheckRuns.timestamp, startDate));
     if (endDate) conditions.push(lte(healthCheckRuns.timestamp, endDate));
 
+    // Source filtering: "local" = no sourceId, UUID = specific satellite
+    if (sourceFilter === "local") {
+      conditions.push(isNull(healthCheckRuns.sourceId));
+    } else if (sourceFilter) {
+      conditions.push(eq(healthCheckRuns.sourceId, sourceFilter));
+    }
+
     // Build where clause
     const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
 
@@ -523,6 +545,8 @@ export class HealthCheckService {
         status: run.status,
         timestamp: run.timestamp,
         latencyMs: run.latencyMs ?? undefined,
+        sourceId: run.sourceId ?? undefined,
+        sourceLabel: run.sourceLabel ?? undefined,
       })),
       total,
     };
@@ -538,6 +562,7 @@ export class HealthCheckService {
     configurationId?: string;
     startDate?: Date;
     endDate?: Date;
+    sourceFilter?: string;
     limit?: number;
     offset?: number;
     sortOrder: "asc" | "desc";
@@ -547,6 +572,7 @@ export class HealthCheckService {
       configurationId,
       startDate,
       endDate,
+      sourceFilter,
       limit = 10,
       offset = 0,
       sortOrder,
@@ -559,6 +585,13 @@ export class HealthCheckService {
     if (startDate) conditions.push(gte(healthCheckRuns.timestamp, startDate));
     if (endDate) conditions.push(lte(healthCheckRuns.timestamp, endDate));
 
+    // Source filtering: "local" = no sourceId, UUID = specific satellite
+    if (sourceFilter === "local") {
+      conditions.push(isNull(healthCheckRuns.sourceId));
+    } else if (sourceFilter) {
+      conditions.push(eq(healthCheckRuns.sourceId, sourceFilter));
+    }
+
     const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
     const total = await this.db.$count(healthCheckRuns, whereClause);
 
@@ -583,6 +616,8 @@ export class HealthCheckService {
         result: run.result ?? {},
         timestamp: run.timestamp,
         latencyMs: run.latencyMs ?? undefined,
+        sourceId: run.sourceId ?? undefined,
+        sourceLabel: run.sourceLabel ?? undefined,
       })),
       total,
     };
@@ -611,6 +646,8 @@ export class HealthCheckService {
       result: r.result ?? {},
       timestamp: r.timestamp,
       latencyMs: r.latencyMs ?? undefined,
+      sourceId: r.sourceId ?? undefined,
+      sourceLabel: r.sourceLabel ?? undefined,
     };
   }
 
@@ -625,6 +662,7 @@ export class HealthCheckService {
       configurationId: string;
       startDate: Date;
       endDate: Date;
+      sourceFilter?: string;
       targetPoints?: number;
     },
     options: { includeAggregatedResult: boolean },
@@ -634,6 +672,7 @@ export class HealthCheckService {
       configurationId,
       startDate,
       endDate,
+      sourceFilter,
       targetPoints = 500,
     } = props;
 
@@ -656,48 +695,66 @@ export class HealthCheckService {
         ? this.registry.getStrategy(config.strategyId)
         : undefined;
 
+    // Build source condition for raw runs
+    const rawConditions = [
+      eq(healthCheckRuns.systemId, systemId),
+      eq(healthCheckRuns.configurationId, configurationId),
+      gte(healthCheckRuns.timestamp, startDate),
+      lte(healthCheckRuns.timestamp, endDate),
+      ...(sourceFilter === "local"
+        ? [isNull(healthCheckRuns.sourceId)]
+        : sourceFilter
+          ? [eq(healthCheckRuns.sourceId, sourceFilter)]
+          : []),
+    ];
+
+    // Build source condition for hourly aggregates
+    const hourlyConditions = [
+      eq(healthCheckAggregates.systemId, systemId),
+      eq(healthCheckAggregates.configurationId, configurationId),
+      eq(healthCheckAggregates.bucketSize, "hourly"),
+      gte(healthCheckAggregates.bucketStart, startDate),
+      lte(healthCheckAggregates.bucketStart, endDate),
+      ...(sourceFilter === "local"
+        ? [isNull(healthCheckAggregates.sourceId)]
+        : sourceFilter
+          ? [eq(healthCheckAggregates.sourceId, sourceFilter)]
+          : []),
+    ];
+
+    // Build source condition for daily aggregates
+    const dailyConditions = [
+      eq(healthCheckAggregates.systemId, systemId),
+      eq(healthCheckAggregates.configurationId, configurationId),
+      eq(healthCheckAggregates.bucketSize, "daily"),
+      gte(healthCheckAggregates.bucketStart, startDate),
+      lte(healthCheckAggregates.bucketStart, endDate),
+      ...(sourceFilter === "local"
+        ? [isNull(healthCheckAggregates.sourceId)]
+        : sourceFilter
+          ? [eq(healthCheckAggregates.sourceId, sourceFilter)]
+          : []),
+    ];
+
     // Query all three tiers in parallel
     const [rawRuns, hourlyAggregates, dailyAggregates] = await Promise.all([
       // Raw runs
       this.db
         .select()
         .from(healthCheckRuns)
-        .where(
-          and(
-            eq(healthCheckRuns.systemId, systemId),
-            eq(healthCheckRuns.configurationId, configurationId),
-            gte(healthCheckRuns.timestamp, startDate),
-            lte(healthCheckRuns.timestamp, endDate),
-          ),
-        )
+        .where(and(...rawConditions))
         .orderBy(healthCheckRuns.timestamp),
       // Hourly aggregates
       this.db
         .select()
         .from(healthCheckAggregates)
-        .where(
-          and(
-            eq(healthCheckAggregates.systemId, systemId),
-            eq(healthCheckAggregates.configurationId, configurationId),
-            eq(healthCheckAggregates.bucketSize, "hourly"),
-            gte(healthCheckAggregates.bucketStart, startDate),
-            lte(healthCheckAggregates.bucketStart, endDate),
-          ),
-        )
+        .where(and(...hourlyConditions))
         .orderBy(healthCheckAggregates.bucketStart),
       // Daily aggregates
       this.db
         .select()
         .from(healthCheckAggregates)
-        .where(
-          and(
-            eq(healthCheckAggregates.systemId, systemId),
-            eq(healthCheckAggregates.configurationId, configurationId),
-            eq(healthCheckAggregates.bucketSize, "daily"),
-            gte(healthCheckAggregates.bucketStart, startDate),
-            lte(healthCheckAggregates.bucketStart, endDate),
-          ),
-        )
+        .where(and(...dailyConditions))
         .orderBy(healthCheckAggregates.bucketStart),
     ]);
 
@@ -928,122 +985,6 @@ 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.
-   *
-   * With incremental real-time aggregation, hourly aggregates are always up-to-date
-   * (updated immediately on every run), so we don't need to query raw runs.
-   */
-  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();
-
-    // Get retention config to determine what data tiers are available
-    const { retentionConfig } = await this.getRetentionConfig(
-      systemId,
-      configurationId,
-    );
-    const config = retentionConfig ?? DEFAULT_RETENTION_CONFIG;
-
-    // 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);
-
-    // Cutoff for hourly aggregates based on retention config
-    const hourlyCutoff = new Date(
-      now.getTime() - config.hourlyRetentionDays * 24 * 60 * 60 * 1000,
-    );
-
-    // Query hourly aggregates for the period they cover (up to hourlyRetentionDays)
-    // These are always up-to-date due to incremental real-time aggregation
-    const hourlyAggregates = 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, "hourly"),
-          gte(healthCheckAggregates.bucketStart, hourlyCutoff),
-        ),
-      );
-
-    // Query daily aggregates for data beyond hourly retention
-    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),
-          lt(healthCheckAggregates.bucketStart, hourlyCutoff),
-        ),
-      );
-
-    // Aggregate counts
-    let totalRuns31Days = 0;
-    let healthyRuns31Days = 0;
-    let totalRuns365Days = 0;
-    let healthyRuns365Days = 0;
-
-    // Process hourly aggregates (fresh data within hourlyRetentionDays)
-    for (const agg of hourlyAggregates) {
-      totalRuns365Days += agg.runCount;
-      healthyRuns365Days += agg.healthyCount;
-
-      if (agg.bucketStart >= cutoff31Days) {
-        totalRuns31Days += agg.runCount;
-        healthyRuns31Days += agg.healthyCount;
-      }
-    }
-
-    // Process daily aggregates (older data beyond hourly retention)
-    for (const agg of dailyAggregates) {
-      totalRuns365Days += agg.runCount;
-      healthyRuns365Days += agg.healthyCount;
-
-      if (agg.bucketStart >= cutoff31Days) {
-        totalRuns31Days += agg.runCount;
-        healthyRuns31Days += agg.healthyCount;
-      }
-    }
-
-    // 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,
@@ -1070,4 +1011,134 @@ export class HealthCheckService {
       updatedAt: row.updatedAt,
     };
   }
+
+  /**
+   * Remove a satellite ID from all systemHealthChecks.satelliteIds arrays.
+   * Called when a satellite is deleted via the satellite.removed hook.
+   */
+  async scrubSatelliteFromAssociations(satelliteId: string): Promise<void> {
+    // Get all associations that reference this satellite
+    const associations = await this.db
+      .select({
+        systemId: systemHealthChecks.systemId,
+        configurationId: systemHealthChecks.configurationId,
+        satelliteIds: systemHealthChecks.satelliteIds,
+      })
+      .from(systemHealthChecks);
+
+    // Update each association that contains this satellite ID
+    for (const assoc of associations) {
+      if (!assoc.satelliteIds?.includes(satelliteId)) continue;
+
+      const updated = assoc.satelliteIds.filter((id) => id !== satelliteId);
+      await this.db
+        .update(systemHealthChecks)
+        .set({
+          satelliteIds: updated.length > 0 ? updated : undefined,
+          updatedAt: new Date(),
+        })
+        .where(
+          and(
+            eq(systemHealthChecks.systemId, assoc.systemId),
+            eq(systemHealthChecks.configurationId, assoc.configurationId),
+          ),
+        );
+    }
+  }
+
+  /**
+   * Get all health check assignments for a specific satellite.
+   * Returns the full configuration payload needed for the satellite to execute checks.
+   */
+  async getAssignmentsForSatellite(satelliteId: string) {
+    // Get all associations that reference this satellite
+    const associations = await this.db
+      .select({
+        systemId: systemHealthChecks.systemId,
+        configurationId: systemHealthChecks.configurationId,
+        satelliteIds: systemHealthChecks.satelliteIds,
+        enabled: systemHealthChecks.enabled,
+      })
+      .from(systemHealthChecks);
+
+    // Filter to associations that include this satellite and are enabled
+    const matchingAssociations = associations.filter(
+      (a) => a.enabled && a.satelliteIds?.includes(satelliteId),
+    );
+
+    if (matchingAssociations.length === 0) return [];
+
+    // Get configurations for each matching association
+    const assignments = [];
+    for (const assoc of matchingAssociations) {
+      const [config] = await this.db
+        .select()
+        .from(healthCheckConfigurations)
+        .where(eq(healthCheckConfigurations.id, assoc.configurationId));
+
+      if (!config || config.paused) continue;
+
+      assignments.push({
+        configId: config.id,
+        systemId: assoc.systemId,
+        strategyId: config.strategyId,
+        config: config.config,
+        collectors: config.collectors ?? undefined,
+        intervalSeconds: config.intervalSeconds,
+      });
+    }
+
+    return assignments;
+  }
+
+  /**
+   * Ingest a health check result from a satellite.
+   * Stores the run with source attribution (sourceId + sourceLabel)
+   * and triggers incremental aggregation to keep charts/availability current.
+   */
+  async ingestSatelliteResult(props: {
+    configId: string;
+    systemId: string;
+    status: HealthCheckStatus;
+    latencyMs?: number;
+    result?: HealthCheckRunResult;
+    executedAt: string;
+    sourceId: string;
+    sourceLabel: string;
+  }) {
+    const {
+      configId,
+      systemId,
+      status,
+      latencyMs,
+      result,
+      sourceId,
+      sourceLabel,
+    } = props;
+
+    const resultRecord = result ? { ...result } as Record<string, unknown> : {};
+
+    await this.db.insert(healthCheckRuns).values({
+      configurationId: configId,
+      systemId,
+      status,
+      latencyMs,
+      result: resultRecord,
+      sourceId,
+      sourceLabel,
+    });
+
+    // Trigger incremental hourly aggregation — same as local executor
+    await incrementHourlyAggregate({
+      db: this.db,
+      systemId,
+      configurationId: configId,
+      status,
+      latencyMs,
+      runTimestamp: new Date(props.executedAt),
+      result: resultRecord,
+      collectorRegistry: this.collectorRegistry,
+      sourceLabel,
+    });
+  }
 }