@checkstack/healthcheck-http-backend 0.2.5 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @checkstack/healthcheck-http-backend
 
+## 0.3.1
+
+### Patch Changes
+
+- 869b4ab: ## Health Check Execution Improvements
+
+  ### Breaking Changes (backend-api)
+
+  - `HealthCheckStrategy.createClient()` now accepts `unknown` instead of `TConfig` due to TypeScript contravariance constraints. Implementations should use `this.config.validate(config)` to narrow the type.
+
+  ### Features
+
+  - **Platform-level hard timeout**: The executor now wraps the entire health check execution (connection + all collectors) in a single timeout, ensuring checks never hang indefinitely.
+  - **Parallel collector execution**: Collectors now run in parallel using `Promise.allSettled()`, improving performance while ensuring all collectors complete regardless of individual failures.
+  - **Base strategy config schema**: All strategy configs now extend `baseStrategyConfigSchema` which provides a standardized `timeout` field with sensible defaults (30s, min 100ms).
+
+  ### Fixes
+
+  - Fixed HTTP and Jenkins strategies clearing timeouts before reading the full response body.
+  - Simplified registry type signatures by using default type parameters.
+
+- Updated dependencies [869b4ab]
+  - @checkstack/backend-api@0.8.0
+
+## 0.3.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.2.5
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-http-backend",
-  "version": "0.2.5",
+  "version": "0.3.1",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
@@ -9,10 +9,10 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.5.2",
-    "@checkstack/healthcheck-common": "0.8.1",
+    "@checkstack/backend-api": "0.7.0",
+    "@checkstack/healthcheck-common": "0.8.2",
     "jsonpath-plus": "^10.3.0",
