@checkstack/healthcheck-dns-backend 0.1.13 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,59 @@
 # @checkstack/healthcheck-dns-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
+
 ## 0.1.13
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-dns-backend",
-  "version": "0.1.13",
+  "version": "0.2.0",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
@@ -9,14 +9,14 @@
     "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/backend-api": "0.5.2",
+    "@checkstack/common": "0.6.1",
+    "@checkstack/healthcheck-common": "0.8.1"
   },
   "devDependencies": {
     "@types/bun": "^1.0.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/lookup-collector.test.ts

@@ -4,7 +4,9 @@ import type { DnsTransportClient } from "./transport-client";
 
 describe("LookupCollector", () => {
   const createMockClient = (
-    response: { values: string[]; error?: string } = { values: ["192.168.1.1"] }
+    response: { values: string[]; error?: string } = {
+      values: ["192.168.1.1"],
+    },
   ): DnsTransportClient => ({
     exec: mock(() => Promise.resolve(response)),
   });
@@ -59,7 +61,7 @@ describe("LookupCollector", () => {
     });
   });
 
-  describe("aggregateResult", () => {
+  describe("mergeResult", () => {
     it("should calculate average resolution time", () => {
       const collector = new LookupCollector();
       const runs = [
@@ -89,10 +91,12 @@ describe("LookupCollector", () => {
         },
       ];
 
-      const aggregated = collector.aggregateResult(runs);
+      // Merge runs incrementally
+      let aggregated = collector.mergeResult(undefined, runs[0]);
+      aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgResolutionTimeMs).toBe(75);
-      expect(aggregated.successRate).toBe(100);
+      expect(aggregated.avgResolutionTimeMs.avg).toBe(75);
+      expect(aggregated.successRate.rate).toBe(100);
     });
 
     it("should calculate success rate correctly", () => {
@@ -120,9 +124,11 @@ describe("LookupCollector", () => {
         },
       ];
 
-      const aggregated = collector.aggregateResult(runs);
+      // Merge runs incrementally
+      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/lookup-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,
@@ -50,20 +56,24 @@ const lookupResultSchema = healthResultSchema({
 
 export type LookupResult = z.infer<typeof lookupResultSchema>;
 
-const lookupAggregatedSchema = healthResultSchema({
-  avgResolutionTimeMs: healthResultNumber({
+// Aggregated result fields definition
+const lookupAggregatedFields = {
+  avgResolutionTimeMs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Resolution Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-});
+};
 
-export type LookupAggregatedResult = z.infer<typeof lookupAggregatedSchema>;
+// Type inferred from field definitions
+export type LookupAggregatedResult = InferAggregatedResult<
+  typeof lookupAggregatedFields
+>;
 
 // ============================================================================
 // LOOKUP COLLECTOR
@@ -73,15 +83,12 @@ export type LookupAggregatedResult = z.infer<typeof lookupAggregatedSchema>;
  * Built-in DNS lookup collector.
  * Resolves DNS records and checks results.
  */
-export class LookupCollector
-  implements
-    CollectorStrategy<
-      DnsTransportClient,
-      LookupConfig,
-      LookupResult,
-      LookupAggregatedResult
-    >
-{
+export class LookupCollector implements CollectorStrategy<
+  DnsTransportClient,
+  LookupConfig,
+  LookupResult,
+  LookupAggregatedResult
+> {
   id = "lookup";
   displayName = "DNS Lookup";
   description = "Resolve DNS records and check the results";
@@ -92,9 +99,9 @@ export class LookupCollector
 
   config = new Versioned({ version: 1, schema: lookupConfigSchema });
   result = new Versioned({ version: 1, schema: lookupResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: lookupAggregatedSchema,
+    fields: lookupAggregatedFields,
   });
 
   async execute({
@@ -124,28 +131,21 @@ export class LookupCollector
     };
   }
 
-  aggregateResult(
-    runs: HealthCheckRunForAggregation<LookupResult>[]
+  mergeResult(
+    existing: LookupAggregatedResult | undefined,
+    run: HealthCheckRunForAggregation<LookupResult>,
   ): LookupAggregatedResult {
-    const times = runs
-      .map((r) => r.metadata?.resolutionTimeMs)
-      .filter((v): v is number => typeof v === "number");
-
-    const recordCounts = runs
-      .map((r) => r.metadata?.recordCount)
-      .filter((v): v is number => typeof v === "number");
+    const metadata = run.metadata;
 
-    const successCount = recordCounts.filter((c) => c > 0).length;
+    // Merge success rate (recordCount > 0 means success)
+    const isSuccess = (metadata?.recordCount ?? 0) > 0;
 
     return {
-      avgResolutionTimeMs:
-        times.length > 0
-          ? Math.round(times.reduce((a, b) => a + b, 0) / times.length)
-          : 0,
-      successRate:
-        recordCounts.length > 0
-          ? Math.round((successCount / recordCounts.length) * 100)
-          : 0,
+      avgResolutionTimeMs: mergeAverage(
+        existing?.avgResolutionTimeMs,
+        metadata?.resolutionTimeMs,
+      ),
+      successRate: mergeRate(existing?.successRate, isSuccess),
     };
   }
 }

package/src/strategy.test.ts

@@ -15,7 +15,7 @@ describe("DnsHealthCheckStrategy", () => {
       resolveMx?: { priority: number; exchange: string }[] | Error;
       resolveTxt?: string[][] | Error;
       resolveNs?: string[] | Error;
-    } = {}
+    } = {},
   ): ResolverFactory => {
     return () =>
       ({
@@ -23,34 +23,34 @@ describe("DnsHealthCheckStrategy", () => {
         resolve4: mock(() =>
           config.resolve4 instanceof Error
             ? Promise.reject(config.resolve4)
-            : Promise.resolve(config.resolve4 ?? [])
+            : Promise.resolve(config.resolve4 ?? []),
         ),
         resolve6: mock(() =>
           config.resolve6 instanceof Error
             ? Promise.reject(config.resolve6)
-            : Promise.resolve(config.resolve6 ?? [])
+            : Promise.resolve(config.resolve6 ?? []),
         ),
         resolveCname: mock(() =>
           config.resolveCname instanceof Error
             ? Promise.reject(config.resolveCname)
-            : Promise.resolve(config.resolveCname ?? [])
+            : Promise.resolve(config.resolveCname ?? []),
         ),
         resolveMx: mock(() =>
           config.resolveMx instanceof Error
             ? Promise.reject(config.resolveMx)
-            : Promise.resolve(config.resolveMx ?? [])
+            : Promise.resolve(config.resolveMx ?? []),
         ),
         resolveTxt: mock(() =>
           config.resolveTxt instanceof Error
             ? Promise.reject(config.resolveTxt)
-            : Promise.resolve(config.resolveTxt ?? [])
+            : Promise.resolve(config.resolveTxt ?? []),
         ),
         resolveNs: mock(() =>
           config.resolveNs instanceof Error
             ? Promise.reject(config.resolveNs)
-            : Promise.resolve(config.resolveNs ?? [])
+            : Promise.resolve(config.resolveNs ?? []),
         ),
-      } as DnsResolver);
+      }) as DnsResolver;
   };
 
   describe("createClient", () => {
@@ -102,7 +102,7 @@ describe("DnsHealthCheckStrategy", () => {
   describe("client.exec", () => {
     it("should return resolved values for successful A record resolution", async () => {
       const strategy = new DnsHealthCheckStrategy(
-        createMockResolver({ resolve4: ["1.2.3.4", "5.6.7.8"] })
+        createMockResolver({ resolve4: ["1.2.3.4", "5.6.7.8"] }),
       );
       const connectedClient = await strategy.createClient({ timeout: 5000 });
 
@@ -118,7 +118,7 @@ describe("DnsHealthCheckStrategy", () => {
 
     it("should return error for DNS error", async () => {
       const strategy = new DnsHealthCheckStrategy(
-        createMockResolver({ resolve4: new Error("NXDOMAIN") })
+        createMockResolver({ resolve4: new Error("NXDOMAIN") }),
       );
       const connectedClient = await strategy.createClient({ timeout: 5000 });
 
@@ -139,7 +139,7 @@ describe("DnsHealthCheckStrategy", () => {
             { priority: 0, exchange: "mail1.example.com" },
             { priority: 10, exchange: "mail2.example.com" },
           ],
-        })
+        }),
       );
       const connectedClient = await strategy.createClient({ timeout: 5000 });
 
@@ -154,7 +154,7 @@ describe("DnsHealthCheckStrategy", () => {
     });
   });
 
-  describe("aggregateResult", () => {
+  describe("mergeResult", () => {
     it("should calculate averages correctly", () => {
       const strategy = new DnsHealthCheckStrategy();
       const runs = [
@@ -184,11 +184,13 @@ describe("DnsHealthCheckStrategy", () => {
         },
       ];
 
-      const aggregated = strategy.aggregateResult(runs);
+      // Merge runs incrementally
+      let aggregated = strategy.mergeResult(undefined, runs[0]);
+      aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgResolutionTime).toBe(15);
-      expect(aggregated.failureCount).toBe(0);
-      expect(aggregated.errorCount).toBe(0);
+      expect(aggregated.avgResolutionTime.avg).toBe(15);
+      expect(aggregated.failureCount.count).toBe(0);
+      expect(aggregated.errorCount.count).toBe(0);
     });
 
     it("should count failures and errors", () => {
@@ -221,10 +223,12 @@ describe("DnsHealthCheckStrategy", () => {
         },
       ];
 
-      const aggregated = strategy.aggregateResult(runs);
+      // Merge runs incrementally
+      let aggregated = strategy.mergeResult(undefined, runs[0]);
+      aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.errorCount).toBe(1);
-      expect(aggregated.failureCount).toBe(2);
+      expect(aggregated.errorCount.count).toBe(1);
+      expect(aggregated.failureCount.count).toBe(2);
     });
   });
 });

package/src/strategy.ts

@@ -3,8 +3,14 @@ import {
   HealthCheckStrategy,
   HealthCheckRunForAggregation,
   Versioned,
+  VersionedAggregated,
+  aggregatedCounter,
+  aggregatedAverage,
+  mergeAverage,
+  mergeCounter,
   z,
   type ConnectedClient,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -70,26 +76,24 @@ const dnsResultSchema = healthResultSchema({
 
 type DnsResult = z.infer<typeof dnsResultSchema>;
 
-/**
- * Aggregated metadata for buckets.
- */
-const dnsAggregatedSchema = healthResultSchema({
-  avgResolutionTime: healthResultNumber({
+/** Aggregated field definitions for bucket merging */
+const dnsAggregatedFields = {
+  avgResolutionTime: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Resolution Time",
     "x-chart-unit": "ms",
   }),
-  failureCount: healthResultNumber({
+  failureCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Failures",
   }),
-  errorCount: healthResultNumber({
+  errorCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Errors",
   }),
-});
+};
 
-type DnsAggregatedResult = z.infer<typeof dnsAggregatedSchema>;
+type DnsAggregatedResult = InferAggregatedResult<typeof dnsAggregatedFields>;
 
 // ============================================================================
 // RESOLVER INTERFACE (for testability)
@@ -101,7 +105,7 @@ export interface DnsResolver {
   resolve6(hostname: string): Promise<string[]>;
   resolveCname(hostname: string): Promise<string[]>;
   resolveMx(
-    hostname: string
+    hostname: string,
   ): Promise<{ priority: number; exchange: string }[]>;
   resolveTxt(hostname: string): Promise<string[][]>;
   resolveNs(hostname: string): Promise<string[]>;
@@ -116,15 +120,12 @@ const defaultResolverFactory: ResolverFactory = () => new dns.Resolver();
 // STRATEGY
 // ============================================================================
 
-export class DnsHealthCheckStrategy
-  implements
-    HealthCheckStrategy<
-      DnsConfig,
-      DnsTransportClient,
-      DnsResult,
-      DnsAggregatedResult
-    >
-{
+export class DnsHealthCheckStrategy implements HealthCheckStrategy<
+  DnsConfig,
+  DnsTransportClient,
+  DnsResult,
+  typeof dnsAggregatedFields
+> {
   id = "dns";
   displayName = "DNS Health Check";
   description = "DNS record resolution with response validation";
@@ -164,44 +165,36 @@ export class DnsHealthCheckStrategy
     ],
   });
 
-  aggregatedResult: Versioned<DnsAggregatedResult> = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: dnsAggregatedSchema,
+    fields: dnsAggregatedFields,
   });
 
-  aggregateResult(
-    runs: HealthCheckRunForAggregation<DnsResult>[]
+  mergeResult(
+    existing: DnsAggregatedResult | undefined,
+    run: HealthCheckRunForAggregation<DnsResult>,
   ): DnsAggregatedResult {
-    const validRuns = runs.filter((r) => r.metadata);
-
-    if (validRuns.length === 0) {
-      return { avgResolutionTime: 0, failureCount: 0, errorCount: 0 };
-    }
-
-    const resolutionTimes = validRuns
-      .map((r) => r.metadata?.resolutionTimeMs)
-      .filter((t): t is number => typeof t === "number");
+    const metadata = run.metadata;
 
-    const avgResolutionTime =
-      resolutionTimes.length > 0
-        ? Math.round(
-            resolutionTimes.reduce((a, b) => a + b, 0) / resolutionTimes.length
-          )
-        : 0;
+    // Merge resolution time average
+    const avgResolutionTime = mergeAverage(
+      existing?.avgResolutionTime,
+      metadata?.resolutionTimeMs,
+    );
 
-    const failureCount = validRuns.filter(
-      (r) => r.metadata?.recordCount === 0
-    ).length;
+    // Merge failure count
+    const isFailure = metadata?.recordCount === 0;
+    const failureCount = mergeCounter(existing?.failureCount, isFailure);
 
-    const errorCount = validRuns.filter(
-      (r) => r.metadata?.error !== undefined
-    ).length;
+    // Merge error count
+    const hasError = metadata?.error !== undefined;
+    const errorCount = mergeCounter(existing?.errorCount, hasError);
 
     return { avgResolutionTime, failureCount, errorCount };
   }
 
   async createClient(
-    config: DnsConfig
+    config: DnsConfig,
   ): Promise<ConnectedClient<DnsTransportClient>> {
     const validatedConfig = this.config.validate(config);
     const resolver = this.resolverFactory();
@@ -214,14 +207,17 @@ export class DnsHealthCheckStrategy
       exec: async (request: DnsLookupRequest): Promise<DnsLookupResult> => {
         const timeout = validatedConfig.timeout;
         const timeoutPromise = new Promise<never>((_, reject) =>
-          setTimeout(() => reject(new Error("DNS resolution timeout")), timeout)
+          setTimeout(
+            () => reject(new Error("DNS resolution timeout")),
+            timeout,
+          ),
         );
 
         try {
           const resolvePromise = this.resolveRecords(
             resolver,
             request.hostname,
-            request.recordType
+            request.recordType,
           );
 
           const values = await Promise.race([resolvePromise, timeoutPromise]);
@@ -246,7 +242,7 @@ export class DnsHealthCheckStrategy
   private async resolveRecords(
     resolver: DnsResolver,
     hostname: string,
-    recordType: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS"
+    recordType: "A" | "AAAA" | "CNAME" | "MX" | "TXT" | "NS",
   ): Promise<string[]> {
     switch (recordType) {
       case "A": {