feat: add shared driver logger config

Author: cmilesio

database_config.go

@@ -23,6 +23,7 @@ type DatabaseConfig struct {
 	ProcessingRecoveryGrace  time.Duration
 	ProcessingLeaseNoTimeout time.Duration
 	Observer                 Observer
+	Logger                   Logger
 }
 
 func (c DatabaseConfig) normalize() DatabaseConfig {
@@ -44,4 +45,3 @@ func (c DatabaseConfig) normalize() DatabaseConfig {
 	}
 	return c
 }
-

driver/redisqueue/redisqueue.go

@@ -11,16 +11,8 @@ import (
 )
 
 // ServerLogger is the Redis worker server logger contract.
-//
-// It intentionally mirrors common leveled logger methods while avoiding
-// exposing the underlying server implementation type in Config.
-type ServerLogger interface {
-	Debug(args ...interface{})
-	Info(args ...interface{})
-	Warn(args ...interface{})
-	Error(args ...interface{})
-	Fatal(args ...interface{})
-}
+// Deprecated: use queue.Logger via Config.DriverBaseConfig.Logger.
+type ServerLogger = queue.Logger
 
 // ServerLogLevel configures Redis worker server log verbosity.
 type ServerLogLevel int
@@ -94,6 +86,7 @@ func NewWithConfig(cfg Config, opts ...queue.Option) (*queue.Queue, error) {
 		Driver:       queue.DriverRedis,
 		DefaultQueue: cfg.DefaultQueue,
 		Observer:     cfg.Observer,
+		Logger:       cfg.Logger,
 	}
 	driverBackend := newRedisQueue(newRedisClient(cfg), newRedisInspector(cfg), newRedisTimelineStore(cfg), true)
 	q, err := driverbridge.NewQueueFromDriver(rootCfg, driverBackend, func(workers int) (any, error) {
@@ -120,6 +113,8 @@ func serverConfig(cfg Config, workers int) backend.Config {
 	}
 	if cfg.ServerLogger != nil {
 		serverCfg.Logger = cfg.ServerLogger
+	} else if cfg.Logger != nil {
+		serverCfg.Logger = cfg.Logger
 	}
 	if level, ok := serverLogLevel(cfg.ServerLogLevel); ok {
 		serverCfg.LogLevel = level

driver/redisqueue/redisqueue_test.go

@@ -4,6 +4,7 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/goforj/queue/queueconfig"
 	backend "github.com/hibiken/asynq"
 )
 
@@ -56,6 +57,21 @@ func TestServerConfig_LoggerAndLogLevelPassthrough(t *testing.T) {
 	}
 }
 
+func TestServerConfig_GenericLoggerPassthrough(t *testing.T) {
+	logger := serverLoggerStub{}
+	cfg := serverConfig(Config{
+		DriverBaseConfig: queueconfig.DriverBaseConfig{
+			Logger: logger,
+		},
+	}, 2)
+	if cfg.Concurrency != 2 {
+		t.Fatalf("expected concurrency 2, got %d", cfg.Concurrency)
+	}
+	if cfg.Logger == nil {
+		t.Fatal("expected generic logger passthrough")
+	}
+}
+
 func TestNormalizeQueues(t *testing.T) {
 	got := normalizeQueues(map[string]int{"": 2, " critical ": 3, "zero": 0, "neg": -1}, "")
 	want := map[string]int{"default": 2, "critical": 3}

driver/sqlqueuecore/wrapper.go

@@ -30,6 +30,7 @@ func NewQueue(driverName string, cfg ModuleConfig, opts ...queue.Option) (*queue
 		ProcessingRecoveryGrace:  cfg.ProcessingRecoveryGrace,
 		ProcessingLeaseNoTimeout: cfg.ProcessingLeaseNoTimeout,
 		Observer:                 cfg.Observer,
+		Logger:                   cfg.Logger,
 	})
 	if err != nil {
 		return nil, err
@@ -38,6 +39,7 @@ func NewQueue(driverName string, cfg ModuleConfig, opts ...queue.Option) (*queue
 		Driver:       queue.DriverDatabase,
 		DefaultQueue: cfg.DefaultQueue,
 		Observer:     cfg.Observer,
+		Logger:       cfg.Logger,
 	}
 	return driverbridge.NewQueueFromDriver(rootCfg, backend, nil, opts...)
 }

logger.go

@@ -0,0 +1,20 @@
+package queue
+
+// Logger is a generic runtime logger contract that drivers may use to surface
+// their internal worker/server lifecycle output.
+type Logger interface {
+	Debug(args ...interface{})
+	Info(args ...interface{})
+	Warn(args ...interface{})
+	Error(args ...interface{})
+	Fatal(args ...interface{})
+}
+
+// NoopLogger disables driver-managed internal logs when passed through config.
+type NoopLogger struct{}
+
+func (NoopLogger) Debug(...interface{}) {}
+func (NoopLogger) Info(...interface{})  {}
+func (NoopLogger) Warn(...interface{})  {}
+func (NoopLogger) Error(...interface{}) {}
+func (NoopLogger) Fatal(...interface{}) {}

logger_test.go

@@ -0,0 +1,15 @@
+package queue
+
+import "testing"
+
+func TestNoopLoggerImplementsLogger(t *testing.T) {
+	var logger Logger = NoopLogger{}
+	if logger == nil {
+		t.Fatal("expected noop logger")
+	}
+	logger.Debug("debug")
+	logger.Info("info")
+	logger.Warn("warn")
+	logger.Error("error")
+	logger.Fatal("fatal")
+}

queue.go

@@ -66,6 +66,7 @@ func (c WorkerpoolConfig) normalize() WorkerpoolConfig {
 type Config struct {
 	Driver   Driver
 	Observer Observer
+	Logger   Logger
 
 	DefaultQueue string
 }

queueconfig/queueconfig.go

@@ -7,4 +7,5 @@ import "github.com/goforj/queue"
 type DriverBaseConfig struct {
 	DefaultQueue string
 	Observer     queue.Observer
+	Logger       queue.Logger
 }