-    "@checkstack/common": "0.6.1"
+    "@checkstack/common": "0.6.2"
   },
   "devDependencies": {
     "@types/bun": "^1.0.0",

package/src/request-collector.test.ts

@@ -156,8 +156,8 @@ describe("RequestCollector", () => {
       let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgResponseTimeMs).toBe(75);
-      expect(aggregated.successRate).toBe(100);
+      expect(aggregated.avgResponseTimeMs.avg).toBe(75);
+      expect(aggregated.successRate.rate).toBe(100);
     });
 
     it("should calculate success rate correctly", () => {
@@ -199,7 +199,7 @@ describe("RequestCollector", () => {
       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/request-collector.ts

@@ -7,8 +7,10 @@ import {
   type CollectorStrategy,
   mergeAverage,
   mergeRate,
-  averageStateSchema,
-  rateStateSchema,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -80,32 +82,24 @@ const requestResultSchema = healthResultSchema({
 
 export type RequestResult = z.infer<typeof requestResultSchema>;
 
-// UI-visible aggregated fields (for charts)
-const requestAggregatedDisplaySchema = healthResultSchema({
-  avgResponseTimeMs: healthResultNumber({
+// Aggregated result fields definition
+const requestAggregatedFields = {
+  avgResponseTimeMs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Response Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-});
-
-// Internal state for incremental aggregation (not shown in charts)
-const requestAggregatedInternalSchema = z.object({
-  _responseTime: averageStateSchema.optional(),
-  _success: rateStateSchema.optional(),
-});
+};
 
-// Combined schema for storage
-const requestAggregatedSchema = requestAggregatedDisplaySchema.and(
-  requestAggregatedInternalSchema,
-);
-
-export type RequestAggregatedResult = z.infer<typeof requestAggregatedSchema>;
+// Type inferred automatically from field definitions
+export type RequestAggregatedResult = InferAggregatedResult<
+  typeof requestAggregatedFields
+>;
 
 // ============================================================================
 // REQUEST COLLECTOR
@@ -131,9 +125,9 @@ export class RequestCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: requestConfigSchema });
   result = new Versioned({ version: 1, schema: requestResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: requestAggregatedSchema,
+    fields: requestAggregatedFields,
   });
 
   async execute({
@@ -182,17 +176,12 @@ export class RequestCollector implements CollectorStrategy<
     existing: RequestAggregatedResult | undefined,
     newRun: HealthCheckRunForAggregation<RequestResult>,
   ): RequestAggregatedResult {
-    const responseTime = mergeAverage(
-      existing?._responseTime,
-      newRun.metadata?.responseTimeMs,
-    );
-    const success = mergeRate(existing?._success, newRun.metadata?.success);
-
     return {
-      avgResponseTimeMs: responseTime.avg,
-      successRate: success.rate,
-      _responseTime: responseTime,
-      _success: success,
+      avgResponseTimeMs: mergeAverage(
+        existing?.avgResponseTimeMs,
+        newRun.metadata?.responseTimeMs,
+      ),
+      successRate: mergeRate(existing?.successRate, newRun.metadata?.success),
     };
   }
 }

package/src/strategy.test.ts

@@ -218,7 +218,7 @@ describe("HttpHealthCheckStrategy", () => {
       aggregated = strategy.mergeResult(aggregated, runs[1]);
       aggregated = strategy.mergeResult(aggregated, runs[2]);
 
-      expect(aggregated.errorCount).toBe(2);
+      expect(aggregated.errorCount.count).toBe(2);
     });
 
     it("should return zero errors when all runs succeed", () => {
@@ -245,7 +245,7 @@ describe("HttpHealthCheckStrategy", () => {
       let aggregated = strategy.mergeResult(undefined, runs[0]);
       aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.errorCount).toBe(0);
+      expect(aggregated.errorCount.count).toBe(0);
     });
   });
 });

package/src/strategy.ts

@@ -2,12 +2,15 @@ import {
   HealthCheckStrategy,
   HealthCheckRunForAggregation,
   Versioned,
+  VersionedAggregated,
+  aggregatedCounter,
+  mergeCounter,
   z,
+  type InferAggregatedResult,
   type ConnectedClient,
-  mergeCounter,
+  baseStrategyConfigSchema,
 } from "@checkstack/backend-api";
 import {
-  healthResultNumber,
   healthResultString,
   healthResultSchema,
 } from "@checkstack/healthcheck-common";
@@ -25,14 +28,7 @@ import type {
  * HTTP health check configuration schema.
  * Global defaults only - action params moved to RequestCollector.
  */
-export const httpHealthCheckConfigSchema = z.object({
-  timeout: z
-    .number()
-    .int()
-    .min(100)
-    .default(30_000)
-    .describe("Default request timeout in milliseconds"),
-});
+export const httpHealthCheckConfigSchema = baseStrategyConfigSchema.extend({});
 
 export type HttpHealthCheckConfig = z.infer<typeof httpHealthCheckConfigSchema>;
 
@@ -58,15 +54,15 @@ const httpResultMetadataSchema = healthResultSchema({
 
 type HttpResultMetadata = z.infer<typeof httpResultMetadataSchema>;
 
-/** Aggregated metadata for buckets */
-const httpAggregatedMetadataSchema = healthResultSchema({
-  errorCount: healthResultNumber({
+/** Aggregated field definitions for bucket merging */
+const httpAggregatedFields = {
+  errorCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Errors",
   }),
-});
+};
 
-type HttpAggregatedMetadata = z.infer<typeof httpAggregatedMetadataSchema>;
+type HttpAggregatedResult = InferAggregatedResult<typeof httpAggregatedFields>;
 
 // ============================================================================
 // STRATEGY
@@ -76,7 +72,7 @@ export class HttpHealthCheckStrategy implements HealthCheckStrategy<
   HttpHealthCheckConfig,
   HttpTransportClient,
   HttpResultMetadata,
-  HttpAggregatedMetadata
+  typeof httpAggregatedFields
 > {
   id = "http";
   displayName = "HTTP/HTTPS Health Check";
@@ -112,21 +108,18 @@ export class HttpHealthCheckStrategy implements HealthCheckStrategy<
     schema: httpResultMetadataSchema,
   });
 
-  aggregatedResult: Versioned<HttpAggregatedMetadata> = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: httpAggregatedMetadataSchema,
+    fields: httpAggregatedFields,
   });
 
   mergeResult(
-    existing: HttpAggregatedMetadata | undefined,
+    existing: HttpAggregatedResult | undefined,
     newRun: HealthCheckRunForAggregation<HttpResultMetadata>,
-  ): HttpAggregatedMetadata {
+  ): HttpAggregatedResult {
     const hasError = !!newRun.metadata?.error;
     return {
-      errorCount: mergeCounter(
-        existing ? { count: existing.errorCount } : undefined,
-        hasError,
-      ).count,
+      errorCount: mergeCounter(existing?.errorCount, hasError),
     };
   }
 
@@ -155,9 +148,10 @@ export class HttpHealthCheckStrategy implements HealthCheckStrategy<
             signal: controller.signal,
           });
 
-          clearTimeout(timeoutId);
-
+          // Read body BEFORE clearing timeout - body streaming can also hang
           const body = await response.text();
+
+          clearTimeout(timeoutId);
           const headers: Record<string, string> = {};
 
           // eslint-disable-next-line unicorn/no-array-for-each