Only log process details if processes have changed

Author: dhurley

internal/watcher/instance/instance_watcher_service.go

@@ -7,6 +7,7 @@ package instance
 
 import (
 	"context"
+	"encoding/json"
 	"log/slog"
 	"slices"
 	"sync"
@@ -43,13 +44,14 @@ type (
 		processOperator           process.ProcessOperatorInterface
 		nginxConfigParser         parser.ConfigParser
 		executer                  exec.ExecInterface
+		nginxParser               processParser
 		enabled                   *atomic.Bool
 		agentConfig               *config.Config
 		instanceCache             map[string]*mpi.Instance
 		nginxConfigCache          map[string]*model.NginxConfigContext
 		instancesChannel          chan<- InstanceUpdatesMessage
 		nginxConfigContextChannel chan<- NginxConfigContextMessage
-		nginxParser               processParser
+		processCache              []*nginxprocess.Process
 		cacheMutex                sync.Mutex
 	}
 
@@ -84,6 +86,7 @@ func NewInstanceWatcherService(agentConfig *config.Config) *InstanceWatcherServi
 		nginxConfigCache:  make(map[string]*model.NginxConfigContext),
 		executer:          &exec.Exec{},
 		enabled:           enabled,
+		processCache:      []*nginxprocess.Process{},
 	}
 }
 
@@ -270,6 +273,18 @@ func (iw *InstanceWatcherService) instanceUpdates(ctx context.Context) (
 		return instanceUpdates, err
 	}
 
+	if !slices.EqualFunc(iw.processCache, nginxProcesses, func(a, b *nginxprocess.Process) bool {
+		return a.Equal(b)
+	}) {
+		processesJSON, marshalErr := json.Marshal(nginxProcesses)
+		if marshalErr != nil {
+			slog.DebugContext(ctx, "Unable to marshal NGINX processes", "error", marshalErr)
+		} else {
+			slog.DebugContext(ctx, "NGINX processes changed", "processes", processesJSON)
+			iw.processCache = nginxProcesses
+		}
+	}
+
 	// NGINX Agent is always the first instance in the list
 	instancesFound := make(map[string]*mpi.Instance)
 	agentInstance := iw.agentInstance(ctx)

internal/watcher/instance/nginx_process_parser.go

@@ -48,24 +48,12 @@ func NewNginxProcessParser() *NginxProcessParser {
 //
 //nolint:revive,gocognit // cognitive complexity of 20 because of the if statements in the for loop
 func (npp *NginxProcessParser) Parse(ctx context.Context, processes []*nginxprocess.Process) map[string]*mpi.Instance {
-	slog.DebugContext(ctx, "Parsing NGINX processes", "number_of_processes", len(processes))
-
 	instanceMap := make(map[string]*mpi.Instance)   // key is instanceID
 	workers := make(map[int32][]*mpi.InstanceChild) // key is ppid of process
 
 	processesByPID := convertToMap(processes)
 
 	for _, proc := range processesByPID {
-		slog.DebugContext(ctx, "NGINX process details",
-			"ppid", proc.PPID,
-			"pid", proc.PID,
-			"name", proc.Name,
-			"created", proc.Created,
-			"status", proc.Status,
-			"cmd", proc.Cmd,
-			"exe", proc.Exe,
-		)
-
 		if proc.IsWorker() {
 			// Here we are determining if the worker process has a master
 			if masterProcess, ok := processesByPID[proc.PPID]; ok {

pkg/nginxprocess/process.go

@@ -18,13 +18,13 @@ import (
 type Process struct {
 	// Created is when this process was created, precision varies by platform and is at best to the millisecond. On
 	// linux there can be significant skew compared to [time.Now], ± 1s.
-	Created time.Time
-	Name    string
-	Cmd     string
-	Exe     string // path to the executable
-	Status  string // process status, only present if this process was created using [WithStatus]
-	PID     int32
-	PPID    int32 // parent PID
+	Created time.Time `json:"created"`
+	Name    string    `json:"name"`
+	Cmd     string    `json:"cmd"`
+	Exe     string    `json:"exe"`    // path to the executable
+	Status  string    `json:"status"` // process status, only present if this process was created using [WithStatus]
+	PID     int32     `json:"pid"`
+	PPID    int32     `json:"ppid"` // parent PID
 }
 
 // IsWorker returns true if the process is a NGINX worker process.
@@ -50,6 +50,11 @@ func (p *Process) IsHealthy() bool {
 	return p.Status != "" && !strings.Contains(p.Status, process.Zombie)
 }
 
+func (p *Process) Equal(b *Process) bool {
+	return p.PID == b.PID && p.Name == b.Name && p.PPID == b.PPID && p.Cmd == b.Cmd &&
+		p.Exe == b.Exe && p.Created.Equal(b.Created) && p.Status == b.Status
+}
+
 type options struct {
 	loadStatus bool
 }