add one minute chart + refactor rpc

- add one minute charts
- update disk io to use bytes
- update hub and agent connection interfaces / handlers to be more
flexible
- change agent cache to use cache time instead of session id
- refactor collection of metrics which require deltas to track
separately per cache time

internal/hub/systems/system.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/henrygd/beszel/internal/common"
 	"github.com/henrygd/beszel/internal/hub/ws"
 
 	"github.com/henrygd/beszel/internal/entities/system"
@@ -107,7 +108,7 @@ func (sys *System) update() error {
 		sys.handlePaused()
 		return nil
 	}
-	data, err := sys.fetchDataFromAgent()
+	data, err := sys.fetchDataFromAgent(common.DataRequestOptions{CacheTimeMs: uint16(interval)})
 	if err == nil {
 		_, err = sys.createRecords(data)
 	}
@@ -209,13 +210,13 @@ func (sys *System) getContext() (context.Context, context.CancelFunc) {
 
 // fetchDataFromAgent attempts to fetch data from the agent,
 // prioritizing WebSocket if available.
-func (sys *System) fetchDataFromAgent() (*system.CombinedData, error) {
+func (sys *System) fetchDataFromAgent(options common.DataRequestOptions) (*system.CombinedData, error) {
 	if sys.data == nil {
 		sys.data = &system.CombinedData{}
 	}
 
 	if sys.WsConn != nil && sys.WsConn.IsConnected() {
-		wsData, err := sys.fetchDataViaWebSocket()
+		wsData, err := sys.fetchDataViaWebSocket(options)
 		if err == nil {
 			return wsData, nil
 		}
@@ -223,18 +224,18 @@ func (sys *System) fetchDataFromAgent() (*system.CombinedData, error) {
 		sys.closeWebSocketConnection()
 	}
 
-	sshData, err := sys.fetchDataViaSSH()
+	sshData, err := sys.fetchDataViaSSH(options)
 	if err != nil {
 		return nil, err
 	}
 	return sshData, nil
 }
 
-func (sys *System) fetchDataViaWebSocket() (*system.CombinedData, error) {
+func (sys *System) fetchDataViaWebSocket(options common.DataRequestOptions) (*system.CombinedData, error) {
 	if sys.WsConn == nil || !sys.WsConn.IsConnected() {
 		return nil, errors.New("no websocket connection")
 	}
-	err := sys.WsConn.RequestSystemData(sys.data)
+	err := sys.WsConn.RequestSystemData(context.Background(), sys.data, options)
 	if err != nil {
 		return nil, err
 	}
@@ -244,7 +245,7 @@ func (sys *System) fetchDataViaWebSocket() (*system.CombinedData, error) {
 // fetchDataViaSSH handles fetching data using SSH.
 // This function encapsulates the original SSH logic.
 // It updates sys.data directly upon successful fetch.
-func (sys *System) fetchDataViaSSH() (*system.CombinedData, error) {
+func (sys *System) fetchDataViaSSH(options common.DataRequestOptions) (*system.CombinedData, error) {
 	maxRetries := 1
 	for attempt := 0; attempt <= maxRetries; attempt++ {
 		if sys.client == nil || sys.Status == down {
@@ -269,12 +270,31 @@ func (sys *System) fetchDataViaSSH() (*system.CombinedData, error) {
 		if err != nil {
 			return nil, err
 		}
+		stdin, stdinErr := session.StdinPipe()
 		if err := session.Shell(); err != nil {
 			return nil, err
 		}
 
 		*sys.data = system.CombinedData{}
 
+		if sys.agentVersion.GTE(beszel.MinVersionAgentResponse) && stdinErr == nil {
+			req := common.HubRequest[any]{Action: common.GetData, Data: options}
+			_ = cbor.NewEncoder(stdin).Encode(req)
+			// Close write side to signal end of request
+			_ = stdin.Close()
+
+			var resp common.AgentResponse
+			if decErr := cbor.NewDecoder(stdout).Decode(&resp); decErr == nil && resp.SystemData != nil {
+				*sys.data = *resp.SystemData
+				// wait for the session to complete
+				if err := session.Wait(); err != nil {
+					return nil, err
+				}
+				return sys.data, nil
+			}
+			// If decoding failed, fall back below
+		}
+
 		if sys.agentVersion.GTE(beszel.MinVersionCbor) {
 			err = cbor.NewDecoder(stdout).Decode(sys.data)
 		} else {
@@ -379,11 +399,11 @@ func extractAgentVersion(versionString string) (semver.Version, error) {
 }
 
 // getJitter returns a channel that will be triggered after a random delay
-// between 40% and 90% of the interval.
+// between 51% and 95% of the interval.
 // This is used to stagger the initial WebSocket connections to prevent clustering.
 func getJitter() <-chan time.Time {
-	minPercent := 40
-	maxPercent := 90
+	minPercent := 51
+	maxPercent := 95
 	jitterRange := maxPercent - minPercent
 	msDelay := (interval * minPercent / 100) + rand.Intn(interval*jitterRange/100)
 	return time.After(time.Duration(msDelay) * time.Millisecond)

internal/hub/systems/system_manager.go

@@ -106,6 +106,8 @@ func (sm *SystemManager) bindEventHooks() {
 	sm.hub.OnRecordAfterUpdateSuccess("systems").BindFunc(sm.onRecordAfterUpdateSuccess)
 	sm.hub.OnRecordAfterDeleteSuccess("systems").BindFunc(sm.onRecordAfterDeleteSuccess)
 	sm.hub.OnRecordAfterUpdateSuccess("fingerprints").BindFunc(sm.onTokenRotated)
+	sm.hub.OnRealtimeSubscribeRequest().BindFunc(sm.onRealtimeSubscribeRequest)
+	sm.hub.OnRealtimeConnectRequest().BindFunc(sm.onRealtimeConnectRequest)
 }
 
 // onTokenRotated handles fingerprint token rotation events.

internal/hub/systems/system_realtime.go

@@ -0,0 +1,187 @@
+package systems
+
+import (
+	"encoding/json"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/henrygd/beszel/internal/common"
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/tools/subscriptions"
+)
+
+type subscriptionInfo struct {
+	subscription     string
+	connectedClients uint8
+}
+
+var (
+	activeSubscriptions = make(map[string]*subscriptionInfo)
+	workerRunning       bool
+	realtimeTicker      *time.Ticker
+	tickerStopChan      chan struct{}
+	realtimeMutex       sync.Mutex
+)
+
+// onRealtimeConnectRequest handles client connection events for realtime subscriptions.
+// It cleans up existing subscriptions when a client connects.
+func (sm *SystemManager) onRealtimeConnectRequest(e *core.RealtimeConnectRequestEvent) error {
+	// after e.Next() is the client disconnection
+	e.Next()
+	subscriptions := e.Client.Subscriptions()
+	for k := range subscriptions {
+		sm.removeRealtimeSubscription(k, subscriptions[k])
+	}
+	return nil
+}
+
+// onRealtimeSubscribeRequest handles client subscription events for realtime metrics.
+// It tracks new subscriptions and unsubscriptions to manage the realtime worker lifecycle.
+func (sm *SystemManager) onRealtimeSubscribeRequest(e *core.RealtimeSubscribeRequestEvent) error {
+	oldSubs := e.Client.Subscriptions()
+	// after e.Next() is the result of the subscribe request
+	err := e.Next()
+	newSubs := e.Client.Subscriptions()
+
+	// handle new subscriptions
+	for k, options := range newSubs {
+		if _, ok := oldSubs[k]; !ok {
+			if strings.HasPrefix(k, "rt_metrics") {
+				systemId := options.Query["system"]
+				if _, ok := activeSubscriptions[systemId]; !ok {
+					activeSubscriptions[systemId] = &subscriptionInfo{
+						subscription: k,
+					}
+				}
+				activeSubscriptions[systemId].connectedClients += 1
+				sm.onRealtimeSubscriptionAdded()
+			}
+		}
+	}
+	// handle unsubscriptions
+	for k := range oldSubs {
+		if _, ok := newSubs[k]; !ok {
+			sm.removeRealtimeSubscription(k, oldSubs[k])
+		}
+	}
+
+	return err
+}
+
+// onRealtimeSubscriptionAdded initializes or starts the realtime worker when the first subscription is added.
+// It ensures only one worker runs at a time and creates the ticker for periodic data fetching.
+func (sm *SystemManager) onRealtimeSubscriptionAdded() {
+	realtimeMutex.Lock()
+	defer realtimeMutex.Unlock()
+
+	// Start the worker if it's not already running
+	if !workerRunning {
+		workerRunning = true
+		// Create a new stop channel for this worker instance
+		tickerStopChan = make(chan struct{})
+		go sm.startRealtimeWorker()
+	}
+
+	// If no ticker exists, create one
+	if realtimeTicker == nil {
+		realtimeTicker = time.NewTicker(1 * time.Second)
+	}
+}
+
+// checkSubscriptions stops the realtime worker when there are no active subscriptions.
+// This prevents unnecessary resource usage when no clients are listening for realtime data.
+func (sm *SystemManager) checkSubscriptions() {
+	if !workerRunning || len(activeSubscriptions) > 0 {
+		return
+	}
+
+	realtimeMutex.Lock()
+	defer realtimeMutex.Unlock()
+
+	// Signal the worker to stop
+	if tickerStopChan != nil {
+		select {
+		case tickerStopChan <- struct{}{}:
+		default:
+		}
+	}
+
+	if realtimeTicker != nil {
+		realtimeTicker.Stop()
+		realtimeTicker = nil
+	}
+
+	// Mark worker as stopped (will be reset when next subscription comes in)
+	workerRunning = false
+}
+
+// removeRealtimeSubscription removes a realtime subscription and checks if the worker should be stopped.
+// It only processes subscriptions with the "rt_metrics" prefix and triggers cleanup when subscriptions are removed.
+func (sm *SystemManager) removeRealtimeSubscription(subscription string, options subscriptions.SubscriptionOptions) {
+	if strings.HasPrefix(subscription, "rt_metrics") {
+		systemId := options.Query["system"]
+		if info, ok := activeSubscriptions[systemId]; ok {
+			info.connectedClients -= 1
+			if info.connectedClients <= 0 {
+				delete(activeSubscriptions, systemId)
+			}
+		}
+		sm.checkSubscriptions()
+	}
+}
+
+// startRealtimeWorker runs the main loop for fetching realtime data from agents.
+// It continuously fetches system data and broadcasts it to subscribed clients via WebSocket.
+func (sm *SystemManager) startRealtimeWorker() {
+	sm.fetchRealtimeDataAndNotify()
+
+	for {
+		select {
+		case <-tickerStopChan:
+			return
+		case <-realtimeTicker.C:
+			// Check if ticker is still valid (might have been stopped)
+			if realtimeTicker == nil || len(activeSubscriptions) == 0 {
+				return
+			}
+			// slog.Debug("activeSubscriptions", "count", len(activeSubscriptions))
+			sm.fetchRealtimeDataAndNotify()
+		}
+	}
+}
+
+// fetchRealtimeDataAndNotify fetches realtime data for all active subscriptions and notifies the clients.
+func (sm *SystemManager) fetchRealtimeDataAndNotify() {
+	for systemId, info := range activeSubscriptions {
+		system, ok := sm.systems.GetOk(systemId)
+		if ok {
+			go func() {
+				data, err := system.fetchDataFromAgent(common.DataRequestOptions{CacheTimeMs: 1000})
+				if err != nil {
+					return
+				}
+				bytes, err := json.Marshal(data)
+				if err == nil {
+					notify(sm.hub, info.subscription, bytes)
+				}
+			}()
+		}
+	}
+}
+
+// notify broadcasts realtime data to all clients subscribed to a specific subscription.
+// It iterates through all connected clients and sends the data only to those with matching subscriptions.
+func notify(app core.App, subscription string, data []byte) error {
+	message := subscriptions.Message{
+		Name: subscription,
+		Data: data,
+	}
+	for _, client := range app.SubscriptionsBroker().Clients() {
+		if !client.HasSubscription(subscription) {
+			continue
+		}
+		client.Send(message)
+	}
+	return nil
+}