Docker integrations

Author: 9technologygroup

cmd/patchmon-agent/commands/report.go

@@ -7,6 +7,8 @@ import (
 
 	"patchmon-agent/internal/client"
 	"patchmon-agent/internal/hardware"
+	"patchmon-agent/internal/integrations"
+	"patchmon-agent/internal/integrations/docker"
 	"patchmon-agent/internal/network"
 	"patchmon-agent/internal/packages"
 	"patchmon-agent/internal/repositories"
@@ -213,6 +215,82 @@ func sendReport() error {
 		}
 	}
 
+	// Collect and send integration data (Docker, etc.) separately
+	// This ensures failures in integrations don't affect core system reporting
+	sendIntegrationData()
+
 	logger.Debug("Report process completed")
 	return nil
 }
+
+// sendIntegrationData collects and sends data from integrations (Docker, etc.)
+func sendIntegrationData() {
+	logger.Debug("Starting integration data collection")
+
+	// Create integration manager
+	integrationMgr := integrations.NewManager(logger)
+
+	// Register available integrations
+	integrationMgr.Register(docker.New(logger))
+	// Future: integrationMgr.Register(proxmox.New(logger))
+	// Future: integrationMgr.Register(kubernetes.New(logger))
+
+	// Discover and collect from all available integrations
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+
+	integrationData := integrationMgr.CollectAll(ctx)
+
+	if len(integrationData) == 0 {
+		logger.Debug("No integration data to send")
+		return
+	}
+
+	// Get system info for integration payloads
+	systemDetector := system.New(logger)
+	hostname, _ := systemDetector.GetHostname()
+	machineID := systemDetector.GetMachineID()
+
+	// Create HTTP client
+	httpClient := client.New(cfgManager, logger)
+
+	// Send Docker data if available
+	if dockerData, exists := integrationData["docker"]; exists && dockerData.Error == "" {
+		sendDockerData(httpClient, dockerData, hostname, machineID)
+	}
+
+	// Future: Send other integration data here
+}
+
+// sendDockerData sends Docker integration data to server
+func sendDockerData(httpClient *client.Client, integrationData *models.IntegrationData, hostname, machineID string) {
+	// Extract Docker data from integration data
+	dockerData, ok := integrationData.Data.(*models.DockerData)
+	if !ok {
+		logger.Warn("Failed to extract Docker data from integration")
+		return
+	}
+
+	payload := &models.DockerPayload{
+		DockerData:   *dockerData,
+		Hostname:     hostname,
+		MachineID:    machineID,
+		AgentVersion: version.Version,
+	}
+
+	logger.Info("Sending Docker data to server...")
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	response, err := httpClient.SendDockerData(ctx, payload)
+	if err != nil {
+		logger.WithError(err).Warn("Failed to send Docker data (will retry on next report)")
+		return
+	}
+
+	logger.WithFields(logrus.Fields{
+		"containers": response.ContainersReceived,
+		"images":     response.ImagesReceived,
+		"updates":    response.UpdatesFound,
+	}).Info("Docker data sent successfully")
+}

cmd/patchmon-agent/commands/serve.go

