@checkstack/collector-hardware-backend 0.1.14 → 0.1.15

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @checkstack/collector-hardware-backend
 
+## 0.1.15
+
+### Patch Changes
+
+- Updated dependencies [3dd1914]
+  - @checkstack/backend-api@0.7.0
+
 ## 0.1.14
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/collector-hardware-backend",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {

package/src/collectors/cpu.test.ts

@@ -121,10 +121,10 @@ describe("CpuCollector", () => {
       let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgUsagePercent).toBe(50);
-      expect(aggregated.maxUsagePercent).toBe(75);
+      expect(aggregated.avgUsagePercent.avg).toBe(50);
+      expect(aggregated.maxUsagePercent.max).toBe(75);
       // (1.0 + 2.0) / 2 = 1.5
-      expect(aggregated.avgLoadAvg1m).toBe(1.5);
+      expect(aggregated.avgLoadAvg1m.avg).toBe(1.5);
     });
   });
 

package/src/collectors/cpu.ts

@@ -6,10 +6,10 @@ import {
   type CollectorStrategy,
   mergeAverage,
   mergeMinMax,
-  averageStateSchema,
-  minMaxStateSchema,
-  type AverageState,
-  type MinMaxState,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedMinMax,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import { healthResultNumber } from "@checkstack/healthcheck-common";
 import {
@@ -64,34 +64,28 @@ const cpuResultSchema = z.object({
 
 export type CpuResult = z.infer<typeof cpuResultSchema>;
 
-const cpuAggregatedDisplaySchema = z.object({
-  avgUsagePercent: healthResultNumber({
+// Aggregated result fields definition
+const cpuAggregatedFields = {
+  avgUsagePercent: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg CPU Usage",
     "x-chart-unit": "%",
   }),
-  maxUsagePercent: healthResultNumber({
+  maxUsagePercent: aggregatedMinMax({
     "x-chart-type": "line",
     "x-chart-label": "Max CPU Usage",
     "x-chart-unit": "%",
   }),
-  avgLoadAvg1m: healthResultNumber({
+  avgLoadAvg1m: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Load (1m)",
   }),
-});
-
-const cpuAggregatedInternalSchema = z.object({
-  _usage: averageStateSchema.optional(),
-  _maxUsage: minMaxStateSchema.optional(),
-  _load: averageStateSchema.optional(),
-});
+};
 
-const cpuAggregatedSchema = cpuAggregatedDisplaySchema.merge(
-  cpuAggregatedInternalSchema,
-);
-
-export type CpuAggregatedResult = z.infer<typeof cpuAggregatedSchema>;
+// Type inferred from field definitions
+export type CpuAggregatedResult = InferAggregatedResult<
+  typeof cpuAggregatedFields
+>;
 
 // ============================================================================
 // CPU COLLECTOR
@@ -111,7 +105,10 @@ export class CpuCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: cpuConfigSchema });
   result = new Versioned({ version: 1, schema: cpuResultSchema });
-  aggregatedResult = new Versioned({ version: 1, schema: cpuAggregatedSchema });
+  aggregatedResult = new VersionedAggregated({
+    version: 1,
+    fields: cpuAggregatedFields,
+  });
 
   async execute({
     config,
@@ -154,28 +151,16 @@ export class CpuCollector implements CollectorStrategy<
   ): CpuAggregatedResult {
     const metadata = run.metadata;
 
-    const usageState = mergeAverage(
-      existing?._usage as AverageState | undefined,
-      metadata?.usagePercent,
-    );
-
-    const maxUsageState = mergeMinMax(
-      existing?._maxUsage as MinMaxState | undefined,
-      metadata?.usagePercent,
-    );
-
-    const loadState = mergeAverage(
-      existing?._load as AverageState | undefined,
-      metadata?.loadAvg1m,
-    );
-
     return {
-      avgUsagePercent: usageState.avg,
-      maxUsagePercent: maxUsageState.max,
-      avgLoadAvg1m: loadState.avg,
-      _usage: usageState,
-      _maxUsage: maxUsageState,
-      _load: loadState,
+      avgUsagePercent: mergeAverage(
+        existing?.avgUsagePercent,
+        metadata?.usagePercent,
+      ),
+      maxUsagePercent: mergeMinMax(
+        existing?.maxUsagePercent,
+        metadata?.usagePercent,
+      ),
+      avgLoadAvg1m: mergeAverage(existing?.avgLoadAvg1m, metadata?.loadAvg1m),
     };
   }
 

package/src/collectors/disk.test.ts

@@ -105,8 +105,8 @@ describe("DiskCollector", () => {
       let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgUsedPercent).toBe(40);
-      expect(aggregated.maxUsedPercent).toBe(50);
+      expect(aggregated.avgUsedPercent.avg).toBe(40);
+      expect(aggregated.maxUsedPercent.max).toBe(50);
     });
   });
 

package/src/collectors/disk.ts

@@ -6,10 +6,10 @@ import {
   type CollectorStrategy,
   mergeAverage,
   mergeMinMax,
-  averageStateSchema,
-  minMaxStateSchema,
-  type AverageState,
-  type MinMaxState,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedMinMax,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -70,29 +70,24 @@ const diskResultSchema = z.object({
 
 export type DiskResult = z.infer<typeof diskResultSchema>;
 
-const diskAggregatedDisplaySchema = z.object({
-  avgUsedPercent: healthResultNumber({
+// Aggregated result fields definition
+const diskAggregatedFields = {
+  avgUsedPercent: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Disk Usage",
     "x-chart-unit": "%",
   }),
-  maxUsedPercent: healthResultNumber({
+  maxUsedPercent: aggregatedMinMax({
     "x-chart-type": "line",
     "x-chart-label": "Max Disk Usage",
     "x-chart-unit": "%",
   }),
-});
-
-const diskAggregatedInternalSchema = z.object({
-  _usage: averageStateSchema.optional(),
-  _maxUsage: minMaxStateSchema.optional(),
-});
-
-const diskAggregatedSchema = diskAggregatedDisplaySchema.merge(
-  diskAggregatedInternalSchema,
-);
+};
 
-export type DiskAggregatedResult = z.infer<typeof diskAggregatedSchema>;
+// Type inferred from field definitions
+export type DiskAggregatedResult = InferAggregatedResult<
+  typeof diskAggregatedFields
+>;
 
 // ============================================================================
 // DISK COLLECTOR
@@ -112,9 +107,9 @@ export class DiskCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: diskConfigSchema });
   result = new Versioned({ version: 1, schema: diskResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: diskAggregatedSchema,
+    fields: diskAggregatedFields,
   });
 
   async execute({
@@ -138,21 +133,15 @@ export class DiskCollector implements CollectorStrategy<
   ): DiskAggregatedResult {
     const metadata = run.metadata;
 
-    const usageState = mergeAverage(
-      existing?._usage as AverageState | undefined,
-      metadata?.usedPercent,
-    );
-
-    const maxUsageState = mergeMinMax(
-      existing?._maxUsage as MinMaxState | undefined,
-      metadata?.usedPercent,
-    );
-
     return {
-      avgUsedPercent: usageState.avg,
-      maxUsedPercent: maxUsageState.max,
-      _usage: usageState,
-      _maxUsage: maxUsageState,
+      avgUsedPercent: mergeAverage(
+        existing?.avgUsedPercent,
+        metadata?.usedPercent,
+      ),
+      maxUsedPercent: mergeMinMax(
+        existing?.maxUsedPercent,
+        metadata?.usedPercent,
+      ),
     };
   }
 

package/src/collectors/memory.test.ts

@@ -111,9 +111,9 @@ Swap:          4096         512        3584`
       let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgUsedPercent).toBe(50);
-      expect(aggregated.maxUsedPercent).toBe(75);
-      expect(aggregated.avgUsedMb).toBe(8000);
+      expect(aggregated.avgUsedPercent.avg).toBe(50);
+      expect(aggregated.maxUsedPercent.max).toBe(75);
+      expect(aggregated.avgUsedMb.avg).toBe(8000);
     });
   });
 

package/src/collectors/memory.ts

@@ -6,10 +6,10 @@ import {
   type CollectorStrategy,
   mergeAverage,
   mergeMinMax,
-  averageStateSchema,
-  minMaxStateSchema,
-  type AverageState,
-  type MinMaxState,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedMinMax,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import { healthResultNumber } from "@checkstack/healthcheck-common";
 import {
@@ -73,35 +73,29 @@ const memoryResultSchema = z.object({
 
 export type MemoryResult = z.infer<typeof memoryResultSchema>;
 
-const memoryAggregatedDisplaySchema = z.object({
-  avgUsedPercent: healthResultNumber({
+// Aggregated result fields definition
+const memoryAggregatedFields = {
+  avgUsedPercent: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Memory Usage",
     "x-chart-unit": "%",
   }),
-  maxUsedPercent: healthResultNumber({
+  maxUsedPercent: aggregatedMinMax({
     "x-chart-type": "line",
     "x-chart-label": "Max Memory Usage",
     "x-chart-unit": "%",
   }),
-  avgUsedMb: healthResultNumber({
+  avgUsedMb: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Memory Used",
     "x-chart-unit": "MB",
   }),
-});
-
-const memoryAggregatedInternalSchema = z.object({
-  _usedPercent: averageStateSchema.optional(),
-  _maxUsedPercent: minMaxStateSchema.optional(),
-  _usedMb: averageStateSchema.optional(),
-});
+};
 
-const memoryAggregatedSchema = memoryAggregatedDisplaySchema.merge(
-  memoryAggregatedInternalSchema,
-);
-
-export type MemoryAggregatedResult = z.infer<typeof memoryAggregatedSchema>;
+// Type inferred from field definitions
+export type MemoryAggregatedResult = InferAggregatedResult<
+  typeof memoryAggregatedFields
+>;
 
 // ============================================================================
 // MEMORY COLLECTOR
@@ -121,9 +115,9 @@ export class MemoryCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: memoryConfigSchema });
   result = new Versioned({ version: 1, schema: memoryResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: memoryAggregatedSchema,
+    fields: memoryAggregatedFields,
   });
 
   async execute({
@@ -159,28 +153,16 @@ export class MemoryCollector implements CollectorStrategy<
   ): MemoryAggregatedResult {
     const metadata = run.metadata;
 
-    const usedPercentState = mergeAverage(
-      existing?._usedPercent as AverageState | undefined,
-      metadata?.usedPercent,
-    );
-
-    const maxUsedPercentState = mergeMinMax(
-      existing?._maxUsedPercent as MinMaxState | undefined,
-      metadata?.usedPercent,
-    );
-
-    const usedMbState = mergeAverage(
-      existing?._usedMb as AverageState | undefined,
-      metadata?.usedMb,
-    );
-
     return {
-      avgUsedPercent: usedPercentState.avg,
-      maxUsedPercent: maxUsedPercentState.max,
-      avgUsedMb: usedMbState.avg,
-      _usedPercent: usedPercentState,
-      _maxUsedPercent: maxUsedPercentState,
-      _usedMb: usedMbState,
+      avgUsedPercent: mergeAverage(
+        existing?.avgUsedPercent,
+        metadata?.usedPercent,
+      ),
+      maxUsedPercent: mergeMinMax(
+        existing?.maxUsedPercent,
+        metadata?.usedPercent,
+      ),
+      avgUsedMb: mergeAverage(existing?.avgUsedMb, metadata?.usedMb),
     };
   }