Snider/Mining
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: Replace log.Printf with structured logging

Browse source 
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 <noreply@anthropic.com>
This commit is contained in:
snider 2025-12-31 11:48:45 +00:00
parent 07c00430b6
commit 89f74aebff
12 changed files with 78 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
pkg/database/hashrate.go
View file

@ -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{}
}

18
pkg/mining/events.go
View file

@ -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()

44
pkg/mining/manager.go
View file

@ -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})
}
}
})

6
pkg/mining/miner.go
View file

@ -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
}

20
pkg/mining/service.go
View file

@ -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"})
}
}

7
pkg/mining/syslog_unix.go
View file

@ -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)
}
}

4
pkg/mining/syslog_windows.go
View file

@ -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)
}

13
pkg/mining/ttminer_start.go
View file

@ -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})
}
}
}

7
pkg/mining/xmrig_start.go
View file

@ -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()
}

4
pkg/node/peer.go
View file

@ -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})
}
}
})

14
pkg/node/transport.go
View file

@ -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 {

9
pkg/node/worker.go
View file

@ -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")
}
}
}