sirupsen/log --> log/slog

Author: oliver006

exporter/clients.go

@@ -1,14 +1,14 @@
 package exporter
 
 import (
+	"log/slog"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
 	"github.com/gomodule/redigo/redis"
 	"github.com/prometheus/client_golang/prometheus"
-	log "github.com/sirupsen/logrus"
 )
 
 type ClientInfo struct {
@@ -50,7 +50,7 @@ func parseClientListString(clientInfo string) (*ClientInfo, bool) {
 	for _, kvPart := range strings.Split(clientInfo, " ") {
 		vPart := strings.Split(kvPart, "=")
 		if len(vPart) != 2 {
-			log.Debugf("Invalid format for client list string, got: %s", kvPart)
+			slog.Debug("Invalid format for client list string", "kvPart", kvPart)
 			return nil, false
 		}
 
@@ -64,14 +64,14 @@ func parseClientListString(clientInfo string) (*ClientInfo, bool) {
 		case "age":
 			createdAt, err := durationFieldToTimestamp(vPart[1])
 			if err != nil {
-				log.Debugf("could not parse 'age' field(%s): %s", vPart[1], err.Error())
+				slog.Debug("could not parse 'age' field", "value", vPart[1], "error", err.Error())
 				return nil, false
 			}
 			connectedClient.CreatedAt = createdAt
 		case "idle":
 			idleSinceTs, err := durationFieldToTimestamp(vPart[1])
 			if err != nil {
-				log.Debugf("could not parse 'idle' field(%s): %s", vPart[1], err.Error())
+				slog.Debug("could not parse 'idle' field", "value", vPart[1], "error", err.Error())
 				return nil, false
 			}
 			connectedClient.IdleSince = idleSinceTs
@@ -102,7 +102,7 @@ func parseClientListString(clientInfo string) (*ClientInfo, bool) {
 		case "addr":
 			hostPortString := strings.Split(vPart[1], ":")
 			if len(hostPortString) < 2 {
-				log.Debug("Invalid value for 'addr' found in client info")
+				slog.Debug("Invalid value for 'addr' found in client info")
 				return nil, false
 			}
 			connectedClient.Host = strings.Join(hostPortString[:len(hostPortString)-1], ":")
@@ -126,7 +126,7 @@ func durationFieldToTimestamp(field string) (int64, error) {
 func (e *Exporter) extractConnectedClientMetrics(ch chan<- prometheus.Metric, c redis.Conn) {
 	reply, err := redis.String(doRedisCmd(c, "CLIENT", "LIST"))
 	if err != nil {
-		log.Errorf("CLIENT LIST err: %s", err)
+		slog.Error("CLIENT LIST err", "error", err)
 		return
 	}
 	e.parseConnectedClientMetrics(reply, ch)
@@ -137,7 +137,7 @@ func (e *Exporter) parseConnectedClientMetrics(input string, ch chan<- prometheu
 	for _, s := range strings.Split(input, "\n") {
 		info, ok := parseClientListString(s)
 		if !ok {
-			log.Debugf("parseClientListString( %s ) - couldn';t parse input", s)
+			slog.Debug("parseClientListString - couldn't parse input", "input", s)
 			continue
 		}
 		clientInfoLabels := []string{"id", "name", "flags", "db", "host"}

exporter/exporter.go

@@ -2,6 +2,7 @@ package exporter
 
 import (
 	"fmt"
+	"log/slog"
 	"net/http"
 	"net/url"
 	"runtime"
@@ -16,7 +17,6 @@ import (
 	"github.com/gomodule/redigo/redis"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
-	log "github.com/sirupsen/logrus"
 )
 
 type BuildInfo struct {
@@ -93,7 +93,7 @@ type Options struct {
 
 // NewRedisExporter returns a new exporter of Redis metrics.
 func NewRedisExporter(uri string, opts Options) (*Exporter, error) {
-	log.Debugf("NewRedisExporter options: %#v", opts)
+	slog.Debug("NewRedisExporter options", "options", opts)
 
 	switch {
 	case strings.HasPrefix(uri, "valkey://"):
@@ -102,7 +102,7 @@ func NewRedisExporter(uri string, opts Options) (*Exporter, error) {
 		uri = strings.Replace(uri, "valkeys://", "rediss://", 1)
 	}
 
-	log.Debugf("NewRedisExporter = using redis uri: %s", uri)
+	slog.Debug("Using redis URI", "uri", uri)
 
 	e := &Exporter{
 		redisAddr: uri,
@@ -403,31 +403,31 @@ func NewRedisExporter(uri string, opts Options) (*Exporter, error) {
 	if keys, err := parseKeyArg(opts.CheckKeys); err != nil {
 		return nil, fmt.Errorf("couldn't parse check-keys: %s", err)
 	} else {
-		log.Debugf("keys: %#v", keys)
+		slog.Debug("keys", "keys", keys)
 	}
 
 	if singleKeys, err := parseKeyArg(opts.CheckSingleKeys); err != nil {
 		return nil, fmt.Errorf("couldn't parse check-single-keys: %s", err)
 	} else {
-		log.Debugf("singleKeys: %#v", singleKeys)
+		slog.Debug("singleKeys", "singleKeys", singleKeys)
 	}
 
 	if streams, err := parseKeyArg(opts.CheckStreams); err != nil {
 		return nil, fmt.Errorf("couldn't parse check-streams: %s", err)
 	} else {
-		log.Debugf("streams: %#v", streams)
+		slog.Debug("streams", "streams", streams)
 	}
 
 	if singleStreams, err := parseKeyArg(opts.CheckSingleStreams); err != nil {
 		return nil, fmt.Errorf("couldn't parse check-single-streams: %s", err)
 	} else {
-		log.Debugf("singleStreams: %#v", singleStreams)
+		slog.Debug("singleStreams", "singleStreams", singleStreams)
 	}
 
 	if countKeys, err := parseKeyArg(opts.CountKeys); err != nil {
 		return nil, fmt.Errorf("couldn't parse count-keys: %s", err)
 	} else {
-		log.Debugf("countKeys: %#v", countKeys)
+		slog.Debug("countKeys", "countKeys", countKeys)
 	}
 
 	if opts.InclSystemMetrics {
@@ -603,13 +603,13 @@ func (e *Exporter) extractConfigMetrics(ch chan<- prometheus.Metric, config []in
 	for pos := 0; pos < len(config)/2; pos++ {
 		strKey, err := redis.String(config[pos*2], nil)
 		if err != nil {
-			log.Errorf("invalid config key name, err: %s, skipped", err)
+			slog.Error("invalid config key name, skipped", "error", err)
 			continue
 		}
 
 		strVal, err := redis.String(config[pos*2+1], nil)
 		if err != nil {
-			log.Debugf("invalid config value for key name %s, err: %s, skipped", strKey, err)
+			slog.Debug("invalid config value for key name, skipped", "key", strKey, "error", err)
 			continue
 		}
 
@@ -665,7 +665,7 @@ func (e *Exporter) extractConfigMetrics(ch chan<- prometheus.Metric, config []in
 }
 
 func (e *Exporter) scrapeRedisHost(ch chan<- prometheus.Metric) error {
-	defer log.Debugf("scrapeRedisHost() done")
+	defer slog.Debug("Finished scraping Redis host")
 
 	startTime := time.Now()
 	c, err := e.connectToRedis()
@@ -675,63 +675,63 @@ func (e *Exporter) scrapeRedisHost(ch chan<- prometheus.Metric) error {
 	if err != nil {
 		var redactedAddr string
 		if redisURL, err2 := url.Parse(e.redisAddr); err2 != nil {
-			log.Debugf("url.Parse( %s ) err: %s", e.redisAddr, err2)
+			slog.Debug("Failed to parse URL", "address", e.redisAddr, "error", err2)
 			redactedAddr = "<redacted>"
 		} else {
 			redactedAddr = redisURL.Redacted()
 		}
-		log.Errorf("Couldn't connect to redis instance (%s)", redactedAddr)
-		log.Debugf("connectToRedis( %s ) err: %s", e.redisAddr, err)
+		slog.Error("Couldn't connect to redis instance", "address", redactedAddr)
+		slog.Debug("Connect to redis failed", "address", e.redisAddr, "error", err)
 		return err
 	}
 	defer c.Close()
 
-	log.Debugf("connected to: %s", e.redisAddr)
-	log.Debugf("connecting took %f seconds", connectTookSeconds)
+	slog.Debug("Connected to redis", "address", e.redisAddr)
+	slog.Debug("connecting took seconds", "seconds", connectTookSeconds)
 
 	if e.options.PingOnConnect {
 		startTime := time.Now()
 
 		if _, err := doRedisCmd(c, "PING"); err != nil {
-			log.Errorf("Couldn't PING server, err: %s", err)
+			slog.Error("Couldn't PING server", "error", err)
 		} else {
 			pingTookSeconds := time.Since(startTime).Seconds()
 			e.registerConstMetricGauge(ch, "exporter_last_scrape_ping_time_seconds", pingTookSeconds)
-			log.Debugf("PING took %f seconds", pingTookSeconds)
+			slog.Debug("PING took seconds", "seconds", pingTookSeconds)
 		}
 	}
 
 	if e.options.SetClientName {
 		if _, err := doRedisCmd(c, "CLIENT", "SETNAME", "redis_exporter"); err != nil {
-			log.Errorf("Couldn't set client name, err: %s", err)
+			slog.Error("Couldn't set client name", "error", err)
 		}
 	}
 
 	dbCount := 0
 	if e.options.ConfigCommandName == "-" {
-		log.Debugf("Skipping extractConfigMetrics()")
+		slog.Debug("Skipping config metrics extraction")
 	} else {
 		if config, err := redis.Values(doRedisCmd(c, e.options.ConfigCommandName, "GET", "*")); err == nil {
 			dbCount, err = e.extractConfigMetrics(ch, config)
 			if err != nil {
-				log.Errorf("Redis extractConfigMetrics() err: %s", err)
+				slog.Error("Failed to extract config metrics", "error", err)
 				return err
 			}
 		} else {
-			log.Debugf("Redis CONFIG err: %s", err)
+			slog.Debug("Redis CONFIG err", "error", err)
 		}
 	}
 
 	infoAll, err := redis.String(doRedisCmd(c, "INFO", "ALL"))
 	if err != nil || infoAll == "" {
-		log.Debugf("Redis INFO ALL err: %s", err)
+		slog.Debug("Redis INFO ALL err", "error", err)
 		infoAll, err = redis.String(doRedisCmd(c, "INFO"))
 		if err != nil {
-			log.Errorf("Redis INFO err: %s", err)
+			slog.Error("Redis INFO err", "error", err)
 			return err
 		}
 	}
-	log.Debugf("Redis INFO ALL result: [%#v]", infoAll)
+	slog.Debug("Redis INFO ALL result", "result", infoAll)
 
 	if strings.Contains(infoAll, "cluster_enabled:1") {
 		if clusterInfo, err := redis.String(doRedisCmd(c, "CLUSTER", "INFO")); err == nil {
@@ -740,7 +740,7 @@ func (e *Exporter) scrapeRedisHost(ch chan<- prometheus.Metric) error {
 			// in cluster mode Redis only supports one database, so no extra DB number padding needed
 			dbCount = 1
 		} else {
-			log.Errorf("Redis CLUSTER INFO err: %s", err)
+			slog.Error("Redis CLUSTER INFO err", "error", err)
 		}
 	} else if dbCount == 0 {
 		// in non-cluster mode, if dbCount is zero, then "CONFIG" failed to retrieve a valid
@@ -749,7 +749,7 @@ func (e *Exporter) scrapeRedisHost(ch chan<- prometheus.Metric) error {
 		dbCount = 16
 	}
 
-	log.Debugf("dbCount: %d", dbCount)
+	slog.Debug("dbCount", "count", dbCount)
 
 	role := e.extractInfoMetrics(ch, infoAll, dbCount)
 
@@ -759,17 +759,17 @@ func (e *Exporter) scrapeRedisHost(ch chan<- prometheus.Metric) error {
 
 	// skip these metrics for master if SkipCheckKeysForRoleMaster is set
 	// (can help with reducing workload on the master node)
-	log.Debugf("checkKeys metric collection for role: %s  SkipCheckKeysForRoleMaster flag: %#v", role, e.options.SkipCheckKeysForRoleMaster)
+	slog.Debug("checkKeys metric collection for role", "role", role, "SkipCheckKeysForRoleMaster", e.options.SkipCheckKeysForRoleMaster)
 	if role == InstanceRoleSlave || !e.options.SkipCheckKeysForRoleMaster {
 		if err := e.extractCheckKeyMetrics(ch, c); err != nil {
-			log.Errorf("extractCheckKeyMetrics() err: %s", err)
+			slog.Error("Failed to extract check key metrics", "error", err)
 		}
 
 		e.extractCountKeysMetrics(ch, c)
 
 		e.extractStreamMetrics(ch, c)
 	} else {
-		log.Infof("skipping checkKeys metrics, role: %s  flag: %#v", role, e.options.SkipCheckKeysForRoleMaster)
+		slog.Info("skipping checkKeys metrics", "role", role, "flag", e.options.SkipCheckKeysForRoleMaster)
 	}
 
 	e.extractSlowLogMetrics(ch, c)

exporter/exporter_test.go

@@ -10,18 +10,18 @@ package exporter
 
 import (
 	"fmt"
-	"github.com/mna/redisc"
 	"net/http/httptest"
 	"os"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/gomodule/redigo/redis"
+	"github.com/mna/redisc"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	dto "github.com/prometheus/client_model/go"
-	log "github.com/sirupsen/logrus"
+	"log/slog"
 )
 
 const (
@@ -92,7 +92,7 @@ func getTestExporterWithAddrAndOptions(addr string, opt Options) *Exporter {
 func setupKeys(t *testing.T, c redis.Conn, dbNum string) error {
 	if _, err := doRedisCmd(c, "SELECT", dbNum); err != nil {
 		// not failing on this one - cluster doesn't allow for SELECT so we log and ignore the error
-		log.Printf("setupTestKeys() - couldn't setup redis, err: %s ", err)
+		slog.Error("setupTestKeys() - couldn't setup redis", "error", err)
 	}
 
 	testValue := 1234.56
@@ -198,7 +198,7 @@ func setupKeys(t *testing.T, c redis.Conn, dbNum string) error {
 
 func deleteKeys(c redis.Conn, dbNum string) {
 	if _, err := doRedisCmd(c, "SELECT", dbNum); err != nil {
-		log.Printf("deleteTestKeys() - couldn't setup redis, err: %s ", err)
+		slog.Error("deleteTestKeys() - couldn't setup redis", "error", err)
 		// not failing on this one - cluster doesn't allow for SELECT so we log and ignore the error
 	}
 
@@ -221,7 +221,7 @@ func deleteKeys(c redis.Conn, dbNum string) {
 }
 
 func setupTestKeys(t *testing.T, uri string) {
-	log.Debugf("setupTestKeys uri: %s", uri)
+	slog.Debug("setupTestKeys uri", "uri", uri)
 	c, err := redis.DialURL(uri)
 	if err != nil {
 		t.Fatalf("couldn't setup redis for uri %s, err: %s ", uri, err)
@@ -241,7 +241,7 @@ func setupTestKeys(t *testing.T, uri string) {
 }
 
 func setupTestKeysCluster(t *testing.T, uri string) {
-	log.Debugf("Creating cluster object")
+	slog.Debug("Creating cluster object")
 	cluster := redisc.Cluster{
 		StartupNodes: []string{
 			strings.Replace(uri, "redis://", "", 1),
@@ -250,17 +250,17 @@ func setupTestKeysCluster(t *testing.T, uri string) {
 	}
 
 	if err := cluster.Refresh(); err != nil {
-		log.Fatalf("Refresh failed: %v", err)
+		slog.Error("Refresh failed", "error", err)
 	}
 
 	conn, err := cluster.Dial()
 	if err != nil {
-		log.Errorf("Dial() failed: %v", err)
+		slog.Error("Dial() failed", "error", err)
 	}
 
 	c, err := redisc.RetryConn(conn, 10, 100*time.Millisecond)
 	if err != nil {
-		log.Errorf("RetryConn() failed: %v", err)
+		slog.Error("RetryConn() failed", "error", err)
 	}
 
 	// cluster only supports db==0
@@ -539,14 +539,8 @@ func TestKeyDbMetrics(t *testing.T) {
 }
 
 func init() {
-	ll := strings.ToLower(os.Getenv("LOG_LEVEL"))
-	if pl, err := log.ParseLevel(ll); err == nil {
-		log.Printf("Setting log level to: %s", ll)
-		log.SetLevel(pl)
-	} else {
-		log.SetLevel(log.InfoLevel)
-	}
-
+	// Note: slog level is configured via handler options in main application
+	// For tests, we'll use the default slog configuration
 	testTimestamp := time.Now().Unix()
 
 	for _, n := range []string{"john", "paul", "ringo", "george"} {