claude-flow-novice 2.0.0 → 2.0.1

package/.claude-flow-novice/dist/src/cfn-loop/redis-health-integration-example.js

@@ -0,0 +1,215 @@
+/**
+ * Redis Health Monitor Integration Example - Sprint 1.3
+ *
+ * Demonstrates how to integrate Redis health monitoring with blocking coordination.
+ * Shows proper health check setup, event handling, and graceful degradation.
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.3 - Redis Health Check
+ *
+ * @module cfn-loop/redis-health-integration-example
+ */ import Redis from "ioredis";
+import { createRedisHealthMonitor } from "./redis-health-monitor.js";
+import { BlockingCoordinationManager } from "./blocking-coordination.js";
+import { HeartbeatWarningSystem } from "./heartbeat-warning-system.js";
+// ===== CONFIGURATION =====
+const REDIS_CONFIG = {
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379', 10),
+    password: process.env.REDIS_PASSWORD,
+    db: parseInt(process.env.REDIS_DB || '0', 10),
+    retryStrategy: (times)=>{
+        // Exponential backoff with max 5s delay
+        const delay = Math.min(times * 200, 5000);
+        return delay;
+    },
+    enableReadyCheck: true,
+    maxRetriesPerRequest: 3
+};
+// ===== INTEGRATION EXAMPLE =====
+async function main() {
+    console.log('🚀 Starting Redis Health Monitor Integration Example\n');
+    // Step 1: Create Redis client
+    console.log('📡 Step 1: Creating Redis client...');
+    const redis = new Redis(REDIS_CONFIG);
+    // Step 2: Create health monitor
+    console.log('🏥 Step 2: Creating Redis health monitor...');
+    const healthMonitor = createRedisHealthMonitor({
+        redisClient: redis,
+        healthCheckInterval: 50000,
+        pingTimeout: 5000,
+        autoReconnect: true,
+        maxReconnectAttempts: 5,
+        reconnectDelayMs: 5000,
+        debug: true
+    });
+    // Step 3: Set up event listeners
+    console.log('👂 Step 3: Setting up event listeners...\n');
+    healthMonitor.on('redis:connected', (event)=>{
+        console.log('✅ Redis Connected:', event);
+    });
+    healthMonitor.on('redis:disconnected', (event)=>{
+        console.log('❌ Redis Disconnected:', event);
+    });
+    healthMonitor.on('redis:reconnecting', (event)=>{
+        console.log(`🔄 Redis Reconnecting (attempt ${event.attempt}/${event.maxAttempts}):`, event);
+    });
+    healthMonitor.on('redis:state:change', (change)=>{
+        console.log('🔀 Redis State Changed:', {
+            from: change.previousState,
+            to: change.newState,
+            reason: change.reason
+        });
+    });
+    healthMonitor.on('redis:reconnect:failed', (event)=>{
+        console.log('💥 Redis Reconnect Failed:', event);
+    });
+    healthMonitor.on('monitoring:started', (event)=>{
+        console.log('🎯 Monitoring Started:', event);
+    });
+    healthMonitor.on('monitoring:stopped', (event)=>{
+        console.log('⏹️  Monitoring Stopped:', event);
+    });
+    // Step 4: Wait for initial connection
+    console.log('⏳ Step 4: Waiting for Redis connection...');
+    await new Promise((resolve, reject)=>{
+        const timeout = setTimeout(()=>{
+            reject(new Error('Redis connection timeout'));
+        }, 10000);
+        redis.once('ready', ()=>{
+            clearTimeout(timeout);
+            console.log('✅ Redis connection established\n');
+            resolve();
+        });
+        redis.once('error', (error)=>{
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+    // Step 5: Perform initial health check
+    console.log('🔍 Step 5: Performing initial health check...');
+    const initialCheck = await healthMonitor.performHealthCheck();
+    console.log('Health Check Result:', initialCheck);
+    console.log('Connection State:', healthMonitor.getConnectionState());
+    console.log('Statistics:', healthMonitor.getStatistics(), '\n');
+    // Step 6: Start periodic monitoring
+    console.log('🔄 Step 6: Starting periodic health monitoring...');
+    healthMonitor.startMonitoring();
+    // Step 7: Create blocking coordination manager (optional integration)
+    console.log('🔗 Step 7: Creating blocking coordination manager...');
+    const blockingCoordination = new BlockingCoordinationManager({
+        redisClient: redis,
+        coordinatorId: 'example-coordinator-1',
+        ackTtl: 3600,
+        debug: true,
+        hmacSecret: process.env.BLOCKING_COORDINATION_SECRET || 'test-secret-key-123'
+    });
+    // Step 8: Create heartbeat warning system (optional integration)
+    console.log('💓 Step 8: Creating heartbeat warning system...');
+    const heartbeatSystem = new HeartbeatWarningSystem({
+        redisClient: redis,
+        monitorInterval: 10000,
+        staleThreshold: 120000,
+        maxWarnings: 3,
+        autoCleanup: true,
+        debug: true
+    });
+    // Start heartbeat monitoring
+    heartbeatSystem.startMonitoring();
+    // Step 9: Demonstrate health-aware operations
+    console.log('\n🎭 Step 9: Demonstrating health-aware operations...\n');
+    // Perform operations with health check
+    async function performHealthAwareOperation(operation, name) {
+        console.log(`📝 Attempting operation: ${name}`);
+        if (!healthMonitor.isHealthy()) {
+            console.log(`⚠️  Redis unhealthy, operation deferred: ${name}`);
+            return;
+        }
+        try {
+            await operation();
+            console.log(`✅ Operation succeeded: ${name}\n`);
+        } catch (error) {
+            console.log(`❌ Operation failed: ${name}`, error instanceof Error ? error.message : error, '\n');
+        }
+    }
+    // Example operations
+    await performHealthAwareOperation(async ()=>{
+        await redis.set('test:key1', 'value1');
+    }, 'Set test key');
+    await performHealthAwareOperation(async ()=>{
+        const value = await redis.get('test:key1');
+        console.log(`   Retrieved value: ${value}`);
+    }, 'Get test key');
+    await performHealthAwareOperation(async ()=>{
+        await heartbeatSystem.registerHeartbeat('example-coordinator-1', 1, {
+            phase: 'example',
+            agentCount: 1,
+            status: 'running'
+        });
+    }, 'Register heartbeat');
+    // Step 10: Simulate disconnection and reconnection
+    console.log('🔌 Step 10: Simulating disconnection and reconnection...\n');
+    console.log('Disconnecting Redis in 3 seconds...');
+    await new Promise((resolve)=>setTimeout(resolve, 3000));
+    console.log('💔 Disconnecting...');
+    await redis.disconnect();
+    console.log('Waiting 2 seconds...');
+    await new Promise((resolve)=>setTimeout(resolve, 2000));
+    console.log('Checking health after disconnect...');
+    const disconnectedCheck = await healthMonitor.performHealthCheck();
+    console.log('Health Check Result:', disconnectedCheck);
+    console.log('Connection State:', healthMonitor.getConnectionState(), '\n');
+    console.log('Reconnecting Redis...');
+    await redis.connect();
+    console.log('Waiting 2 seconds...');
+    await new Promise((resolve)=>setTimeout(resolve, 2000));
+    console.log('Checking health after reconnect...');
+    const reconnectedCheck = await healthMonitor.performHealthCheck();
+    console.log('Health Check Result:', reconnectedCheck);
+    console.log('Connection State:', healthMonitor.getConnectionState(), '\n');
+    // Step 11: Display final statistics
+    console.log('📊 Step 11: Final Statistics\n');
+    const healthStats = healthMonitor.getStatistics();
+    console.log('Health Monitor Statistics:', {
+        totalChecks: healthStats.totalHealthChecks,
+        successfulChecks: healthStats.successfulChecks,
+        failedChecks: healthStats.failedChecks,
+        successRate: `${(healthStats.successRate * 100).toFixed(1)}%`,
+        reconnectAttempts: healthStats.reconnectAttempts,
+        successfulReconnects: healthStats.successfulReconnects,
+        reconnectSuccessRate: `${(healthStats.reconnectSuccessRate * 100).toFixed(1)}%`,
+        averageLatency: `${healthStats.averageLatencyMs.toFixed(2)}ms`,
+        currentState: healthStats.currentState
+    });
+    const heartbeatStats = heartbeatSystem.getStatistics();
+    console.log('\nHeartbeat System Statistics:', heartbeatStats);
+    // Step 12: Cleanup
+    console.log('\n🧹 Step 12: Cleaning up...');
+    // Stop monitoring
+    heartbeatSystem.stopMonitoring();
+    healthMonitor.stopMonitoring();
+    // Cleanup resources
+    await blockingCoordination.cleanup();
+    await healthMonitor.cleanup();
+    // Close Redis connection
+    await redis.quit();
+    console.log('✅ Cleanup complete\n');
+    console.log('🎉 Integration example complete!');
+}
+// ===== ERROR HANDLING WRAPPER =====
+async function runWithErrorHandling() {
+    try {
+        await main();
+        process.exit(0);
+    } catch (error) {
+        console.error('💥 Integration example failed:', error);
+        process.exit(1);
+    }
+}
+// ===== EXECUTION =====
+// Run example if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runWithErrorHandling();
+}
+// ===== EXPORTS =====
+export { main as runRedisHealthIntegrationExample };

package/.claude-flow-novice/dist/src/cfn-loop/redis-health-monitor.js

@@ -0,0 +1,414 @@
+/**
+ * Redis Health Monitor - Sprint 1.3: Redis Health Check
+ *
+ * Monitors Redis connection health with periodic PING validation.
+ * Detects disconnection within 5 seconds, reconnect within 30 seconds.
+ *
+ * Features:
+ * - Periodic health check every 10 iterations (~50s based on 5s intervals)
+ * - Redis PING validation with 5-second timeout
+ * - Connection state tracking (connected, disconnected, reconnecting)
+ * - Event emission for connection state changes
+ * - Graceful degradation when Redis unavailable
+ * - Exponential backoff reconnection (1s, 2s, 4s)
+ *
+ * Epic: production-blocking-coordination
+ * Sprint: 1.3 - Redis Health Check
+ * Target: Detect disconnection within 5s, reconnect within 30s
+ *
+ * @module cfn-loop/redis-health-monitor
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { EventEmitter } from "events";
+import { Logger } from "../core/logger.js";
+// ===== TYPE DEFINITIONS =====
+/**
+ * Redis connection state
+ */ export var RedisConnectionState = /*#__PURE__*/ function(RedisConnectionState) {
+    RedisConnectionState["CONNECTED"] = "connected";
+    RedisConnectionState["DISCONNECTED"] = "disconnected";
+    RedisConnectionState["RECONNECTING"] = "reconnecting";
+    return RedisConnectionState;
+}({});
+// ===== REDIS HEALTH MONITOR =====
+/**
+ * Manages Redis connection health monitoring and state tracking
+ */ export class RedisHealthMonitor extends EventEmitter {
+    /**
+   * Start health monitoring
+   */ startMonitoring() {
+        if (this.isMonitoring) {
+            this.logger.warn('Health monitoring already running');
+            return;
+        }
+        this.isMonitoring = true;
+        this.logger.info('Starting Redis health monitoring', {
+            interval: this.healthCheckInterval,
+            pingTimeout: this.pingTimeout
+        });
+        // Perform initial health check immediately
+        this.performHealthCheck().catch((error)=>{
+            this.logger.error('Initial health check failed', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        });
+        // Start periodic health checks
+        this.checkTimer = setInterval(()=>{
+            this.performHealthCheck().catch((error)=>{
+                this.logger.error('Periodic health check failed', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            });
+        }, this.healthCheckInterval);
+        // Emit monitoring started event
+        this.emit('monitoring:started', {
+            interval: this.healthCheckInterval,
+            timeout: this.pingTimeout
+        });
+    }
+    /**
+   * Stop health monitoring
+   */ stopMonitoring() {
+        if (!this.isMonitoring) {
+            this.logger.warn('Health monitoring not running');
+            return;
+        }
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = null;
+        }
+        this.isMonitoring = false;
+        this.logger.info('Stopped Redis health monitoring', {
+            statistics: this.getStatistics()
+        });
+        // Emit monitoring stopped event
+        this.emit('monitoring:stopped', {
+            statistics: this.getStatistics()
+        });
+    }
+    /**
+   * Perform health check with PING validation
+   *
+   * @returns Health check result with state and latency
+   */ async performHealthCheck() {
+        this.stats.totalHealthChecks++;
+        const startTime = Date.now();
+        this.logger.debug('Performing health check', {
+            currentState: this.connectionState,
+            checkNumber: this.stats.totalHealthChecks
+        });
+        try {
+            // Execute PING command with timeout
+            const pingPromise = this.redis.ping();
+            const timeoutPromise = new Promise((_, reject)=>{
+                setTimeout(()=>reject(new Error('PING timeout')), this.pingTimeout);
+            });
+            await Promise.race([
+                pingPromise,
+                timeoutPromise
+            ]);
+            const latencyMs = Date.now() - startTime;
+            // Update latency statistics
+            this.stats.totalLatencyMs += latencyMs;
+            this.stats.latencySamples++;
+            this.stats.averageLatencyMs = this.stats.totalLatencyMs / this.stats.latencySamples;
+            this.stats.successfulChecks++;
+            const result = {
+                healthy: true,
+                state: "connected",
+                latencyMs,
+                timestamp: Date.now()
+            };
+            this.lastCheckResult = result;
+            // Update connection state if changed
+            if (this.connectionState !== "connected") {
+                this.updateConnectionState("connected", 'PING successful');
+                this.reconnectAttempts = 0; // Reset reconnect attempts on success
+            }
+            this.logger.debug('Health check passed', {
+                latencyMs,
+                state: this.connectionState
+            });
+            return result;
+        } catch (error) {
+            this.stats.failedChecks++;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const result = {
+                healthy: false,
+                state: "disconnected",
+                error: errorMessage,
+                timestamp: Date.now()
+            };
+            this.lastCheckResult = result;
+            this.logger.error('Health check failed', {
+                error: errorMessage,
+                currentState: this.connectionState
+            });
+            // Update connection state if changed
+            if (this.connectionState !== "disconnected") {
+                this.updateConnectionState("disconnected", errorMessage);
+            }
+            // Emit disconnected event
+            this.emit('redis:disconnected', {
+                error: errorMessage,
+                timestamp: Date.now()
+            });
+            // Attempt reconnection if enabled
+            if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+                await this.attemptReconnection();
+            }
+            return result;
+        }
+    }
+    /**
+   * Attempt to reconnect to Redis
+   */ async attemptReconnection() {
+        this.reconnectAttempts++;
+        this.stats.reconnectAttempts++;
+        this.logger.info('Attempting Redis reconnection', {
+            attempt: this.reconnectAttempts,
+            maxAttempts: this.maxReconnectAttempts
+        });
+        // Update state to reconnecting
+        this.updateConnectionState("reconnecting", `Reconnection attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts}`);
+        // Emit reconnecting event
+        this.emit('redis:reconnecting', {
+            attempt: this.reconnectAttempts,
+            maxAttempts: this.maxReconnectAttempts,
+            timestamp: Date.now()
+        });
+        // Wait before attempting reconnection
+        await this.sleep(this.reconnectDelayMs);
+        try {
+            // Try to reconnect using ioredis built-in reconnect
+            await this.redis.ping();
+            this.logger.info('Reconnection successful', {
+                attempt: this.reconnectAttempts,
+                totalAttempts: this.maxReconnectAttempts
+            });
+            this.stats.successfulReconnects++;
+            this.reconnectAttempts = 0;
+            // Update state to connected
+            this.updateConnectionState("connected", 'Reconnection successful');
+            // Emit connected event
+            this.emit('redis:connected', {
+                timestamp: Date.now()
+            });
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error('Reconnection failed', {
+                attempt: this.reconnectAttempts,
+                maxAttempts: this.maxReconnectAttempts,
+                error: errorMessage
+            });
+            if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+                this.logger.error('Max reconnection attempts reached', {
+                    attempts: this.reconnectAttempts,
+                    maxAttempts: this.maxReconnectAttempts
+                });
+                this.emit('redis:reconnect:failed', {
+                    attempts: this.reconnectAttempts,
+                    error: errorMessage,
+                    timestamp: Date.now()
+                });
+            }
+        }
+    }
+    /**
+   * Update connection state and emit event if changed
+   */ updateConnectionState(newState, reason, error) {
+        const previousState = this.connectionState;
+        if (previousState === newState) {
+            return; // No change
+        }
+        this.connectionState = newState;
+        this.stats.stateChanges++;
+        const stateChange = {
+            previousState,
+            newState,
+            timestamp: Date.now(),
+            reason,
+            error
+        };
+        this.logger.info('Connection state changed', {
+            previousState,
+            newState,
+            reason,
+            error
+        });
+        // Emit state change event
+        this.emit('redis:state:change', stateChange);
+    }
+    /**
+   * Set up Redis native event listeners
+   */ setupRedisEventListeners() {
+        // Redis connect event
+        this.redis.on('connect', ()=>{
+            this.logger.info('Redis native connect event');
+            this.updateConnectionState("connected", 'Redis native connect event');
+            this.emit('redis:connected', {
+                timestamp: Date.now()
+            });
+        });
+        // Redis ready event (after successful AUTH)
+        this.redis.on('ready', ()=>{
+            this.logger.info('Redis native ready event');
+            this.updateConnectionState("connected", 'Redis native ready event');
+            this.emit('redis:connected', {
+                timestamp: Date.now()
+            });
+        });
+        // Redis error event
+        this.redis.on('error', (error)=>{
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error('Redis native error event', {
+                error: errorMessage
+            });
+            this.updateConnectionState("disconnected", 'Redis native error event', errorMessage);
+            this.emit('redis:disconnected', {
+                error: errorMessage,
+                timestamp: Date.now()
+            });
+        });
+        // Redis close event
+        this.redis.on('close', ()=>{
+            this.logger.warn('Redis native close event');
+            this.updateConnectionState("disconnected", 'Redis native close event');
+            this.emit('redis:disconnected', {
+                timestamp: Date.now()
+            });
+        });
+        // Redis reconnecting event
+        this.redis.on('reconnecting', ()=>{
+            this.logger.info('Redis native reconnecting event');
+            this.updateConnectionState("reconnecting", 'Redis native reconnecting event');
+            this.emit('redis:reconnecting', {
+                timestamp: Date.now()
+            });
+        });
+    }
+    /**
+   * Get current connection state
+   */ getConnectionState() {
+        return this.connectionState;
+    }
+    /**
+   * Get last health check result
+   */ getLastCheckResult() {
+        return this.lastCheckResult;
+    }
+    /**
+   * Get statistics
+   */ getStatistics() {
+        return {
+            ...this.stats,
+            currentState: this.connectionState,
+            successRate: this.stats.totalHealthChecks > 0 ? this.stats.successfulChecks / this.stats.totalHealthChecks : 0,
+            reconnectSuccessRate: this.stats.reconnectAttempts > 0 ? this.stats.successfulReconnects / this.stats.reconnectAttempts : 0
+        };
+    }
+    /**
+   * Reset statistics
+   */ resetStatistics() {
+        this.stats = {
+            totalHealthChecks: 0,
+            successfulChecks: 0,
+            failedChecks: 0,
+            reconnectAttempts: 0,
+            successfulReconnects: 0,
+            stateChanges: 0,
+            averageLatencyMs: 0,
+            totalLatencyMs: 0,
+            latencySamples: 0
+        };
+    }
+    /**
+   * Check if Redis is healthy
+   */ isHealthy() {
+        return this.connectionState === "connected";
+    }
+    /**
+   * Cleanup and disconnect
+   */ async cleanup() {
+        this.logger.info('Cleaning up Redis health monitor');
+        // Stop monitoring
+        this.stopMonitoring();
+        // Remove all listeners
+        this.removeAllListeners();
+        this.logger.info('Redis health monitor cleanup complete', {
+            statistics: this.getStatistics()
+        });
+    }
+    // ===== PRIVATE HELPER METHODS =====
+    /**
+   * Sleep utility for delays
+   */ sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    constructor(config){
+        super(), _define_property(this, "logger", void 0), _define_property(this, "redis", void 0), _define_property(this, "healthCheckInterval", void 0), _define_property(this, "pingTimeout", void 0), _define_property(this, "autoReconnect", void 0), _define_property(this, "maxReconnectAttempts", void 0), _define_property(this, "reconnectDelayMs", void 0), _define_property(this, "debug", void 0), // Monitoring state
+        _define_property(this, "checkTimer", null), _define_property(this, "isMonitoring", false), _define_property(this, "connectionState", "disconnected"), _define_property(this, "reconnectAttempts", 0), // Statistics
+        _define_property(this, "stats", {
+            totalHealthChecks: 0,
+            successfulChecks: 0,
+            failedChecks: 0,
+            reconnectAttempts: 0,
+            successfulReconnects: 0,
+            stateChanges: 0,
+            averageLatencyMs: 0,
+            totalLatencyMs: 0,
+            latencySamples: 0
+        }), // Last check result
+        _define_property(this, "lastCheckResult", null);
+        this.redis = config.redisClient;
+        this.healthCheckInterval = config.healthCheckInterval ?? 50000; // 50 seconds (10 iterations × 5s)
+        this.pingTimeout = config.pingTimeout ?? 5000; // 5 seconds
+        this.autoReconnect = config.autoReconnect ?? true;
+        this.maxReconnectAttempts = config.maxReconnectAttempts ?? 5;
+        this.reconnectDelayMs = config.reconnectDelayMs ?? 5000; // 5 seconds
+        this.debug = config.debug ?? false;
+        // Initialize logger
+        const loggerConfig = process.env.CLAUDE_FLOW_ENV === 'test' ? {
+            level: 'error',
+            format: 'json',
+            destination: 'console'
+        } : {
+            level: this.debug ? 'debug' : 'info',
+            format: 'json',
+            destination: 'console'
+        };
+        this.logger = new Logger(loggerConfig, {
+            component: 'RedisHealthMonitor'
+        });
+        this.logger.info('Redis Health Monitor initialized', {
+            healthCheckInterval: this.healthCheckInterval,
+            pingTimeout: this.pingTimeout,
+            autoReconnect: this.autoReconnect,
+            maxReconnectAttempts: this.maxReconnectAttempts
+        });
+        // Set up Redis event listeners for native connection events
+        this.setupRedisEventListeners();
+    }
+}
+// ===== FACTORY FUNCTION =====
+/**
+ * Create a RedisHealthMonitor instance
+ *
+ * @param config - Configuration for Redis health monitor
+ * @returns Configured RedisHealthMonitor
+ */ export function createRedisHealthMonitor(config) {
+    return new RedisHealthMonitor(config);
+}
+// ===== EXPORTS =====
+export default RedisHealthMonitor;