Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

3.4 KB
Raw Blame
import { useState, useEffect, useCallback, useRef } from 'react';
import socketService from '../services/socket';
import api from '../services/api';
import { usePolling } from './usePolling';
import { subscribeToMetrics } from '../utils/metricsSubscription';

const DEFAULT_POLL_INTERVAL = 10000;

// `enabled` selects the local host; `autoRefresh` also controls the live stream.
// Manual refresh and the initial snapshot remain available with auto-refresh off.
export function useMetrics(useWebSocket = true, pollInterval = DEFAULT_POLL_INTERVAL, options = {}) {
    const { enabled = true, autoRefresh = true } = options;
    const [metrics, setMetrics] = useState(null);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);
    const [connected, setConnected] = useState(false);
    const inFlight = useRef(null);
    const active = useRef(false);

    const fetchMetrics = useCallback(() => {
        // Mount, manual refresh, and restarted pollers share this guard, even
        // when a slow request spans a socket reconnect.
        if (inFlight.current) return inFlight.current;
        const request = Promise.resolve().then(() => api.getSystemMetrics())
            .then((data) => {
                if (active.current) { setMetrics(data); setError(null); }
            }).catch((err) => {
                if (active.current) setError(err.message);
            }).finally(() => {
                inFlight.current = null;
                if (active.current) setLoading(false);
            });
        inFlight.current = request;
        return request;
    }, []);

    useEffect(() => {
        active.current = enabled;
        if (enabled) fetchMetrics();
        return () => { active.current = false; };
    }, [enabled, fetchMetrics]);

    useEffect(() => {
        setConnected(false);
        if (!enabled || !autoRefresh || !useWebSocket) return undefined;
        return subscribeToMetrics(socketService, {
            onConnected: setConnected,
            onMetrics: (data) => { setMetrics(data); setLoading(false); setError(null); },
            onError: (err) => setError(err?.message || 'WebSocket error'),
        });
    }, [enabled, autoRefresh, useWebSocket]);

    usePolling(fetchMetrics, pollInterval, {
        enabled: enabled && autoRefresh && pollInterval > 0 && !connected,
        immediate: false,
    });

    return { metrics, loading, error, connected, refresh: fetchMetrics };
}

export function useLogs(filepath) {
    const [logs, setLogs] = useState([]);
    const [loading, setLoading] = useState(true);

    useEffect(() => {
        if (!filepath) return;

        // Fetch initial logs
        api.readLog(filepath, 100).then(result => {
            if (result.success) {
                setLogs(result.lines);
            }
            setLoading(false);
        });

        // Connect WebSocket for real-time updates
        socketService.connect();

        const unsubLine = socketService.on('log_line', (data) => {
            if (data.filepath === filepath) {
                setLogs(prev => [...prev.slice(-499), data.line]);
            }
        });

        // Subscribe to log stream
        socketService.subscribeLogs(filepath);

        return () => {
            unsubLine();
            socketService.unsubscribeLogs();
        };
    }, [filepath]);

    const clearLogs = useCallback(() => {
        setLogs([]);
    }, []);

    return { logs, loading, clearLogs };
}

export default useMetrics;