@checkstack/healthcheck-ssh-backend 0.1.13 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,60 @@
 # @checkstack/healthcheck-ssh-backend
 
+## 0.2.0
+
+### Minor Changes
+
+- 3dd1914: Migrate health check strategies to VersionedAggregated with \_type discriminator
+
+  All 13 health check strategies now use `VersionedAggregated` for their `aggregatedResult` property, enabling automatic bucket merging with 100% mathematical fidelity.
+
+  **Key changes:**
+
+  - **`_type` discriminator**: All aggregated state objects now include a required `_type` field (`"average"`, `"rate"`, `"counter"`, `"minmax"`) for reliable type detection
+  - The `HealthCheckStrategy` interface now requires `aggregatedResult` to be a `VersionedAggregated<AggregatedResultShape>`
+  - Strategy/collector `mergeResult` methods return state objects with `_type` (e.g., `{ _type: "average", _sum, _count, avg }`)
+  - `mergeAggregatedBucketResults`, `combineBuckets`, and `reaggregateBuckets` now require `registry` and `strategyId` parameters
+  - `HealthCheckService` constructor now requires both `registry` and `collectorRegistry` parameters
+  - Frontend `extractComputedValue` now uses `_type` discriminator for robust type detection
+
+  **Breaking Change**: State objects now require `_type`. Merge functions automatically add `_type` to output. The bucket merging functions and `HealthCheckService` now require additional required parameters.
+
+### Patch Changes
+
+- Updated dependencies [3dd1914]
+  - @checkstack/backend-api@0.7.0
+
+## 0.1.14
+
+### Patch Changes
+
+- 48c2080: Migrate aggregation from batch to incremental (`mergeResult`)
+
+  ### Breaking Changes (Internal)
+
+  - Replaced `aggregateResult(runs[])` with `mergeResult(existing, run)` interface across all HealthCheckStrategy and CollectorStrategy implementations
+
+  ### New Features
+
+  - Added incremental aggregation utilities in `@checkstack/backend-api`:
+    - `mergeCounter()` - track occurrences
+    - `mergeAverage()` - track sum/count, compute avg
+    - `mergeRate()` - track success/total, compute %
+    - `mergeMinMax()` - track min/max values
+  - Exported Zod schemas for internal state: `averageStateSchema`, `rateStateSchema`, `minMaxStateSchema`, `counterStateSchema`
+
+  ### Improvements
+
+  - Enables O(1) storage overhead by maintaining incremental aggregation state
+  - Prepares for real-time hourly aggregation without batch accumulation
+
+- Updated dependencies [f676e11]
+- Updated dependencies [48c2080]
+  - @checkstack/common@0.6.2
+  - @checkstack/backend-api@0.6.0
+  - @checkstack/healthcheck-common@0.8.2
+  - @checkstack/healthcheck-ssh-common@0.1.8
+
 ## 0.1.13
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-ssh-backend",
-  "version": "0.1.13",
+  "version": "0.2.0",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
@@ -9,17 +9,17 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.5.1",
-    "@checkstack/common": "0.6.0",
-    "@checkstack/healthcheck-common": "0.7.0",
-    "@checkstack/healthcheck-ssh-common": "0.1.6",
+    "@checkstack/backend-api": "0.5.2",
+    "@checkstack/common": "0.6.1",
+    "@checkstack/healthcheck-common": "0.8.1",
+    "@checkstack/healthcheck-ssh-common": "0.1.7",
     "ssh2": "^1.15.0"
   },
   "devDependencies": {
     "@types/bun": "^1.0.0",
     "@types/ssh2": "^1.15.0",
     "typescript": "^5.0.0",
-    "@checkstack/tsconfig": "0.0.2",
-    "@checkstack/scripts": "0.1.0"
+    "@checkstack/tsconfig": "0.0.3",
+    "@checkstack/scripts": "0.1.1"
   }
 }

package/src/command-collector.test.ts

@@ -69,7 +69,7 @@ describe("CommandCollector", () => {
     });
   });
 
