Switched from Dockmon to Beszel

dockmon/stats-service/event_cache.go

@@ -0,0 +1,106 @@
+package main
+
+import (
+	"sync"
+)
+
+// EventCache stores recent events for each host (ring buffer)
+type EventCache struct {
+	mu       sync.RWMutex
+	events   map[string][]DockerEvent // key: hostID, value: ring buffer of events
+	maxSize  int                      // maximum events to keep per host
+}
+
+// NewEventCache creates a new event cache
+func NewEventCache(maxSize int) *EventCache {
+	return &EventCache{
+		events:  make(map[string][]DockerEvent),
+		maxSize: maxSize,
+	}
+}
+
+// AddEvent adds an event to the cache for a specific host
+func (ec *EventCache) AddEvent(hostID string, event DockerEvent) {
+	ec.mu.Lock()
+	defer ec.mu.Unlock()
+
+	// Initialize slice if needed
+	if _, exists := ec.events[hostID]; !exists {
+		ec.events[hostID] = make([]DockerEvent, 0, ec.maxSize)
+	}
+
+	// Add event
+	ec.events[hostID] = append(ec.events[hostID], event)
+
+	// Trim if over max size (keep most recent)
+	if len(ec.events[hostID]) > ec.maxSize {
+		ec.events[hostID] = ec.events[hostID][len(ec.events[hostID])-ec.maxSize:]
+	}
+}
+
+// GetRecentEvents returns recent events for a specific host
+func (ec *EventCache) GetRecentEvents(hostID string, limit int) []DockerEvent {
+	ec.mu.RLock()
+	defer ec.mu.RUnlock()
+
+	events, exists := ec.events[hostID]
+	if !exists || len(events) == 0 {
+		return []DockerEvent{}
+	}
+
+	// Return last N events
+	if limit <= 0 || limit > len(events) {
+		limit = len(events)
+	}
+
+	// Return copy to avoid race conditions
+	result := make([]DockerEvent, limit)
+	copy(result, events[len(events)-limit:])
+	return result
+}
+
+// GetAllRecentEvents returns recent events for all hosts
+func (ec *EventCache) GetAllRecentEvents(limit int) map[string][]DockerEvent {
+	ec.mu.RLock()
+	defer ec.mu.RUnlock()
+
+	result := make(map[string][]DockerEvent)
+
+	for hostID, events := range ec.events {
+		if len(events) == 0 {
+			continue
+		}
+
+		// Get last N events
+		count := limit
+		if count <= 0 || count > len(events) {
+			count = len(events)
+		}
+
+		// Copy to avoid race conditions
+		hostEvents := make([]DockerEvent, count)
+		copy(hostEvents, events[len(events)-count:])
+		result[hostID] = hostEvents
+	}
+
+	return result
+}
+
+// ClearHost removes all cached events for a specific host
+func (ec *EventCache) ClearHost(hostID string) {
+	ec.mu.Lock()
+	defer ec.mu.Unlock()
+	delete(ec.events, hostID)
+}
+
+// GetStats returns cache statistics
+func (ec *EventCache) GetStats() (hostCount int, totalEvents int) {
+	ec.mu.RLock()
+	defer ec.mu.RUnlock()
+
+	hostCount = len(ec.events)
+	for _, events := range ec.events {
+		totalEvents += len(events)
+	}
+	return
+}