From 39c6664a7827f2c6c1eaf5fdf61832d0bb4f2363 Mon Sep 17 00:00:00 2001
From: Timo Behrendt <t.behrendt@t00n.de>
Date: Fri, 27 Dec 2024 19:49:03 +0100
Subject: [PATCH] feat: introduce logger into realDynDns main loop

---
 main.go                           | 14 +++++++----
 pkg/realDynDns/realDynDns.go      | 40 ++++++++++++++++++++++++++++++-
 pkg/realDynDns/realDynDns_test.go |  9 +++++--
 3 files changed, 55 insertions(+), 8 deletions(-)

diff --git a/main.go b/main.go
index 68bfa61..a010529 100644
--- a/main.go
+++ b/main.go
@@ -86,23 +86,27 @@ func main() {
 		notificationProvider = notificationProviderConsole.New()
 	}
 
-	rdd := realDynDns.New(externalIpProvider, dnsProvider, notificationProvider, configClient.Domains)
+	rdd := realDynDns.New(externalIpProvider, dnsProvider, notificationProvider, configClient.Domains, logger.With(slog.String("service", "realDynDns")))
 
 	switch configClient.Mode {
 	case config.ScheduledMode:
+		logger.Info("Running in scheduled mode", slog.String("interval", configClient.CheckInterval))
+
 		schedule, job, err := rdd.RunWithSchedule(configClient.CheckInterval)
 		if err != nil {
+			logger.Error("Failed to create scheduler", slog.String("error", err.Error()))
 			panic(err)
 		}
 
-		fmt.Println("Starting scheduler")
-		fmt.Println("Next run:", job.NextRun())
+		logger.Info("Next run:", slog.String("time", job.NextRun().String()))
 		schedule.StartBlocking()
 	case config.RunOnceMode:
-		numberOfChanges, err := rdd.RunOnce()
+		logger.Info("Running in run once mode")
+
+		_, err := rdd.RunOnce()
 		if err != nil {
+			logger.Error("Failed to run once", slog.String("error", err.Error()))
 			panic(err)
 		}
-		fmt.Println("Number of changes:", numberOfChanges)
 	}
 }
diff --git a/pkg/realDynDns/realDynDns.go b/pkg/realDynDns/realDynDns.go
index c08c800..ffc3cd5 100644
--- a/pkg/realDynDns/realDynDns.go
+++ b/pkg/realDynDns/realDynDns.go
@@ -2,6 +2,7 @@ package realDynDns
 
 import (
 	"fmt"
+	"log/slog"
 	"time"
 
 	"realdnydns/pkg/config"
@@ -17,6 +18,7 @@ type ChangeDetector struct {
 	dnsProvider          dnsProvider.DNSProvider
 	notificationProvider notificationProvider.NotificationProvider
 	domains              []config.DomainConfig
+	logger               *slog.Logger
 }
 
 func New(
@@ -24,12 +26,14 @@ func New(
 	dnsProvider dnsProvider.DNSProvider,
 	notificationProvider notificationProvider.NotificationProvider,
 	domains []config.DomainConfig,
+	logger *slog.Logger,
 ) ChangeDetector {
 	return ChangeDetector{
 		externalIpProvider:   externalIpProvider,
 		dnsProvider:          dnsProvider,
 		notificationProvider: notificationProvider,
 		domains:              domains,
+		logger:               logger,
 	}
 }
 
@@ -58,8 +62,11 @@ func (c *ChangeDetector) RunOnce() (int, error) {
 }
 
 func (c *ChangeDetector) detectAndApplyChanges() (int, error) {
+	c.logger.Info("Detecting and applying changes")
+
 	externalIp, err := c.externalIpProvider.GetExternalIp()
 	if err != nil {
+		c.logger.Error("Failed to retrieve external IP", slog.String("error", err.Error()))
 		return 0, err
 	}
 
@@ -67,28 +74,59 @@ func (c *ChangeDetector) detectAndApplyChanges() (int, error) {
 
 	for _, domain := range c.domains {
 		for _, subdomain := range domain.Subdomains {
+			c.logger.Info("Checking record",
+				slog.String("tld", domain.TLD),
+				slog.String("subdomain", subdomain),
+			)
 			currentRecord, err := c.dnsProvider.GetRecord(domain.TLD, subdomain)
 			if err != nil {
+				c.logger.Error("Failed to retrieve record",
+					slog.String("error", err.Error()),
+					slog.String("tld", domain.TLD),
+					slog.String("subdomain", subdomain),
+				)
 				return numberUpdated, err
 			}
 
 			if currentRecord.IP != externalIp.String() {
+				c.logger.Info("Record has changed",
+					slog.String("tld", domain.TLD),
+					slog.String("subdomain", subdomain),
+					slog.String("current_ip", currentRecord.IP),
+					slog.String("external_ip", externalIp.String()),
+				)
+
 				err = c.notificationProvider.SendNotification(
 					fmt.Sprintf("Update %s.%s", subdomain, domain.TLD),
 					fmt.Sprintf("The IP of %s has changed from %s to %s", domain.TLD, currentRecord.IP, externalIp.String()),
 				)
 				if err != nil {
+					c.logger.Warn("Failed to send notification",
+						slog.String("error", err.Error()),
+					)
 					return numberUpdated, err
 				}
 
+				c.logger.Info("Updating record",
+					slog.String("tld", domain.TLD),
+					slog.String("subdomain", subdomain),
+					slog.String("current_ip", currentRecord.IP),
+					slog.String("external_ip", externalIp.String()),
+				)
 				_, err = c.dnsProvider.UpdateRecord(domain.TLD, subdomain, externalIp, currentRecord.TTL, currentRecord.Prio, currentRecord.Disabled)
-				numberUpdated++
 				if err != nil {
+					c.logger.Error("Failed to update record",
+						slog.String("error", err.Error()),
+						slog.String("tld", domain.TLD),
+						slog.String("subdomain", subdomain),
+					)
 					return numberUpdated, err
 				}
+				numberUpdated++
 			}
 		}
 	}
 
+	c.logger.Info("Run completed", slog.Int("number_of_changes", numberUpdated))
 	return numberUpdated, nil
 }
diff --git a/pkg/realDynDns/realDynDns_test.go b/pkg/realDynDns/realDynDns_test.go
index 22eb603..7e5e355 100644
--- a/pkg/realDynDns/realDynDns_test.go
+++ b/pkg/realDynDns/realDynDns_test.go
@@ -1,6 +1,7 @@
 package realDynDns
 
 import (
+	"log/slog"
 	"net"
 	"realdnydns/model/common"
 	"realdnydns/pkg/config"
@@ -72,7 +73,9 @@ func testDetectAndApplyChangesWithChanges() func(t *testing.T) {
 						"@",
 					},
 				},
-			})
+			},
+			slog.Default(),
+		)
 
 		numberUpdated, err := changeDetector.RunOnce()
 		if err != nil {
@@ -101,7 +104,9 @@ func testDetectAndApplyChangesWithoutChanges() func(t *testing.T) {
 						"@",
 					},
 				},
-			})
+			},
+			slog.Default(),
+		)
 
 		numberUpdated, err := changeDetector.RunOnce()
 		if err != nil {