@checkstack/healthcheck-backend 0.12.1 → 0.13.1

package/src/queue-executor.ts

@@ -259,6 +259,8 @@ async function executeHealthCheckJob(props: {
         interval: healthCheckConfigurations.intervalSeconds,
         enabled: systemHealthChecks.enabled,
         paused: healthCheckConfigurations.paused,
+        includeLocal: systemHealthChecks.includeLocal,
+        satelliteIds: systemHealthChecks.satelliteIds,
       })
       .from(systemHealthChecks)
       .innerJoin(
@@ -289,6 +291,19 @@ async function executeHealthCheckJob(props: {
       return;
     }
 
+    // If includeLocal is false and satellites are assigned, skip local execution
+    // (satellites handle execution, local core doesn't run this check)
+    if (
+      !configRow.includeLocal &&
+      configRow.satelliteIds &&
+      configRow.satelliteIds.length > 0
+    ) {
+      logger.debug(
+        `Health check ${configId} for system ${systemId} is satellite-only, skipping local execution`,
+      );
+      return;
+    }
+
     // Fetch system name for signal payload
     let systemName = systemId;
     try {
@@ -395,6 +410,7 @@ async function executeHealthCheckJob(props: {
                 result: {
                   _collectorId: collectorEntry.collectorId,
                   _assertionFailed: assertionFailed,
+                  _collectorError: collectorError,
                   ...strippedResult,
                 },
               };
@@ -410,7 +426,7 @@ async function executeHealthCheckJob(props: {
                 result: {
                   _collectorId: collectorEntry.collectorId,
                   _assertionFailed: undefined,
-                  error: errorStr,
+                  _collectorError: errorStr,
                 },
               };
             }
@@ -486,6 +502,8 @@ async function executeHealthCheckJob(props: {
         status: result.status,
         latencyMs: result.latencyMs,
         result: { ...result } as Record<string, unknown>,
+        sourceId: undefined,
+        sourceLabel: "Local",
       });
 
       await incrementHourlyAggregate({
@@ -497,6 +515,7 @@ async function executeHealthCheckJob(props: {
         runTimestamp: new Date(),
         result: { ...result } as Record<string, unknown>,
         collectorRegistry,
+        sourceLabel: "Local",
       });
 
       logger.debug(
@@ -560,6 +579,8 @@ async function executeHealthCheckJob(props: {
       status: result.status,
       latencyMs: result.latencyMs,
       result: { ...result } as Record<string, unknown>,
+      sourceId: undefined,
+      sourceLabel: "Local",
     });
 
     // Trigger incremental hourly aggregation
@@ -572,6 +593,7 @@ async function executeHealthCheckJob(props: {
       runTimestamp: new Date(),
       result: { ...result } as Record<string, unknown>,
       collectorRegistry,
+      sourceLabel: "Local",
     });
 
     logger.debug(
@@ -660,6 +682,8 @@ async function executeHealthCheckJob(props: {
       systemId,
       status: "unhealthy",
       result: { error: String(error) } as Record<string, unknown>,
+      sourceId: undefined,
+      sourceLabel: "Local",
     });
 
     // Trigger incremental hourly aggregation
@@ -672,6 +696,7 @@ async function executeHealthCheckJob(props: {
       runTimestamp: new Date(),
       // No collector data for error cases
       collectorRegistry,
+      sourceLabel: "Local",
     });
 
     // Try to fetch names for the enriched signal (best-effort)

package/src/realtime-aggregation.ts

@@ -67,6 +67,10 @@ interface IncrementHourlyAggregateParams {
   result?: Record<string, unknown>;
   /** Collector registry for aggregating collector data via mergeResult */
   collectorRegistry?: CollectorRegistry;
+  /** Source identifier: undefined = local core, string = satellite ID */
+  sourceId?: string;
+  /** Human-readable source label for display */
+  sourceLabel?: string;
 }
 
 /**
@@ -88,6 +92,8 @@ export async function incrementHourlyAggregate(
     runTimestamp,
     result,
     collectorRegistry,
+    sourceId,
+    sourceLabel,
   } = params;
 
   const bucketStart = getHourBucketStart(runTimestamp);
@@ -107,6 +113,9 @@ export async function incrementHourlyAggregate(
         eq(healthCheckAggregates.configurationId, configurationId),
         eq(healthCheckAggregates.bucketStart, bucketStart),
         eq(healthCheckAggregates.bucketSize, "hourly"),
+        sourceId
+          ? eq(healthCheckAggregates.sourceId, sourceId)
+          : sql`${healthCheckAggregates.sourceId} IS NULL`,
       ),
     )
     .limit(1);
@@ -181,6 +190,8 @@ export async function incrementHourlyAggregate(
       p95LatencyMs: latencyUpdate?.p95,
       tdigestState: latencyUpdate?.tdigestState,
       aggregatedResult,
+      sourceId: sourceId ?? undefined,
+      sourceLabel: sourceLabel ?? undefined,
     })
     .onConflictDoUpdate({
       target: [
@@ -188,6 +199,7 @@ export async function incrementHourlyAggregate(
         healthCheckAggregates.systemId,
         healthCheckAggregates.bucketStart,
         healthCheckAggregates.bucketSize,
+        healthCheckAggregates.sourceId,
       ],
       set: {
         runCount: sql`${healthCheckAggregates.runCount} + 1`,

package/src/router.test.ts

@@ -50,11 +50,12 @@ describe("HealthCheck Router", () => {
     getCollectorsForPlugin: mock(() => []),
   };
 
-  const router = createHealthCheckRouter(
-    mockDb as never,
-    mockRegistry,
-    mockCollectorRegistry as never,
-  );
+  const router = createHealthCheckRouter({
+    database: mockDb as never,
+    registry: mockRegistry,
+    collectorRegistry: mockCollectorRegistry as never,
+    getEmitHook: () => undefined,
+  });
 
   it("getStrategies returns strategies from registry", async () => {
     const context = createMockRpcContext({

package/src/router.ts

@@ -10,6 +10,7 @@ import {
 import { healthCheckContract } from "@checkstack/healthcheck-common";
 import type { StrategyCategory } from "@checkstack/healthcheck-common";
 import { HealthCheckService } from "./service";
+import { healthCheckHooks } from "./hooks";
 import * as schema from "./schema";
 import { toJsonSchemaWithChartMeta } from "./schema-utils";
 
@@ -19,11 +20,13 @@ import { toJsonSchemaWithChartMeta } from "./schema-utils";
  * Auth and access rules are automatically enforced via autoAuthMiddleware
  * based on the contract's meta.userType and meta.access.
  */
-export const createHealthCheckRouter = (
-  database: SafeDatabase<typeof schema>,
-  registry: HealthCheckRegistry,
-  collectorRegistry: CollectorRegistry,
-) => {
+export const createHealthCheckRouter = (opts: {
+  database: SafeDatabase<typeof schema>;
+  registry: HealthCheckRegistry;
+  collectorRegistry: CollectorRegistry;
+  getEmitHook: () => ((hook: { id: string }, payload: Record<string, unknown>) => Promise<void>) | undefined;
+}) => {
+  const { database, registry, collectorRegistry, getEmitHook } = opts;
   // Create service instance once - shared across all handlers
   const service = new HealthCheckService(database, registry, collectorRegistry);
 
@@ -137,6 +140,8 @@ export const createHealthCheckRouter = (
         configurationId: input.body.configurationId,
         enabled: input.body.enabled,
         stateThresholds: input.body.stateThresholds,
+        satelliteIds: input.body.satelliteIds,
+        includeLocal: input.body.includeLocal,
       });
 
       // If enabling the health check, schedule it immediately
@@ -156,10 +161,28 @@ export const createHealthCheckRouter = (
           });
         }
       }
+
+      // Notify subscribers (e.g., satellite-backend) that assignments changed
+      const emitHook = getEmitHook();
+      if (emitHook) {
+        await emitHook(healthCheckHooks.assignmentChanged, {
+          systemId: input.systemId,
+          configurationId: input.body.configurationId,
+        });
+      }
     }),
 
     disassociateSystem: os.disassociateSystem.handler(async ({ input }) => {
       await service.disassociateSystem(input.systemId, input.configId);
+
+      // Notify subscribers that assignments changed
+      const emitHook = getEmitHook();
+      if (emitHook) {
+        await emitHook(healthCheckHooks.assignmentChanged, {
+          systemId: input.systemId,
+          configurationId: input.configId,
+        });
+      }
     }),
 
     getRetentionConfig: os.getRetentionConfig.handler(async ({ input }) => {
@@ -230,6 +253,22 @@ export const createHealthCheckRouter = (
         return service.getSystemHealthOverview(input.systemId);
       },
     ),
+
+    // ========================================================================
+    // SERVICE INTERFACE (S2S — satellite-backend)
+    // ========================================================================
+
+    getAssignmentsForSatellite: os.getAssignmentsForSatellite.handler(
+      async ({ input }) => {
+        return service.getAssignmentsForSatellite(input.satelliteId);
+      },
+    ),
+
+    ingestSatelliteResult: os.ingestSatelliteResult.handler(
+      async ({ input }) => {
+        await service.ingestSatelliteResult(input);
+      },
+    ),
   });
 };
 

package/src/schema.ts

@@ -90,6 +90,16 @@ export const systemHealthChecks = pgTable(
      * Null means use default retention settings.
      */
     retentionConfig: jsonb("retention_config").$type<RetentionConfig>(),
+    /**
+     * IDs of satellites assigned to execute this health check.
+     * When set, the check runs on these satellite nodes in addition to (or instead of) the core.
+     */
+    satelliteIds: jsonb("satellite_ids").$type<string[]>(),
+    /**
+     * Whether to also run this check locally on the core instance.
+     * Defaults to true. Only relevant when satelliteIds is set.
+     */
+    includeLocal: boolean("include_local").default(true).notNull(),
     createdAt: timestamp("created_at").defaultNow().notNull(),
     updatedAt: timestamp("updated_at").defaultNow().notNull(),
   },
@@ -108,6 +118,16 @@ export const healthCheckRuns = pgTable("health_check_runs", {
   /** Execution duration in milliseconds */
   latencyMs: integer("latency_ms"),
   result: jsonb("result").$type<Record<string, unknown>>(),
+  /**
+   * Source identifier for result attribution.
+   * null = local core execution, UUID = satellite ID.
+   */
+  sourceId: text("source_id"),
+  /**
+   * Human-readable source label for UI display.
+   * e.g. "Local" or "EU West (eu-west-1)".
+   */
+  sourceLabel: text("source_label"),
   timestamp: timestamp("timestamp").defaultNow().notNull(),
 });
 
@@ -151,14 +171,24 @@ export const healthCheckAggregates = pgTable(
       jsonb("aggregated_result").$type<Record<string, unknown>>(),
     /** Serialized t-digest state for incremental p95 calculation */
     tdigestState: jsonb("tdigest_state").$type<number[]>(),
+    /**
+     * Source identifier for per-region aggregation.
+     * null = local core execution, UUID = satellite ID.
+     */
+    sourceId: text("source_id"),
+    /**
+     * Human-readable source label for UI display.
+     */
+    sourceLabel: text("source_label"),
   },
   (t) => ({
-    // Unique constraint for upsert operations
+    // Unique constraint includes sourceId for per-region aggregation
     bucketUnique: uniqueIndex("health_check_aggregates_bucket_unique").on(
       t.configurationId,
       t.systemId,
       t.bucketStart,
       t.bucketSize,
+      t.sourceId,
     ),
   }),
 );

package/src/service.ts

@@ -5,6 +5,7 @@ import {
   StateThresholds,
   HealthCheckStatus,
   RetentionConfig,
+  type HealthCheckRunResult,
 } from "@checkstack/healthcheck-common";
 import {
   healthCheckConfigurations,
@@ -14,10 +15,11 @@ import {
   VersionedStateThresholds,
 } from "./schema";
 import * as schema from "./schema";
-import { eq, and, InferSelectModel, desc, gte, lte } 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,
@@ -129,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
@@ -148,6 +154,8 @@ export class HealthCheckService {
         configurationId,
         enabled,
         stateThresholds: versionedThresholds,
+        satelliteIds: satelliteIds ?? undefined,
+        includeLocal,
       })
       .onConflictDoUpdate({
         target: [
@@ -157,6 +165,8 @@ export class HealthCheckService {
         set: {
           enabled,
           stateThresholds: versionedThresholds,
+          satelliteIds: satelliteIds ?? undefined,
+          includeLocal,
           updatedAt: new Date(),
         },
       });
@@ -270,6 +280,8 @@ export class HealthCheckService {
         configName: healthCheckConfigurations.name,
         enabled: systemHealthChecks.enabled,
         stateThresholds: systemHealthChecks.stateThresholds,
+        satelliteIds: systemHealthChecks.satelliteIds,
+        includeLocal: systemHealthChecks.includeLocal,
       })
       .from(systemHealthChecks)
       .innerJoin(
@@ -290,6 +302,8 @@ export class HealthCheckService {
         configurationName: row.configName,
         enabled: row.enabled,
         stateThresholds: thresholds,
+        satelliteIds: row.satelliteIds ?? undefined,
+        includeLocal: row.includeLocal,
       });
     }
     return results;
@@ -474,6 +488,7 @@ export class HealthCheckService {
     configurationId?: string;
     startDate?: Date;
     endDate?: Date;
+    sourceFilter?: string;
     limit?: number;
     offset?: number;
     sortOrder: "asc" | "desc";
@@ -483,6 +498,7 @@ export class HealthCheckService {
       configurationId,
       startDate,
       endDate,
+      sourceFilter,
       limit = 10,
       offset = 0,
       sortOrder,
@@ -495,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;
 
@@ -522,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,
     };
@@ -537,6 +562,7 @@ export class HealthCheckService {
     configurationId?: string;
     startDate?: Date;
     endDate?: Date;
+    sourceFilter?: string;
     limit?: number;
     offset?: number;
     sortOrder: "asc" | "desc";
@@ -546,6 +572,7 @@ export class HealthCheckService {
       configurationId,
       startDate,
       endDate,
+      sourceFilter,
       limit = 10,
       offset = 0,
       sortOrder,
@@ -558,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);
 
@@ -582,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,
     };
@@ -610,6 +646,8 @@ export class HealthCheckService {
       result: r.result ?? {},
       timestamp: r.timestamp,
       latencyMs: r.latencyMs ?? undefined,
+      sourceId: r.sourceId ?? undefined,
+      sourceLabel: r.sourceLabel ?? undefined,
     };
   }
 
@@ -624,6 +662,7 @@ export class HealthCheckService {
       configurationId: string;
       startDate: Date;
       endDate: Date;
+      sourceFilter?: string;
       targetPoints?: number;
     },
     options: { includeAggregatedResult: boolean },
@@ -633,6 +672,7 @@ export class HealthCheckService {
       configurationId,
       startDate,
       endDate,
+      sourceFilter,
       targetPoints = 500,
     } = props;
 
@@ -655,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),
     ]);
 
@@ -953,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,
+    });
+  }
 }