@checkstack/healthcheck-redis-backend 0.0.2 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @checkstack/healthcheck-redis-backend
 
+## 0.1.0
+
+### Minor Changes
+
+- f5b1f49: Refactored health check strategies to use `createClient()` pattern with built-in collectors.
+
+  **Strategy Changes:**
+
+  - Replaced `execute()` with `createClient()` that returns a transport client
+  - Strategy configs now only contain connection parameters
+  - Collector configs handle what to do with the connection
+
+  **Built-in Collectors Added:**
+
+  - DNS: `LookupCollector` for hostname resolution
+  - gRPC: `HealthCollector` for gRPC health protocol
+  - HTTP: `RequestCollector` for HTTP requests
+  - MySQL: `QueryCollector` for database queries
+  - Ping: `PingCollector` for ICMP ping
+  - Postgres: `QueryCollector` for database queries
+  - Redis: `CommandCollector` for Redis commands
+  - Script: `ExecuteCollector` for script execution
+  - SSH: `CommandCollector` for SSH commands
+  - TCP: `BannerCollector` for TCP banner grabbing
+  - TLS: `CertificateCollector` for certificate inspection
+
+### Patch Changes
+
+- Updated dependencies [f5b1f49]
+- Updated dependencies [f5b1f49]
+- Updated dependencies [f5b1f49]
+- Updated dependencies [f5b1f49]
+  - @checkstack/backend-api@0.1.0
+  - @checkstack/healthcheck-common@0.1.0
+  - @checkstack/common@0.0.3
+
+## 0.0.3
+
+### Patch Changes
+
+- Updated dependencies [cb82e4d]
+  - @checkstack/healthcheck-common@0.0.3
+
 ## 0.0.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-redis-backend",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {

package/src/command-collector.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it, mock } from "bun:test";
+import { CommandCollector, type CommandConfig } from "./command-collector";
+import type { RedisTransportClient } from "./transport-client";
+
+describe("CommandCollector", () => {
+  const createMockClient = (
+    response: {
+      value?: string;
+      error?: string;
+    } = {}
+  ): RedisTransportClient => ({
+    exec: mock(() =>
+      Promise.resolve({
+        value: response.value ?? "PONG",
+        error: response.error,
+      })
+    ),
+  });
+
+  describe("execute", () => {
+    it("should execute PING successfully", async () => {
+      const collector = new CommandCollector();
+      const client = createMockClient({ value: "PONG" });
+
+      const result = await collector.execute({
+        config: { command: "PING" },
+        client,
+        pluginId: "test",
+      });
+
+      expect(result.result.response).toBe("PONG");
+      expect(result.result.success).toBe(true);
+      expect(result.result.responseTimeMs).toBeGreaterThanOrEqual(0);
+      expect(result.error).toBeUndefined();
+    });
+
+    it("should execute INFO with section", async () => {
+      const collector = new CommandCollector();
+      const client = createMockClient({ value: "redis_version:7.0.0" });
+
+      const result = await collector.execute({
+        config: { command: "INFO", args: "server" },
+        client,
+        pluginId: "test",
+      });
+
+      expect(result.result.response).toContain("redis_version");
+      expect(result.result.success).toBe(true);
+    });
+
+    it("should return error for failed command", async () => {
+      const collector = new CommandCollector();
+      const client = createMockClient({ error: "NOAUTH" });
+
+      const result = await collector.execute({
+        config: { command: "PING" },
+        client,
+        pluginId: "test",
+      });
+
+      expect(result.result.success).toBe(false);
+      expect(result.error).toBe("NOAUTH");
+    });
+
+    it("should pass correct parameters to client", async () => {
+      const collector = new CommandCollector();
+      const client = createMockClient();
+
+      await collector.execute({
+        config: { command: "GET", args: "mykey" },
+        client,
+        pluginId: "test",
+      });
+
+      expect(client.exec).toHaveBeenCalledWith({
+        cmd: "GET",
+        args: ["mykey"],
+      });
+    });
+  });
+
+  describe("aggregateResult", () => {
+    it("should calculate average response time and success rate", () => {
+      const collector = new CommandCollector();
+      const runs = [
+        {
+          id: "1",
+          status: "healthy" as const,
+          latencyMs: 10,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: { responseTimeMs: 5, success: true },
+        },
+        {
+          id: "2",
+          status: "healthy" as const,
+          latencyMs: 15,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: { responseTimeMs: 15, success: true },
+        },
+      ];
+
+      const aggregated = collector.aggregateResult(runs);
+
+      expect(aggregated.avgResponseTimeMs).toBe(10);
+      expect(aggregated.successRate).toBe(100);
+    });
+
+    it("should calculate success rate correctly", () => {
+      const collector = new CommandCollector();
+      const runs = [
+        {
+          id: "1",
+          status: "healthy" as const,
+          latencyMs: 10,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: { responseTimeMs: 5, success: true },
+        },
+        {
+          id: "2",
+          status: "unhealthy" as const,
+          latencyMs: 15,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: { responseTimeMs: 15, success: false },
+        },
+      ];
+
+      const aggregated = collector.aggregateResult(runs);
+
+      expect(aggregated.successRate).toBe(50);
+    });
+  });
+
+  describe("metadata", () => {
+    it("should have correct static properties", () => {
+      const collector = new CommandCollector();
+
+      expect(collector.id).toBe("command");
+      expect(collector.displayName).toBe("Redis Command");
+      expect(collector.allowMultiple).toBe(true);
+      expect(collector.supportedPlugins).toHaveLength(1);
+    });
+  });
+});

