all: slog conversion

alpine/distributionscanner.go

@@ -6,12 +6,11 @@ import (
 	"errors"
 	"fmt"
 	"io/fs"
+	"log/slog"
 	"regexp"
 	"runtime/trace"
 	"strings"
 
-	"github.com/quay/zlog"
-
 	"github.com/quay/claircore"
 	"github.com/quay/claircore/indexer"
 	"github.com/quay/claircore/osrelease"
@@ -61,12 +60,10 @@ func (*DistributionScanner) Kind() string { return scannerKind }
 // If the files are found but all regexp fail to match an empty slice is returned.
 func (s *DistributionScanner) Scan(ctx context.Context, l *claircore.Layer) ([]*claircore.Distribution, error) {
 	defer trace.StartRegion(ctx, "Scanner.Scan").End()
-	ctx = zlog.ContextWithValues(ctx,
-		"component", "alpine/DistributionScanner.Scan",
+	slog.DebugContext(ctx, "start",
 		"version", s.Version(),
 		"layer", l.Hash.String())
-	zlog.Debug(ctx).Msg("start")
-	defer zlog.Debug(ctx).Msg("done")
+	defer slog.DebugContext(ctx, "done")
 	sys, err := l.FS()
 	if err != nil {
 		return nil, fmt.Errorf("alpine: unable to open layer: %w", err)
@@ -102,13 +99,13 @@ func readOSRelease(ctx context.Context, sys fs.FS) (*claircore.Distribution, err
 			return nil, err
 		}
 		if id := m[`ID`]; id != `alpine` {
-			zlog.Debug(ctx).Str("id", id).Msg("seemingly not alpine")
+			slog.DebugContext(ctx, "seemingly not alpine", "id", id)
 			break
 		}
 		vid := m[`VERSION_ID`]
 		idx := strings.LastIndexByte(vid, '.')
 		if idx == -1 {
-			zlog.Debug(ctx).Str("val", vid).Msg("martian VERSION_ID")
+			slog.DebugContext(ctx, "martian VERSION_ID", "val", vid)
 			break
 		}
 		v := vid[:idx]
@@ -126,9 +123,9 @@ func readOSRelease(ctx context.Context, sys fs.FS) (*claircore.Distribution, err
 			PrettyName: m[`PRETTY_NAME`],
 		}, nil
 	case errors.Is(err, fs.ErrNotExist):
-		zlog.Debug(ctx).
-			Str("path", osrelease.Path).
-			Msg("file doesn't exist")
+		slog.DebugContext(ctx,
+			"file doesn't exist",
+			"path", osrelease.Path)
 	default:
 		return nil, err
 	}
@@ -153,7 +150,7 @@ func readIssue(ctx context.Context, sys fs.FS) (*claircore.Distribution, error)
 
 		ms := issueRegexp.FindSubmatch(b)
 		if ms == nil {
-			zlog.Debug(ctx).Msg("seemingly not alpine")
+			slog.DebugContext(ctx, "seemingly not alpine")
 			break
 		}
 		v := string(ms[1])
@@ -164,9 +161,9 @@ func readIssue(ctx context.Context, sys fs.FS) (*claircore.Distribution, error)
 			PrettyName: fmt.Sprintf(`Alpine Linux v%s`, v),
 		}, nil
 	case errors.Is(err, fs.ErrNotExist):
-		zlog.Debug(ctx).
-			Str("path", issuePath).
-			Msg("file doesn't exist")
+		slog.DebugContext(ctx,
+			"file doesn't exist",
+			"path", issuePath)
 	default:
 		return nil, err
 	}

alpine/distributionscanner_test.go

@@ -8,14 +8,13 @@ import (
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
-	"github.com/quay/zlog"
 
 	"github.com/quay/claircore"
+	"github.com/quay/claircore/test"
 )
 
 func TestScanFs(t *testing.T) {
-	ctx := context.Background()
-	ctx = zlog.Test(ctx, t)
+	ctx := test.Logging(t)
 
 	td := os.DirFS("testdata")
 	ms, err := fs.Glob(td, "3.*")
@@ -46,7 +45,6 @@ func scanFsTestcase(ctx context.Context, sys fs.FS) func(*testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		ctx := zlog.Test(ctx, t)
 		got, err := s.scanFs(ctx, sys)
 		if err != nil {
 			t.Error(err)

alpine/fetcher.go

@@ -4,27 +4,24 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"log/slog"
 	"net/http"
 
-	"github.com/quay/zlog"
-
 	"github.com/quay/claircore/libvuln/driver"
 	"github.com/quay/claircore/pkg/tmp"
 )
 
 func (u *updater) Fetch(ctx context.Context, hint driver.Fingerprint) (io.ReadCloser, driver.Fingerprint, error) {
-	ctx = zlog.ContextWithValues(ctx, "component", "alpine/Updater.Fetch")
-
-	zlog.Info(ctx).Str("database", u.url).Msg("starting fetch")
+	slog.InfoContext(ctx, "starting fetch", "database", u.url)
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.url, nil)
 	if err != nil {
 		return nil, hint, fmt.Errorf("alpine: unable to construct request: %w", err)
 	}
 
 	if hint != "" {
-		zlog.Debug(ctx).
-			Str("hint", string(hint)).
-			Msg("using hint")
+		slog.DebugContext(ctx,
+			"using hint",
+			"hint", string(hint))
 		req.Header.Set("if-none-match", string(hint))
 	}
 
@@ -41,25 +38,27 @@ func (u *updater) Fetch(ctx context.Context, hint driver.Fingerprint) (io.ReadCl
 		}
 		fallthrough
 	case http.StatusNotModified:
-		zlog.Info(ctx).Msg("database unchanged since last fetch")
+		slog.InfoContext(ctx, "database unchanged since last fetch")
 		return nil, hint, driver.Unchanged
 	default:
 		return nil, hint, fmt.Errorf("alpine: http response error: %s %d", res.Status, res.StatusCode)
 	}
-	zlog.Debug(ctx).Msg("successfully requested database")
+	slog.DebugContext(ctx, "successfully requested database")
 
 	tf, err := tmp.NewFile("", u.Name()+".")
 	if err != nil {
 		return nil, hint, fmt.Errorf("alpine: unable to open tempfile: %w", err)
 	}
-	zlog.Debug(ctx).
-		Str("name", tf.Name()).
-		Msg("created tempfile")
+	slog.DebugContext(ctx,
+		"created tempfile",
+		"name", tf.Name())
 	var success bool
 	defer func() {
 		if !success {
 			if err := tf.Close(); err != nil {
-				zlog.Warn(ctx).Err(err).Msg("unable to close spool")
+				slog.WarnContext(ctx,
+					"unable to close spool",
+					"reason", err)
 			}
 		}
 	}()
@@ -71,13 +70,13 @@ func (u *updater) Fetch(ctx context.Context, hint driver.Fingerprint) (io.ReadCl
 	if n, err := tf.Seek(0, io.SeekStart); err != nil || n != 0 {
 		return nil, hint, fmt.Errorf("alpine: unable to seek database to start: at %d, %v", n, err)
 	}
-	zlog.Debug(ctx).Msg("decompressed and buffered database")
+	slog.DebugContext(ctx, "decompressed and buffered database")
 
 	success = true
 	hint = driver.Fingerprint(res.Header.Get("etag"))
-	zlog.Debug(ctx).
-		Str("hint", string(hint)).
-		Msg("using new hint")
+	slog.DebugContext(ctx,
+		"using new hint",
+		"hint", string(hint))
 
 	return tf, hint, nil
 }

alpine/fetcher_test.go

@@ -1,13 +1,13 @@
 package alpine
 
 import (
-	"context"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
-	"github.com/quay/zlog"
+
+	"github.com/quay/claircore/test"
 )
 
 func serveSecDB(t *testing.T) (string, *http.Client) {
@@ -17,7 +17,8 @@ func serveSecDB(t *testing.T) (string, *http.Client) {
 }
 
 func TestFactory(t *testing.T) {
-	ctx := zlog.Test(context.Background(), t)
+	ctx := test.Logging(t)
+
 	root, c := serveSecDB(t)
 	fac := &Factory{}
 	err := fac.Configure(ctx, func(v any) error {

alpine/parser.go

@@ -4,8 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"io"
-
-	"github.com/quay/zlog"
+	"log/slog"
 
 	"github.com/quay/claircore"
 	"github.com/quay/claircore/libvuln/driver"
@@ -18,8 +17,8 @@ const (
 var _ driver.Parser = (*updater)(nil)
 
 func (u *updater) Parse(ctx context.Context, r io.ReadCloser) ([]*claircore.Vulnerability, error) {
-	ctx = zlog.ContextWithValues(ctx, "component", "alpine/Updater.Parse")
-	zlog.Info(ctx).Msg("starting parse")
+	slog.InfoContext(ctx, "parse start")
+	defer slog.InfoContext(ctx, "parse done")
 	defer r.Close()
 
 	var db SecurityDB

alpine/parser_test.go

@@ -8,9 +8,9 @@ import (
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
-	"github.com/quay/zlog"
 
 	"github.com/quay/claircore"
+	"github.com/quay/claircore/test"
 )
 
 var dist310 = stableRelease{3, 10}.Distribution()
@@ -128,8 +128,8 @@ var v3_10CommunityTruncatedVulns = []*claircore.Vulnerability{
 
 func TestParser(t *testing.T) {
 	t.Parallel()
-	ctx := context.Background()
-	var table = []struct {
+	ctx := test.Logging(t)
+	table := []struct {
 		release  release
 		repo     string
 		testFile string
@@ -145,7 +145,8 @@ func TestParser(t *testing.T) {
 
 	for _, test := range table {
 		t.Run(test.testFile, func(t *testing.T) {
-			ctx := zlog.Test(ctx, t)
+			ctx, done := context.WithCancel(ctx)
+			t.Cleanup(done)
 
 			path := fmt.Sprintf("testdata/%s", test.testFile)
 			f, err := os.Open(path)

alpine/secdb_test.go

@@ -48,7 +48,7 @@ var v3_10CommunityTruncatedSecDB = SecurityDB{
 }
 
 func TestSecDBParse(t *testing.T) {
-	var table = []struct {
+	table := []struct {
 		testFile string
 		expected SecurityDB
 	}{