Replace logrus with stdlib log/slog (#655)

* Replace logrus with stdlib log/slog for structured logging

Migrate the entire codebase from github.com/sirupsen/logrus to Go's
standard library log/slog package. This introduces proper structured
logging with key-value pairs and adds LOG_LEVEL environment variable
support (debug, info, warn, error) for runtime log level configuration.

Key changes:
- Replace logging.Logger interface with type alias to *slog.Logger
- Add ParseLevel() and NewLogger() helpers in pkg/logging
- Add NewWriter() to replace logrus.Logger.Writer() for subprocess
  output capture
- Update backends.Logger interface to use slog-compatible signatures
- Convert all log calls from printf-style to structured key-value pairs
- Remove direct logrus dependency (remains as indirect via transitive deps)

Closes #384

* Convert all fmt.Sprintf log calls to slog structured key-value pairs

Address review feedback: replace fmt.Sprintf anti-pattern across the
entire codebase with proper slog structured key-value args so log
aggregation tools can parse/filter/query individual fields.

Also fixes:
- t.Error(fmt.Sprintf(...)) -> t.Errorf(...) (staticcheck S1038)
- Import ordering (gci: standard first, then third-party)
- Race condition in testregistry (concurrent map access in handleBlobUpload)
- Removed unused fmt imports

* Fix lint: gci import ordering and staticcheck S1038

Sort stdlib imports alphabetically in main.go, remove unused fmt
import and trailing blank line in scheduler_test.go, and replace
t.Error(fmt.Sprintf(...)) with t.Errorf(...) in test files.

* Address reviewer feedback: restore Fatal exit behavior, fix structured logging

- Add os.Exit(1) after log.Error where log.Fatal was originally used
  (prevents app from continuing with nil backends/listeners)
- Convert all remaining fmt.Sprintf log calls to proper slog key-value
  pairs for structured logging benefits
- Restore createLlamaCppConfigFromEnv Fatal exit behavior via exitFunc
- Fix test assertions: restore t.Fatalf for setup errors, use t.Errorf
  for assertion checks
- Fix gci import ordering (log/slog in correct alphabetical position)
- Remove trailing newlines from log messages

* fix: resolve rebase conflicts - convert new upstream logrus calls to slog

Convert new logrus-style logging calls (Infof, Errorf, Warnf, Infoln) added
in upstream to slog structured logging pattern. Fix go.mod dependencies and
test file imports after rebase onto latest main.

* fix: resolve rebase conflicts, lint and test fixes after slog migration

- Fixed import ordering (gci) in select_backend_test.go
- Fixed tc.log -> c.log typo in client.go
- Moved logrus from direct to indirect dependency in go.mod
- All tests pass, go vet clean, golangci-lint passes

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: veeceey

go.mod

@@ -30,7 +30,6 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/prometheus/client_model v0.6.2
 	github.com/prometheus/common v0.67.5
-	github.com/sirupsen/logrus v1.9.4
 	github.com/spf13/cobra v1.10.2
 	github.com/spf13/pflag v1.0.10
 	github.com/stretchr/testify v1.11.1
@@ -116,6 +115,7 @@ require (
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/shirou/gopsutil/v4 v4.25.6 // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/smallnest/ringbuffer v0.0.0-20241116012123-461381446e3d // indirect
 	github.com/tklauser/go-sysconf v0.3.12 // indirect
 	github.com/tklauser/numcpus v0.6.1 // indirect

go.sum

@@ -255,8 +255,8 @@ github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/shirou/gopsutil/v4 v4.25.6 h1:kLysI2JsKorfaFPcYmcJqbzROzsBWEOAtw6A7dIfqXs=
 github.com/shirou/gopsutil/v4 v4.25.6/go.mod h1:PfybzyydfZcN+JMMjkF6Zb8Mq1A/VcogFFg7hj50W9c=
-github.com/sirupsen/logrus v1.9.4 h1:TsZE7l11zFCLZnZ+teH4Umoq5BhEIfIzfRDZ1Uzql2w=
-github.com/sirupsen/logrus v1.9.4/go.mod h1:ftWc9WdOfJ0a92nsE2jF5u5ZwH8Bv2zdeOC42RjbV2g=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/smallnest/ringbuffer v0.0.0-20241116012123-461381446e3d h1:3VwvTjiRPA7cqtgOWddEL+JrcijMlXUmj99c/6YyZoY=
 github.com/smallnest/ringbuffer v0.0.0-20241116012123-461381446e3d/go.mod h1:tAG61zBM1DYRaGIPloumExGvScf08oHuo0kFoOqdbT0=
 github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
@@ -268,6 +268,7 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/testcontainers/testcontainers-go v0.40.0 h1:pSdJYLOVgLE8YdUY2FHQ1Fxu+aMnb6JfVz1mxk7OeMU=
@@ -351,6 +352,7 @@ golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -391,6 +393,7 @@ gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntN
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=

main.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"crypto/tls"
 	"encoding/json"
+	"fmt"
+	"log/slog"
 	"net"
 	"net/http"
 	"os"
@@ -19,25 +21,34 @@ import (
 	"github.com/docker/model-runner/pkg/inference/backends/sglang"
 	"github.com/docker/model-runner/pkg/inference/config"
 	"github.com/docker/model-runner/pkg/inference/models"
+	"github.com/docker/model-runner/pkg/logging"
 	"github.com/docker/model-runner/pkg/metrics"
 	"github.com/docker/model-runner/pkg/routing"
 	modeltls "github.com/docker/model-runner/pkg/tls"
-	"github.com/sirupsen/logrus"
 )
 
 const (
 	// DefaultTLSPort is the default TLS port for Moby
 	DefaultTLSPort = "12444"
 )
 
-var log = logrus.New()
+// initLogger creates the application logger based on LOG_LEVEL env var.
+func initLogger() *slog.Logger {
+	level := logging.ParseLevel(os.Getenv("LOG_LEVEL"))
+	return logging.NewLogger(level)
+}
+
+var log = initLogger()
 
 // Log is the logger used by the application, exported for testing purposes.
 var Log = log
 
 // testLog is a test-override logger used by createLlamaCppConfigFromEnv.
 var testLog = log
 
+// exitFunc is used for Fatal-like exits; overridden in tests.
+var exitFunc = func(code int) { os.Exit(code) }
+
 func main() {
 	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer cancel()
@@ -49,7 +60,8 @@ func main() {
 
 	userHomeDir, err := os.UserHomeDir()
 	if err != nil {
-		log.Fatalf("Failed to get user home directory: %v", err)
+		log.Error("Failed to get user home directory", "error", err)
+		exitFunc(1)
 	}
 
 	modelPath := os.Getenv("MODELS_PATH")
@@ -91,18 +103,18 @@ func main() {
 	}
 	baseTransport.Proxy = http.ProxyFromEnvironment
 
-	log.Infof("LLAMA_SERVER_PATH: %s", llamaServerPath)
+	log.Info("LLAMA_SERVER_PATH", "path", llamaServerPath)
 	if vllmServerPath != "" {
-		log.Infof("VLLM_SERVER_PATH: %s", vllmServerPath)
+		log.Info("VLLM_SERVER_PATH", "path", vllmServerPath)
 	}
 	if sglangServerPath != "" {
-		log.Infof("SGLANG_SERVER_PATH: %s", sglangServerPath)
+		log.Info("SGLANG_SERVER_PATH", "path", sglangServerPath)
 	}
 	if mlxServerPath != "" {
-		log.Infof("MLX_SERVER_PATH: %s", mlxServerPath)
+		log.Info("MLX_SERVER_PATH", "path", mlxServerPath)
 	}
 	if vllmMetalServerPath != "" {
-		log.Infof("VLLM_METAL_SERVER_PATH: %s", vllmMetalServerPath)
+		log.Info("VLLM_METAL_SERVER_PATH", "path", vllmMetalServerPath)
 	}
 
 	// Create llama.cpp configuration from environment variables
@@ -119,7 +131,7 @@ func main() {
 		Log: log,
 		ClientConfig: models.ClientConfig{
 			StoreRootPath: modelPath,
-			Logger:        log.WithFields(logrus.Fields{"component": "model-manager"}),
+			Logger:        log.With("component", "model-manager"),
 			Transport:     baseTransport,
 		},
 		Backends: append(
@@ -135,26 +147,27 @@ func main() {
 				VLLMMetalPath:        vllmMetalServerPath,
 			}),
 			routing.BackendDef{Name: sglang.Name, Init: func(mm *models.Manager) (inference.Backend, error) {
-				return sglang.New(log, mm, log.WithFields(logrus.Fields{"component": sglang.Name}), nil, sglangServerPath)
+				return sglang.New(log, mm, log.With("component", sglang.Name), nil, sglangServerPath)
 			}},
 			routing.BackendDef{Name: diffusers.Name, Init: func(mm *models.Manager) (inference.Backend, error) {
-				return diffusers.New(log, mm, log.WithFields(logrus.Fields{"component": diffusers.Name}), nil, diffusersServerPath)
+				return diffusers.New(log, mm, log.With("component", diffusers.Name), nil, diffusersServerPath)
 			}},
 		),
 		OnBackendError: func(name string, err error) {
-			log.Fatalf("unable to initialize %s backend: %v", name, err)
+			log.Error("unable to initialize backend", "backend", name, "error", err)
+			exitFunc(1)
 		},
 		DefaultBackendName: llamacpp.Name,
 		HTTPClient:         http.DefaultClient,
 		MetricsTracker: metrics.NewTracker(
 			http.DefaultClient,
-			log.WithField("component", "metrics"),
+			log.With("component", "metrics"),
 			"",
 			false,
 		),
 		IncludeResponsesAPI: true,
 		ExtraRoutes: func(r *routing.NormalizedServeMux, s *routing.Service) {
-			// Root handler – only catches exact "/" requests
+			// Root handler - only catches exact "/" requests
 			r.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
 				if req.URL.Path != "/" {
 					http.NotFound(w, req)
@@ -168,14 +181,14 @@ func main() {
 			r.HandleFunc("/version", func(w http.ResponseWriter, req *http.Request) {
 				w.Header().Set("Content-Type", "application/json")
 				if err := json.NewEncoder(w).Encode(map[string]string{"version": Version}); err != nil {
-					log.Warnf("failed to write version response: %v", err)
+					log.Warn("failed to write version response", "error", err)
 				}
 			})
 
 			// Metrics endpoint
 			if os.Getenv("DISABLE_METRICS") != "1" {
 				metricsHandler := metrics.NewAggregatedMetricsHandler(
-					log.WithField("component", "metrics"),
+					log.With("component", "metrics"),
 					s.SchedulerHTTP,
 				)
 				r.Handle("/metrics", metricsHandler)
@@ -186,7 +199,8 @@ func main() {
 		},
 	})
 	if err != nil {
-		log.Fatalf("failed to initialize service: %v", err)
+		log.Error("failed to initialize service", "error", err)
+		exitFunc(1)
 	}
 
 	server := &http.Server{
@@ -204,7 +218,7 @@ func main() {
 	if tcpPort != "" {
 		// Use TCP port
 		addr := ":" + tcpPort
-		log.Infof("Listening on TCP port %s", tcpPort)
+		log.Info("Listening on TCP port", "port", tcpPort)
 		server.Addr = addr
 		go func() {
 			serverErrors <- server.ListenAndServe()
@@ -213,12 +227,14 @@ func main() {
 		// Use Unix socket
 		if err := os.Remove(sockName); err != nil {
 			if !os.IsNotExist(err) {
-				log.Fatalf("Failed to remove existing socket: %v", err)
+				log.Error("Failed to remove existing socket", "error", err)
+				exitFunc(1)
 			}
 		}
 		ln, err := net.ListenUnix("unix", &net.UnixAddr{Name: sockName, Net: "unix"})
 		if err != nil {
-			log.Fatalf("Failed to listen on socket: %v", err)
+			log.Error("Failed to listen on socket", "error", err)
+			exitFunc(1)
 		}
 		go func() {
 			serverErrors <- server.Serve(ln)
@@ -243,19 +259,22 @@ func main() {
 				var err error
 				certPath, keyPath, err = modeltls.EnsureCertificates("", "")
 				if err != nil {
-					log.Fatalf("Failed to ensure TLS certificates: %v", err)
+					log.Error("Failed to ensure TLS certificates", "error", err)
+					exitFunc(1)
 				}
-				log.Infof("Using TLS certificate: %s", certPath)
-				log.Infof("Using TLS key: %s", keyPath)
+				log.Info("Using TLS certificate", "cert", certPath)
+				log.Info("Using TLS key", "key", keyPath)
 			} else {
-				log.Fatal("TLS enabled but no certificate provided and auto-cert is disabled")
+				log.Error("TLS enabled but no certificate provided and auto-cert is disabled")
+				exitFunc(1)
 			}
 		}
 
 		// Load TLS configuration
 		tlsConfig, err := modeltls.LoadTLSConfig(certPath, keyPath)
 		if err != nil {
-			log.Fatalf("Failed to load TLS configuration: %v", err)
+			log.Error("Failed to load TLS configuration", "error", err)
+			exitFunc(1)
 		}
 
 		tlsServer = &http.Server{
@@ -265,7 +284,7 @@ func main() {
 			ReadHeaderTimeout: 10 * time.Second,
 		}
 
-		log.Infof("Listening on TLS port %s", tlsPort)
+		log.Info("Listening on TLS port", "port", tlsPort)
 		go func() {
 			// Use ListenAndServeTLS with empty strings since TLSConfig already has the certs
 			ln, err := tls.Listen("tcp", tlsServer.Addr, tlsConfig)
@@ -293,30 +312,30 @@ func main() {
 	select {
 	case err := <-serverErrors:
 		if err != nil {
-			log.Errorf("Server error: %v", err)
+			log.Error("Server error", "error", err)
 		}
 	case err := <-tlsServerErrorsChan:
 		if err != nil {
-			log.Errorf("TLS server error: %v", err)
+			log.Error("TLS server error", "error", err)
 		}
 	case <-ctx.Done():
-		log.Infoln("Shutdown signal received")
-		log.Infoln("Shutting down the server")
+		log.Info("Shutdown signal received")
+		log.Info("Shutting down the server")
 		if err := server.Close(); err != nil {
-			log.Errorf("Server shutdown error: %v", err)
+			log.Error("Server shutdown error", "error", err)
 		}
 		if tlsServer != nil {
-			log.Infoln("Shutting down the TLS server")
+			log.Info("Shutting down the TLS server")
 			if err := tlsServer.Close(); err != nil {
-				log.Errorf("TLS server shutdown error: %v", err)
+				log.Error("TLS server shutdown error", "error", err)
 			}
 		}
-		log.Infoln("Waiting for the scheduler to stop")
+		log.Info("Waiting for the scheduler to stop")
 		if err := <-schedulerErrors; err != nil {
-			log.Errorf("Scheduler error: %v", err)
+			log.Error("Scheduler error", "error", err)
 		}
 	}
-	log.Infoln("Docker Model Runner stopped")
+	log.Info("Docker Model Runner stopped")
 }
 
 // createLlamaCppConfigFromEnv creates a LlamaCppConfig from environment variables
@@ -337,12 +356,13 @@ func createLlamaCppConfigFromEnv() config.BackendConfig {
 	for _, arg := range args {
 		for _, disallowed := range disallowedArgs {
 			if arg == disallowed {
-				testLog.Fatalf("LLAMA_ARGS cannot override the %s argument as it is controlled by the model runner", disallowed)
+				testLog.Error(fmt.Sprintf("LLAMA_ARGS cannot override the %s argument as it is controlled by the model runner", disallowed))
+				exitFunc(1)
 			}
 		}
 	}
 
-	testLog.Infof("Using custom arguments: %v", args)
+	testLog.Info("Using custom arguments", "args", fmt.Sprintf("%v", args))
 	return &llamacpp.Config{
 		Args: args,
 	}

main_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/docker/model-runner/pkg/inference/backends/llamacpp"
-	"github.com/sirupsen/logrus"
 )
 
 func TestCreateLlamaCppConfigFromEnv(t *testing.T) {
@@ -61,17 +60,14 @@ func TestCreateLlamaCppConfigFromEnv(t *testing.T) {
 				t.Setenv("LLAMA_ARGS", tt.llamaArgs)
 			}
 
-			// Create a test logger that captures fatal errors
-			originalLog := testLog
-			defer func() { testLog = originalLog }()
+			// Override exitFunc to capture exit calls instead of actually exiting
+			originalExitFunc := exitFunc
+			defer func() { exitFunc = originalExitFunc }()
 
-			// Create a new logger that will exit with a special exit code
-			newTestLog := logrus.New()
 			var exitCode int
-			newTestLog.ExitFunc = func(code int) {
+			exitFunc = func(code int) {
 				exitCode = code
 			}
-			testLog = newTestLog
 
 			config := createLlamaCppConfigFromEnv()
 

pkg/anthropic/handler.go

@@ -59,7 +59,7 @@ func NewHandler(log logging.Logger, schedulerHTTP *scheduling.HTTPHandler, allow
 func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	safeMethod := utils.SanitizeForLog(r.Method, -1)
 	safePath := utils.SanitizeForLog(r.URL.Path, -1)
-	h.log.Infof("Anthropic API request: %s %s", safeMethod, safePath)
+	h.log.Info("Anthropic API request", "method", safeMethod, "path", safePath)
 	h.httpHandler.ServeHTTP(w, r)
 }
 
@@ -169,6 +169,6 @@ func (h *Handler) writeAnthropicError(w http.ResponseWriter, statusCode int, err
 	}
 
 	if err := json.NewEncoder(w).Encode(errResp); err != nil {
-		h.log.Errorf("Failed to encode error response: %v", err)
+		h.log.Error("Failed to encode error response", "error", err)
 	}
 }