package/src/command-collector.ts

@@ -0,0 +1,153 @@
+import {
+  Versioned,
+  z,
+  type HealthCheckRunForAggregation,
+  type CollectorResult,
+  type CollectorStrategy,
+} from "@checkstack/backend-api";
+import {
+  healthResultNumber,
+  healthResultString,
+  healthResultBoolean,
+} from "@checkstack/healthcheck-common";
+import { pluginMetadata } from "./plugin-metadata";
+import type { RedisTransportClient } from "./transport-client";
+
+// ============================================================================
+// CONFIGURATION SCHEMA
+// ============================================================================
+
+const commandConfigSchema = z.object({
+  command: z
+    .enum(["PING", "INFO", "GET"])
+    .default("PING")
+    .describe("Redis command to execute"),
+  args: z
+    .string()
+    .optional()
+    .describe("Command argument (section for INFO, key for GET)"),
+});
+
+export type CommandConfig = z.infer<typeof commandConfigSchema>;
+
+// ============================================================================
+// RESULT SCHEMAS
+// ============================================================================
+
+const commandResultSchema = z.object({
+  response: healthResultString({
+    "x-chart-type": "text",
+    "x-chart-label": "Response",
+  }).optional(),
+  responseTimeMs: healthResultNumber({
+    "x-chart-type": "line",
+    "x-chart-label": "Response Time",
+    "x-chart-unit": "ms",
+  }),
+  success: healthResultBoolean({
+    "x-chart-type": "boolean",
+    "x-chart-label": "Success",
+  }),
+});
+
+export type CommandResult = z.infer<typeof commandResultSchema>;
+
+const commandAggregatedSchema = z.object({
+  avgResponseTimeMs: healthResultNumber({
+    "x-chart-type": "line",
+    "x-chart-label": "Avg Response Time",
+    "x-chart-unit": "ms",
+  }),
+  successRate: healthResultNumber({
+    "x-chart-type": "gauge",
+    "x-chart-label": "Success Rate",
+    "x-chart-unit": "%",
+  }),
+});
+
+export type CommandAggregatedResult = z.infer<typeof commandAggregatedSchema>;
+
+// ============================================================================
+// COMMAND COLLECTOR
+// ============================================================================
+
+/**
+ * Built-in Redis command collector.
+ * Executes Redis commands and checks results.
+ */
+export class CommandCollector
+  implements
+    CollectorStrategy<
+      RedisTransportClient,
+      CommandConfig,
+      CommandResult,
+      CommandAggregatedResult
+    >
+{
+  id = "command";
+  displayName = "Redis Command";
+  description = "Execute a Redis command and check the result";
+
+  supportedPlugins = [pluginMetadata];
+
+  allowMultiple = true;
+
+  config = new Versioned({ version: 1, schema: commandConfigSchema });
+  result = new Versioned({ version: 1, schema: commandResultSchema });
+  aggregatedResult = new Versioned({
+    version: 1,
+    schema: commandAggregatedSchema,
+  });
+
+  async execute({
+    config,
+    client,
+  }: {
+    config: CommandConfig;
+    client: RedisTransportClient;
+    pluginId: string;
+  }): Promise<CollectorResult<CommandResult>> {
+    const startTime = Date.now();
+
+    const response = await client.exec({
+      cmd: config.command,
+      args: config.args ? [config.args] : undefined,
+    });
+
+    const responseTimeMs = Date.now() - startTime;
+
+    return {
+      result: {
+        response: response.value,
+        responseTimeMs,
+        success: !response.error,
+      },
+      error: response.error,
+    };
+  }
+
+  aggregateResult(
+    runs: HealthCheckRunForAggregation<CommandResult>[]
+  ): CommandAggregatedResult {
+    const times = runs
+      .map((r) => r.metadata?.responseTimeMs)
+      .filter((v): v is number => typeof v === "number");
+
+    const successes = runs
+      .map((r) => r.metadata?.success)
+      .filter((v): v is boolean => typeof v === "boolean");
+
+    const successCount = successes.filter(Boolean).length;
+
+    return {
+      avgResponseTimeMs:
+        times.length > 0
+          ? Math.round(times.reduce((a, b) => a + b, 0) / times.length)
+          : 0,
+      successRate:
+        successes.length > 0
+          ? Math.round((successCount / successes.length) * 100)
+          : 0,
+    };
+  }
+}

