Replace logger with slogger in powereventwatcher, debug server, compa…

…ctdb, and keyidentifier

cmd/launcher/launcher.go

@@ -160,7 +160,7 @@ func runLauncher(ctx context.Context, cancel func(), multiSlogger, systemMultiSl
 	}
 
 	debugAddrPath := filepath.Join(rootDirectory, "debug_addr")
-	debug.AttachDebugHandler(debugAddrPath, logger)
+	debug.AttachDebugHandler(debugAddrPath, slogger)
 	defer os.Remove(debugAddrPath)
 
 	// open the database for storing launcher data, we do it here
@@ -281,7 +281,7 @@ func runLauncher(ctx context.Context, cancel func(), multiSlogger, systemMultiSl
 	// For now, remediation is not performed -- we only log the hardware change.
 	agent.DetectAndRemediateHardwareChange(ctx, k)
 
-	powerEventWatcher, err := powereventwatcher.New(ctx, k, log.With(logger, "component", "power_event_watcher"))
+	powerEventWatcher, err := powereventwatcher.New(ctx, k, slogger)
 	if err != nil {
 		slogger.Log(ctx, slog.LevelDebug,
 			"could not init power event watcher",

cmd/launcher/run_compactdb.go

@@ -1,13 +1,15 @@
 package main
 
 import (
+	"context"
 	"errors"
+	"log/slog"
+	"os"
 	"path/filepath"
 
-	"github.com/go-kit/kit/log/level"
-	"github.com/kolide/kit/logutil"
 	"github.com/kolide/launcher/ee/agent"
 	"github.com/kolide/launcher/pkg/launcher"
+	"github.com/kolide/launcher/pkg/log/multislogger"
 )
 
 func runCompactDb(args []string) error {
@@ -21,7 +23,14 @@ func runCompactDb(args []string) error {
 	}
 
 	// relevel
-	logger := logutil.NewServerLogger(opts.Debug)
+	slogLevel := slog.LevelInfo
+	if opts.Debug {
+		slogLevel = slog.LevelDebug
+	}
+
+	slogger := multislogger.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
+		Level: slogLevel,
+	})).Logger
 
 	boltPath := filepath.Join(opts.RootDirectory, "launcher.db")
 
@@ -30,7 +39,10 @@ func runCompactDb(args []string) error {
 		return err
 	}
 
-	level.Info(logger).Log("msg", "Done compacting. Safe to remove old db", "path", oldDbPath)
+	slogger.Log(context.TODO(), slog.LevelInfo,
+		"done compacting, safe to remove old db",
+		"path", oldDbPath,
+	)
 
 	return nil
 }

ee/keyidentifier/examples/key-identifier/main.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/kolide/kit/logutil"
 	"github.com/kolide/launcher/ee/keyidentifier"
