Operational Monitoring & Maintenance

// Mining Operations Monitoring Dashboard
class MiningDashboard {
    constructor() {
        this.monitoringData = {};
        this.alerts = [];
        this.thresholds = {
            maxTemperature: 85, // °C
            minHashRate: 0.95, // 95% of expected
            maxRejectionRate: 0.01, // 1%
            maxPowerVariation: 0.05, // 5% from expected
            minUptime: 0.95 // 95% uptime target
        };
    }
    
    updateMinerStatus(minerId, status) {
        const {
            hashRate,
            expectedHashRate,
            temperature,
            powerConsumption,
            expectedPower,
            rejectionRate,
            uptime,
            poolConnection
        } = status;
        
        // Calculate efficiency metrics
        const hashEfficiency = hashRate / expectedHashRate;
        const powerEfficiency = powerConsumption / expectedPower;
        const temperatureStatus = this.getTemperatureStatus(temperature);
        
        this.monitoringData[minerId] = {
            timestamp: new Date(),
            hashRate: hashRate,
            expectedHashRate: expectedHashRate,
            hashEfficiency: Math.round(hashEfficiency * 100),
            temperature: temperature,
            temperatureStatus: temperatureStatus,
            powerConsumption: powerConsumption,
            expectedPower: expectedPower,
            powerEfficiency: Math.round(powerEfficiency * 100),
            rejectionRate: rejectionRate,
            uptime: uptime,
            poolConnection: poolConnection
        };
        
        // Check for alerts
        this.checkAlerts(minerId, status);
        
        return this.generateDashboard(minerId);
    }
    
    getTemperatureStatus(temperature) {
        if (temperature < this.thresholds.maxTemperature - 20) return 'excellent';
        if (temperature < this.thresholds.maxTemperature - 10) return 'good';
        if (temperature < this.thresholds.maxTemperature) return 'warning';
        return 'critical';
    }
    
    checkAlerts(minerId, status) {
        const alerts = [];
        
        // Temperature alert
        if (status.temperature > this.thresholds.maxTemperature) {
            alerts.push({
                type: 'critical',
                message: `High temperature: ${status.temperature}°C for miner ${minerId}`,
                action: 'Check cooling system immediately'
            });
        }
        
        // Hash rate alert
        if (status.hashRate / status.expectedHashRate < this.thresholds.minHashRate) {
            alerts.push({
                type: 'warning',
                message: `Low hash rate: ${Math.round(status.hashRate / status.expectedHashRate * 100)}% of expected for miner ${minerId}`,
                action: 'Check hardware status and pool connection'
            });
        }
        
        // Rejection rate alert
        if (status.rejectionRate > this.thresholds.maxRejectionRate) {
            alerts.push({
                type: 'warning',
                message: `High rejection rate: ${Math.round(status.rejectionRate * 100)}% for miner ${minerId}`,
                action: 'Check pool connection and network stability'
            });
        }
        
        // Power variation alert
        if (Math.abs(status.powerConsumption / status.expectedPower - 1) > this.thresholds.maxPowerVariation) {
            alerts.push({
                type: 'info',
                message: `Power consumption variation for miner ${minerId}`,
                action: 'Monitor for hardware efficiency changes'
            });
        }
        
        if (alerts.length > 0) {
            this.alerts.push(...alerts.map(alert => ({
                ...alert,
                minerId: minerId,
                timestamp: new Date()
            })));
        }
    }
    
    generateDashboard(minerId) {
        const data = this.monitoringData[minerId];
        if (!data) return null;
        
        return {
            minerId: minerId,
            status: this.getOverallStatus(data),
            metrics: {
                hashRate: `${data.hashRate} TH/s (${data.hashEfficiency}%)`,
                temperature: `${data.temperature}°C (${data.temperatureStatus})`,
                power: `${data.powerConsumption}W (${data.powerEfficiency}% of expected)`,
                rejectionRate: `${Math.round(data.rejectionRate * 100)}%`,
                uptime: `${Math.round(data.uptime * 100)}%`
            },
            recommendations: this.getRecommendations(data),
            recentAlerts: this.getRecentAlerts(minerId)
        };
    }
    
    getOverallStatus(data) {
        if (data.temperatureStatus === 'critical') return 'critical';
        if (data.hashEfficiency < 95 || data.temperatureStatus === 'warning') return 'warning';
        if (data.uptime < 0.95) return 'unstable';
        return 'healthy';
    }
    
    getRecommendations(data) {
        const recommendations = [];
        
        if (data.temperatureStatus === 'warning' || data.temperatureStatus === 'critical') {
            recommendations.push('Check and clean cooling system');
        }
        
        if (data.hashEfficiency < 95) {
            recommendations.push('Verify pool connection and hardware status');
        }
        
        if (data.rejectionRate > 0.005) {
            recommendations.push('Check network stability and pool server');
        }
        
        return recommendations;
    }
    
    getRecentAlerts(minerId, hours = 24) {
        const cutoff = new Date(Date.now() - hours * 60 * 60 * 1000);
        return this.alerts.filter(alert => 
            alert.minerId === minerId && alert.timestamp > cutoff
        ).slice(-5); // Last 5 alerts
    }
}

// Example usage
const dashboard = new MiningDashboard();

// Simulate miner status update
const minerStatus = {
    hashRate: 94, // TH/s
    expectedHashRate: 96,
    temperature: 78, // °C
    powerConsumption: 3080, // W
    expectedPower: 3068,
    rejectionRate: 0.008, // 0.8%
    uptime: 0.98, // 98%
    poolConnection: 'good'
};

const dashboardData = dashboard.updateMinerStatus('miner-001', minerStatus);
console.log('Dashboard Data:', dashboardData);