feat(logging): Create log attributes for common groups

Author: PythonGermany

config/endpoint/endpoint.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"math/rand"
 	"net"
 	"net/http"
@@ -151,6 +152,16 @@ type Endpoint struct {
 	AlwaysRun bool `yaml:"always-run,omitempty"`
 }
 
+func (e *Endpoint) GetLogAttribute() slog.Attr {
+	return slog.Attr{
+		Key: "endpoint",
+		Value: slog.GroupValue(
+			slog.String("name", e.Name),
+			slog.String("group", e.Group),
+		),
+	}
+}
+
 // IsEnabled returns whether the endpoint is enabled or not
 func (e *Endpoint) IsEnabled() bool {
 	if e.Enabled == nil {

config/endpoint/external_endpoint.go

@@ -2,6 +2,7 @@ package endpoint
 
 import (
 	"errors"
+	"log/slog"
 	"time"
 
 	"github.com/TwiN/gatus/v5/alerting/alert"
@@ -50,6 +51,16 @@ type ExternalEndpoint struct {
 	NumberOfSuccessesInARow int `yaml:"-"`
 }
 
+func (ee *ExternalEndpoint) GetLogAttribute() slog.Attr {
+	return slog.Attr{
+		Key: "external-endpoint",
+		Value: slog.GroupValue(
+			slog.String("group", ee.Group),
+			slog.String("name", ee.Name),
+		),
+	}
+}
+
 // ValidateAndSetDefaults validates the ExternalEndpoint and sets the default values
 func (externalEndpoint *ExternalEndpoint) ValidateAndSetDefaults() error {
 	if err := validateEndpointNameGroupAndAlerts(externalEndpoint.Name, externalEndpoint.Group, externalEndpoint.Alerts); err != nil {

config/suite/suite.go

@@ -3,6 +3,7 @@ package suite
 import (
 	"errors"
 	"fmt"
+	"log/slog"
 	"strconv"
 	"strings"
 	"time"
@@ -56,6 +57,16 @@ type Suite struct {
 	Endpoints []*endpoint.Endpoint `yaml:"endpoints"`
 }
 
+func (s *Suite) GetLogAttribute() slog.Attr {
+	return slog.Attr{
+		Key: "suite",
+		Value: slog.GroupValue(
+			slog.String("name", s.Name),
+			slog.String("group", s.Group),
+		),
+	}
+}
+
 // IsEnabled returns whether the suite is enabled
 func (s *Suite) IsEnabled() bool {
 	if s.Enabled == nil {

watchdog/endpoint.go

@@ -34,44 +34,45 @@ func monitorEndpoint(ep *endpoint.Endpoint, cfg *config.Config, extraLabels []st
 }
 
 func executeEndpoint(ep *endpoint.Endpoint, cfg *config.Config, extraLabels []string) {
+	logger := slog.With(ep.GetLogAttribute())
+
 	// Acquire semaphore to limit concurrent endpoint monitoring
 	if err := monitoringSemaphore.Acquire(ctx, 1); err != nil {
 		// Only fails if context is cancelled (during shutdown)
-		slog.Debug("Context cancelled, skipping execution", "error", err.Error())
+		logger.Debug("Context cancelled; skipping execution", "error", err.Error())
 		return
 	}
 	defer monitoringSemaphore.Release(1)
 	// If there's a connectivity checker configured, check if Gatus has internet connectivity
 	if cfg.Connectivity != nil && cfg.Connectivity.Checker != nil && !cfg.Connectivity.Checker.IsConnected() {
-		slog.Info("No connectivity; skipping execution")
+		logger.Info("No connectivity, skipping execution")
 		return
 	}
 
-	// TODO#1185 This might be a good method to create a logger with added fields for group, endpoint, key, etc. and use that logger throughout the method.
-	slog.Debug("Monitoring endpoint", "group", ep.Group, "endpoint", ep.Name, "key", ep.Key())
+	logger.Debug("Monitoring start")
 	result := ep.EvaluateHealth()
 	if cfg.Metrics {
 		metrics.PublishMetricsForEndpoint(ep, result, extraLabels)
 	}
 	UpdateEndpointStatus(ep, result)
-	if logging.Level() == slog.LevelDebug && !result.Success { // TODO: Check if it is possible to get the configured level directly from slog
-		slog.Debug("Monitored endpoint", "group", ep.Group, "name", ep.Name, "key", ep.Key(), "success", result.Success, "errors", len(result.Errors), "duration", result.Duration.Round(time.Millisecond), "body", result.Body)
+	if logging.Level() == slog.LevelDebug && !result.Success { // TODO#1185 Check if it is possible to get the configured level directly from slog
+		logger.Debug("Monitoring done with errors", "errors", len(result.Errors), "duration", result.Duration.Round(time.Millisecond), "body", result.Body)
 	} else {
-		slog.Info("Monitored endpoint", "group", ep.Group, "name", ep.Name, "key", ep.Key(), "success", result.Success, "errors", len(result.Errors), "duration", result.Duration.Round(time.Millisecond))
+		logger.Info("Monitoring done", "success", result.Success, "errors", len(result.Errors), "duration", result.Duration.Round(time.Millisecond))
 	}
 	inEndpointMaintenanceWindow := false
 	for _, maintenanceWindow := range ep.MaintenanceWindows {
 		if maintenanceWindow.IsUnderMaintenance() {
-			slog.Debug("Under endpoint maintenance window")
+			logger.Debug("Under endpoint maintenance window")
 			inEndpointMaintenanceWindow = true
 		}
 	}
 	if !cfg.Maintenance.IsUnderMaintenance() && !inEndpointMaintenanceWindow {
 		HandleAlerting(ep, result, cfg.Alerting)
 	} else {
-		slog.Debug("Not handling alerting because currently in the maintenance window")
+		logger.Debug("Not handling alerting due to maintenance window")
 	}
-	slog.Debug("Waiting for next execution", "group", ep.Group, "endpoint", ep.Name, "key", ep.Key(), "interval", ep.Interval)
+	logger.Debug("Wait for next monitoring", "interval", ep.Interval)
 }
 
 // UpdateEndpointStatus persists the endpoint result in the storage

watchdog/external_endpoint.go

@@ -26,31 +26,34 @@ func monitorExternalEndpointHeartbeat(ee *endpoint.ExternalEndpoint, cfg *config
 }
 
 func executeExternalEndpointHeartbeat(ee *endpoint.ExternalEndpoint, cfg *config.Config, extraLabels []string) {
+	logger := slog.With(ee.GetLogAttribute())
+
 	// Acquire semaphore to limit concurrent external endpoint monitoring
 	if err := monitoringSemaphore.Acquire(ctx, 1); err != nil {
 		// Only fails if context is cancelled (during shutdown)
-		slog.Debug("Context cancelled, skipping execution", "error", err.Error())
+		logger.Debug("Context cancelled; skipping execution", "error", err.Error())
 		return
 	}
 	defer monitoringSemaphore.Release(1)
 	// If there's a connectivity checker configured, check if Gatus has internet connectivity
 	if cfg.Connectivity != nil && cfg.Connectivity.Checker != nil && !cfg.Connectivity.Checker.IsConnected() {
-		slog.Info("No connectivity; skipping external endpoint execution")
+		logger.Info("No connectivity, skipping execution")
 		return
 	}
-	slog.Debug("Monitoring external endpoint", "group", ee.Group, "name", ee.Name, "key", ee.Key())
+	logger.Debug("Monitoring start")
 	convertedEndpoint := ee.ToEndpoint()
 	hasReceivedResultWithinHeartbeatInterval, err := store.Get().HasEndpointStatusNewerThan(ee.Key(), time.Now().Add(-ee.Heartbeat.Interval))
 	if err != nil {
 		slog.Error("Failed to check if external endpoint has received a result within the heartbeat interval", "group", ee.Group, "name", ee.Name, "key", ee.Key(), "error", err.Error())
+		logger.Error("Monitoring error", "error", err.Error())
 		return
 	}
 	if hasReceivedResultWithinHeartbeatInterval {
 		// If we received a result within the heartbeat interval, we don't want to create a successful result, so we
 		// skip the rest. We don't have to worry about alerting or metrics, because if the previous heartbeat failed
 		// while this one succeeds, it implies that there was a new result pushed, and that result being pushed
 		// should've resolved the alert.
-		slog.Info("External endpint heartbeat received within interval", "group", ee.Group, "name", ee.Name, "key", ee.Key(), "success", hasReceivedResultWithinHeartbeatInterval, "errors", 0)
+		logger.Info("Monitoring success, heartbeat received within interval", "success", hasReceivedResultWithinHeartbeatInterval, "errors", 0)
 		return
 	}
 	// All code after this point assumes the heartbeat failed
@@ -63,7 +66,7 @@ func executeExternalEndpointHeartbeat(ee *endpoint.ExternalEndpoint, cfg *config
 		metrics.PublishMetricsForEndpoint(convertedEndpoint, result, extraLabels)
 	}
 	UpdateEndpointStatus(convertedEndpoint, result)
-	slog.Info("Heartbeat checked for external endpoint", "group", ee.Group, "name", ee.Name, "key", ee.Key(), "success", result.Success, "errors", len(result.Errors), "duration", result.Duration.Round(time.Millisecond))
+	logger.Info("Monitoring done", "success", result.Success, "errors", len(result.Errors), "duration", result.Duration.Round(time.Millisecond))
 	inEndpointMaintenanceWindow := false
 	for _, maintenanceWindow := range ee.MaintenanceWindows {
 		if maintenanceWindow.IsUnderMaintenance() {
@@ -77,7 +80,6 @@ func executeExternalEndpointHeartbeat(ee *endpoint.ExternalEndpoint, cfg *config
 		ee.NumberOfSuccessesInARow = convertedEndpoint.NumberOfSuccessesInARow
 		ee.NumberOfFailuresInARow = convertedEndpoint.NumberOfFailuresInARow
 	} else {
-		slog.Debug("Not handling alerting because currently in the maintenance window")
+		logger.Debug("Not handling alerting due to maintenance window")
 	}
-	slog.Debug("Waiting for next external endpoint execution", "group", ee.Group, "name", ee.Name, "key", ee.Key(), "interval", ee.Heartbeat.Interval)
 }

watchdog/suite.go

@@ -31,19 +31,21 @@ func monitorSuite(s *suite.Suite, cfg *config.Config, extraLabels []string, ctx
 
 // executeSuite executes a suite with proper concurrency control
 func executeSuite(s *suite.Suite, cfg *config.Config, extraLabels []string) {
+	logger := slog.With(s.GetLogAttribute())
+
 	// Acquire semaphore to limit concurrent suite monitoring
 	if err := monitoringSemaphore.Acquire(ctx, 1); err != nil {
 		// Only fails if context is cancelled (during shutdown)
-		slog.Debug("Context cancelled, skipping execution", "suite", s.Name, "error", err.Error())
+		logger.Debug("Context cancelled; skipping execution", "error", err.Error())
 		return
 	}
 	defer monitoringSemaphore.Release(1)
 	// Check connectivity if configured
 	if cfg.Connectivity != nil && cfg.Connectivity.Checker != nil && !cfg.Connectivity.Checker.IsConnected() {
-		slog.Info("No connectivity; skipping suite execution", "name", s.Name)
+		logger.Info("No connectivity, skipping execution")
 		return
 	}
-	slog.Debug("Monitoring suite", "group", s.Group, "name", s.Name, "key", s.Key())
+	logger.Debug("Monitoring start")
 	// Execute the suite using its Execute method
 	result := s.Execute()
 	// Publish metrics for the suite execution
@@ -62,7 +64,7 @@ func executeSuite(s *suite.Suite, cfg *config.Config, extraLabels []string) {
 				inEndpointMaintenanceWindow := false
 				for _, maintenanceWindow := range ep.MaintenanceWindows {
 					if maintenanceWindow.IsUnderMaintenance() {
-						slog.Debug("Endpoint under maintenance window", "suite", s.Name, "endpoint", ep.Name)
+						logger.Debug("Under endpoint maintenance window", ep.GetLogAttribute())
 						inEndpointMaintenanceWindow = true
 						break
 					}
@@ -73,14 +75,13 @@ func executeSuite(s *suite.Suite, cfg *config.Config, extraLabels []string) {
 			}
 		}
 	}
-	slog.Info("Completed suite execution", slog.Group("details",
-		slog.String("name", s.Name),
+	logger.Info("Completed suite execution",
 		slog.Bool("success", result.Success),
 		slog.Int("errors", len(result.Errors)),
 		slog.Duration("duration", result.Duration),
 		slog.Int("endpoints_executed", len(result.EndpointResults)),
 		slog.Int("total_endpoints", len(s.Endpoints)),
-	))
+	)
 }
 
 // UpdateSuiteStatus persists the suite result in the database