+	"github.com/kolide/launcher/pkg/log/multislogger"
 )
 
 func main() {
@@ -18,7 +18,7 @@ func main() {
 }
 
 func testIdentifyFile(path string) error {
-	kIdentifer, _ := keyidentifier.New(keyidentifier.WithLogger(logutil.NewCLILogger(true)))
+	kIdentifer, _ := keyidentifier.New(keyidentifier.WithSlogger(multislogger.New().Logger))
 
 	ki, err := kIdentifer.IdentifyFile(path)
 	if err != nil {

ee/keyidentifier/keyidentifier.go

@@ -2,16 +2,17 @@ package keyidentifier
 
 import (
 	"bytes"
+	"context"
 	"crypto/ecdsa"
 	"crypto/rsa"
 	"crypto/x509"
 	"encoding/pem"
 	"errors"
 	"fmt"
+	"log/slog"
 	"os"
 
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
+	"github.com/kolide/launcher/pkg/log/multislogger"
 
 	"golang.org/x/crypto/ssh"
 )
@@ -29,35 +30,35 @@ type KeyInfo struct {
 }
 
 // keyidentifier attempts to identify a key. It uses a set of
-// herusitics to try to guiess what kind, what size, and whether or
+// heuristics to try to guiess what kind, what size, and whether or
 // not it's encrypted.
 type KeyIdentifier struct {
-	logger log.Logger
+	slogger *slog.Logger
 }
 
 type Option func(*KeyIdentifier)
 
-func WithLogger(logger log.Logger) Option {
-	return func(kIdentifer *KeyIdentifier) {
-		kIdentifer.logger = logger
+func WithSlogger(slogger *slog.Logger) Option {
+	return func(kIdentifier *KeyIdentifier) {
+		kIdentifier.slogger = slogger.With("component", "key_identifier")
 	}
 }
 
 func New(opts ...Option) (*KeyIdentifier, error) {
-	kIdentifer := &KeyIdentifier{
-		logger: log.NewNopLogger(),
+	kIdentifier := &KeyIdentifier{
+		slogger: multislogger.NewNopLogger(),
 	}
 
 	for _, opt := range opts {
-		opt(kIdentifer)
+		opt(kIdentifier)
 	}
 
-	return kIdentifer, nil
+	return kIdentifier, nil
 }
 
-func (kIdentifer *KeyIdentifier) IdentifyFile(path string) (*KeyInfo, error) {
-	level.Debug(kIdentifer.logger).Log(
-		"msg", "starting a key identification",
+func (kIdentifier *KeyIdentifier) IdentifyFile(path string) (*KeyInfo, error) {
+	kIdentifier.slogger.Log(context.TODO(), slog.LevelDebug,
+		"starting a key identification",
 		"file", path,
 	)
 
@@ -66,7 +67,7 @@ func (kIdentifer *KeyIdentifier) IdentifyFile(path string) (*KeyInfo, error) {
 		return nil, fmt.Errorf("reading file %s: %w", path, err)
 	}
 
-	ki, err := kIdentifer.Identify(keyBytes)
+	ki, err := kIdentifier.Identify(keyBytes)
 	if err != nil {
 		return nil, fmt.Errorf("identifying key: %w", err)
 	}
@@ -77,9 +78,9 @@ func (kIdentifer *KeyIdentifier) IdentifyFile(path string) (*KeyInfo, error) {
 // Identify uses a manually curated set of heuristics to determine
 // what kind of key something is. Generally speaking, we consider `err
 // == nil` as success, and throw away errors as unparsable keys.
-func (kIdentifer *KeyIdentifier) Identify(keyBytes []byte) (*KeyInfo, error) {
-	level.Debug(kIdentifer.logger).Log(
-		"msg", "starting a key identification",
+func (kIdentifier *KeyIdentifier) Identify(keyBytes []byte) (*KeyInfo, error) {
+	kIdentifier.slogger.Log(context.TODO(), slog.LevelDebug,
+		"starting a key identification",
 		"file", "<bytestream>",
 	)
 
@@ -94,7 +95,7 @@ func (kIdentifer *KeyIdentifier) Identify(keyBytes []byte) (*KeyInfo, error) {
 	}
 
 	// If nothing else fits. treat it like a pem
-	if ki, err := kIdentifer.attemptPem(keyBytes); err == nil {
+	if ki, err := kIdentifier.attemptPem(keyBytes); err == nil {
 		return ki, nil
 	}
 
@@ -105,7 +106,7 @@ func (kIdentifer *KeyIdentifier) Identify(keyBytes []byte) (*KeyInfo, error) {
 // attemptPem tries to decode the pem, and then work with the key. It's
 // based on code from x/crypto's ssh.ParseRawPrivateKey, but more
 // flexible in handling encryption and formats.
-func (kIdentifer *KeyIdentifier) attemptPem(keyBytes []byte) (*KeyInfo, error) {
+func (kIdentifier *KeyIdentifier) attemptPem(keyBytes []byte) (*KeyInfo, error) {
 	ki := &KeyInfo{
 		Format: "",
 		Parser: "attemptPem",
@@ -118,8 +119,8 @@ func (kIdentifer *KeyIdentifier) attemptPem(keyBytes []byte) (*KeyInfo, error) {
 
 	ki.Encrypted = boolPtr(pemEncryptedBlock(block))
 
-	level.Debug(kIdentifer.logger).Log(
-		"msg", "pem decoded",
+	kIdentifier.slogger.Log(context.TODO(), slog.LevelDebug,
+		"pem decoded",
 		"block type", block.Type,
 	)
 
@@ -156,8 +157,8 @@ func (kIdentifer *KeyIdentifier) attemptPem(keyBytes []byte) (*KeyInfo, error) {
 		if key, err := x509.ParseECPrivateKey(block.Bytes); err == nil {
 			ki.Bits = key.PublicKey.Curve.Params().BitSize
 		} else {
-			level.Debug(kIdentifer.logger).Log(
-				"msg", "x509.ParseECPrivateKey failed to parse",
+			kIdentifier.slogger.Log(context.TODO(), slog.LevelDebug,
+				"x509.ParseECPrivateKey failed to parse",
 				"err", err,
 			)
 		}
@@ -179,8 +180,8 @@ func (kIdentifer *KeyIdentifier) attemptPem(keyBytes []byte) (*KeyInfo, error) {
 	}
 
 	// Unmatched. return what we have
-	level.Debug(kIdentifer.logger).Log(
-		"msg", "pem failed to match block type",
+	kIdentifier.slogger.Log(context.TODO(), slog.LevelDebug,
+		"pem failed to match block type",
 		"type", block.Type,
 	)
 	return ki, nil

ee/keyidentifier/keyidentifier_test.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/kolide/kit/logutil"
+	"github.com/kolide/launcher/pkg/log/multislogger"
 	"github.com/stretchr/testify/require"
 )
 
@@ -21,7 +21,7 @@ type spec struct {
 func TestIdentifyFiles(t *testing.T) {
 	t.Parallel()
 
-	kIdentifier, err := New(WithLogger(logutil.NewCLILogger(true)))
+	kIdentifier, err := New(WithSlogger(multislogger.NewNopLogger()))
 	require.NoError(t, err)
 
 	testFiles, err := filepath.Glob("testdata/specs/*.json")

ee/powereventwatcher/power_event_watcher_other.go

@@ -5,8 +5,8 @@ package powereventwatcher
 
 import (
 	"context"
+	"log/slog"
 
-	"github.com/go-kit/kit/log"
 	"github.com/kolide/launcher/ee/agent/types"
 	"github.com/kolide/launcher/pkg/traces"
 )
@@ -16,7 +16,7 @@ type noOpPowerEventWatcher struct {
 	interrupted bool
 }
 
-func New(ctx context.Context, _ types.Knapsack, _ log.Logger) (*noOpPowerEventWatcher, error) {
+func New(ctx context.Context, _ types.Knapsack, _ *slog.Logger) (*noOpPowerEventWatcher, error) {
 	_, span := traces.StartSpan(ctx)
 	defer span.End()
 

ee/powereventwatcher/power_event_watcher_other_test.go

@@ -9,15 +9,15 @@ import (
 	"testing"
 	"time"
 
-	"github.com/go-kit/kit/log"
 	typesmocks "github.com/kolide/launcher/ee/agent/types/mocks"
+	"github.com/kolide/launcher/pkg/log/multislogger"
 	"github.com/stretchr/testify/require"
 )
 
 func TestInterrupt_Multiple(t *testing.T) {
 	t.Parallel()
 
-	p, err := New(context.TODO(), typesmocks.NewKnapsack(t), log.NewNopLogger())
+	p, err := New(context.TODO(), typesmocks.NewKnapsack(t), multislogger.NewNopLogger())
 	require.NoError(t, err)
 
 	// Start and then interrupt