-  describe("aggregateResult", () => {
+  describe("mergeResult", () => {
     it("should calculate average execution time and success rate", () => {
       const collector = new CommandCollector();
       const runs = [
@@ -101,10 +101,11 @@ describe("CommandCollector", () => {
         },
       ];
 
-      const aggregated = collector.aggregateResult(runs);
+      let aggregated = collector.mergeResult(undefined, runs[0]);
+      aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgExecutionTimeMs).toBe(75);
-      expect(aggregated.successRate).toBe(100);
+      expect(aggregated.avgExecutionTimeMs.avg).toBe(75);
+      expect(aggregated.successRate.rate).toBe(100);
     });
 
     it("should calculate success rate based on exit codes", () => {
@@ -138,9 +139,10 @@ describe("CommandCollector", () => {
         },
       ];
 
-      const aggregated = collector.aggregateResult(runs);
+      let aggregated = collector.mergeResult(undefined, runs[0]);
+      aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.successRate).toBe(50);
+      expect(aggregated.successRate.rate).toBe(50);
     });
   });
 

package/src/command-collector.ts

@@ -4,6 +4,12 @@ import {
   type HealthCheckRunForAggregation,
   type CollectorResult,
   type CollectorStrategy,
+  mergeAverage,
+  mergeRate,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -49,20 +55,24 @@ const commandResultSchema = healthResultSchema({
 
 export type CommandResult = z.infer<typeof commandResultSchema>;
 
-const commandAggregatedSchema = healthResultSchema({
-  avgExecutionTimeMs: healthResultNumber({
+// Aggregated result fields definition
+const commandAggregatedFields = {
+  avgExecutionTimeMs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Execution Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-});
+};
 
-export type CommandAggregatedResult = z.infer<typeof commandAggregatedSchema>;
+// Type inferred from field definitions
+export type CommandAggregatedResult = InferAggregatedResult<
+  typeof commandAggregatedFields
+>;
 
 // ============================================================================
 // COMMAND COLLECTOR (PSEUDO-COLLECTOR)
@@ -73,15 +83,12 @@ export type CommandAggregatedResult = z.infer<typeof commandAggregatedSchema>;
  * Allows users to run arbitrary shell commands as check items.
  * This is the "basic mode" functionality exposed as a collector.
  */
-export class CommandCollector
-  implements
-    CollectorStrategy<
-      SshTransportClient,
-      CommandConfig,
-      CommandResult,
-      CommandAggregatedResult
-    >
-{
+export class CommandCollector implements CollectorStrategy<
+  SshTransportClient,
+  CommandConfig,
+  CommandResult,
+  CommandAggregatedResult
+> {
   /**
    * ID for this collector.
    * Built-in collectors are identified by ownerPlugin matching the strategy's plugin.
@@ -98,9 +105,9 @@ export class CommandCollector
 
   config = new Versioned({ version: 1, schema: commandConfigSchema });
   result = new Versioned({ version: 1, schema: commandResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: commandAggregatedSchema,
+    fields: commandAggregatedFields,
   });
 
   async execute({
@@ -125,28 +132,19 @@ export class CommandCollector
     };
   }
 
-  aggregateResult(
-    runs: HealthCheckRunForAggregation<CommandResult>[]
+  mergeResult(
+    existing: CommandAggregatedResult | undefined,
+    run: HealthCheckRunForAggregation<CommandResult>,
   ): CommandAggregatedResult {
-    const times = runs
-      .map((r) => r.metadata?.executionTimeMs)
-      .filter((v): v is number => typeof v === "number");
-
-    const exitCodes = runs
-      .map((r) => r.metadata?.exitCode)
-      .filter((v): v is number => typeof v === "number");
-
-    const successCount = exitCodes.filter((code) => code === 0).length;
+    const metadata = run.metadata;
 
+    // Success is exit code 0
     return {
-      avgExecutionTimeMs:
-        times.length > 0
-          ? Math.round(times.reduce((a, b) => a + b, 0) / times.length)
-          : 0,
-      successRate:
-        exitCodes.length > 0
-          ? Math.round((successCount / exitCodes.length) * 100)
-          : 0,
+      avgExecutionTimeMs: mergeAverage(
+        existing?.avgExecutionTimeMs,
+        metadata?.executionTimeMs,
+      ),
+      successRate: mergeRate(existing?.successRate, metadata?.exitCode === 0),
     };
   }
 }

package/src/strategy.test.ts

@@ -10,7 +10,7 @@ describe("SshHealthCheckStrategy", () => {
       stderr?: string;
       execError?: Error;
       connectError?: Error;
-    } = {}
+    } = {},
   ): SshClient => ({
     connect: mock(() =>
       config.connectError
@@ -23,10 +23,10 @@ describe("SshHealthCheckStrategy", () => {
                     exitCode: config.exitCode ?? 0,
                     stdout: config.stdout ?? "",
                     stderr: config.stderr ?? "",
-                  })
+                  }),
             ),
             end: mock(() => {}),
-          })
+          }),
     ),
   });
 
@@ -51,7 +51,7 @@ describe("SshHealthCheckStrategy", () => {
 
     it("should throw for connection error", async () => {
       const strategy = new SshHealthCheckStrategy(
-        createMockClient({ connectError: new Error("Connection refused") })
+        createMockClient({ connectError: new Error("Connection refused") }),
       );
 
       await expect(
@@ -61,7 +61,7 @@ describe("SshHealthCheckStrategy", () => {
           username: "user",
           password: "secret",
           timeout: 5000,
-        })
+        }),
       ).rejects.toThrow("Connection refused");
     });
   });
@@ -69,7 +69,7 @@ describe("SshHealthCheckStrategy", () => {
   describe("client.exec", () => {
     it("should execute command successfully", async () => {
       const strategy = new SshHealthCheckStrategy(
-        createMockClient({ exitCode: 0, stdout: "OK" })
+        createMockClient({ exitCode: 0, stdout: "OK" }),
       );
       const connectedClient = await strategy.createClient({
         host: "localhost",
@@ -90,7 +90,7 @@ describe("SshHealthCheckStrategy", () => {
 
     it("should return non-zero exit code for failed command", async () => {
       const strategy = new SshHealthCheckStrategy(
-        createMockClient({ exitCode: 1, stderr: "Error" })
+        createMockClient({ exitCode: 1, stderr: "Error" }),
       );
       const connectedClient = await strategy.createClient({
         host: "localhost",
@@ -109,7 +109,7 @@ describe("SshHealthCheckStrategy", () => {
     });
   });
 
-  describe("aggregateResult", () => {
+  describe("mergeResult", () => {
     it("should calculate averages correctly", () => {
       const strategy = new SshHealthCheckStrategy();
       const runs = [
@@ -139,34 +139,33 @@ describe("SshHealthCheckStrategy", () => {
         },
       ];
 
-      const aggregated = strategy.aggregateResult(runs);
+      let aggregated = strategy.mergeResult(undefined, runs[0]);
+      aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgConnectionTime).toBe(75);
-      expect(aggregated.successRate).toBe(100);
-      expect(aggregated.errorCount).toBe(0);
+      expect(aggregated.avgConnectionTime.avg).toBe(75);
+      expect(aggregated.successRate.rate).toBe(100);
+      expect(aggregated.errorCount.count).toBe(0);
     });
 
     it("should count errors", () => {
       const strategy = new SshHealthCheckStrategy();
-      const runs = [
-        {
-          id: "1",
-          status: "unhealthy" as const,
-          latencyMs: 100,
-          checkId: "c1",
-          timestamp: new Date(),
-          metadata: {
-            connected: false,
-            connectionTimeMs: 100,
-            error: "Connection refused",
-          },
+      const run = {
+        id: "1",
+        status: "unhealthy" as const,
+        latencyMs: 100,
+        checkId: "c1",
+        timestamp: new Date(),
+        metadata: {
+          connected: false,
+          connectionTimeMs: 100,
+          error: "Connection refused",
         },
-      ];
+      };
 
-      const aggregated = strategy.aggregateResult(runs);
+      const aggregated = strategy.mergeResult(undefined, run);
 
-      expect(aggregated.errorCount).toBe(1);
-      expect(aggregated.successRate).toBe(0);
+      expect(aggregated.errorCount.count).toBe(1);
+      expect(aggregated.successRate.rate).toBe(0);
     });
   });
 });

package/src/strategy.ts

@@ -3,10 +3,20 @@ import {
   HealthCheckStrategy,
   HealthCheckRunForAggregation,
   Versioned,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedMinMax,
+  aggregatedRate,
+  aggregatedCounter,
+  mergeAverage,
+  mergeRate,
+  mergeCounter,
+  mergeMinMax,
   z,
   configString,
   configNumber,
   type ConnectedClient,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultBoolean,
@@ -66,32 +76,30 @@ const sshResultSchema = healthResultSchema({
 
 type SshResult = z.infer<typeof sshResultSchema>;
 
-/**
- * Aggregated metadata for buckets.
- */
-const sshAggregatedSchema = healthResultSchema({
-  avgConnectionTime: healthResultNumber({
+/** Aggregated field definitions for bucket merging */
+const sshAggregatedFields = {
+  avgConnectionTime: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Connection Time",
     "x-chart-unit": "ms",
   }),
-  maxConnectionTime: healthResultNumber({
+  maxConnectionTime: aggregatedMinMax({
     "x-chart-type": "line",
     "x-chart-label": "Max Connection Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-  errorCount: healthResultNumber({
+  errorCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Errors",
   }),
-});
+};
 
-type SshAggregatedResult = z.infer<typeof sshAggregatedSchema>;
+type SshAggregatedResult = InferAggregatedResult<typeof sshAggregatedFields>;
 
 // ============================================================================
 // SSH CLIENT INTERFACE (for testability)
@@ -178,15 +186,12 @@ const defaultSshClient: SshClient = {
 // STRATEGY
 // ============================================================================
 
-export class SshHealthCheckStrategy
-  implements
-    HealthCheckStrategy<
-      SshConfig,
-      SshTransportClient,
-      SshResult,
-      SshAggregatedResult
-    >
-{
+export class SshHealthCheckStrategy implements HealthCheckStrategy<
+  SshConfig,
+  SshTransportClient,
+  SshResult,
+  typeof sshAggregatedFields
+> {
   id = "ssh";
   displayName = "SSH Health Check";
   description = "SSH server connectivity and command execution health check";
@@ -207,61 +212,41 @@ export class SshHealthCheckStrategy
     schema: sshResultSchema,
   });
 
-  aggregatedResult: Versioned<SshAggregatedResult> = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: sshAggregatedSchema,
+    fields: sshAggregatedFields,
   });
 
-  aggregateResult(
-    runs: HealthCheckRunForAggregation<SshResult>[]
+  mergeResult(
+    existing: SshAggregatedResult | undefined,
+    run: HealthCheckRunForAggregation<SshResult>,
   ): SshAggregatedResult {
-    const validRuns = runs.filter((r) => r.metadata);
-
-    if (validRuns.length === 0) {
-      return {
-        avgConnectionTime: 0,
-        maxConnectionTime: 0,
-        successRate: 0,
-        errorCount: 0,
-      };
-    }
-
-    const connectionTimes = validRuns
-      .map((r) => r.metadata?.connectionTimeMs)
-      .filter((t): t is number => typeof t === "number");
-
-    const avgConnectionTime =
-      connectionTimes.length > 0
-        ? Math.round(
-            connectionTimes.reduce((a, b) => a + b, 0) / connectionTimes.length
-          )
-        : 0;
-
-    const maxConnectionTime =
-      connectionTimes.length > 0 ? Math.max(...connectionTimes) : 0;
-
-    const successCount = validRuns.filter(
-      (r) => r.metadata?.connected === true
-    ).length;
-    const successRate = Math.round((successCount / validRuns.length) * 100);
-
-    const errorCount = validRuns.filter(
-      (r) => r.metadata?.error !== undefined
-    ).length;
+    const metadata = run.metadata;
 
-    return {
-      avgConnectionTime,
-      maxConnectionTime,
-      successRate,
-      errorCount,
-    };
+    const avgConnectionTime = mergeAverage(
+      existing?.avgConnectionTime,
+      metadata?.connectionTimeMs,
+    );
+
+    const maxConnectionTime = mergeMinMax(
+      existing?.maxConnectionTime,
+      metadata?.connectionTimeMs,
+    );
+
+    const isSuccess = metadata?.connected ?? false;
+    const successRate = mergeRate(existing?.successRate, isSuccess);
+
+    const hasError = metadata?.error !== undefined;
+    const errorCount = mergeCounter(existing?.errorCount, hasError);
+
+    return { avgConnectionTime, maxConnectionTime, successRate, errorCount };
   }
 
   /**
    * Create a connected SSH transport client.
    */
   async createClient(
-    config: SshConfigInput
+    config: SshConfigInput,
   ): Promise<ConnectedClient<SshTransportClient>> {
     const validatedConfig = this.config.validate(config);