From 89f74aebfface06b2efe7eb222518d178cc41e7a Mon Sep 17 00:00:00 2001 From: snider Date: Wed, 31 Dec 2025 11:48:45 +0000 Subject: [PATCH] refactor: Replace log.Printf with structured logging MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Migrate all log.Printf/Println calls across the codebase to use the new pkg/logging structured logging package. This provides consistent log formatting with levels, timestamps, and structured key-value fields. Files updated: - pkg/mining/manager.go, service.go, events.go, miner.go - pkg/mining/xmrig_start.go, ttminer_start.go - pkg/mining/syslog_unix.go, syslog_windows.go - pkg/database/hashrate.go - pkg/node/worker.go, transport.go, peer.go 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- pkg/database/hashrate.go | 5 ++-- pkg/mining/events.go | 18 +++++++-------- pkg/mining/manager.go | 44 ++++++++++++++++++------------------ pkg/mining/miner.go | 6 ++--- pkg/mining/service.go | 20 ++++++++-------- pkg/mining/syslog_unix.go | 7 +++--- pkg/mining/syslog_windows.go | 4 ++-- pkg/mining/ttminer_start.go | 13 ++++++----- pkg/mining/xmrig_start.go | 7 +++--- pkg/node/peer.go | 4 ++-- pkg/node/transport.go | 14 ++++++------ pkg/node/worker.go | 9 ++++---- 12 files changed, 78 insertions(+), 73 deletions(-) diff --git a/pkg/database/hashrate.go b/pkg/database/hashrate.go index cbedb9e..ed2a497 100644 --- a/pkg/database/hashrate.go +++ b/pkg/database/hashrate.go @@ -2,8 +2,9 @@ package database import ( "fmt" - "log" "time" + + "github.com/Snider/Mining/pkg/logging" ) // parseSQLiteTimestamp parses timestamp strings from SQLite which may use various formats. @@ -28,7 +29,7 @@ func parseSQLiteTimestamp(s string) time.Time { } } - log.Printf("Warning: failed to parse timestamp '%s' from database", s) + logging.Warn("failed to parse timestamp from database", logging.Fields{"timestamp": s}) return time.Time{} } diff --git a/pkg/mining/events.go b/pkg/mining/events.go index 91fbadb..9f3a911 100644 --- a/pkg/mining/events.go +++ b/pkg/mining/events.go @@ -2,10 +2,10 @@ package mining import ( "encoding/json" - "log" "sync" "time" + "github.com/Snider/Mining/pkg/logging" "github.com/gorilla/websocket" ) @@ -135,7 +135,7 @@ func (h *EventHub) Run() { h.clients[client] = true stateProvider := h.stateProvider h.mu.Unlock() - log.Printf("[EventHub] Client connected (total: %d)", len(h.clients)) + logging.Debug("client connected", logging.Fields{"total": len(h.clients)}) // Send initial state sync if provider is set if stateProvider != nil { @@ -149,7 +149,7 @@ func (h *EventHub) Run() { } data, err := json.Marshal(event) if err != nil { - log.Printf("[EventHub] Failed to marshal state sync: %v", err) + logging.Error("failed to marshal state sync", logging.Fields{"error": err}) return } select { @@ -168,12 +168,12 @@ func (h *EventHub) Run() { close(client.send) } h.mu.Unlock() - log.Printf("[EventHub] Client disconnected (total: %d)", len(h.clients)) + logging.Debug("client disconnected", logging.Fields{"total": len(h.clients)}) case event := <-h.broadcast: data, err := json.Marshal(event) if err != nil { - log.Printf("[EventHub] Failed to marshal event: %v", err) + logging.Error("failed to marshal event", logging.Fields{"error": err}) continue } @@ -255,7 +255,7 @@ func (h *EventHub) Broadcast(event Event) { select { case h.broadcast <- event: default: - log.Printf("[EventHub] Broadcast channel full, dropping event: %s", event.Type) + logging.Warn("broadcast channel full, dropping event", logging.Fields{"type": event.Type}) } } @@ -330,7 +330,7 @@ func (c *wsClient) readPump() { _, message, err := c.conn.ReadMessage() if err != nil { if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) { - log.Printf("[EventHub] WebSocket error: %v", err) + logging.Debug("WebSocket error", logging.Fields{"error": err}) } break } @@ -351,7 +351,7 @@ func (c *wsClient) readPump() { for _, m := range msg.Miners { c.miners[m] = true } - log.Printf("[EventHub] Client subscribed to miners: %v", msg.Miners) + logging.Debug("client subscribed to miners", logging.Fields{"miners": msg.Miners}) case "ping": // Respond with pong @@ -372,7 +372,7 @@ func (h *EventHub) ServeWs(conn *websocket.Conn) bool { h.mu.RUnlock() if currentCount >= h.maxConnections { - log.Printf("[EventHub] Connection rejected: limit reached (%d/%d)", currentCount, h.maxConnections) + logging.Warn("connection rejected: limit reached", logging.Fields{"current": currentCount, "max": h.maxConnections}) conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseTryAgainLater, "connection limit reached")) conn.Close() diff --git a/pkg/mining/manager.go b/pkg/mining/manager.go index 33ca319..3af4baa 100644 --- a/pkg/mining/manager.go +++ b/pkg/mining/manager.go @@ -3,7 +3,6 @@ package mining import ( "context" "fmt" - "log" "net" "regexp" "strconv" @@ -12,6 +11,7 @@ import ( "time" "github.com/Snider/Mining/pkg/database" + "github.com/Snider/Mining/pkg/logging" ) // sanitizeInstanceName ensures the instance name only contains safe characters. @@ -94,7 +94,7 @@ func NewManagerForSimulation() *Manager { func (m *Manager) initDatabase() { cfg, err := LoadMinersConfig() if err != nil { - log.Printf("Warning: could not load config for database init: %v", err) + logging.Warn("could not load config for database init", logging.Fields{"error": err}) return } @@ -105,7 +105,7 @@ func (m *Manager) initDatabase() { } if !m.dbEnabled { - log.Println("Database persistence is disabled") + logging.Debug("database persistence is disabled") return } @@ -115,12 +115,12 @@ func (m *Manager) initDatabase() { } if err := database.Initialize(dbCfg); err != nil { - log.Printf("Warning: failed to initialize database: %v", err) + logging.Warn("failed to initialize database", logging.Fields{"error": err}) m.dbEnabled = false return } - log.Printf("Database persistence enabled (retention: %d days)", m.dbRetention) + logging.Info("database persistence enabled", logging.Fields{"retention_days": m.dbRetention}) // Start periodic cleanup m.startDBCleanup() @@ -137,14 +137,14 @@ func (m *Manager) startDBCleanup() { // Run initial cleanup if err := database.Cleanup(m.dbRetention); err != nil { - log.Printf("Warning: database cleanup failed: %v", err) + logging.Warn("database cleanup failed", logging.Fields{"error": err}) } for { select { case <-ticker.C: if err := database.Cleanup(m.dbRetention); err != nil { - log.Printf("Warning: database cleanup failed: %v", err) + logging.Warn("database cleanup failed", logging.Fields{"error": err}) } case <-m.stopChan: return @@ -157,7 +157,7 @@ func (m *Manager) startDBCleanup() { func (m *Manager) syncMinersConfig() { cfg, err := LoadMinersConfig() if err != nil { - log.Printf("Warning: could not load miners config for sync: %v", err) + logging.Warn("could not load miners config for sync", logging.Fields{"error": err}) return } @@ -179,13 +179,13 @@ func (m *Manager) syncMinersConfig() { Config: nil, // No default config }) configUpdated = true - log.Printf("Added default config for missing miner: %s", availableMiner.Name) + logging.Info("added default config for missing miner", logging.Fields{"miner": availableMiner.Name}) } } if configUpdated { if err := SaveMinersConfig(cfg); err != nil { - log.Printf("Warning: failed to save updated miners config: %v", err) + logging.Warn("failed to save updated miners config", logging.Fields{"error": err}) } } } @@ -194,15 +194,15 @@ func (m *Manager) syncMinersConfig() { func (m *Manager) autostartMiners() { cfg, err := LoadMinersConfig() if err != nil { - log.Printf("Warning: could not load miners config for autostart: %v", err) + logging.Warn("could not load miners config for autostart", logging.Fields{"error": err}) return } for _, minerCfg := range cfg.Miners { if minerCfg.Autostart && minerCfg.Config != nil { - log.Printf("Autostarting miner: %s", minerCfg.MinerType) + logging.Info("autostarting miner", logging.Fields{"type": minerCfg.MinerType}) if _, err := m.StartMiner(context.Background(), minerCfg.MinerType, minerCfg.Config); err != nil { - log.Printf("Failed to autostart miner %s: %v", minerCfg.MinerType, err) + logging.Error("failed to autostart miner", logging.Fields{"type": minerCfg.MinerType, "error": err}) } } } @@ -302,7 +302,7 @@ func (m *Manager) StartMiner(ctx context.Context, minerType string, config *Conf m.miners[instanceName] = miner if err := m.updateMinerConfig(minerType, true, config); err != nil { - log.Printf("Warning: failed to save miner config for autostart: %v", err) + logging.Warn("failed to save miner config for autostart", logging.Fields{"error": err}) } logMessage := fmt.Sprintf("CryptoCurrency Miner started: %s (Binary: %s)", miner.GetName(), miner.GetBinaryPath()) @@ -349,7 +349,7 @@ func (m *Manager) UninstallMiner(ctx context.Context, minerType string) error { // Stop miners outside the lock to avoid blocking for i, miner := range minersToStop { if err := miner.Stop(); err != nil { - log.Printf("Warning: failed to stop running miner %s during uninstall: %v", minersToDelete[i], err) + logging.Warn("failed to stop running miner during uninstall", logging.Fields{"miner": minersToDelete[i], "error": err}) } } @@ -493,7 +493,7 @@ func (m *Manager) RegisterMiner(miner Miner) error { m.miners[name] = miner m.mu.Unlock() - log.Printf("Registered miner: %s", name) + logging.Info("registered miner", logging.Fields{"name": name}) // Emit miner started event (outside lock) m.emitEvent(EventMinerStarted, map[string]interface{}{ @@ -594,7 +594,7 @@ func (m *Manager) collectSingleMinerStats(miner Miner, minerType string, now tim cancel() // Release context resources immediately if err != nil { - log.Printf("Error getting stats for miner %s: %v\n", minerName, err) + logging.Error("failed to get miner stats", logging.Fields{"miner": minerName, "error": err}) return } @@ -615,7 +615,7 @@ func (m *Manager) collectSingleMinerStats(miner Miner, minerType string, now tim Hashrate: point.Hashrate, } if err := database.InsertHashratePoint(minerName, minerType, dbPoint, database.ResolutionHigh); err != nil { - log.Printf("Warning: failed to persist hashrate for %s: %v", minerName, err) + logging.Warn("failed to persist hashrate", logging.Fields{"miner": minerName, "error": err}) } } @@ -653,7 +653,7 @@ func (m *Manager) Stop() { m.mu.Lock() for name, miner := range m.miners { if err := miner.Stop(); err != nil { - log.Printf("Warning: failed to stop miner %s: %v", name, err) + logging.Warn("failed to stop miner", logging.Fields{"miner": name, "error": err}) } } m.mu.Unlock() @@ -669,15 +669,15 @@ func (m *Manager) Stop() { select { case <-done: - log.Printf("All goroutines stopped gracefully") + logging.Info("all goroutines stopped gracefully") case <-time.After(ShutdownTimeout): - log.Printf("Warning: shutdown timeout - some goroutines may not have stopped") + logging.Warn("shutdown timeout - some goroutines may not have stopped") } // Close the database if m.dbEnabled { if err := database.Close(); err != nil { - log.Printf("Warning: failed to close database: %v", err) + logging.Warn("failed to close database", logging.Fields{"error": err}) } } }) diff --git a/pkg/mining/miner.go b/pkg/mining/miner.go index 2f9be2d..44c1d05 100644 --- a/pkg/mining/miner.go +++ b/pkg/mining/miner.go @@ -8,7 +8,6 @@ import ( "errors" "fmt" "io" - "log" "net/http" "os" "os/exec" @@ -21,6 +20,7 @@ import ( "syscall" "time" + "github.com/Snider/Mining/pkg/logging" "github.com/adrg/xdg" ) @@ -349,7 +349,7 @@ func (b *BaseMiner) findMinerBinary() (string, error) { if highestVersionDir != "" { fullPath := filepath.Join(baseInstallPath, highestVersionDir, executableName) if _, err := os.Stat(fullPath); err == nil { - log.Printf("Found miner binary at highest versioned path: %s", fullPath) + logging.Debug("found miner binary at highest versioned path", logging.Fields{"path": fullPath}) return fullPath, nil } } @@ -362,7 +362,7 @@ func (b *BaseMiner) findMinerBinary() (string, error) { if err != nil { return "", fmt.Errorf("failed to get absolute path for '%s': %w", path, err) } - log.Printf("Found miner binary in system PATH: %s", absPath) + logging.Debug("found miner binary in system PATH", logging.Fields{"path": absPath}) return absPath, nil } diff --git a/pkg/mining/service.go b/pkg/mining/service.go index 505182b..0e547eb 100644 --- a/pkg/mining/service.go +++ b/pkg/mining/service.go @@ -5,7 +5,6 @@ import ( "encoding/base64" "encoding/json" "fmt" - "log" "net" "net/http" "os" @@ -16,6 +15,7 @@ import ( "github.com/Masterminds/semver/v3" "github.com/Snider/Mining/docs" + "github.com/Snider/Mining/pkg/logging" "github.com/adrg/xdg" "github.com/gin-contrib/cors" "github.com/gin-gonic/gin" @@ -153,7 +153,7 @@ func NewService(manager ManagerInterface, listenAddr string, displayAddr string, // Initialize node service (optional - only fails if XDG paths are broken) nodeService, err := NewNodeService() if err != nil { - log.Printf("Warning: failed to initialize node service: %v", err) + logging.Warn("failed to initialize node service", logging.Fields{"error": err}) // Continue without node service - P2P features will be unavailable } @@ -282,7 +282,7 @@ func (s *Service) ServiceStartup(ctx context.Context) error { go func() { if err := s.Server.ListenAndServe(); err != nil && err != http.ErrServerClosed { - log.Printf("Server error on %s: %v", s.Server.Addr, err) + logging.Error("server error", logging.Fields{"addr": s.Server.Addr, "error": err}) errChan <- err } close(errChan) // Prevent goroutine leak @@ -294,7 +294,7 @@ func (s *Service) ServiceStartup(ctx context.Context) error { ctxShutdown, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() if err := s.Server.Shutdown(ctxShutdown); err != nil { - log.Printf("Server shutdown error: %v", err) + logging.Error("server shutdown error", logging.Fields{"error": err}) } }() @@ -426,7 +426,7 @@ func (s *Service) updateInstallationCache() (*SystemInfo, error) { } details, err := miner.CheckInstallation() if err != nil { - log.Printf("Warning: failed to check installation for %s: %v", availableMiner.Name, err) + logging.Warn("failed to check installation", logging.Fields{"miner": availableMiner.Name, "error": err}) } systemInfo.InstalledMinersInfo = append(systemInfo.InstalledMinersInfo, details) } @@ -531,7 +531,7 @@ func (s *Service) handleUninstallMiner(c *gin.Context) { return } if _, err := s.updateInstallationCache(); err != nil { - log.Printf("Warning: failed to update cache after uninstall: %v", err) + logging.Warn("failed to update cache after uninstall", logging.Fields{"error": err}) } c.JSON(http.StatusOK, gin.H{"status": minerType + " uninstalled successfully."}) } @@ -582,7 +582,7 @@ func (s *Service) handleInstallMiner(c *gin.Context) { } if _, err := s.updateInstallationCache(); err != nil { - log.Printf("Warning: failed to update cache after install: %v", err) + logging.Warn("failed to update cache after install", logging.Fields{"error": err}) } details, err := miner.CheckInstallation() @@ -966,12 +966,12 @@ func (s *Service) handleMinerHistoricalHashrate(c *gin.Context) { func (s *Service) handleWebSocketEvents(c *gin.Context) { conn, err := wsUpgrader.Upgrade(c.Writer, c.Request, nil) if err != nil { - log.Printf("[WebSocket] Failed to upgrade connection: %v", err) + logging.Error("failed to upgrade WebSocket connection", logging.Fields{"error": err}) return } - log.Printf("[WebSocket] New connection from %s", c.Request.RemoteAddr) + logging.Info("new WebSocket connection", logging.Fields{"remote": c.Request.RemoteAddr}) if !s.EventHub.ServeWs(conn) { - log.Printf("[WebSocket] Connection from %s rejected (limit reached)", c.Request.RemoteAddr) + logging.Warn("WebSocket connection rejected", logging.Fields{"remote": c.Request.RemoteAddr, "reason": "limit reached"}) } } diff --git a/pkg/mining/syslog_unix.go b/pkg/mining/syslog_unix.go index ee58f66..a08ba9c 100644 --- a/pkg/mining/syslog_unix.go +++ b/pkg/mining/syslog_unix.go @@ -3,8 +3,9 @@ package mining import ( - "log" "log/syslog" + + "github.com/Snider/Mining/pkg/logging" ) var syslogWriter *syslog.Writer @@ -17,7 +18,7 @@ func init() { var err error syslogWriter, err = syslog.New(syslog.LOG_NOTICE|syslog.LOG_DAEMON, "mining-service") if err != nil { - log.Printf("Failed to connect to syslog: %v. Syslog logging will be disabled.", err) + logging.Warn("failed to connect to syslog, syslog logging disabled", logging.Fields{"error": err}) syslogWriter = nil // Ensure it's nil on failure } } @@ -27,6 +28,6 @@ func logToSyslog(message string) { if syslogWriter != nil { _ = syslogWriter.Notice(message) } else { - log.Println(message) + logging.Info(message) } } diff --git a/pkg/mining/syslog_windows.go b/pkg/mining/syslog_windows.go index 98605af..7aa225d 100644 --- a/pkg/mining/syslog_windows.go +++ b/pkg/mining/syslog_windows.go @@ -3,7 +3,7 @@ package mining import ( - "log" + "github.com/Snider/Mining/pkg/logging" ) // On Windows, syslog is not available. We'll use a dummy implementation @@ -11,5 +11,5 @@ import ( // logToSyslog logs a message to the standard logger, mimicking the syslog function's signature. func logToSyslog(message string) { - log.Println(message) + logging.Info(message) } diff --git a/pkg/mining/ttminer_start.go b/pkg/mining/ttminer_start.go index 9f1a850..d2acc1e 100644 --- a/pkg/mining/ttminer_start.go +++ b/pkg/mining/ttminer_start.go @@ -4,11 +4,12 @@ import ( "errors" "fmt" "io" - "log" "os" "os/exec" "strings" "time" + + "github.com/Snider/Mining/pkg/logging" ) // Start launches the TT-Miner with the given configuration. @@ -40,7 +41,7 @@ func (m *TTMiner) Start(config *Config) error { // Build command line arguments for TT-Miner args := m.buildArgs(config) - log.Printf("Executing TT-Miner command: %s %s", m.MinerBinary, strings.Join(args, " ")) + logging.Info("executing TT-Miner command", logging.Fields{"binary": m.MinerBinary, "args": strings.Join(args, " ")}) m.cmd = exec.Command(m.MinerBinary, args...) @@ -85,7 +86,7 @@ func (m *TTMiner) Start(config *Config) error { // Normal exit case <-time.After(5 * time.Minute): // Process didn't exit after 5 minutes - force cleanup - log.Printf("TT-Miner process wait timeout, forcing cleanup") + logging.Warn("TT-Miner process wait timeout, forcing cleanup") if cmd.Process != nil { cmd.Process.Kill() } @@ -100,9 +101,9 @@ func (m *TTMiner) Start(config *Config) error { } m.mu.Unlock() if err != nil { - log.Printf("TT-Miner exited with error: %v", err) + logging.Debug("TT-Miner exited with error", logging.Fields{"error": err}) } else { - log.Printf("TT-Miner exited normally") + logging.Debug("TT-Miner exited normally") } }() @@ -166,7 +167,7 @@ func addTTMinerCliArgs(config *Config, args *[]string) { if isValidCLIArg(arg) { *args = append(*args, arg) } else { - log.Printf("Warning: skipping invalid CLI argument: %s", arg) + logging.Warn("skipping invalid CLI argument", logging.Fields{"arg": arg}) } } } diff --git a/pkg/mining/xmrig_start.go b/pkg/mining/xmrig_start.go index 22e48e4..c873d1a 100644 --- a/pkg/mining/xmrig_start.go +++ b/pkg/mining/xmrig_start.go @@ -5,12 +5,13 @@ import ( "errors" "fmt" "io" - "log" "os" "os/exec" "path/filepath" "strings" "time" + + "github.com/Snider/Mining/pkg/logging" ) // Start launches the XMRig miner with the specified configuration. @@ -63,7 +64,7 @@ func (m *XMRigMiner) Start(config *Config) error { addCliArgs(config, &args) - log.Printf("Executing XMRig command: %s %s", m.MinerBinary, strings.Join(args, " ")) + logging.Info("executing XMRig command", logging.Fields{"binary": m.MinerBinary, "args": strings.Join(args, " ")}) m.cmd = exec.Command(m.MinerBinary, args...) @@ -112,7 +113,7 @@ func (m *XMRigMiner) Start(config *Config) error { // Normal exit case <-time.After(5 * time.Minute): // Process didn't exit after 5 minutes - force cleanup - log.Printf("Miner process wait timeout, forcing cleanup") + logging.Warn("miner process wait timeout, forcing cleanup") if cmd.Process != nil { cmd.Process.Kill() } diff --git a/pkg/node/peer.go b/pkg/node/peer.go index e2616e8..02c2649 100644 --- a/pkg/node/peer.go +++ b/pkg/node/peer.go @@ -3,12 +3,12 @@ package node import ( "encoding/json" "fmt" - "log" "os" "path/filepath" "sync" "time" + "github.com/Snider/Mining/pkg/logging" "github.com/Snider/Poindexter" "github.com/adrg/xdg" ) @@ -381,7 +381,7 @@ func (r *PeerRegistry) scheduleSave() { r.mu.RUnlock() if err != nil { // Log error but continue - best effort persistence - log.Printf("Warning: failed to save peer registry: %v", err) + logging.Warn("failed to save peer registry", logging.Fields{"error": err}) } } }) diff --git a/pkg/node/transport.go b/pkg/node/transport.go index 28e3815..1765a33 100644 --- a/pkg/node/transport.go +++ b/pkg/node/transport.go @@ -5,13 +5,13 @@ import ( "encoding/base64" "encoding/json" "fmt" - "log" "net/http" "net/url" "sync" "time" "github.com/Snider/Borg/pkg/smsg" + "github.com/Snider/Mining/pkg/logging" "github.com/gorilla/websocket" ) @@ -193,7 +193,7 @@ func (t *Transport) Connect(peer *Peer) (*PeerConnection, error) { t.conns[pc.Peer.ID] = pc t.mu.Unlock() - log.Printf("[Connect] Connected to %s, SharedSecret len: %d", pc.Peer.ID, len(pc.SharedSecret)) + logging.Debug("connected to peer", logging.Fields{"peer_id": pc.Peer.ID, "secret_len": len(pc.SharedSecret)}) // Update registry t.registry.SetConnected(pc.Peer.ID, true) @@ -202,7 +202,7 @@ func (t *Transport) Connect(peer *Peer) (*PeerConnection, error) { t.wg.Add(1) go t.readLoop(pc) - log.Printf("[Connect] Started readLoop for %s", pc.Peer.ID) + logging.Debug("started readLoop for peer", logging.Fields{"peer_id": pc.Peer.ID}) // Start keepalive t.wg.Add(1) @@ -462,13 +462,13 @@ func (t *Transport) readLoop(pc *PeerConnection) { // Set read deadline to prevent blocking forever on unresponsive connections readDeadline := t.config.PingInterval + t.config.PongTimeout if err := pc.Conn.SetReadDeadline(time.Now().Add(readDeadline)); err != nil { - log.Printf("[readLoop] SetReadDeadline error for %s: %v", pc.Peer.ID, err) + logging.Error("SetReadDeadline error", logging.Fields{"peer_id": pc.Peer.ID, "error": err}) return } _, data, err := pc.Conn.ReadMessage() if err != nil { - log.Printf("[readLoop] Read error from %s: %v", pc.Peer.ID, err) + logging.Debug("read error from peer", logging.Fields{"peer_id": pc.Peer.ID, "error": err}) return } @@ -477,11 +477,11 @@ func (t *Transport) readLoop(pc *PeerConnection) { // Decrypt message using SMSG with shared secret msg, err := t.decryptMessage(data, pc.SharedSecret) if err != nil { - log.Printf("[readLoop] Decrypt error from %s: %v (data len: %d)", pc.Peer.ID, err, len(data)) + logging.Debug("decrypt error from peer", logging.Fields{"peer_id": pc.Peer.ID, "error": err, "data_len": len(data)}) continue // Skip invalid messages } - log.Printf("[readLoop] Received %s from %s (reply to: %s)", msg.Type, pc.Peer.ID, msg.ReplyTo) + logging.Debug("received message from peer", logging.Fields{"type": msg.Type, "peer_id": pc.Peer.ID, "reply_to": msg.ReplyTo}) // Dispatch to handler if t.handler != nil { diff --git a/pkg/node/worker.go b/pkg/node/worker.go index 6be5583..518f252 100644 --- a/pkg/node/worker.go +++ b/pkg/node/worker.go @@ -3,8 +3,9 @@ package node import ( "encoding/json" "fmt" - "log" "time" + + "github.com/Snider/Mining/pkg/logging" ) // MinerManager interface for the mining package integration. @@ -98,11 +99,11 @@ func (w *Worker) HandleMessage(conn *PeerConnection, msg *Message) { } if response != nil { - log.Printf("[Worker] Sending %s response to %s", response.Type, msg.From) + logging.Debug("sending response", logging.Fields{"type": response.Type, "to": msg.From}) if err := conn.Send(response); err != nil { - log.Printf("[Worker] Failed to send response: %v", err) + logging.Error("failed to send response", logging.Fields{"error": err}) } else { - log.Printf("[Worker] Response sent successfully") + logging.Debug("response sent successfully") } } }