@@ -9,6 +9,9 @@ import (
 	"time"
 
 	"patchmon-agent/internal/client"
+	"patchmon-agent/internal/integrations"
+	"patchmon-agent/internal/integrations/docker"
+	"patchmon-agent/pkg/models"
 
 	"github.com/gorilla/websocket"
 	"github.com/spf13/cobra"
@@ -47,14 +50,30 @@ func runService() error {
 	ticker := time.NewTicker(time.Duration(intervalMinutes) * time.Minute)
 	defer ticker.Stop()
 
+	// Send startup ping to notify server that agent has started
+	logger.Info("🚀 Agent starting up, notifying server...")
+	if _, err := httpClient.Ping(ctx); err != nil {
+		logger.WithError(err).Warn("startup ping failed, will retry")
+	} else {
+		logger.Info("✅ Startup notification sent to server")
+	}
+
 	// initial report on boot
+	logger.Info("Sending initial report on startup...")
 	if err := sendReport(); err != nil {
 		logger.WithError(err).Warn("initial report failed")
+	} else {
+		logger.Info("✅ Initial report sent successfully")
 	}
 
 	// start websocket loop
+	logger.Info("Establishing WebSocket connection...")
 	messages := make(chan wsMsg, 10)
-	go wsLoop(messages)
+	dockerEvents := make(chan interface{}, 100)
+	go wsLoop(messages, dockerEvents)
+
+	// Start integration monitoring (Docker real-time events, etc.)
+	startIntegrationMonitoring(ctx, dockerEvents)
 
 	for {
 		select {
@@ -93,17 +112,40 @@ func runService() error {
 	}
 }
 
+// startIntegrationMonitoring starts real-time monitoring for integrations that support it
+func startIntegrationMonitoring(ctx context.Context, eventChan chan<- interface{}) {
+	// Create integration manager
+	integrationMgr := integrations.NewManager(logger)
+
+	// Register integrations
+	dockerInteg := docker.New(logger)
+	integrationMgr.Register(dockerInteg)
+
+	// Start monitoring for real-time integrations
+	realtimeIntegrations := integrationMgr.GetRealtimeIntegrations()
+	for _, integration := range realtimeIntegrations {
+		logger.WithField("integration", integration.Name()).Info("Starting real-time monitoring")
+
+		// Start monitoring in a goroutine
+		go func(integ integrations.RealtimeIntegration) {
+			if err := integ.StartMonitoring(ctx, eventChan); err != nil {
+				logger.WithError(err).Warn("Failed to start integration monitoring")
+			}
+		}(integration)
+	}
+}
+
 type wsMsg struct {
 	kind     string
 	interval int
 	version  string
 	force    bool
 }
 
-func wsLoop(out chan<- wsMsg) {
+func wsLoop(out chan<- wsMsg, dockerEvents <-chan interface{}) {
 	backoff := time.Second
 	for {
-		if err := connectOnce(out); err != nil {
+		if err := connectOnce(out, dockerEvents); err != nil {
 			logger.WithError(err).Warn("ws disconnected; retrying")
 		}
 		time.Sleep(backoff)
@@ -113,7 +155,7 @@ func wsLoop(out chan<- wsMsg) {
 	}
 }
 
-func connectOnce(out chan<- wsMsg) error {
+func connectOnce(out chan<- wsMsg, dockerEvents <-chan interface{}) error {
 	server := cfgManager.GetConfig().PatchmonServer
 	if server == "" {
 		return nil
@@ -169,6 +211,32 @@ func connectOnce(out chan<- wsMsg) error {
 	})
 
 	logger.WithField("url", wsURL).Info("WebSocket connected")
+
+	// Create a goroutine to send Docker events through WebSocket
+	go func() {
+		for event := range dockerEvents {
+			if dockerEvent, ok := event.(models.DockerStatusEvent); ok {
+				eventJSON, err := json.Marshal(map[string]interface{}{
+					"type":         "docker_status",
+					"event":        dockerEvent,
+					"container_id": dockerEvent.ContainerID,
+					"name":         dockerEvent.Name,
+					"status":       dockerEvent.Status,
+					"timestamp":    dockerEvent.Timestamp,
+				})
+				if err != nil {
+					logger.WithError(err).Warn("Failed to marshal Docker event")
+					continue
+				}
+
+				if err := conn.WriteMessage(websocket.TextMessage, eventJSON); err != nil {
+					logger.WithError(err).Debug("Failed to send Docker event via WebSocket")
+					return
+				}
+			}
+		}
+	}()
+
 	for {
 		_, data, err := conn.ReadMessage()
 		if err != nil {

go.mod

@@ -3,6 +3,7 @@ module patchmon-agent
 go 1.25
 
 require (
+	github.com/docker/docker v28.5.1+incompatible
 	github.com/go-resty/resty/v2 v2.16.5
 	github.com/gorilla/websocket v1.5.3
 	github.com/shirou/gopsutil/v4 v4.25.9
@@ -14,14 +15,31 @@ require (
 )
 
 require (
+	github.com/Microsoft/go-winio v0.6.2 // indirect
+	github.com/containerd/errdefs v1.0.0 // indirect
+	github.com/containerd/errdefs/pkg v0.3.0 // indirect
+	github.com/containerd/log v0.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/distribution/reference v0.6.0 // indirect
+	github.com/docker/go-connections v0.6.0 // indirect
+	github.com/docker/go-units v0.5.0 // indirect
 	github.com/ebitengine/purego v0.9.0 // indirect
+	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect
+	github.com/moby/docker-image-spec v1.3.1 // indirect
+	github.com/moby/sys/atomicwriter v0.1.0 // indirect
+	github.com/moby/term v0.5.2 // indirect
+	github.com/morikuni/aec v1.0.0 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.1.1 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
 	github.com/sagikazarmark/locafero v0.12.0 // indirect
@@ -32,10 +50,16 @@ require (
 	github.com/tklauser/go-sysconf v0.3.15 // indirect
 	github.com/tklauser/numcpus v0.10.0 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/net v0.44.0 // indirect
 	golang.org/x/sys v0.36.0 // indirect
 	golang.org/x/text v0.29.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gotest.tools/v3 v3.5.2 // indirect
 )