package/src/index.ts

@@ -1,9 +1,7 @@
-import {
-  createBackendPlugin,
-  coreServices,
-} from "@checkstack/backend-api";
+import { createBackendPlugin, coreServices } from "@checkstack/backend-api";
 import { RedisHealthCheckStrategy } from "./strategy";
 import { pluginMetadata } from "./plugin-metadata";
+import { CommandCollector } from "./command-collector";
 
 export default createBackendPlugin({
   metadata: pluginMetadata,
@@ -11,13 +9,17 @@ export default createBackendPlugin({
     env.registerInit({
       deps: {
         healthCheckRegistry: coreServices.healthCheckRegistry,
+        collectorRegistry: coreServices.collectorRegistry,
         logger: coreServices.logger,
       },
-      init: async ({ healthCheckRegistry, logger }) => {
+      init: async ({ healthCheckRegistry, collectorRegistry, logger }) => {
         logger.debug("🔌 Registering Redis Health Check Strategy...");
         const strategy = new RedisHealthCheckStrategy();
         healthCheckRegistry.register(strategy);
+        collectorRegistry.register(new CommandCollector());
       },
     });
   },
 });
+
+export { pluginMetadata } from "./plugin-metadata";

package/src/strategy.test.ts

@@ -1,7 +1,33 @@
 import { describe, expect, it, mock } from "bun:test";
-import { RedisHealthCheckStrategy, RedisClient } from "./strategy";
+import {
+  RedisHealthCheckStrategy,
+  RedisClient,
+  RedisConnection,
+} from "./strategy";
 
 describe("RedisHealthCheckStrategy", () => {
+  // Helper to create mock Redis connection
+  const createMockConnection = (
+    config: {
+      pingResponse?: string;
+      infoResponse?: string;
+      pingError?: Error;
+    } = {}
+  ): RedisConnection => ({
+    ping: mock(() =>
+      config.pingError
+        ? Promise.reject(config.pingError)
+        : Promise.resolve(config.pingResponse ?? "PONG")
+    ),
+    info: mock(() =>
+      Promise.resolve(
+        config.infoResponse ?? "redis_version:7.0.0\r\nrole:master\r\n"
+      )
+    ),
+    get: mock(() => Promise.resolve(undefined)),
+    quit: mock(() => Promise.resolve("OK")),
+  });
+
   // Helper to create mock Redis client
   const createMockClient = (
     config: {
@@ -14,127 +40,91 @@ describe("RedisHealthCheckStrategy", () => {
     connect: mock(() =>
       config.connectError
         ? Promise.reject(config.connectError)
-        : Promise.resolve({
-            ping: mock(() =>
-              config.pingError
-                ? Promise.reject(config.pingError)
-                : Promise.resolve(config.pingResponse ?? "PONG")
-            ),
-            info: mock(() =>
-              Promise.resolve(
-                config.infoResponse ?? "redis_version:7.0.0\r\nrole:master\r\n"
-              )
-            ),
-            quit: mock(() => Promise.resolve("OK")),
-          })
+        : Promise.resolve(createMockConnection(config))
     ),
   });
 
-  describe("execute", () => {
-    it("should return healthy for successful connection", async () => {
+  describe("createClient", () => {
+    it("should return a connected client for successful connection", async () => {
       const strategy = new RedisHealthCheckStrategy(createMockClient());
 
-      const result = await strategy.execute({
+      const connectedClient = await strategy.createClient({
         host: "localhost",
         port: 6379,
         timeout: 5000,
       });
 
-      expect(result.status).toBe("healthy");
-      expect(result.metadata?.connected).toBe(true);
-      expect(result.metadata?.pingSuccess).toBe(true);
-      expect(result.metadata?.redisVersion).toBe("7.0.0");
-      expect(result.metadata?.role).toBe("master");
+      expect(connectedClient.client).toBeDefined();
+      expect(connectedClient.client.exec).toBeDefined();
+      expect(connectedClient.close).toBeDefined();
+
+      connectedClient.close();
     });
 
-    it("should return unhealthy for connection error", async () => {
+    it("should throw for connection error", async () => {
       const strategy = new RedisHealthCheckStrategy(
         createMockClient({ connectError: new Error("Connection refused") })
       );
 
-      const result = await strategy.execute({
+      await expect(
+        strategy.createClient({
+          host: "localhost",
+          port: 6379,
+          timeout: 5000,
+        })
+      ).rejects.toThrow("Connection refused");
+    });
+  });
+
+  describe("client.exec", () => {
+    it("should execute PING successfully", async () => {
+      const strategy = new RedisHealthCheckStrategy(createMockClient());
+      const connectedClient = await strategy.createClient({
         host: "localhost",
         port: 6379,
         timeout: 5000,
       });
 
-      expect(result.status).toBe("unhealthy");
-      expect(result.message).toContain("Connection refused");
-      expect(result.metadata?.connected).toBe(false);
+      const result = await connectedClient.client.exec({ cmd: "PING" });
+
+      expect(result.value).toBe("PONG");
+
+      connectedClient.close();
     });
 
-    it("should return unhealthy for PING failure", async () => {
+    it("should return error for ping failure", async () => {
       const strategy = new RedisHealthCheckStrategy(
         createMockClient({ pingError: new Error("NOAUTH") })
       );
-
-      const result = await strategy.execute({
+      const connectedClient = await strategy.createClient({
         host: "localhost",
         port: 6379,
         timeout: 5000,
       });
 
-      expect(result.status).toBe("unhealthy");
-      expect(result.metadata?.pingSuccess).toBe(false);
-    });
+      const result = await connectedClient.client.exec({ cmd: "PING" });
 
-    it("should pass connectionTime assertion when below threshold", async () => {
-      const strategy = new RedisHealthCheckStrategy(createMockClient());
+      expect(result.error).toContain("NOAUTH");
 
-      const result = await strategy.execute({
-        host: "localhost",
-        port: 6379,
-        timeout: 5000,
-        assertions: [
-          { field: "connectionTime", operator: "lessThan", value: 5000 },
-        ],
-      });
-
-      expect(result.status).toBe("healthy");
+      connectedClient.close();
     });
 
-    it("should pass role assertion", async () => {
+    it("should return server info", async () => {
       const strategy = new RedisHealthCheckStrategy(createMockClient());
-
-      const result = await strategy.execute({
+      const connectedClient = await strategy.createClient({
         host: "localhost",
         port: 6379,
         timeout: 5000,
-        assertions: [{ field: "role", operator: "equals", value: "master" }],
       });
 
-      expect(result.status).toBe("healthy");
-    });
-
-    it("should fail role assertion when replica", async () => {
-      const strategy = new RedisHealthCheckStrategy(
-        createMockClient({
-          infoResponse: "redis_version:7.0.0\r\nrole:slave\r\n",
-        })
-      );
-
-      const result = await strategy.execute({
-        host: "localhost",
-        port: 6379,
-        timeout: 5000,
-        assertions: [{ field: "role", operator: "equals", value: "master" }],
+      const result = await connectedClient.client.exec({
+        cmd: "INFO",
+        args: ["server"],
       });
 
-      expect(result.status).toBe("unhealthy");
-      expect(result.message).toContain("Assertion failed");
-    });
-
-    it("should pass pingSuccess assertion", async () => {
-      const strategy = new RedisHealthCheckStrategy(createMockClient());
-
-      const result = await strategy.execute({
-        host: "localhost",
-        port: 6379,
-        timeout: 5000,
-        assertions: [{ field: "pingSuccess", operator: "isTrue" }],
-      });
+      expect(result.value).toContain("redis_version");
 
-      expect(result.status).toBe("healthy");
+      connectedClient.close();
     });
   });
 
@@ -151,7 +141,6 @@ describe("RedisHealthCheckStrategy", () => {
           metadata: {
             connected: true,
             connectionTimeMs: 5,
-            pingTimeMs: 1,
             pingSuccess: true,
             role: "master",
           },
@@ -165,7 +154,6 @@ describe("RedisHealthCheckStrategy", () => {
           metadata: {
             connected: true,
             connectionTimeMs: 15,
-            pingTimeMs: 3,
             pingSuccess: true,
             role: "master",
           },
@@ -175,7 +163,6 @@ describe("RedisHealthCheckStrategy", () => {
       const aggregated = strategy.aggregateResult(runs);
 
       expect(aggregated.avgConnectionTime).toBe(10);
-      expect(aggregated.avgPingTime).toBe(2);
       expect(aggregated.successRate).toBe(100);
       expect(aggregated.errorCount).toBe(0);
     });

package/src/strategy.ts

@@ -1,46 +1,29 @@
 import Redis from "ioredis";
 import {
   HealthCheckStrategy,
-  HealthCheckResult,
   HealthCheckRunForAggregation,
   Versioned,
   z,
-  timeThresholdField,
-  booleanField,
-  enumField,
   configString,
   configNumber,
   configBoolean,
-  evaluateAssertions,
+  type ConnectedClient,
 } from "@checkstack/backend-api";
 import {
   healthResultBoolean,
   healthResultNumber,
   healthResultString,
 } from "@checkstack/healthcheck-common";
+import type {
+  RedisTransportClient,
+  RedisCommand,
+  RedisCommandResult,
+} from "./transport-client";
 
 // ============================================================================
 // SCHEMAS
 // ============================================================================
 
-/**
- * Valid Redis server roles from the INFO replication command.
- */
-const RedisRole = z.enum(["master", "slave", "sentinel"]);
-export type RedisRole = z.infer<typeof RedisRole>;
-
-/**
- * Assertion schema for Redis health checks using shared factories.
- */
-const redisAssertionSchema = z.discriminatedUnion("field", [
-  timeThresholdField("connectionTime"),
-  timeThresholdField("pingTime"),
-  booleanField("pingSuccess"),
-  enumField("role", RedisRole.options),
-]);
-
-export type RedisAssertion = z.infer<typeof redisAssertionSchema>;
-
 /**
  * Configuration schema for Redis health checks.
  */
@@ -53,18 +36,18 @@ export const redisConfigSchema = z.object({
     .default(6379)
     .describe("Redis port"),
   password: configString({ "x-secret": true })
-    .describe("Password for authentication")
-    .optional(),
-  database: configNumber({}).int().min(0).default(0).describe("Database index"),
+    .optional()
+    .describe("Redis password"),
+  database: configNumber({})
+    .int()
+    .min(0)
+    .default(0)
+    .describe("Redis database number"),
   tls: configBoolean({}).default(false).describe("Use TLS connection"),
   timeout: configNumber({})
     .min(100)
     .default(5000)
     .describe("Connection timeout in milliseconds"),
-  assertions: z
-    .array(redisAssertionSchema)
-    .optional()
-    .describe("Validation conditions"),
 });
 
 export type RedisConfig = z.infer<typeof redisConfigSchema>;
@@ -83,31 +66,13 @@ const redisResultSchema = z.object({
     "x-chart-label": "Connection Time",
     "x-chart-unit": "ms",
   }),
-  pingTimeMs: healthResultNumber({
-    "x-chart-type": "line",
-    "x-chart-label": "Ping Time",
-    "x-chart-unit": "ms",
-  }).optional(),
-  pingSuccess: healthResultBoolean({
-    "x-chart-type": "boolean",
-    "x-chart-label": "Ping Success",
-  }),
-  role: healthResultString({
-    "x-chart-type": "text",
-    "x-chart-label": "Role",
-  }).optional(),
-  redisVersion: healthResultString({
-    "x-chart-type": "text",
-    "x-chart-label": "Redis Version",
-  }).optional(),
-  failedAssertion: redisAssertionSchema.optional(),
   error: healthResultString({
     "x-chart-type": "status",
     "x-chart-label": "Error",
   }).optional(),
 });
 
-export type RedisResult = z.infer<typeof redisResultSchema>;
+type RedisResult = z.infer<typeof redisResultSchema>;
 
 /**
  * Aggregated metadata for buckets.
@@ -118,9 +83,9 @@ const redisAggregatedSchema = z.object({
     "x-chart-label": "Avg Connection Time",
     "x-chart-unit": "ms",
   }),
-  avgPingTime: healthResultNumber({
+  maxConnectionTime: healthResultNumber({
     "x-chart-type": "line",
-    "x-chart-label": "Avg Ping Time",
+    "x-chart-label": "Max Connection Time",
     "x-chart-unit": "ms",
   }),
   successRate: healthResultNumber({
@@ -134,7 +99,7 @@ const redisAggregatedSchema = z.object({
   }),
 });
 
-export type RedisAggregatedResult = z.infer<typeof redisAggregatedSchema>;
+type RedisAggregatedResult = z.infer<typeof redisAggregatedSchema>;
 
 // ============================================================================
 // REDIS CLIENT INTERFACE (for testability)
@@ -143,6 +108,7 @@ export type RedisAggregatedResult = z.infer<typeof redisAggregatedSchema>;
 export interface RedisConnection {
   ping(): Promise<string>;
   info(section: string): Promise<string>;
+  get(key: string): Promise<string | undefined>;
   quit(): Promise<string>;
 }
 
@@ -159,24 +125,33 @@ export interface RedisClient {
 
 // Default client using ioredis
 const defaultRedisClient: RedisClient = {
-  async connect(config) {
-    const redis = new Redis({
-      host: config.host,
-      port: config.port,
-      password: config.password,
-      db: config.db,
-      tls: config.tls ? {} : undefined,
-      connectTimeout: config.connectTimeout,
-      lazyConnect: true,
-    });
-
-    await redis.connect();
+  connect(config) {
+    return new Promise((resolve, reject) => {
+      const redis = new Redis({
+        host: config.host,
+        port: config.port,
+        password: config.password,
+        db: config.db,
+        tls: config.tls ? {} : undefined,
+        connectTimeout: config.connectTimeout,
+        lazyConnect: true,
+        maxRetriesPerRequest: 0,
+      });
 
-    return {
-      ping: () => redis.ping(),
-      info: (section: string) => redis.info(section),
-      quit: () => redis.quit(),
-    };
+      redis.on("error", reject);
+
+      redis
+        .connect()
+        .then(() => {
+          resolve({
+            ping: () => redis.ping(),
+            info: (section: string) => redis.info(section),
+            get: (key: string) => redis.get(key).then((v) => v ?? undefined),
+            quit: () => redis.quit(),
+          });
+        })
+        .catch(reject);
+    });
   },
 };
 
@@ -186,7 +161,12 @@ const defaultRedisClient: RedisClient = {
 
 export class RedisHealthCheckStrategy
   implements
-    HealthCheckStrategy<RedisConfig, RedisResult, RedisAggregatedResult>
+    HealthCheckStrategy<
+      RedisConfig,
+      RedisTransportClient,
+      RedisResult,
+      RedisAggregatedResult
+    >
 {
   id = "redis";
   displayName = "Redis Health Check";
@@ -199,13 +179,29 @@ export class RedisHealthCheckStrategy
   }
 
   config: Versioned<RedisConfig> = new Versioned({
-    version: 1,
+    version: 2, // Bumped for createClient pattern
     schema: redisConfigSchema,
+    migrations: [
+      {
+        fromVersion: 1,
+        toVersion: 2,
+        description: "Migrate to createClient pattern (no config changes)",
+        migrate: (data: unknown) => data,
+      },
+    ],
   });
 
   result: Versioned<RedisResult> = new Versioned({
-    version: 1,
+    version: 2,
     schema: redisResultSchema,
+    migrations: [
+      {
+        fromVersion: 1,
+        toVersion: 2,
+        description: "Migrate to createClient pattern (no result changes)",
+        migrate: (data: unknown) => data,
+      },
+    ],
   });
 
   aggregatedResult: Versioned<RedisAggregatedResult> = new Versioned({
@@ -216,147 +212,103 @@ export class RedisHealthCheckStrategy
   aggregateResult(
     runs: HealthCheckRunForAggregation<RedisResult>[]
   ): RedisAggregatedResult {
-    let totalConnectionTime = 0;
-    let totalPingTime = 0;
-    let successCount = 0;
-    let errorCount = 0;
-    let validRuns = 0;
-    let pingRuns = 0;
-
-    for (const run of runs) {
-      if (run.metadata?.error) {
-        errorCount++;
-        continue;
-      }
-      if (run.status === "healthy") {
-        successCount++;
-      }
-      if (run.metadata) {
-        totalConnectionTime += run.metadata.connectionTimeMs;
-        if (run.metadata.pingTimeMs !== undefined) {
-          totalPingTime += run.metadata.pingTimeMs;
-          pingRuns++;
-        }
-        validRuns++;
-      }
+    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;
+
     return {
-      avgConnectionTime: validRuns > 0 ? totalConnectionTime / validRuns : 0,
-      avgPingTime: pingRuns > 0 ? totalPingTime / pingRuns : 0,
-      successRate: runs.length > 0 ? (successCount / runs.length) * 100 : 0,
+      avgConnectionTime,
+      maxConnectionTime,
+      successRate,
       errorCount,
     };
   }
 
-  async execute(
+  async createClient(
     config: RedisConfigInput
-  ): Promise<HealthCheckResult<RedisResult>> {
+  ): Promise<ConnectedClient<RedisTransportClient>> {
     const validatedConfig = this.config.validate(config);
-    const start = performance.now();
-
-    try {
-      // Connect to Redis
-      const connection = await this.redisClient.connect({
-        host: validatedConfig.host,
-        port: validatedConfig.port,
-        password: validatedConfig.password,
-        db: validatedConfig.database,
-        tls: validatedConfig.tls,
-        connectTimeout: validatedConfig.timeout,
-      });
-
-      const connectionTimeMs = Math.round(performance.now() - start);
-
-      // Execute PING command
-      const pingStart = performance.now();
-      let pingSuccess = false;
-      let pingTimeMs: number | undefined;
-
-      try {
-        const pong = await connection.ping();
-        pingSuccess = pong === "PONG";
-        pingTimeMs = Math.round(performance.now() - pingStart);
-      } catch {
-        pingSuccess = false;
-        pingTimeMs = Math.round(performance.now() - pingStart);
-      }
-
-      // Get server info
-      let role: string | undefined;
-      let redisVersion: string | undefined;
-
-      try {
-        const info = await connection.info("server");
-        const roleMatch = /role:(\w+)/i.exec(info);
-        const versionMatch = /redis_version:([^\r\n]+)/i.exec(info);
-        role = roleMatch?.[1];
-        redisVersion = versionMatch?.[1];
-      } catch {
-        // Info command failed, continue without it
-      }
-
-      await connection.quit();
-
-      const result: Omit<RedisResult, "failedAssertion" | "error"> = {
-        connected: true,
-        connectionTimeMs,
-        pingTimeMs,
-        pingSuccess,
-        role,
-        redisVersion,
-      };
 
-      // Evaluate assertions using shared utility
-      const failedAssertion = evaluateAssertions(validatedConfig.assertions, {
-        connectionTime: connectionTimeMs,
-        pingTime: pingTimeMs ?? 0,
-        pingSuccess,
-        role: role ?? "",
-      });
+    const connection = await this.redisClient.connect({
+      host: validatedConfig.host,
+      port: validatedConfig.port,
+      password: validatedConfig.password,
+      db: validatedConfig.database,
+      tls: validatedConfig.tls,
+      connectTimeout: validatedConfig.timeout,
+    });
 
-      if (failedAssertion) {
-        return {
-          status: "unhealthy",
-          latencyMs: connectionTimeMs + (pingTimeMs ?? 0),
-          message: `Assertion failed: ${failedAssertion.field} ${
-            failedAssertion.operator
-          }${"value" in failedAssertion ? ` ${failedAssertion.value}` : ""}`,
-          metadata: { ...result, failedAssertion },
-        };
-      }
-
-      if (!pingSuccess) {
-        return {
-          status: "unhealthy",
-          latencyMs: connectionTimeMs + (pingTimeMs ?? 0),
-          message: "Redis PING failed",
-          metadata: result,
-        };
-      }
+    const client: RedisTransportClient = {
+      async exec(command: RedisCommand): Promise<RedisCommandResult> {
+        try {
+          let value: string | undefined;
+          switch (command.cmd) {
+            case "PING": {
+              value = await connection.ping();
+              break;
+            }
+            case "INFO": {
+              value = await connection.info(command.args?.[0] ?? "server");
+              break;
+            }
+            case "GET": {
+              value = await connection.get(command.args?.[0] ?? "");
+              break;
+            }
+            default: {
+              return {
+                value: undefined,
+                error: `Unsupported command: ${command.cmd}`,
+              };
+            }
+          }
+          return { value };
+        } catch (error) {
+          return {
+            value: undefined,
+            error: error instanceof Error ? error.message : String(error),
+          };
+        }
+      },
+    };
 
-      return {
-        status: "healthy",
-        latencyMs: connectionTimeMs + (pingTimeMs ?? 0),
-        message: `Redis ${redisVersion ?? "unknown"} (${
-          role ?? "unknown"
-        }) - PONG in ${pingTimeMs}ms`,
-        metadata: result,
-      };
-    } catch (error: unknown) {
-      const end = performance.now();
-      const isError = error instanceof Error;
-      return {
-        status: "unhealthy",
-        latencyMs: Math.round(end - start),
-        message: isError ? error.message : "Redis connection failed",
-        metadata: {
-          connected: false,
-          connectionTimeMs: Math.round(end - start),
-          pingSuccess: false,
-          error: isError ? error.name : "UnknownError",
-        },
-      };
-    }
+    return {
+      client,
+      close: () => {
+        connection.quit().catch(() => {
+          // Ignore quit errors
+        });
+      },
+    };
   }
 }

package/src/transport-client.ts

@@ -0,0 +1,25 @@
+import type { TransportClient } from "@checkstack/common";
+
+/**
+ * Redis command for transport client.
+ */
+export interface RedisCommand {
+  cmd: "PING" | "INFO" | "GET" | "SET" | "KEYS" | "CUSTOM";
+  args?: string[];
+}
+
+/**
+ * Redis command result.
+ */
+export interface RedisCommandResult {
+  value: string | undefined;
+  error?: string;
+}
+
+/**
+ * Redis transport client for collector execution.
+ */
+export type RedisTransportClient = TransportClient<
+  RedisCommand,
+  RedisCommandResult
+>;