From b1842ab9e031ddfd6270d24b4a69abb26cd84f21 Mon Sep 17 00:00:00 2001 From: Ramkumar Chinchani <45800463+rchincha@users.noreply.github.com> Date: Fri, 3 Oct 2025 12:34:03 -0700 Subject: [PATCH] fix: migrate from github.com/rs/zerolog to golang-native log/slog (#3405) * fix: migrate from github.com/rs/zerolog to golang-native log/slog We have been using zerolog for a really long time. golang now has structured logging using slog. Best to move to this in interests of long-term support. This is a tech debt item. Signed-off-by: Ramkumar Chinchani * fix: a few changes on top Signed-off-by: Ramkumar Chinchani * fix: address comments Signed-off-by: Ramkumar Chinchani --------- Signed-off-by: Ramkumar Chinchani --- .gitignore | 1 + cmd/zb/main.go | 5 +- go.mod | 1 - go.sum | 6 - pkg/api/authn_test.go | 4 +- pkg/api/config/redis/redis_test.go | 5 +- pkg/api/controller.go | 2 +- pkg/api/controller_test.go | 49 ++- pkg/api/routes_test.go | 2 +- pkg/cli/client/cve_cmd_test.go | 12 +- pkg/cli/client/image_cmd_test.go | 2 +- pkg/cli/client/root.go | 5 +- pkg/cli/server/config_reloader.go | 18 +- pkg/cli/server/root.go | 227 ++++++----- pkg/debug/pprof/pprof.go | 2 +- pkg/exporter/cli/cli.go | 12 +- pkg/extensions/events/events_test.go | 8 +- pkg/extensions/extension_image_trust_test.go | 31 +- pkg/extensions/extension_ui_test.go | 3 +- pkg/extensions/extension_userprefs_test.go | 2 +- pkg/extensions/imagetrust/image_trust_test.go | 3 +- pkg/extensions/lint/lint_test.go | 42 +- pkg/extensions/monitoring/monitoring_test.go | 3 +- pkg/extensions/scrub/scrub_test.go | 6 +- .../search/convert/convert_internal_test.go | 2 +- pkg/extensions/search/convert/convert_test.go | 6 +- pkg/extensions/search/cve/cve_test.go | 18 +- pkg/extensions/search/cve/pagination_test.go | 4 +- pkg/extensions/search/cve/scan.go | 2 +- pkg/extensions/search/cve/scan_test.go | 8 +- .../search/cve/trivy/scanner_internal_test.go | 12 +- .../search/cve/trivy/scanner_test.go | 6 +- pkg/extensions/search/cve/update_test.go | 3 +- pkg/extensions/search/resolver_test.go | 60 +-- pkg/extensions/search/search_test.go | 36 +- pkg/extensions/search/userprefs_test.go | 2 +- pkg/extensions/sync/content_test.go | 12 +- pkg/extensions/sync/sync_internal_test.go | 34 +- pkg/extensions/sync/sync_test.go | 14 +- pkg/log/log.go | 365 +++++++++++++++--- pkg/log/log_test.go | 5 +- pkg/meta/boltdb/boltdb_test.go | 2 +- pkg/meta/dynamodb/dynamodb_internal_test.go | 5 +- pkg/meta/dynamodb/dynamodb_test.go | 7 +- pkg/meta/hooks_test.go | 4 +- pkg/meta/meta_test.go | 12 +- pkg/meta/parse_test.go | 30 +- pkg/meta/redis/redis_internal_test.go | 2 +- pkg/meta/redis/redis_test.go | 8 +- pkg/meta/version/version_test.go | 6 +- pkg/scheduler/scheduler.go | 2 +- pkg/storage/cache/boltdb_internal_test.go | 5 +- pkg/storage/cache/boltdb_test.go | 4 +- pkg/storage/cache/dynamodb_test.go | 6 +- pkg/storage/cache/redis_test.go | 10 +- pkg/storage/cache_test.go | 4 +- pkg/storage/common/common_test.go | 11 +- pkg/storage/gc/gc_internal_test.go | 6 +- pkg/storage/gc/gc_test.go | 6 +- pkg/storage/local/local_elevated_test.go | 3 +- pkg/storage/local/local_test.go | 101 +++-- pkg/storage/s3/s3_test.go | 15 +- pkg/storage/scrub_test.go | 6 +- pkg/storage/storage_test.go | 21 +- pkg/test/oci-utils/oci_layout_test.go | 34 +- 65 files changed, 816 insertions(+), 534 deletions(-) diff --git a/.gitignore b/.gitignore index 4e0ce816..49d69077 100644 --- a/.gitignore +++ b/.gitignore @@ -32,3 +32,4 @@ vendor/ .vscode/ examples/config-sync-localhost.json node_modules +zot-test diff --git a/cmd/zb/main.go b/cmd/zb/main.go index 0846b4a1..e10eff14 100644 --- a/cmd/zb/main.go +++ b/cmd/zb/main.go @@ -4,10 +4,10 @@ import ( "os" distspec "github.com/opencontainers/distribution-spec/specs-go" - "github.com/rs/zerolog/log" "github.com/spf13/cobra" "zotregistry.dev/zot/pkg/api/config" + "zotregistry.dev/zot/pkg/log" ) // "zb" - performance benchmark and stress. @@ -26,7 +26,8 @@ func NewPerfRootCmd() *cobra.Command { Long: "`zb`", Run: func(cmd *cobra.Command, args []string) { if showVersion { - log.Info().Str("distribution-spec", distspec.Version).Str("commit", config.Commit). + logger := log.NewLogger("info", "") + logger.Info().Str("distribution-spec", distspec.Version).Str("commit", config.Commit). Str("binary-type", config.BinaryType).Str("go version", config.GoVersion).Msg("version") } diff --git a/go.mod b/go.mod index 5b3a89ab..27df659a 100644 --- a/go.mod +++ b/go.mod @@ -58,7 +58,6 @@ require ( github.com/prometheus/client_model v0.6.2 github.com/redis/go-redis/v9 v9.14.0 github.com/regclient/regclient v0.9.2 - github.com/rs/zerolog v1.34.0 github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 github.com/sigstore/cosign/v2 v2.5.2 github.com/sigstore/sigstore v1.9.5 diff --git a/go.sum b/go.sum index edb9e0a4..4ea5dd55 100644 --- a/go.sum +++ b/go.sum @@ -1270,7 +1270,6 @@ github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw= github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA= github.com/gocsaf/csaf/v3 v3.3.0 h1:zQwCgBJfMMM/Q5vuIuj8eo5fVLcCKpaBa3t5uw6ku1U= github.com/gocsaf/csaf/v3 v3.3.0/go.mod h1:cDvnE5tnrO37OcOGWJsOl3mgfZjA4/EuC7TlDVRLGos= -github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk= github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA= @@ -1644,12 +1643,10 @@ github.com/masahiro331/go-vmdk-parser v0.0.0-20221225061455-612096e4bbbd/go.mod github.com/masahiro331/go-xfs-filesystem v0.0.0-20231205045356-1b22259a6c44 h1:VmSjn0UCyfXUNdePDr7uM/uZTnGSp+mKD5+cYkEoLx4= github.com/masahiro331/go-xfs-filesystem v0.0.0-20231205045356-1b22259a6c44/go.mod h1:QKBZqdn6teT0LK3QhAf3K6xakItd1LonOShOEC44idQ= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= @@ -1902,9 +1899,6 @@ github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0t github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA= github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= -github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= -github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY= -github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ= github.com/rubenv/sql-migrate v1.8.0 h1:dXnYiJk9k3wetp7GfQbKJcPHjVJL6YK19tKj8t2Ns0o= github.com/rubenv/sql-migrate v1.8.0/go.mod h1:F2bGFBwCU+pnmbtNYDeKvSuvL6lBVtXDXUUv5t+u1qw= github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww= diff --git a/pkg/api/authn_test.go b/pkg/api/authn_test.go index 3aecfe7d..7838685d 100644 --- a/pkg/api/authn_test.go +++ b/pkg/api/authn_test.go @@ -903,7 +903,7 @@ func TestAPIKeysOpenDBError(t *testing.T) { func TestAPIKeysGeneratorErrors(t *testing.T) { Convey("Test API keys - unable to generate API keys and API Key IDs", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() apiKey, apiKeyID, err := api.GenerateAPIKey(guuid.DefaultGenerator, log) So(err, ShouldBeNil) @@ -931,7 +931,7 @@ func TestAPIKeysGeneratorErrors(t *testing.T) { } func TestCookiestoreCleanup(t *testing.T) { - log := log.Logger{} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(true, log) Convey("Test cookiestore cleanup works", t, func() { diff --git a/pkg/api/config/redis/redis_test.go b/pkg/api/config/redis/redis_test.go index d0d71d70..3267950c 100644 --- a/pkg/api/config/redis/redis_test.go +++ b/pkg/api/config/redis/redis_test.go @@ -22,9 +22,8 @@ func TestRedisLogger(t *testing.T) { logFile, err := os.CreateTemp(t.TempDir(), "zot-log*.txt") So(err, ShouldBeNil) - logger := log.NewLogger("debug", logFile.Name()) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) + logger := log.NewLoggerWithWriter("debug", writers) rlog := rediscfg.RedisLogger{logger} rlog.Printf(context.Background(), "this is a rest string") @@ -38,7 +37,7 @@ func TestRedisLogger(t *testing.T) { func TestRedisOptions(t *testing.T) { Convey("Test redis initialization", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) Convey("Test redis url parsing", func() { diff --git a/pkg/api/controller.go b/pkg/api/controller.go index e501589a..7b197a0a 100644 --- a/pkg/api/controller.go +++ b/pkg/api/controller.go @@ -98,7 +98,7 @@ func NewController(appConfig *config.Config) *Controller { } appConfig.Cluster.Proxy = internalProxyConfig - logger.Logger = logger.Logger.With(). + logger = logger.With(). Str("clusterMember", memberSocket). Str("clusterMemberIndex", strconv.Itoa(memberSocketIdx)).Logger() } diff --git a/pkg/api/controller_test.go b/pkg/api/controller_test.go index f0ded5b0..89066eb6 100644 --- a/pkg/api/controller_test.go +++ b/pkg/api/controller_test.go @@ -139,7 +139,7 @@ func TestNew(t *testing.T) { func TestCreateCacheDatabaseDriver(t *testing.T) { Convey("Test CreateCacheDatabaseDriver boltdb", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() // fail create db, no perm dir := t.TempDir() @@ -167,7 +167,7 @@ func TestCreateCacheDatabaseDriver(t *testing.T) { Convey("Test CreateCacheDatabaseDriver redisdb", t, func() { miniRedis := miniredis.RunT(t) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() dir := t.TempDir() conf := config.New() @@ -216,7 +216,7 @@ func TestCreateCacheDatabaseDriver(t *testing.T) { tskip.SkipDynamo(t) tskip.SkipS3(t) Convey("Test CreateCacheDatabaseDriver dynamodb", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() dir := t.TempDir() // good config conf := config.New() @@ -310,7 +310,7 @@ func TestCreateCacheDatabaseDriver(t *testing.T) { func TestCreateMetaDBDriver(t *testing.T) { Convey("Test create MetaDB dynamo", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() dir := t.TempDir() conf := config.New() conf.Storage.RootDirectory = dir @@ -389,7 +389,7 @@ func TestCreateMetaDBDriver(t *testing.T) { Convey("Test create MetaDB redis", t, func() { miniRedis := miniredis.RunT(t) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() dir := t.TempDir() conf := config.New() conf.Storage.RootDirectory = dir @@ -440,7 +440,7 @@ func TestCreateMetaDBDriver(t *testing.T) { }) Convey("Test create MetaDB bolt", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() dir := t.TempDir() conf := config.New() conf.Storage.RootDirectory = dir @@ -2490,7 +2490,7 @@ func TestAuthnErrors(t *testing.T) { } So(func() { - api.NewRelyingPartyGithub(conf, "prov", nil, nil, log.NewLogger("debug", "")) + api.NewRelyingPartyGithub(conf, "prov", nil, nil, log.NewTestLogger()) }, ShouldPanic) }) } @@ -3810,27 +3810,29 @@ func TestLDAPFailures(t *testing.T) { defer ldapServer.Stop() Convey("Empty config", func() { - lc := &api.LDAPClient{} - err := lc.Connect() + lclient := &api.LDAPClient{Log: log.NewTestLogger()} + err := lclient.Connect() So(err, ShouldNotBeNil) }) Convey("Basic connectivity config", func() { - lc := &api.LDAPClient{ + lclient := &api.LDAPClient{ Host: LDAPAddress, Port: ldapPort, + Log: log.NewTestLogger(), } - err := lc.Connect() + err := lclient.Connect() So(err, ShouldNotBeNil) }) Convey("Basic TLS connectivity config", func() { - lc := &api.LDAPClient{ + lclient := &api.LDAPClient{ Host: LDAPAddress, Port: ldapPort, UseSSL: true, + Log: log.NewTestLogger(), } - err := lc.Connect() + err := lclient.Connect() So(err, ShouldNotBeNil) }) }) @@ -3853,6 +3855,7 @@ func TestLDAPClient(t *testing.T) { BindDN: "bad-user", BindPassword: "bad-pass", SkipTLS: true, + Log: log.NewTestLogger(), } _, _, _, err = lClient.Authenticate("bad-user", "bad-pass") @@ -3865,6 +3868,7 @@ func TestLDAPClient(t *testing.T) { BindDN: "bad-user", BindPassword: "", SkipTLS: true, + Log: log.NewTestLogger(), } _, _, _, err = lClient.Authenticate("user", "") @@ -3880,6 +3884,7 @@ func TestLDAPClient(t *testing.T) { UserAttribute: LDAPUserAttr, UserFilter: "", SkipTLS: true, + Log: log.NewTestLogger(), } _, _, _, err = lClient.Authenticate("fail-user-bind", "") @@ -3895,6 +3900,7 @@ func TestLDAPClient(t *testing.T) { UserAttribute: LDAPUserAttr, UserFilter: "", SkipTLS: true, + Log: log.NewTestLogger(), } _, _, _, err = lClient.Authenticate("fail-user-bind", "pass") @@ -3910,6 +3916,7 @@ func TestLDAPClient(t *testing.T) { UserAttribute: LDAPUserAttr, UserFilter: "(!(nsaccountlock=TRUE))", SkipTLS: true, + Log: log.NewTestLogger(), } _, _, _, err = lClient.Authenticate("locked-user", "pass") @@ -4487,7 +4494,7 @@ func TestNewRelyingPartyOIDC(t *testing.T) { } Convey("provider not found in config", func() { - So(func() { _ = api.NewRelyingPartyOIDC(ctx, conf, "notDex", nil, nil, log.NewLogger("debug", "")) }, ShouldPanic) + So(func() { _ = api.NewRelyingPartyOIDC(ctx, conf, "notDex", nil, nil, log.NewTestLogger()) }, ShouldPanic) }) Convey("key path not found on disk", func() { @@ -4495,7 +4502,7 @@ func TestNewRelyingPartyOIDC(t *testing.T) { oidcProviderCfg.KeyPath = "path/to/file" conf.HTTP.Auth.OpenID.Providers["oidc"] = oidcProviderCfg - So(func() { _ = api.NewRelyingPartyOIDC(ctx, conf, "oidc", nil, nil, log.NewLogger("debug", "")) }, ShouldPanic) + So(func() { _ = api.NewRelyingPartyOIDC(ctx, conf, "oidc", nil, nil, log.NewTestLogger()) }, ShouldPanic) }) Convey("https callback", func() { @@ -4504,7 +4511,7 @@ func TestNewRelyingPartyOIDC(t *testing.T) { Key: ServerKey, } - rp := api.NewRelyingPartyOIDC(ctx, conf, "oidc", nil, nil, log.NewLogger("debug", "")) + rp := api.NewRelyingPartyOIDC(ctx, conf, "oidc", nil, nil, log.NewTestLogger()) So(rp, ShouldNotBeNil) }) @@ -4513,7 +4520,7 @@ func TestNewRelyingPartyOIDC(t *testing.T) { oidcProvider.ClientSecret = "" conf.HTTP.Auth.OpenID.Providers["oidc"] = oidcProvider - rp := api.NewRelyingPartyOIDC(ctx, conf, "oidc", nil, nil, log.NewLogger("debug", "")) + rp := api.NewRelyingPartyOIDC(ctx, conf, "oidc", nil, nil, log.NewTestLogger()) So(rp, ShouldNotBeNil) }) @@ -4522,7 +4529,7 @@ func TestNewRelyingPartyOIDC(t *testing.T) { oidcProvider.Issuer = "" conf.HTTP.Auth.OpenID.Providers["oidc"] = oidcProvider - So(func() { _ = api.NewRelyingPartyOIDC(ctx, conf, "oidc", nil, nil, log.NewLogger("debug", "")) }, ShouldPanic) + So(func() { _ = api.NewRelyingPartyOIDC(ctx, conf, "oidc", nil, nil, log.NewTestLogger()) }, ShouldPanic) }) }) } @@ -12747,7 +12754,7 @@ func TestGetGithubUserInfo(t *testing.T) { client := github.NewClient(mockedHTTPClient) - _, _, err := api.GetGithubUserInfo(context.Background(), client, log.Logger{}) + _, _, err := api.GetGithubUserInfo(context.Background(), client, log.NewTestLogger()) So(err, ShouldBeNil) }) @@ -12767,7 +12774,7 @@ func TestGetGithubUserInfo(t *testing.T) { client := github.NewClient(mockedHTTPClient) - _, _, err := api.GetGithubUserInfo(context.Background(), client, log.Logger{}) + _, _, err := api.GetGithubUserInfo(context.Background(), client, log.NewTestLogger()) So(err, ShouldNotBeNil) }) @@ -12796,7 +12803,7 @@ func TestGetGithubUserInfo(t *testing.T) { client := github.NewClient(mockedHTTPClient) - _, _, err := api.GetGithubUserInfo(context.Background(), client, log.Logger{}) + _, _, err := api.GetGithubUserInfo(context.Background(), client, log.NewTestLogger()) So(err, ShouldNotBeNil) }) } diff --git a/pkg/api/routes_test.go b/pkg/api/routes_test.go index 2a218bb5..96c97627 100644 --- a/pkg/api/routes_test.go +++ b/pkg/api/routes_test.go @@ -1665,7 +1665,7 @@ func TestWriteDataFromReader(t *testing.T) { Convey("", t, func() { response := httptest.NewRecorder() api.WriteDataFromReader(response, 200, 100, ispec.MediaTypeImageManifest, readerThatFails{}, - log.NewLogger("debug", "")) + log.NewTestLogger()) So(response.Code, ShouldEqual, 200) }) diff --git a/pkg/cli/client/cve_cmd_test.go b/pkg/cli/client/cve_cmd_test.go index adad8cb3..cfa52fd3 100644 --- a/pkg/cli/client/cve_cmd_test.go +++ b/pkg/cli/client/cve_cmd_test.go @@ -50,7 +50,7 @@ func TestNegativeServerResponse(t *testing.T) { dir := t.TempDir() - srcStorageCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + srcStorageCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateDefaultVulnerableImage(), "zot-cve-test", "0.0.1", srcStorageCtlr) So(err, ShouldBeNil) @@ -82,7 +82,7 @@ func TestNegativeServerResponse(t *testing.T) { writers := io.MultiWriter(os.Stdout, logFile) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("info", writers) cm := test.NewControllerManager(ctlr) cm.StartAndWait(conf.HTTP.Port) @@ -119,7 +119,7 @@ func TestNegativeServerResponse(t *testing.T) { dir := t.TempDir() imageStore := local.NewImageStore(dir, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), nil, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), nil, nil, nil, nil) storeController := storage.StoreController{ DefaultStore: imageStore, @@ -163,7 +163,7 @@ func TestNegativeServerResponse(t *testing.T) { writers := io.MultiWriter(os.Stdout, logFile) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("info", writers) if err := ctlr.Init(); err != nil { panic(err) @@ -238,7 +238,7 @@ func TestCVEDiffList(t *testing.T) { writers := io.MultiWriter(os.Stdout, logFile) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("info", writers) if err := ctlr.Init(); err != nil { panic(err) @@ -513,7 +513,7 @@ func TestServerCVEResponse(t *testing.T) { writers := io.MultiWriter(os.Stdout, logFile) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("info", writers) if err := ctlr.Init(); err != nil { panic(err) diff --git a/pkg/cli/client/image_cmd_test.go b/pkg/cli/client/image_cmd_test.go index a95a056c..5f84c834 100644 --- a/pkg/cli/client/image_cmd_test.go +++ b/pkg/cli/client/image_cmd_test.go @@ -900,7 +900,7 @@ func TestServerResponseGQLWithoutPermissions(t *testing.T) { dir := t.TempDir() - srcStorageCtlr := ociutils.GetDefaultStoreController(dir, zlog.NewLogger("debug", "")) + srcStorageCtlr := ociutils.GetDefaultStoreController(dir, zlog.NewTestLogger()) err := WriteImageToFileSystem(CreateDefaultImage(), "zot-test", "0.0.1", srcStorageCtlr) So(err, ShouldBeNil) diff --git a/pkg/cli/client/root.go b/pkg/cli/client/root.go index 030bc422..dd75ae7f 100644 --- a/pkg/cli/client/root.go +++ b/pkg/cli/client/root.go @@ -5,10 +5,10 @@ package client import ( distspec "github.com/opencontainers/distribution-spec/specs-go" - "github.com/rs/zerolog/log" "github.com/spf13/cobra" "zotregistry.dev/zot/pkg/api/config" + "zotregistry.dev/zot/pkg/log" ) // "zli" - client-side cli. @@ -21,7 +21,8 @@ func NewCliRootCmd() *cobra.Command { Long: "`zli`", Run: func(cmd *cobra.Command, args []string) { if showVersion { - log.Info().Str("distribution-spec", distspec.Version).Str("commit", config.Commit). + logger := log.NewLogger("info", "") + logger.Info().Str("distribution-spec", distspec.Version).Str("commit", config.Commit). Str("binary-type", config.BinaryType).Str("go version", config.GoVersion).Msg("version") } else { _ = cmd.Usage() diff --git a/pkg/cli/server/config_reloader.go b/pkg/cli/server/config_reloader.go index 5d2ccbe6..55691021 100644 --- a/pkg/cli/server/config_reloader.go +++ b/pkg/cli/server/config_reloader.go @@ -7,10 +7,10 @@ import ( "syscall" "github.com/fsnotify/fsnotify" - "github.com/rs/zerolog/log" "zotregistry.dev/zot/pkg/api" "zotregistry.dev/zot/pkg/api/config" + "zotregistry.dev/zot/pkg/log" ) type HotReloader struct { @@ -18,6 +18,7 @@ type HotReloader struct { configPath string ldapCredentialsPath string ctlr *api.Controller + logger log.Logger } func NewHotReloader(ctlr *api.Controller, filePath, ldapCredentialsPath string) (*HotReloader, error) { @@ -32,6 +33,7 @@ func NewHotReloader(ctlr *api.Controller, filePath, ldapCredentialsPath string) configPath: filePath, ldapCredentialsPath: ldapCredentialsPath, ctlr: ctlr, + logger: log.NewLogger("info", ""), } return hotReloader, nil @@ -72,13 +74,13 @@ func (hr *HotReloader) Start() { // watch for events case event := <-hr.watcher.Events: if event.Op == fsnotify.Write { - log.Info().Msg("config file changed, trying to reload config") + hr.logger.Info().Msg("config file changed, trying to reload config") newConfig := config.New() err := LoadConfiguration(newConfig, hr.configPath) if err != nil { - log.Error().Err(err).Msg("failed to reload config, retry writing it.") + hr.logger.Error().Err(err).Msg("failed to reload config, retry writing it.") continue } @@ -87,12 +89,12 @@ func (hr *HotReloader) Start() { hr.ctlr.Config.HTTP.Auth.LDAP.CredentialsFile != newConfig.HTTP.Auth.LDAP.CredentialsFile { err = hr.watcher.Remove(hr.ctlr.Config.HTTP.Auth.LDAP.CredentialsFile) if err != nil && !errors.Is(err, fsnotify.ErrNonExistentWatch) { - log.Error().Err(err).Msg("failed to remove old watch for the credentials file") + hr.logger.Error().Err(err).Msg("failed to remove old watch for the credentials file") } err = hr.watcher.Add(newConfig.HTTP.Auth.LDAP.CredentialsFile) if err != nil { - log.Panic().Err(err).Str("ldap-credentials-file", newConfig.HTTP.Auth.LDAP.CredentialsFile). + hr.logger.Panic().Err(err).Str("ldap-credentials-file", newConfig.HTTP.Auth.LDAP.CredentialsFile). Msg("failed to watch ldap credentials file") } } @@ -108,18 +110,18 @@ func (hr *HotReloader) Start() { } // watch for errors case err := <-hr.watcher.Errors: - log.Panic().Err(err).Str("config", hr.configPath).Msg("fsnotfy error while watching config") + hr.logger.Panic().Err(err).Str("config", hr.configPath).Msg("fsnotfy error while watching config") } } }() if err := hr.watcher.Add(hr.configPath); err != nil { - log.Panic().Err(err).Str("config", hr.configPath).Msg("failed to add config file to fsnotity watcher") + hr.logger.Panic().Err(err).Str("config", hr.configPath).Msg("failed to add config file to fsnotity watcher") } if hr.ldapCredentialsPath != "" { if err := hr.watcher.Add(hr.ldapCredentialsPath); err != nil { - log.Panic().Err(err).Str("ldap-credentials", hr.ldapCredentialsPath). + hr.logger.Panic().Err(err).Str("ldap-credentials", hr.ldapCredentialsPath). Msg("failed to add ldap-credentials to fsnotity watcher") } } diff --git a/pkg/cli/server/root.go b/pkg/cli/server/root.go index 2ce32f3c..693df286 100644 --- a/pkg/cli/server/root.go +++ b/pkg/cli/server/root.go @@ -17,7 +17,6 @@ import ( glob "github.com/bmatcuk/doublestar/v4" "github.com/go-viper/mapstructure/v2" distspec "github.com/opencontainers/distribution-spec/specs-go" - "github.com/rs/zerolog/log" "github.com/spf13/cobra" "github.com/spf13/viper" @@ -50,6 +49,8 @@ func newServeCmd(conf *config.Config) *cobra.Command { Long: "`serve` stores and distributes OCI images", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { + logger := zlog.NewLogger("info", "") + if len(args) > 0 { if err := LoadConfiguration(conf, args[0]); err != nil { return err @@ -82,7 +83,7 @@ func newServeCmd(conf *config.Config) *cobra.Command { initShutDownRoutine(ctlr) if err := ctlr.Run(); err != nil { - log.Error().Err(err).Msg("failed to start controller, exiting") + logger.Error().Err(err).Msg("failed to start controller, exiting") } return nil @@ -100,6 +101,8 @@ func newScrubCmd(conf *config.Config) *cobra.Command { Short: "`scrub` checks manifest/blob integrity", Long: "`scrub` checks manifest/blob integrity", RunE: func(cmd *cobra.Command, args []string) error { + logger := zlog.NewLogger("info", "") + if len(args) > 0 { if err := LoadConfiguration(conf, args[0]); err != nil { return err @@ -121,7 +124,7 @@ func newScrubCmd(conf *config.Config) *cobra.Command { fmt.Sprintf("http://%s/v2", net.JoinHostPort(conf.HTTP.Address, conf.HTTP.Port)), nil) if err != nil { - log.Error().Err(err).Msg("failed to create a new http request") + logger.Error().Err(err).Msg("failed to create a new http request") return err } @@ -129,7 +132,7 @@ func newScrubCmd(conf *config.Config) *cobra.Command { response, err := http.DefaultClient.Do(req) if err == nil { response.Body.Close() - log.Warn().Err(zerr.ErrServerIsRunning). + logger.Warn().Err(zerr.ErrServerIsRunning). Msg("server is running, in order to perform the scrub command the server should be shut down") return zerr.ErrServerIsRunning @@ -165,16 +168,18 @@ func newVerifyCmd(conf *config.Config) *cobra.Command { Short: "`verify` validates a zot config file", Long: "`verify` validates a zot config file", RunE: func(cmd *cobra.Command, args []string) error { + logger := zlog.NewLogger("info", "") + if len(args) > 0 { cmd.SilenceUsage = true if err := LoadConfiguration(conf, args[0]); err != nil { - log.Error().Str("config", args[0]).Msg("invalid config file") + logger.Error().Str("config", args[0]).Msg("invalid config file") return err } - log.Info().Str("config", args[0]).Msg("config file is valid") + logger.Info().Str("config", args[0]).Msg("config file is valid") } return nil @@ -194,8 +199,10 @@ func NewServerRootCmd() *cobra.Command { Short: "`zot`", Long: "`zot`", RunE: func(cmd *cobra.Command, args []string) error { + logger := zlog.NewLogger("info", "") + if showVersion { - log.Info().Str("distribution-spec", distspec.Version).Str("commit", config.Commit). + logger.Info().Str("distribution-spec", distspec.Version).Str("commit", config.Commit). Str("binary-type", config.BinaryType).Str("go version", config.GoVersion).Msg("version") } else { _ = cmd.Usage() @@ -218,7 +225,7 @@ func NewServerRootCmd() *cobra.Command { return rootCmd } -func validateStorageConfig(cfg *config.Config, log zlog.Logger) error { +func validateStorageConfig(cfg *config.Config, logger zlog.Logger) error { expConfigMap := make(map[string]config.StorageConfig, 0) defaultRootDir := cfg.Storage.RootDirectory @@ -226,7 +233,7 @@ func validateStorageConfig(cfg *config.Config, log zlog.Logger) error { for _, storageConfig := range cfg.Storage.SubPaths { if strings.EqualFold(defaultRootDir, storageConfig.RootDirectory) { msg := "invalid storage config, storage subpaths cannot use default storage root directory" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -236,7 +243,7 @@ func validateStorageConfig(cfg *config.Config, log zlog.Logger) error { equal := expConfig.ParamsEqual(storageConfig) if !equal { msg := "invalid storage config, storage config with same root directory should have same parameters" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -248,13 +255,13 @@ func validateStorageConfig(cfg *config.Config, log zlog.Logger) error { return nil } -func validateCacheConfig(cfg *config.Config, log zlog.Logger) error { +func validateCacheConfig(cfg *config.Config, logger zlog.Logger) error { // global // dedupe true, remote storage, remoteCache true, but no cacheDriver (remote) //nolint: lll if cfg.Storage.Dedupe && cfg.Storage.StorageDriver != nil && cfg.Storage.RemoteCache && cfg.Storage.CacheDriver == nil { msg := "invalid database config, dedupe set to true with remote storage and database, but no remote database configured" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -265,7 +272,7 @@ func validateCacheConfig(cfg *config.Config, log zlog.Logger) error { // redis is only supported with local storage in a non-clustering scenario with a single zot instance, if cfg.Storage.StorageDriver == nil && cfg.Storage.CacheDriver["name"] != storageConstants.RedisDriverName { msg := "invalid database config, cannot have local storage driver with remote database!" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -274,14 +281,14 @@ func validateCacheConfig(cfg *config.Config, log zlog.Logger) error { if cfg.Storage.CacheDriver["name"] != storageConstants.DynamoDBDriverName && cfg.Storage.CacheDriver["name"] != storageConstants.RedisDriverName { msg := "invalid database config, unsupported database driver" - log.Error().Err(zerr.ErrBadConfig).Interface("cacheDriver", cfg.Storage.CacheDriver["name"]).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Interface("cacheDriver", cfg.Storage.CacheDriver["name"]).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } } if !cfg.Storage.RemoteCache && cfg.Storage.CacheDriver != nil { - log.Warn().Err(zerr.ErrBadConfig).Str("directory", cfg.Storage.RootDirectory). + logger.Warn().Err(zerr.ErrBadConfig).Str("directory", cfg.Storage.RootDirectory). Msg("invalid database config, remoteCache set to false but cacheDriver config (remote database)" + " provided for directory will ignore and use local database") } @@ -292,7 +299,7 @@ func validateCacheConfig(cfg *config.Config, log zlog.Logger) error { //nolint: lll if subPath.Dedupe && subPath.StorageDriver != nil && subPath.RemoteCache && subPath.CacheDriver == nil { msg := "invalid database config, dedupe set to true with remote storage and database, but no remote database configured!" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -301,7 +308,7 @@ func validateCacheConfig(cfg *config.Config, log zlog.Logger) error { // local storage with remote caching if subPath.StorageDriver == nil { msg := "invalid database config, cannot have local storage driver with remote database!" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -309,14 +316,14 @@ func validateCacheConfig(cfg *config.Config, log zlog.Logger) error { // unsupported cache driver if subPath.CacheDriver["name"] != storageConstants.DynamoDBDriverName { msg := "invalid database config, unsupported database driver" - log.Error().Err(zerr.ErrBadConfig).Interface("cacheDriver", cfg.Storage.CacheDriver["name"]).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Interface("cacheDriver", cfg.Storage.CacheDriver["name"]).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } } if !subPath.RemoteCache && subPath.CacheDriver != nil { - log.Warn().Err(zerr.ErrBadConfig).Str("directory", cfg.Storage.RootDirectory). + logger.Warn().Err(zerr.ErrBadConfig).Str("directory", cfg.Storage.RootDirectory). Msg("invalid database config, remoteCache set to false but cacheDriver config (remote database)" + "provided for directory, will ignore and use local database") } @@ -325,13 +332,13 @@ func validateCacheConfig(cfg *config.Config, log zlog.Logger) error { return nil } -func validateExtensionsConfig(cfg *config.Config, log zlog.Logger) error { +func validateExtensionsConfig(cfg *config.Config, logger zlog.Logger) error { if cfg.Extensions != nil && cfg.Extensions.Mgmt != nil { - log.Warn().Msg("mgmt extensions configuration option has been made redundant and will be ignored.") + logger.Warn().Msg("mgmt extensions configuration option has been made redundant and will be ignored.") } if cfg.Extensions != nil && cfg.Extensions.APIKey != nil { - log.Warn().Msg("apikey extension configuration will be ignored as API keys " + + logger.Warn().Msg("apikey extension configuration will be ignored as API keys " + "are now configurable in the HTTP settings.") } @@ -340,7 +347,7 @@ func validateExtensionsConfig(cfg *config.Config, log zlog.Logger) error { // but those are both enabled by having the search and ui extensions enabled if cfg.Extensions.Search == nil || !*cfg.Extensions.Search.Enable { msg := "failed to enable ui, search extension must be enabled" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -350,7 +357,7 @@ func validateExtensionsConfig(cfg *config.Config, log zlog.Logger) error { if cfg.Storage.StorageDriver != nil && cfg.Extensions != nil && cfg.Extensions.Search != nil && cfg.Extensions.Search.Enable != nil && *cfg.Extensions.Search.Enable && cfg.Extensions.Search.CVE != nil { msg := "failed to enable cve scanning due to incompatibility with remote storage, please disable cve" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -360,7 +367,7 @@ func validateExtensionsConfig(cfg *config.Config, log zlog.Logger) error { if subPath.StorageDriver != nil && cfg.Extensions != nil && cfg.Extensions.Search != nil && cfg.Extensions.Search.Enable != nil && *cfg.Extensions.Search.Enable && cfg.Extensions.Search.CVE != nil { msg := "failed to enable cve scanning due to incompatibility with remote storage, please disable cve" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -369,43 +376,43 @@ func validateExtensionsConfig(cfg *config.Config, log zlog.Logger) error { return nil } -func validateConfiguration(config *config.Config, log zlog.Logger) error { - if err := validateHTTP(config, log); err != nil { +func validateConfiguration(config *config.Config, logger zlog.Logger) error { + if err := validateHTTP(config, logger); err != nil { return err } - if err := validateGC(config, log); err != nil { + if err := validateGC(config, logger); err != nil { return err } - if err := validateLDAP(config, log); err != nil { + if err := validateLDAP(config, logger); err != nil { return err } - if err := validateOpenIDConfig(config, log); err != nil { + if err := validateOpenIDConfig(config, logger); err != nil { return err } - if err := validateSync(config, log); err != nil { + if err := validateSync(config, logger); err != nil { return err } - if err := validateStorageConfig(config, log); err != nil { + if err := validateStorageConfig(config, logger); err != nil { return err } - if err := validateCacheConfig(config, log); err != nil { + if err := validateCacheConfig(config, logger); err != nil { return err } - if err := validateExtensionsConfig(config, log); err != nil { + if err := validateExtensionsConfig(config, logger); err != nil { return err } // check authorization config, it should have basic auth enabled or ldap, api keys or OpenID if config.HTTP.AccessControl != nil { // checking for anonymous policy only authorization config: no users, no policies but anonymous policy - if err := validateAuthzPolicies(config, log); err != nil { + if err := validateAuthzPolicies(config, logger); err != nil { return err } } @@ -414,7 +421,7 @@ func validateConfiguration(config *config.Config, log zlog.Logger) error { // enforce s3 driver in case of using storage driver if config.Storage.StorageDriver["name"] != storageConstants.S3StorageDriverName { msg := "unsupported storage driver" - log.Error().Err(zerr.ErrBadConfig).Interface("cacheDriver", config.Storage.StorageDriver["name"]).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Interface("cacheDriver", config.Storage.StorageDriver["name"]).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -422,7 +429,7 @@ func validateConfiguration(config *config.Config, log zlog.Logger) error { // enforce tmpDir in case sync + s3 if config.Extensions != nil && config.Extensions.Sync != nil && config.Extensions.Sync.DownloadDir == "" { msg := "using both sync and remote storage features needs config.Extensions.Sync.DownloadDir to be specified" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -437,7 +444,7 @@ func validateConfiguration(config *config.Config, log zlog.Logger) error { if len(storageConfig.StorageDriver) != 0 { if storageConfig.StorageDriver["name"] != storageConstants.S3StorageDriverName { msg := "unsupported storage driver" - log.Error().Err(zerr.ErrBadConfig).Str("subpath", route).Interface("storageDriver", + logger.Error().Err(zerr.ErrBadConfig).Str("subpath", route).Interface("storageDriver", storageConfig.StorageDriver["name"]).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) @@ -446,7 +453,7 @@ func validateConfiguration(config *config.Config, log zlog.Logger) error { // enforce tmpDir in case sync + s3 if config.Extensions != nil && config.Extensions.Sync != nil && config.Extensions.Sync.DownloadDir == "" { msg := "using both sync and remote storage features needs config.Extensions.Sync.DownloadDir to be specified" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -461,7 +468,7 @@ func validateConfiguration(config *config.Config, log zlog.Logger) error { ok := glob.ValidatePattern(pattern) if !ok { msg := "failed to compile authorization pattern" - log.Error().Err(glob.ErrBadPattern).Str("pattern", pattern).Msg(msg) + logger.Error().Err(glob.ErrBadPattern).Str("pattern", pattern).Msg(msg) return fmt.Errorf("%w: %s", glob.ErrBadPattern, msg) } @@ -469,14 +476,14 @@ func validateConfiguration(config *config.Config, log zlog.Logger) error { } // check validity of scale out cluster config - if err := validateClusterConfig(config, log); err != nil { + if err := validateClusterConfig(config, logger); err != nil { return err } return nil } -func validateOpenIDConfig(cfg *config.Config, log zlog.Logger) error { +func validateOpenIDConfig(cfg *config.Config, logger zlog.Logger) error { if cfg.HTTP.Auth != nil && cfg.HTTP.Auth.OpenID != nil { for provider, providerConfig := range cfg.HTTP.Auth.OpenID.Providers { //nolint: gocritic @@ -484,20 +491,20 @@ func validateOpenIDConfig(cfg *config.Config, log zlog.Logger) error { if providerConfig.ClientID == "" || providerConfig.Issuer == "" || len(providerConfig.Scopes) == 0 { msg := "OpenID provider config requires clientid, issuer and scopes parameters" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } } else if config.IsOauth2Supported(provider) { if providerConfig.ClientID == "" || len(providerConfig.Scopes) == 0 { msg := "OAuth2 provider config requires clientid and scopes parameters" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } } else { msg := "unsupported openid/oauth2 provider" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -507,12 +514,12 @@ func validateOpenIDConfig(cfg *config.Config, log zlog.Logger) error { return nil } -func validateAuthzPolicies(config *config.Config, log zlog.Logger) error { +func validateAuthzPolicies(config *config.Config, logger zlog.Logger) error { if (config.HTTP.Auth == nil || (config.HTTP.Auth.HTPasswd.Path == "" && config.HTTP.Auth.LDAP == nil && config.HTTP.Auth.OpenID == nil)) && !authzContainsOnlyAnonymousPolicy(config) { msg := "access control config requires one of httpasswd, ldap or openid authentication " + "or using only 'anonymousPolicy' policies" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -521,7 +528,7 @@ func validateAuthzPolicies(config *config.Config, log zlog.Logger) error { } //nolint:gocyclo,cyclop,nestif -func applyDefaultValues(config *config.Config, viperInstance *viper.Viper, log zlog.Logger) { +func applyDefaultValues(config *config.Config, viperInstance *viper.Viper, logger zlog.Logger) { defaultVal := true if config.Extensions == nil && viperInstance.Get("extensions") != nil { @@ -589,7 +596,7 @@ func applyDefaultValues(config *config.Config, viperInstance *viper.Viper, log z if config.Extensions.Search.CVE.UpdateInterval < defaultUpdateInterval { config.Extensions.Search.CVE.UpdateInterval = defaultUpdateInterval - log.Warn().Msg("cve update interval set to too-short interval < 2h, " + + logger.Warn().Msg("cve update interval set to too-short interval < 2h, " + "changing update duration to 2 hours and continuing.") } @@ -599,7 +606,7 @@ func applyDefaultValues(config *config.Config, viperInstance *viper.Viper, log z if config.Extensions.Search.CVE.Trivy.DBRepository == "" { defaultDBDownloadURL := "ghcr.io/aquasecurity/trivy-db" - log.Info().Str("url", defaultDBDownloadURL).Str("component", "config"). + logger.Info().Str("url", defaultDBDownloadURL).Str("component", "config"). Msg("using default trivy-db download URL.") config.Extensions.Search.CVE.Trivy.DBRepository = defaultDBDownloadURL @@ -607,7 +614,7 @@ func applyDefaultValues(config *config.Config, viperInstance *viper.Viper, log z if config.Extensions.Search.CVE.Trivy.JavaDBRepository == "" { defaultJavaDBDownloadURL := "ghcr.io/aquasecurity/trivy-java-db" - log.Info().Str("url", defaultJavaDBDownloadURL).Str("component", "config"). + logger.Info().Str("url", defaultJavaDBDownloadURL).Str("component", "config"). Msg("using default trivy-java-db download URL.") config.Extensions.Search.CVE.Trivy.JavaDBRepository = defaultJavaDBDownloadURL @@ -687,8 +694,8 @@ func applyDefaultValues(config *config.Config, viperInstance *viper.Viper, log z cachePath := path.Join(cacheDir, storageConstants.BoltdbName+storageConstants.DBExtensionName) if _, err := os.Stat(cachePath); err == nil { - log.Info().Str("component", "config").Msg("dedupe set to false for s3 driver but used to be true.") - log.Info().Str("cache path", cachePath).Msg("found cache database") + logger.Info().Str("component", "config").Msg("dedupe set to false for s3 driver but used to be true.") + logger.Info().Str("cache path", cachePath).Msg("found cache database") config.Storage.RemoteCache = false } @@ -702,7 +709,7 @@ func applyDefaultValues(config *config.Config, viperInstance *viper.Viper, log z _, hasForcePathStyle := config.Storage.StorageDriver["forcepathstyle"] if hasRegionEndpoint && !hasForcePathStyle { - log.Warn(). + logger.Warn(). Msg("deprecated: automatically setting forcepathstyle to true for s3 storage driver.") config.Storage.StorageDriver["forcepathstyle"] = true } @@ -723,8 +730,8 @@ func applyDefaultValues(config *config.Config, viperInstance *viper.Viper, log z subpathCachePath := path.Join(subpathCacheDir, storageConstants.BoltdbName+storageConstants.DBExtensionName) if _, err := os.Stat(subpathCachePath); err == nil { - log.Info().Str("component", "config").Msg("dedupe set to false for s3 driver but used to be true. ") - log.Info().Str("cache path", subpathCachePath).Msg("found cache database") + logger.Info().Str("component", "config").Msg("dedupe set to false for s3 driver but used to be true. ") + logger.Info().Str("cache path", subpathCachePath).Msg("found cache database") storageConfig.RemoteCache = false } @@ -768,18 +775,20 @@ func applyDefaultValues(config *config.Config, viperInstance *viper.Viper, log z } } -func updateDistSpecVersion(config *config.Config, log zlog.Logger) { +func updateDistSpecVersion(config *config.Config, logger zlog.Logger) { if config.DistSpecVersion == distspec.Version { return } - log.Warn().Str("config version", config.DistSpecVersion).Str("supported version", distspec.Version). + logger.Warn().Str("config version", config.DistSpecVersion).Str("supported version", distspec.Version). Msg("config dist-spec version differs from version actually used") config.DistSpecVersion = distspec.Version } func LoadConfiguration(config *config.Config, configPath string) error { + logger := zlog.NewLogger("info", "") + // Default is dot (.) but because we allow glob patterns in authz // we need another key delimiter. viperInstance := viper.NewWithOptions(viper.KeyDelimiter("::")) @@ -795,7 +804,7 @@ func LoadConfiguration(config *config.Config, configPath string) error { switch ext { case "": - log.Info().Str("path", configPath).Msg("config file with no extension, trying all supported config types") + logger.Info().Str("path", configPath).Msg("config file with no extension, trying all supported config types") var err error @@ -810,7 +819,7 @@ func LoadConfiguration(config *config.Config, configPath string) error { } if err != nil { - log.Error().Err(err).Str("path", configPath).Msg("failed to read configuration, tried all supported config types") + logger.Error().Err(err).Str("path", configPath).Msg("failed to read configuration, tried all supported config types") return err } @@ -818,7 +827,7 @@ func LoadConfiguration(config *config.Config, configPath string) error { viperInstance.SetConfigFile(configPath) if err := viperInstance.ReadInConfig(); err != nil { - log.Error().Err(err).Str("path", configPath).Msg("failed to read configuration") + logger.Error().Err(err).Str("path", configPath).Msg("failed to read configuration") return err } @@ -837,7 +846,7 @@ func LoadConfiguration(config *config.Config, configPath string) error { } if err := viperInstance.UnmarshalExact(&config, decoderOpts...); err != nil { - log.Error().Err(err).Msg("failed to unmarshal new config") + logger.Error().Err(err).Msg("failed to unmarshal new config") return err } @@ -846,32 +855,32 @@ func LoadConfiguration(config *config.Config, configPath string) error { if len(metaData.Keys) == 0 { msg := "failed to load config due to the absence of any key:value pair" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } if len(metaData.Unused) > 0 { msg := "failed to load config due to unknown keys" - log.Error().Err(zerr.ErrBadConfig).Strs("keys", metaData.Unused).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Strs("keys", metaData.Unused).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } if err := updateLDAPConfig(config); err != nil { - log.Error().Err(err).Msg("failed to read ldap config file") + logger.Error().Err(err).Msg("failed to read ldap config file") return err } if err := updateOpenIDConfig(config); err != nil { - log.Error().Err(err).Msg("failed to read openid provider config file(s)") + logger.Error().Err(err).Msg("failed to read openid provider config file(s)") return err } if err := loadSessionKeys(config); err != nil { - log.Error().Err(err).Msg("failed to read sessionKeysFile") + logger.Error().Err(err).Msg("failed to read sessionKeysFile") return err } @@ -934,6 +943,8 @@ func updateLDAPConfig(conf *config.Config) error { } func updateOpenIDConfig(conf *config.Config) error { + logger := zlog.NewLogger("info", "") + if conf.HTTP.Auth == nil || conf.HTTP.Auth.OpenID == nil { return nil } @@ -951,7 +962,7 @@ func updateOpenIDConfig(conf *config.Config) error { conf.HTTP.Auth.OpenID.Providers[name] = provider } else { - log.Warn().Str("provider", name). + logger.Warn().Str("provider", name). Msg("deprecated: use the new OpenID provider credentialsfile instead of clientid and clientsecret.") } } @@ -960,40 +971,42 @@ func updateOpenIDConfig(conf *config.Config) error { } func readSecretFile(path string, v any, checkUnsetFields bool) error { //nolint: varnamelen + logger := zlog.NewLogger("info", "") + viperInstance := viper.NewWithOptions(viper.KeyDelimiter("::")) viperInstance.SetConfigFile(path) if err := viperInstance.ReadInConfig(); err != nil { - log.Error().Err(err).Str("path", path).Msg("failed to read secret file configuration") + logger.Error().Err(err).Str("path", path).Msg("failed to read secret file configuration") return errors.Join(zerr.ErrBadConfig, err) } metaData := &mapstructure.Metadata{} if err := viperInstance.Unmarshal(v, metadataConfig(metaData)); err != nil { - log.Error().Err(err).Str("path", path).Msg("failed to unmarshal secret file config") + logger.Error().Err(err).Str("path", path).Msg("failed to unmarshal secret file config") return errors.Join(zerr.ErrBadConfig, err) } if len(metaData.Keys) == 0 { msg := "failed to load secret file due to the absence of any key:value pair" - log.Error().Err(zerr.ErrBadConfig).Str("path", path).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Str("path", path).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } if len(metaData.Unused) > 0 { msg := "failed to load secret file due to unknown keys" - log.Error().Err(zerr.ErrBadConfig).Str("path", path).Strs("keys", metaData.Unused).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Str("path", path).Strs("keys", metaData.Unused).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } if checkUnsetFields && len(metaData.Unset) > 0 { msg := "failed to load secret file due to unset keys" - log.Error().Err(zerr.ErrBadConfig).Strs("keys", metaData.Unset).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Strs("keys", metaData.Unset).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -1002,34 +1015,36 @@ func readSecretFile(path string, v any, checkUnsetFields bool) error { //nolint: } func authzContainsOnlyAnonymousPolicy(cfg *config.Config) bool { + logger := zlog.NewLogger("info", "") + adminPolicy := cfg.HTTP.AccessControl.AdminPolicy anonymousPolicyPresent := false - log.Info().Msg("checking if anonymous authorization is the only type of authorization policy configured") + logger.Info().Msg("checking if anonymous authorization is the only type of authorization policy configured") if len(adminPolicy.Actions)+len(adminPolicy.Users) > 0 { - log.Info().Msg("admin policy detected, anonymous authorization is not the only authorization policy configured") + logger.Info().Msg("admin policy detected, anonymous authorization is not the only authorization policy configured") return false } for _, repository := range cfg.HTTP.AccessControl.Repositories { if len(repository.DefaultPolicy) > 0 { - log.Info().Interface("repository", repository). + logger.Info().Interface("repository", repository). Msg("default policy detected, anonymous authorization is not the only authorization policy configured") return false } if len(repository.AnonymousPolicy) > 0 { - log.Info().Msg("anonymous authorization detected") + logger.Info().Msg("anonymous authorization detected") anonymousPolicyPresent = true } for _, policy := range repository.Policies { if len(policy.Actions)+len(policy.Users) > 0 { - log.Info().Interface("repository", repository). + logger.Info().Interface("repository", repository). Msg("repository with non-empty policy detected, " + "anonymous authorization is not the only authorization policy configured") @@ -1041,27 +1056,27 @@ func authzContainsOnlyAnonymousPolicy(cfg *config.Config) bool { return anonymousPolicyPresent } -func validateLDAP(config *config.Config, log zlog.Logger) error { +func validateLDAP(config *config.Config, logger zlog.Logger) error { // LDAP mandatory configuration if config.HTTP.Auth != nil && config.HTTP.Auth.LDAP != nil { ldap := config.HTTP.Auth.LDAP if ldap.UserAttribute == "" { msg := "invalid LDAP configuration, missing mandatory key: userAttribute" - log.Error().Str("userAttribute", ldap.UserAttribute).Msg(msg) + logger.Error().Str("userAttribute", ldap.UserAttribute).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrLDAPConfig, msg) } if ldap.Address == "" { msg := "invalid LDAP configuration, missing mandatory key: address" - log.Error().Str("address", ldap.Address).Msg(msg) + logger.Error().Str("address", ldap.Address).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrLDAPConfig, msg) } if ldap.BaseDN == "" { msg := "invalid LDAP configuration, missing mandatory key: basedn" - log.Error().Str("basedn", ldap.BaseDN).Msg(msg) + logger.Error().Str("basedn", ldap.BaseDN).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrLDAPConfig, msg) } @@ -1070,11 +1085,11 @@ func validateLDAP(config *config.Config, log zlog.Logger) error { return nil } -func validateHTTP(config *config.Config, log zlog.Logger) error { +func validateHTTP(config *config.Config, logger zlog.Logger) error { if config.HTTP.Port != "" { port, err := strconv.ParseInt(config.HTTP.Port, 10, 64) if err != nil || (port < 0 || port > 65535) { - log.Error().Str("port", config.HTTP.Port).Msg("invalid port") + logger.Error().Str("port", config.HTTP.Port).Msg("invalid port") return fmt.Errorf("%w: invalid port %s", zerr.ErrBadConfig, config.HTTP.Port) } @@ -1083,10 +1098,10 @@ func validateHTTP(config *config.Config, log zlog.Logger) error { return nil } -func validateGC(config *config.Config, log zlog.Logger) error { +func validateGC(config *config.Config, logger zlog.Logger) error { // enforce GC params if config.Storage.GCDelay < 0 { - log.Error().Err(zerr.ErrBadConfig).Dur("delay", config.Storage.GCDelay). + logger.Error().Err(zerr.ErrBadConfig).Dur("delay", config.Storage.GCDelay). Msg("invalid garbage-collect delay specified") return fmt.Errorf("%w: invalid garbage-collect delay specified %s", @@ -1094,7 +1109,7 @@ func validateGC(config *config.Config, log zlog.Logger) error { } if config.Storage.GCInterval < 0 { - log.Error().Err(zerr.ErrBadConfig).Dur("interval", config.Storage.GCInterval). + logger.Error().Err(zerr.ErrBadConfig).Dur("interval", config.Storage.GCInterval). Msg("invalid garbage-collect interval specified") return fmt.Errorf("%w: invalid garbage-collect interval specified %s", @@ -1103,24 +1118,24 @@ func validateGC(config *config.Config, log zlog.Logger) error { if !config.Storage.GC { if config.Storage.GCDelay != 0 { - log.Warn().Err(zerr.ErrBadConfig). + logger.Warn().Err(zerr.ErrBadConfig). Msg("garbage-collect delay specified without enabling garbage-collect, will be ignored") } if config.Storage.GCInterval != 0 { - log.Warn().Err(zerr.ErrBadConfig). + logger.Warn().Err(zerr.ErrBadConfig). Msg("periodic garbage-collect interval specified without enabling garbage-collect, will be ignored") } } - if err := validateGCRules(config.Storage.Retention, log); err != nil { + if err := validateGCRules(config.Storage.Retention, logger); err != nil { return err } // subpaths for name, subPath := range config.Storage.SubPaths { if subPath.GC && subPath.GCDelay <= 0 { - log.Error().Err(zerr.ErrBadConfig). + logger.Error().Err(zerr.ErrBadConfig). Str("subPath", name). Interface("gcDelay", subPath.GCDelay). Msg("invalid GC delay configuration - cannot be negative or zero") @@ -1129,7 +1144,7 @@ func validateGC(config *config.Config, log zlog.Logger) error { zerr.ErrBadConfig, subPath.GCDelay) } - if err := validateGCRules(subPath.Retention, log); err != nil { + if err := validateGCRules(subPath.Retention, logger); err != nil { return err } } @@ -1137,11 +1152,11 @@ func validateGC(config *config.Config, log zlog.Logger) error { return nil } -func validateGCRules(retention config.ImageRetention, log zlog.Logger) error { +func validateGCRules(retention config.ImageRetention, logger zlog.Logger) error { for _, policy := range retention.Policies { for _, pattern := range policy.Repositories { if ok := glob.ValidatePattern(pattern); !ok { - log.Error().Err(glob.ErrBadPattern).Str("pattern", pattern). + logger.Error().Err(glob.ErrBadPattern).Str("pattern", pattern). Msg("retention repo glob pattern could not be compiled") return fmt.Errorf("%w: retention repo glob pattern could not be compiled: %s", @@ -1153,7 +1168,7 @@ func validateGCRules(retention config.ImageRetention, log zlog.Logger) error { for _, regex := range tagRule.Patterns { _, err := regexp.Compile(regex) if err != nil { - log.Error().Err(glob.ErrBadPattern).Str("regex", regex). + logger.Error().Err(glob.ErrBadPattern).Str("regex", regex). Msg("retention tag regex could not be compiled") return fmt.Errorf("%w: retention tag regex could not be compiled: %s", @@ -1166,14 +1181,14 @@ func validateGCRules(retention config.ImageRetention, log zlog.Logger) error { return nil } -func validateSync(config *config.Config, log zlog.Logger) error { +func validateSync(config *config.Config, logger zlog.Logger) error { // check glob patterns in sync config are compilable if config.Extensions != nil && config.Extensions.Sync != nil { for regID, regCfg := range config.Extensions.Sync.Registries { // check retry options are configured for sync if regCfg.MaxRetries != nil && regCfg.RetryDelay == nil { msg := "retryDelay is required when using maxRetries" - log.Error().Err(zerr.ErrBadConfig).Int("id", regID).Interface("extensions.sync.registries[id]", + logger.Error().Err(zerr.ErrBadConfig).Int("id", regID).Interface("extensions.sync.registries[id]", config.Extensions.Sync.Registries[regID]).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) @@ -1182,7 +1197,7 @@ func validateSync(config *config.Config, log zlog.Logger) error { // check preserveDigest without compat if regCfg.PreserveDigest && !config.IsCompatEnabled() { msg := "can not use PreserveDigest option without enabling http.Compat" - log.Error().Err(zerr.ErrBadConfig).Int("id", regID).Interface("extensions.sync.registries[id]", + logger.Error().Err(zerr.ErrBadConfig).Int("id", regID).Interface("extensions.sync.registries[id]", config.Extensions.Sync.Registries[regID]).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) @@ -1193,7 +1208,7 @@ func validateSync(config *config.Config, log zlog.Logger) error { ok := glob.ValidatePattern(content.Prefix) if !ok { msg := "sync prefix could not be compiled" - log.Error().Err(glob.ErrBadPattern).Str("prefix", content.Prefix).Msg(msg) + logger.Error().Err(glob.ErrBadPattern).Str("prefix", content.Prefix).Msg(msg) return fmt.Errorf("%w: %s: %s", zerr.ErrBadConfig, msg, content.Prefix) } @@ -1202,7 +1217,7 @@ func validateSync(config *config.Config, log zlog.Logger) error { _, err := regexp.Compile(*content.Tags.Regex) if err != nil { msg := "sync content regex could not be compiled" - log.Error().Err(glob.ErrBadPattern).Str("regex", *content.Tags.Regex).Msg(msg) + logger.Error().Err(glob.ErrBadPattern).Str("regex", *content.Tags.Regex).Msg(msg) return fmt.Errorf("%w: %s: %s", zerr.ErrBadConfig, msg, *content.Tags.Regex) } @@ -1212,7 +1227,7 @@ func validateSync(config *config.Config, log zlog.Logger) error { _, err := regexp.Compile(*content.Tags.ExcludeRegex) if err != nil { msg := "sync content excludeRegex could not be compiled" - log.Error().Err(glob.ErrBadPattern).Str("excludeRegex", *content.Tags.ExcludeRegex).Msg(msg) + logger.Error().Err(glob.ErrBadPattern).Str("excludeRegex", *content.Tags.ExcludeRegex).Msg(msg) return fmt.Errorf("%w: %s: %s", zerr.ErrBadConfig, msg, *content.Tags.ExcludeRegex) } @@ -1220,14 +1235,14 @@ func validateSync(config *config.Config, log zlog.Logger) error { if content.StripPrefix && !strings.Contains(content.Prefix, "/*") && content.Destination == "/" { msg := "can not use stripPrefix true and destination '/' without using glob patterns in prefix" - log.Error().Err(zerr.ErrBadConfig). + logger.Error().Err(zerr.ErrBadConfig). Interface("sync content", content).Str("component", "sync").Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } // check sync config doesn't overlap with retention config - validateRetentionSyncOverlaps(config, content, regCfg.URLs, log) + validateRetentionSyncOverlaps(config, content, regCfg.URLs, logger) } } } @@ -1236,11 +1251,11 @@ func validateSync(config *config.Config, log zlog.Logger) error { return nil } -func validateClusterConfig(config *config.Config, log zlog.Logger) error { +func validateClusterConfig(config *config.Config, logger zlog.Logger) error { if config.Cluster != nil { if len(config.Cluster.Members) == 0 { msg := "cannot have 0 members in a scale out cluster" - log.Error().Err(zerr.ErrBadConfig).Msg(msg) + logger.Error().Err(zerr.ErrBadConfig).Msg(msg) return fmt.Errorf("%w: %s", zerr.ErrBadConfig, msg) } @@ -1250,7 +1265,7 @@ func validateClusterConfig(config *config.Config, log zlog.Logger) error { allowedHashKeyLength := 16 if len(config.Cluster.HashKey) != allowedHashKeyLength { msg := fmt.Sprintf("hashKey for scale out cluster must have %d characters", allowedHashKeyLength) - log.Error().Err(zerr.ErrBadConfig). + logger.Error().Err(zerr.ErrBadConfig). Str("hashkey", config.Cluster.HashKey). Msg(msg) diff --git a/pkg/debug/pprof/pprof.go b/pkg/debug/pprof/pprof.go index c2e6bd94..c722f106 100644 --- a/pkg/debug/pprof/pprof.go +++ b/pkg/debug/pprof/pprof.go @@ -95,7 +95,7 @@ func SetupPprofRoutes(conf *config.Config, router *mux.Router, authFunc mux.Midd }) if err := indexTmplExecute(w, profiles); err != nil { - log.Print(err) + log.Error().Err(err).Msg("unexpected failure") } })) } diff --git a/pkg/exporter/cli/cli.go b/pkg/exporter/cli/cli.go index f3502f4a..421d3f8c 100644 --- a/pkg/exporter/cli/cli.go +++ b/pkg/exporter/cli/cli.go @@ -5,12 +5,12 @@ package cli import ( "github.com/go-viper/mapstructure/v2" - "github.com/rs/zerolog/log" "github.com/spf13/cobra" "github.com/spf13/viper" zerr "zotregistry.dev/zot/errors" "zotregistry.dev/zot/pkg/exporter/api" + "zotregistry.dev/zot/pkg/log" ) // metadataConfig reports metadata after parsing, which we use to track @@ -59,21 +59,23 @@ func NewExporterCmd() *cobra.Command { func loadConfiguration(config *api.Config, configPath string) { viper.SetConfigFile(configPath) + logger := log.NewLogger("info", "") + if err := viper.ReadInConfig(); err != nil { - log.Panic().Err(err).Str("config", configPath).Msg("failed to read configuration") + logger.Panic().Err(err).Str("config", configPath).Msg("failed to read configuration") } metaData := &mapstructure.Metadata{} if err := viper.Unmarshal(&config, metadataConfig(metaData)); err != nil { - log.Panic().Err(err).Str("config", configPath).Msg("failed to unmarshal config") + logger.Panic().Err(err).Str("config", configPath).Msg("failed to unmarshal config") } if len(metaData.Keys) == 0 { - log.Panic().Err(zerr.ErrBadConfig).Str("config", configPath).Msg("bad configuration") + logger.Panic().Err(zerr.ErrBadConfig).Str("config", configPath).Msg("bad configuration") } if len(metaData.Unused) > 0 { - log.Panic().Err(zerr.ErrBadConfig).Interface("unknown fields", metaData.Unused). + logger.Panic().Err(zerr.ErrBadConfig).Interface("unknown fields", metaData.Unused). Str("config", configPath).Msg("bad configuration") } } diff --git a/pkg/extensions/events/events_test.go b/pkg/extensions/events/events_test.go index 2f358d36..2b5024c1 100644 --- a/pkg/extensions/events/events_test.go +++ b/pkg/extensions/events/events_test.go @@ -48,7 +48,7 @@ func newMockSink() *mockSink { func TestEventSinkMissing(t *testing.T) { Convey("missing sink", t, func() { - _, err := events.NewRecorder(log.NewLogger("debug", "")) + _, err := events.NewRecorder(log.NewTestLogger()) So(err, ShouldNotBeNil) So(err, ShouldEqual, zerr.ErrEventSinkIsNil) }) @@ -57,7 +57,7 @@ func TestEventSinkMissing(t *testing.T) { func TestEvents(t *testing.T) { Convey("emits events", t, func() { sink := newMockSink() - recorder, err := events.NewRecorder(log.NewLogger("debug", ""), sink) + recorder, err := events.NewRecorder(log.NewTestLogger(), sink) So(err, ShouldBeNil) Convey("repository created", func() { recorder.RepositoryCreated("test") @@ -108,7 +108,7 @@ func TestHTTPSinkEvents(t *testing.T) { sink, err := events.NewHTTPSink(config) So(err, ShouldBeNil) - recorder, err := events.NewRecorder(log.NewLogger("debug", ""), sink) + recorder, err := events.NewRecorder(log.NewTestLogger(), sink) So(err, ShouldBeNil) Convey("repository created", func() { @@ -276,7 +276,7 @@ func createRecorder(t *testing.T, natsURL, testChannel string) (events.Recorder, return nil, err } - recorder, err := events.NewRecorder(log.NewLogger("debug", ""), sink) + recorder, err := events.NewRecorder(log.NewTestLogger(), sink) if err != nil { return nil, err } diff --git a/pkg/extensions/extension_image_trust_test.go b/pkg/extensions/extension_image_trust_test.go index 16a0bd4e..4373465f 100644 --- a/pkg/extensions/extension_image_trust_test.go +++ b/pkg/extensions/extension_image_trust_test.go @@ -49,7 +49,7 @@ func (errReader) Read(p []byte) (int, error) { func TestSignatureHandlers(t *testing.T) { conf := config.New() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() trust := extensions.ImageTrust{ Conf: conf, @@ -209,9 +209,8 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ defer os.Remove(logFile.Name()) // cleanup So(err, ShouldBeNil) - logger := log.NewLogger("debug", logFile.Name()) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) + logger := log.NewLoggerWithWriter("debug", writers) imageStore := local.NewImageStore(globalDir, false, false, logger, monitoring.NewMetricsServer(false, logger), nil, nil, nil, nil) @@ -225,7 +224,7 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ So(err, ShouldBeNil) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctlr.Config.Storage.RootDirectory = globalDir @@ -330,9 +329,8 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ defer os.Remove(logFile.Name()) // cleanup So(err, ShouldBeNil) - logger := log.NewLogger("debug", logFile.Name()) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) + logger := log.NewLoggerWithWriter("debug", writers) imageStore := local.NewImageStore(globalDir, false, false, logger, monitoring.NewMetricsServer(false, logger), nil, nil, nil, nil) @@ -346,7 +344,7 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ So(err, ShouldBeNil) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctlr.Config.Storage.RootDirectory = globalDir @@ -438,9 +436,8 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ defer os.Remove(logFile.Name()) // cleanup So(err, ShouldBeNil) - logger := log.NewLogger("debug", logFile.Name()) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) + logger := log.NewLoggerWithWriter("debug", writers) imageStore := local.NewImageStore(globalDir, false, false, logger, monitoring.NewMetricsServer(false, logger), nil, nil, nil, nil) @@ -454,7 +451,7 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ So(err, ShouldBeNil) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctlr.Config.Storage.RootDirectory = globalDir @@ -601,9 +598,8 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ defer os.Remove(logFile.Name()) // cleanup So(err, ShouldBeNil) - logger := log.NewLogger("debug", logFile.Name()) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) + logger := log.NewLoggerWithWriter("debug", writers) imageStore := local.NewImageStore(globalDir, false, false, logger, monitoring.NewMetricsServer(false, logger), nil, nil, nil, nil) @@ -617,7 +613,7 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ So(err, ShouldBeNil) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctlr.Config.Storage.RootDirectory = globalDir @@ -779,12 +775,10 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ defer os.Remove(logFile.Name()) // cleanup So(err, ShouldBeNil) - logger := log.NewLogger("debug", logFile.Name()) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctlr.Config.Storage.RootDirectory = globalDir @@ -865,9 +859,8 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ defer os.Remove(logFile.Name()) // cleanup So(err, ShouldBeNil) - logger := log.NewLogger("debug", logFile.Name()) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) + logger := log.NewLoggerWithWriter("debug", writers) imageStore := local.NewImageStore(globalDir, false, false, logger, monitoring.NewMetricsServer(false, logger), nil, nil, nil, nil) @@ -892,7 +885,7 @@ func RunSignatureUploadAndVerificationTests(t *testing.T, cacheDriverParams map[ So(err, ShouldBeNil) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctlr.Config.Storage.RootDirectory = globalDir diff --git a/pkg/extensions/extension_ui_test.go b/pkg/extensions/extension_ui_test.go index c011589b..8f30587f 100644 --- a/pkg/extensions/extension_ui_test.go +++ b/pkg/extensions/extension_ui_test.go @@ -16,6 +16,7 @@ import ( "zotregistry.dev/zot/pkg/api" "zotregistry.dev/zot/pkg/api/config" extconf "zotregistry.dev/zot/pkg/extensions/config" + "zotregistry.dev/zot/pkg/log" test "zotregistry.dev/zot/pkg/test/common" . "zotregistry.dev/zot/pkg/test/image-utils" ) @@ -46,7 +47,7 @@ func TestUIExtension(t *testing.T) { conf.Storage.RootDirectory = t.TempDir() ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctlrManager := test.NewControllerManager(ctlr) ctlrManager.StartAndWait(port) diff --git a/pkg/extensions/extension_userprefs_test.go b/pkg/extensions/extension_userprefs_test.go index 85c30e79..042fc81b 100644 --- a/pkg/extensions/extension_userprefs_test.go +++ b/pkg/extensions/extension_userprefs_test.go @@ -63,7 +63,7 @@ func TestAllowedMethodsHeaderUserPrefs(t *testing.T) { func TestHandlers(t *testing.T) { const UserprefsBaseURL = "http://127.0.0.1:8080/v2/_zot/ext/userprefs" - log := log.NewLogger("debug", "") + log := log.NewTestLogger() mockmetaDB := mocks.MetaDBMock{} Convey("No repo in request", t, func() { diff --git a/pkg/extensions/imagetrust/image_trust_test.go b/pkg/extensions/imagetrust/image_trust_test.go index bfad641b..c0baafdd 100644 --- a/pkg/extensions/imagetrust/image_trust_test.go +++ b/pkg/extensions/imagetrust/image_trust_test.go @@ -41,6 +41,7 @@ import ( zcommon "zotregistry.dev/zot/pkg/common" extconf "zotregistry.dev/zot/pkg/extensions/config" "zotregistry.dev/zot/pkg/extensions/imagetrust" + "zotregistry.dev/zot/pkg/log" test "zotregistry.dev/zot/pkg/test/common" . "zotregistry.dev/zot/pkg/test/image-utils" "zotregistry.dev/zot/pkg/test/mocks" @@ -1234,7 +1235,7 @@ func RunVerificationTests(t *testing.T, dbDriverParams map[string]interface{}) { conf.Extensions.Trust.Notation = defaultValue ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctlr.Config.Storage.RootDirectory = rootDir cm := test.NewControllerManager(ctlr) diff --git a/pkg/extensions/lint/lint_test.go b/pkg/extensions/lint/lint_test.go index 5309a3af..b3544361 100644 --- a/pkg/extensions/lint/lint_test.go +++ b/pkg/extensions/lint/lint_test.go @@ -481,15 +481,15 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { dir := t.TempDir() - testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateRandomImage(), "zot-test", "0.0.1", testStoreCtlr) So(err, ShouldBeNil) var index ispec.Index - linter := lint.NewLinter(lintConfig, log.NewLogger("debug", "")) + linter := lint.NewLinter(lintConfig, log.NewTestLogger()) imgStore := local.NewImageStore(dir, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), linter, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), linter, nil, nil, nil) indexContent, err := imgStore.GetIndexContent("zot-test") So(err, ShouldBeNil) @@ -513,15 +513,15 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { dir := t.TempDir() - testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateRandomImage(), "zot-test", "0.0.1", testStoreCtlr) So(err, ShouldBeNil) var index ispec.Index - linter := lint.NewLinter(lintConfig, log.NewLogger("debug", "")) + linter := lint.NewLinter(lintConfig, log.NewTestLogger()) imgStore := local.NewImageStore(dir, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), linter, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), linter, nil, nil, nil) indexContent, err := imgStore.GetIndexContent("zot-test") So(err, ShouldBeNil) @@ -545,7 +545,7 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { dir := t.TempDir() - testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateRandomImage(), "zot-test", "0.0.1", testStoreCtlr) So(err, ShouldBeNil) @@ -589,9 +589,9 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { index.Manifests = append(index.Manifests, manifestDesc) - linter := lint.NewLinter(lintConfig, log.NewLogger("debug", "")) + linter := lint.NewLinter(lintConfig, log.NewTestLogger()) imgStore := local.NewImageStore(dir, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), linter, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), linter, nil, nil, nil) pass, err := linter.CheckMandatoryAnnotations("zot-test", digest, imgStore) So(err, ShouldBeNil) @@ -608,7 +608,7 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { dir := t.TempDir() - testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateRandomImage(), "zot-test", "0.0.1", testStoreCtlr) So(err, ShouldBeNil) @@ -651,9 +651,9 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { index.Manifests = append(index.Manifests, manifestDesc) - linter := lint.NewLinter(lintConfig, log.NewLogger("debug", "")) + linter := lint.NewLinter(lintConfig, log.NewTestLogger()) imgStore := local.NewImageStore(dir, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), linter, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), linter, nil, nil, nil) pass, err := linter.CheckMandatoryAnnotations("zot-test", digest, imgStore) So(err, ShouldNotBeNil) @@ -670,7 +670,7 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { dir := t.TempDir() - testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateRandomImage(), "zot-test", "0.0.1", testStoreCtlr) So(err, ShouldBeNil) @@ -715,9 +715,9 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { index.Manifests = append(index.Manifests, manifestDesc) - linter := lint.NewLinter(lintConfig, log.NewLogger("debug", "")) + linter := lint.NewLinter(lintConfig, log.NewTestLogger()) imgStore := local.NewImageStore(dir, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), linter, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), linter, nil, nil, nil) pass, err := linter.CheckMandatoryAnnotations("zot-test", digest, imgStore) So(err, ShouldBeNil) @@ -734,7 +734,7 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { dir := t.TempDir() - testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateRandomImage(), "zot-test", "0.0.1", testStoreCtlr) So(err, ShouldBeNil) @@ -778,9 +778,9 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { index.Manifests = append(index.Manifests, manifestDesc) - linter := lint.NewLinter(lintConfig, log.NewLogger("debug", "")) + linter := lint.NewLinter(lintConfig, log.NewTestLogger()) imgStore := local.NewImageStore(dir, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), linter, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), linter, nil, nil, nil) err = os.Chmod(path.Join(dir, "zot-test", "blobs"), 0o000) if err != nil { @@ -807,7 +807,7 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { dir := t.TempDir() - testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + testStoreCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateRandomImage(), "zot-test", "0.0.1", testStoreCtlr) So(err, ShouldBeNil) @@ -876,9 +876,9 @@ func TestVerifyMandatoryAnnotationsFunction(t *testing.T) { index.Manifests = append(index.Manifests, manifestDesc) - linter := lint.NewLinter(lintConfig, log.NewLogger("debug", "")) + linter := lint.NewLinter(lintConfig, log.NewTestLogger()) imgStore := local.NewImageStore(dir, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), linter, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), linter, nil, nil, nil) err = os.Chmod(path.Join(dir, "zot-test", "blobs", "sha256", manifest.Config.Digest.Encoded()), 0o000) if err != nil { diff --git a/pkg/extensions/monitoring/monitoring_test.go b/pkg/extensions/monitoring/monitoring_test.go index cd68e90f..d22c9032 100644 --- a/pkg/extensions/monitoring/monitoring_test.go +++ b/pkg/extensions/monitoring/monitoring_test.go @@ -20,6 +20,7 @@ import ( "zotregistry.dev/zot/pkg/api/config" extconf "zotregistry.dev/zot/pkg/extensions/config" "zotregistry.dev/zot/pkg/extensions/monitoring" + "zotregistry.dev/zot/pkg/log" "zotregistry.dev/zot/pkg/scheduler" common "zotregistry.dev/zot/pkg/storage/common" test "zotregistry.dev/zot/pkg/test/common" @@ -450,7 +451,7 @@ func TestPopulateStorageMetrics(t *testing.T) { ctlr := api.NewController(conf) So(ctlr, ShouldNotBeNil) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) cm := test.NewControllerManager(ctlr) cm.StartAndWait(port) diff --git a/pkg/extensions/scrub/scrub_test.go b/pkg/extensions/scrub/scrub_test.go index f9d0e137..81304ad7 100644 --- a/pkg/extensions/scrub/scrub_test.go +++ b/pkg/extensions/scrub/scrub_test.go @@ -63,7 +63,7 @@ func TestScrubExtension(t *testing.T) { ctlr := api.NewController(conf) - srcStorageCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + srcStorageCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err = WriteImageToFileSystem(CreateDefaultVulnerableImage(), repoName, "0.0.1", srcStorageCtlr) So(err, ShouldBeNil) @@ -105,7 +105,7 @@ func TestScrubExtension(t *testing.T) { ctlr := api.NewController(conf) - srcStorageCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + srcStorageCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) image := CreateDefaultVulnerableImage() err = WriteImageToFileSystem(image, repoName, "0.0.1", srcStorageCtlr) So(err, ShouldBeNil) @@ -155,7 +155,7 @@ func TestScrubExtension(t *testing.T) { ctlr := api.NewController(conf) - srcStorageCtlr := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + srcStorageCtlr := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) image := CreateDefaultVulnerableImage() err = WriteImageToFileSystem(image, repoName, "0.0.1", srcStorageCtlr) diff --git a/pkg/extensions/search/convert/convert_internal_test.go b/pkg/extensions/search/convert/convert_internal_test.go index 6a265cf4..b75ee28d 100644 --- a/pkg/extensions/search/convert/convert_internal_test.go +++ b/pkg/extensions/search/convert/convert_internal_test.go @@ -29,7 +29,7 @@ func TestCVEConvert(t *testing.T) { boltDB, err := boltdb.GetBoltDriver(params) So(err, ShouldBeNil) - metaDB, err := boltdb.New(boltDB, log.NewLogger("debug", "")) + metaDB, err := boltdb.New(boltDB, log.NewTestLogger()) So(err, ShouldBeNil) image := CreateImageWith(). diff --git a/pkg/extensions/search/convert/convert_test.go b/pkg/extensions/search/convert/convert_test.go index 9e4106c9..c5d1a374 100644 --- a/pkg/extensions/search/convert/convert_test.go +++ b/pkg/extensions/search/convert/convert_test.go @@ -282,7 +282,7 @@ func TestPaginatedConvert(t *testing.T) { t.FailNow() } - metaDB, err := boltdb.New(driver, log.NewLogger("debug", "")) + metaDB, err := boltdb.New(driver, log.NewTestLogger()) if err != nil { t.FailNow() } @@ -585,7 +585,7 @@ func TestIndexAnnotations(t *testing.T) { t.FailNow() } - metaDB, err := boltdb.New(driver, log.NewLogger("debug", "")) + metaDB, err := boltdb.New(driver, log.NewTestLogger()) So(err, ShouldBeNil) defaultCreatedTime := *DefaultTimeRef() @@ -840,7 +840,7 @@ func TestIndexAnnotations(t *testing.T) { func TestConvertErrors(t *testing.T) { ctx := context.Background() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("Errors", t, func() { Convey("RepoMeta2ExpandedRepoInfo", func() { diff --git a/pkg/extensions/search/cve/cve_test.go b/pkg/extensions/search/cve/cve_test.go index e49394b1..5a8aef49 100644 --- a/pkg/extensions/search/cve/cve_test.go +++ b/pkg/extensions/search/cve/cve_test.go @@ -85,7 +85,7 @@ func testSetup(t *testing.T) (string, error) { return "", err } - testStorageCtrl := ociutils.GetDefaultStoreController(dir, log.NewLogger("debug", "")) + testStorageCtrl := ociutils.GetDefaultStoreController(dir, log.NewTestLogger()) err = WriteImageToFileSystem(CreateRandomVulnerableImage(), "zot-test", "0.0.1", testStorageCtrl) if err != nil { @@ -314,7 +314,7 @@ func makeTestFile(fileName, content string) error { func TestImageFormat(t *testing.T) { Convey("Test valid image", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() imgDir := "../../../../test/data" dbDir := t.TempDir() @@ -382,7 +382,7 @@ func TestImageFormat(t *testing.T) { }) Convey("isIndexScanable", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metaDB := &mocks.MetaDBMock{ GetRepoMetaFn: func(ctx context.Context, repo string) (mTypes.RepoMeta, error) { @@ -456,7 +456,7 @@ func TestCVESearchDisabled(t *testing.T) { ctlr := api.NewController(conf) ctlr.Log.Info().Int64("seedUser", seedUser).Int64("seedPass", seedPass).Msg("random seed for username & password") - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctrlManager := test.NewControllerManager(ctlr) ctrlManager.StartAndWait(port) @@ -534,7 +534,7 @@ func TestCVESearch(t *testing.T) { writers := io.MultiWriter(os.Stdout, logFile) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) ctlr.Log.Info().Int64("seedUser", seedUser).Int64("seedPass", seedPass).Msg("random seed for username & password") ctrlManager := test.NewControllerManager(ctlr) @@ -772,7 +772,7 @@ func TestCVEStruct(t *testing.T) { //nolint:gocyclo boltDriver, err := boltdb.GetBoltDriver(params) So(err, ShouldBeNil) - metaDB, err := boltdb.New(boltDriver, log.NewLogger("debug", "")) + metaDB, err := boltdb.New(boltDriver, log.NewTestLogger()) So(err, ShouldBeNil) // Create metadb data for scannable image with vulnerabilities @@ -925,7 +925,7 @@ func TestCVEStruct(t *testing.T) { //nolint:gocyclo indexM3Name := "repoIndex@" + indexM3Digest imageMap[indexM3Name] = indexM3Digest - log := log.NewLogger("debug", "") + log := log.NewTestLogger() // Initialize a test CVE cache cache := cvecache.NewCveCache(100, log) @@ -1764,7 +1764,7 @@ func TestFixedTagsWithIndex(t *testing.T) { writers := io.MultiWriter(os.Stdout, logFile) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) cm := test.NewControllerManager(ctlr) cm.StartAndWait(port) @@ -1841,7 +1841,7 @@ func TestGetCVESummaryForImageMediaErrors(t *testing.T) { storeController.DefaultStore = mocks.MockedImageStore{} metaDB := mocks.MetaDBMock{} - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("IsImageMediaScannable returns false", func() { scanner := mocks.CveScannerMock{ diff --git a/pkg/extensions/search/cve/pagination_test.go b/pkg/extensions/search/cve/pagination_test.go index 99607437..1041aaf2 100644 --- a/pkg/extensions/search/cve/pagination_test.go +++ b/pkg/extensions/search/cve/pagination_test.go @@ -29,7 +29,7 @@ func TestCVEPagination(t *testing.T) { boltDriver, err := boltdb.GetBoltDriver(params) So(err, ShouldBeNil) - metaDB, err := boltdb.New(boltDriver, log.NewLogger("debug", "")) + metaDB, err := boltdb.New(boltDriver, log.NewTestLogger()) So(err, ShouldBeNil) // Create metadb data for scannable image with vulnerabilities @@ -103,7 +103,7 @@ func TestCVEPagination(t *testing.T) { }, } - log := log.NewLogger("debug", "") + log := log.NewTestLogger() cveInfo := cveinfo.BaseCveInfo{Log: log, Scanner: scanner, MetaDB: metaDB} ctx := context.Background() diff --git a/pkg/extensions/search/cve/scan.go b/pkg/extensions/search/cve/scan.go index a5344aea..82d99100 100644 --- a/pkg/extensions/search/cve/scan.go +++ b/pkg/extensions/search/cve/scan.go @@ -19,7 +19,7 @@ func NewScanTaskGenerator( sublogger := logC.With().Str("component", "cve").Logger() return &scanTaskGenerator{ - log: log.Logger{Logger: sublogger}, + log: sublogger, metaDB: metaDB, scanner: scanner, lock: &sync.Mutex{}, diff --git a/pkg/extensions/search/cve/scan_test.go b/pkg/extensions/search/cve/scan_test.go index bcdb8c3b..f0b679f8 100644 --- a/pkg/extensions/search/cve/scan_test.go +++ b/pkg/extensions/search/cve/scan_test.go @@ -52,9 +52,8 @@ func TestScanGeneratorWithMockedData(t *testing.T) { //nolint: gocyclo defer os.Remove(logFile.Name()) // clean up - logger := log.NewLogger("debug", logPath) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) + logger := log.NewLoggerWithWriter("debug", writers) cfg := config.New() cfg.Scheduler = &config.SchedulerConfig{NumWorkers: 3} @@ -67,7 +66,7 @@ func TestScanGeneratorWithMockedData(t *testing.T) { //nolint: gocyclo boltDriver, err := boltdb.GetBoltDriver(params) So(err, ShouldBeNil) - metaDB, err := boltdb.New(boltDriver, log.NewLogger("debug", "")) + metaDB, err := boltdb.New(boltDriver, log.NewTestLogger()) So(err, ShouldBeNil) // Refactor Idea: We can use InitializeTestMetaDB @@ -490,9 +489,8 @@ func TestScanGeneratorWithRealData(t *testing.T) { defer os.Remove(logFile.Name()) // clean up - logger := log.NewLogger("debug", logPath) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) + logger := log.NewLoggerWithWriter("debug", writers) cfg := config.New() cfg.Scheduler = &config.SchedulerConfig{NumWorkers: 3} diff --git a/pkg/extensions/search/cve/trivy/scanner_internal_test.go b/pkg/extensions/search/cve/trivy/scanner_internal_test.go index 883bf9ff..9ea6183e 100644 --- a/pkg/extensions/search/cve/trivy/scanner_internal_test.go +++ b/pkg/extensions/search/cve/trivy/scanner_internal_test.go @@ -49,7 +49,7 @@ func TestMultipleStoragePath(t *testing.T) { secondRootDir := t.TempDir() thirdRootDir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) // Create ImageStore @@ -168,7 +168,7 @@ func TestTrivyLibraryErrors(t *testing.T) { // Create temporary directory rootDir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) // Create ImageStore @@ -261,7 +261,7 @@ func TestImageScannable(t *testing.T) { panic(err) } - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metaDB, err := boltdb.New(boltDriver, log) if err != nil { @@ -363,7 +363,7 @@ func TestTrivyDBUrl(t *testing.T) { err = test.CopyFiles("../../../../../test/data/zot-cve-java-test", path.Join(rootDir, "zot-cve-java-test")) So(err, ShouldBeNil) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) // Create ImageStore @@ -426,7 +426,7 @@ func TestIsIndexScanable(t *testing.T) { storeController.DefaultStore = &imagestore.ImageStore{} metaDB := &boltdb.BoltDB{} - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("Find index in cache", func() { scanner := Scanner{ @@ -451,7 +451,7 @@ func TestIsIndexScannableErrors(t *testing.T) { storeController.DefaultStore = mocks.MockedImageStore{} metaDB := mocks.MetaDBMock{} - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("all manifests of a index are not scannable", func() { unscannableLayer := []Layer{{MediaType: "unscannable-layer-type", Digest: godigest.FromString("123")}} diff --git a/pkg/extensions/search/cve/trivy/scanner_test.go b/pkg/extensions/search/cve/trivy/scanner_test.go index 3475a8b8..117f5954 100644 --- a/pkg/extensions/search/cve/trivy/scanner_test.go +++ b/pkg/extensions/search/cve/trivy/scanner_test.go @@ -166,7 +166,7 @@ func TestVulnerableLayer(t *testing.T) { tempDir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() imageStore := local.NewImageStore(tempDir, false, false, log, monitoring.NewMetricsServer(false, log), nil, nil, nil, nil) @@ -237,7 +237,7 @@ func TestVulnerableLayer(t *testing.T) { tempDir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() imageStore := local.NewImageStore(tempDir, false, false, log, monitoring.NewMetricsServer(false, log), nil, nil, nil, nil) @@ -291,7 +291,7 @@ func TestScannerErrors(t *testing.T) { Convey("Errors", t, func() { storeController := storage.StoreController{} metaDB := mocks.MetaDBMock{} - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("IsImageFormatScannable", func() { storeController.DefaultStore = mocks.MockedImageStore{} diff --git a/pkg/extensions/search/cve/update_test.go b/pkg/extensions/search/cve/update_test.go index f1d34366..e64847c7 100644 --- a/pkg/extensions/search/cve/update_test.go +++ b/pkg/extensions/search/cve/update_test.go @@ -33,9 +33,8 @@ func TestCVEDBGenerator(t *testing.T) { defer os.Remove(logFile.Name()) // clean up - logger := log.NewLogger("debug", logPath) writers := io.MultiWriter(os.Stdout, logFile) - logger.Logger = logger.Output(writers) + logger := log.NewLoggerWithWriter("debug", writers) cfg := config.New() cfg.Scheduler = &config.SchedulerConfig{NumWorkers: 3} diff --git a/pkg/extensions/search/resolver_test.go b/pkg/extensions/search/resolver_test.go index bee9075a..3207fc38 100644 --- a/pkg/extensions/search/resolver_test.go +++ b/pkg/extensions/search/resolver_test.go @@ -49,7 +49,7 @@ func TestResolverGlobalSearch(t *testing.T) { graphql.DefaultRecover) mockCve := mocks.CveInfoMock{} repos, images, layers, err := globalSearch(responseContext, query, mockMetaDB, &gql_generated.Filter{}, - &gql_generated.PageInput{}, mockCve, log.NewLogger("debug", "")) + &gql_generated.PageInput{}, mockCve, log.NewTestLogger()) So(err, ShouldNotBeNil) So(images, ShouldBeEmpty) So(layers, ShouldBeEmpty) @@ -65,11 +65,11 @@ func TestResolverGlobalSearch(t *testing.T) { graphql.DefaultRecover) _, _, _, err := globalSearch(responseContext, "repo", mocks.MetaDBMock{}, &gql_generated.Filter{}, - pageInput, mocks.CveInfoMock{}, log.NewLogger("debug", "")) + pageInput, mocks.CveInfoMock{}, log.NewTestLogger()) So(err, ShouldNotBeNil) _, _, _, err = globalSearch(responseContext, "repo:tag", mocks.MetaDBMock{}, &gql_generated.Filter{}, - pageInput, mocks.CveInfoMock{}, log.NewLogger("debug", "")) + pageInput, mocks.CveInfoMock{}, log.NewTestLogger()) So(err, ShouldNotBeNil) }) @@ -86,7 +86,7 @@ func TestResolverGlobalSearch(t *testing.T) { responseContext := graphql.WithResponseContext(context.Background(), graphql.DefaultErrorPresenter, graphql.DefaultRecover) repos, images, layers, err := globalSearch(responseContext, query, mockMetaDB, &gql_generated.Filter{}, - &gql_generated.PageInput{}, mockCve, log.NewLogger("debug", "")) + &gql_generated.PageInput{}, mockCve, log.NewTestLogger()) So(err, ShouldNotBeNil) So(images, ShouldBeEmpty) So(layers, ShouldBeEmpty) @@ -106,7 +106,7 @@ func TestResolverGlobalSearch(t *testing.T) { responseContext := graphql.WithResponseContext(ctx, graphql.DefaultErrorPresenter, graphql.DefaultRecover) repos, images, layers, err := globalSearch(responseContext, query, mockMetaDB, &gql_generated.Filter{}, - &gql_generated.PageInput{}, mocks.CveInfoMock{}, log.NewLogger("debug", "")) + &gql_generated.PageInput{}, mocks.CveInfoMock{}, log.NewTestLogger()) So(err, ShouldNotBeNil) So(images, ShouldBeEmpty) So(layers, ShouldBeEmpty) @@ -119,7 +119,7 @@ func TestResolverGlobalSearch(t *testing.T) { responseContext := graphql.WithResponseContext(ctx, graphql.DefaultErrorPresenter, graphql.DefaultRecover) repos, images, layers, err := globalSearch(responseContext, query, mocks.MetaDBMock{}, &gql_generated.Filter{}, - &gql_generated.PageInput{Limit: ref(-10)}, mocks.CveInfoMock{}, log.NewLogger("debug", "")) + &gql_generated.PageInput{Limit: ref(-10)}, mocks.CveInfoMock{}, log.NewTestLogger()) So(err, ShouldNotBeNil) So(images, ShouldBeEmpty) So(layers, ShouldBeEmpty) @@ -139,7 +139,7 @@ func TestResolverGlobalSearch(t *testing.T) { responseContext := graphql.WithResponseContext(ctx, graphql.DefaultErrorPresenter, graphql.DefaultRecover) repos, images, layers, err := globalSearch(responseContext, query, mockMetaDB, &gql_generated.Filter{}, - &gql_generated.PageInput{}, mocks.CveInfoMock{}, log.NewLogger("debug", "")) + &gql_generated.PageInput{}, mocks.CveInfoMock{}, log.NewTestLogger()) So(err, ShouldNotBeNil) So(images, ShouldBeEmpty) So(layers, ShouldBeEmpty) @@ -152,7 +152,7 @@ func TestResolverGlobalSearch(t *testing.T) { responseContext := graphql.WithResponseContext(ctx, graphql.DefaultErrorPresenter, graphql.DefaultRecover) repos, images, layers, err := globalSearch(responseContext, query, mocks.MetaDBMock{}, &gql_generated.Filter{}, - &gql_generated.PageInput{Limit: ref(-10)}, mocks.CveInfoMock{}, log.NewLogger("debug", "")) + &gql_generated.PageInput{Limit: ref(-10)}, mocks.CveInfoMock{}, log.NewTestLogger()) So(err, ShouldNotBeNil) So(images, ShouldBeEmpty) So(layers, ShouldBeEmpty) @@ -165,7 +165,7 @@ func TestResolverGlobalSearch(t *testing.T) { responseContext := graphql.WithResponseContext(ctx, graphql.DefaultErrorPresenter, graphql.DefaultRecover) repos, images, layers, err := globalSearch(responseContext, query, mocks.MetaDBMock{}, &gql_generated.Filter{}, - &gql_generated.PageInput{}, mocks.CveInfoMock{}, log.NewLogger("debug", "")) + &gql_generated.PageInput{}, mocks.CveInfoMock{}, log.NewTestLogger()) So(err, ShouldNotBeNil) So(images, ShouldBeEmpty) So(layers, ShouldBeEmpty) @@ -191,7 +191,7 @@ func TestRepoListWithNewestImage(t *testing.T) { Offset: ref(0), SortBy: ref(gql_generated.SortCriteriaUpdateTime), } - repos, err := repoListWithNewestImage(responseContext, mockCve, log.NewLogger("debug", ""), &pageInput, mockMetaDB) + repos, err := repoListWithNewestImage(responseContext, mockCve, log.NewTestLogger(), &pageInput, mockMetaDB) So(err, ShouldNotBeNil) So(repos.Results, ShouldBeEmpty) }) @@ -204,7 +204,7 @@ func TestRepoListWithNewestImage(t *testing.T) { responseContext := graphql.WithResponseContext(context.Background(), graphql.DefaultErrorPresenter, graphql.DefaultRecover) - _, err := repoListWithNewestImage(responseContext, mocks.CveInfoMock{}, log.NewLogger("debug", ""), + _, err := repoListWithNewestImage(responseContext, mocks.CveInfoMock{}, log.NewTestLogger(), pageInput, mocks.MetaDBMock{}) So(err, ShouldNotBeNil) }) @@ -300,7 +300,7 @@ func TestRepoListWithNewestImage(t *testing.T) { responseContext := graphql.WithResponseContext(context.Background(), graphql.DefaultErrorPresenter, graphql.DefaultRecover) mockCve := mocks.CveInfoMock{} - repos, err := repoListWithNewestImage(responseContext, mockCve, log.NewLogger("debug", ""), nil, mockMetaDB) + repos, err := repoListWithNewestImage(responseContext, mockCve, log.NewTestLogger(), nil, mockMetaDB) So(err, ShouldBeNil) So(repos.Results, ShouldNotBeEmpty) }) @@ -317,7 +317,7 @@ func TestRepoListWithNewestImage(t *testing.T) { mockCve := mocks.CveInfoMock{} repos, err := repoListWithNewestImage(responseContext, mockCve, - log.NewLogger("debug", ""), &pageInput, mockMetaDB) + log.NewTestLogger(), &pageInput, mockMetaDB) So(err, ShouldBeNil) So(repos, ShouldNotBeEmpty) So(len(repos.Results), ShouldEqual, 2) @@ -330,7 +330,7 @@ func TestRepoListWithNewestImage(t *testing.T) { func TestGetFilteredPaginatedRepos(t *testing.T) { ctx := context.Background() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("getFilteredPaginatedRepos", t, func() { metaDB := mocks.MetaDBMock{} @@ -368,7 +368,7 @@ func TestGetBookmarkedRepos(t *testing.T) { _, err := getBookmarkedRepos( responseContext, mocks.CveInfoMock{}, - log.NewLogger("debug", ""), + log.NewTestLogger(), nil, mocks.MetaDBMock{ GetBookmarkedReposFn: func(ctx context.Context) ([]string, error) { @@ -387,7 +387,7 @@ func TestGetStarredRepos(t *testing.T) { _, err := getStarredRepos( responseContext, mocks.CveInfoMock{}, - log.NewLogger("debug", ""), + log.NewTestLogger(), nil, mocks.MetaDBMock{ GetStarredReposFn: func(ctx context.Context) ([]string, error) { @@ -553,7 +553,7 @@ func TestGetImageSummaryError(t *testing.T) { return nil, ErrTestError }, } - log := log.NewLogger("debug", "") + log := log.NewTestLogger() _, err := getImageSummary(context.Background(), "repo", "tag", nil, convert.SkipQGLField{}, metaDB, nil, log) @@ -585,7 +585,7 @@ func TestImageListError(t *testing.T) { graphql.DefaultRecover) _, err := getImageList(responseContext, "test", mocks.MetaDBMock{}, mocks.CveInfoMock{}, - &gql_generated.PageInput{Limit: ref(-1)}, log.NewLogger("debug", "")) + &gql_generated.PageInput{Limit: ref(-1)}, log.NewTestLogger()) So(err, ShouldNotBeNil) }) @@ -640,14 +640,14 @@ func TestGetReferrers(t *testing.T) { referredDigest := godigest.FromString("t").String() Convey("referredDigest is empty", func() { - testLogger := log.NewLogger("debug", "") + testLogger := log.NewTestLogger() _, err := getReferrers(mocks.MetaDBMock{}, "test", "", nil, testLogger) So(err, ShouldNotBeNil) }) Convey("GetReferrers returns error", func() { - testLogger := log.NewLogger("debug", "") + testLogger := log.NewTestLogger() mockedStore := mocks.MetaDBMock{ GetReferrersInfoFn: func(repo string, referredDigest godigest.Digest, artifactTypes []string, ) ([]mTypes.ReferrerInfo, error) { @@ -660,7 +660,7 @@ func TestGetReferrers(t *testing.T) { }) Convey("GetReferrers return index of descriptors", func() { - testLogger := log.NewLogger("debug", "") + testLogger := log.NewTestLogger() referrerDescriptor := ispec.Descriptor{ MediaType: ispec.MediaTypeImageManifest, ArtifactType: "com.artifact.test", @@ -698,7 +698,7 @@ func TestGetReferrers(t *testing.T) { func TestQueryResolverErrors(t *testing.T) { Convey("Errors", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() ctx := graphql.WithResponseContext(context.Background(), graphql.DefaultErrorPresenter, graphql.DefaultRecover) @@ -1039,7 +1039,7 @@ func TestQueryResolverErrors(t *testing.T) { func TestCVEResolvers(t *testing.T) { //nolint:gocyclo ctx := context.Background() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() LINUX := "linux" AMD := "amd" ARM := "arm64" @@ -2418,7 +2418,7 @@ func TestMockedBaseImageList(t *testing.T) { mockCve := mocks.CveInfoMock{} images, err := baseImageList(responseContext, "repo1:1.0.2", nil, mockMetaDB, &gql_generated.PageInput{}, - mockCve, log.NewLogger("debug", "")) + mockCve, log.NewTestLogger()) So(err, ShouldNotBeNil) So(images.Results, ShouldBeEmpty) }) @@ -2445,7 +2445,7 @@ func TestMockedBaseImageList(t *testing.T) { return map[string]mTypes.ImageMeta{image.DigestStr(): image.AsImageMeta()}, nil }, }, - pageInput, mocks.CveInfoMock{}, log.NewLogger("debug", "")) + pageInput, mocks.CveInfoMock{}, log.NewTestLogger()) So(err, ShouldNotBeNil) }) @@ -2475,7 +2475,7 @@ func TestMockedBaseImageList(t *testing.T) { mockCve := mocks.CveInfoMock{} images, err := baseImageList(responseContext, "repo1:1.0.2", nil, mockMetaDB, &gql_generated.PageInput{}, - mockCve, log.NewLogger("debug", "")) + mockCve, log.NewTestLogger()) So(err, ShouldBeNil) So(images.Results, ShouldBeEmpty) }) @@ -2550,7 +2550,7 @@ func TestMockedBaseImageList(t *testing.T) { Convey("valid baseImageList, results not affected by pageInput", func() { images, err := baseImageList(responseContext, "repo1:1.0.2", nil, mockMetaDB, - &gql_generated.PageInput{}, mockCve, log.NewLogger("debug", "")) + &gql_generated.PageInput{}, mockCve, log.NewTestLogger()) So(err, ShouldBeNil) So(images.Results, ShouldNotBeEmpty) So(len(images.Results), ShouldEqual, 2) @@ -2570,7 +2570,7 @@ func TestMockedBaseImageList(t *testing.T) { } images, err := baseImageList(responseContext, "repo1:1.0.2", nil, mockMetaDB, - &pageInput, mockCve, log.NewLogger("debug", "")) + &pageInput, mockCve, log.NewTestLogger()) So(err, ShouldBeNil) So(images.Results, ShouldNotBeEmpty) So(len(images.Results), ShouldEqual, limit) @@ -2642,14 +2642,14 @@ func TestMockedBaseImageList(t *testing.T) { mockCve := mocks.CveInfoMock{} images, err := baseImageList(responseContext, "repo1:1.0.2", nil, mockMetaDB, &gql_generated.PageInput{}, - mockCve, log.NewLogger("debug", "")) + mockCve, log.NewTestLogger()) So(err, ShouldBeNil) So(images.Results, ShouldBeEmpty) }) } func TestExpandedRepoInfoErrors(t *testing.T) { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("Access error", t, func() { userAc := reqCtx.NewUserAccessControl() diff --git a/pkg/extensions/search/search_test.go b/pkg/extensions/search/search_test.go index 1033217e..cc9f2859 100644 --- a/pkg/extensions/search/search_test.go +++ b/pkg/extensions/search/search_test.go @@ -689,7 +689,7 @@ func TestRepoListWithNewestImage(t *testing.T) { writers := io.MultiWriter(os.Stdout, logFile) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) if err := ctlr.Init(); err != nil { panic(err) @@ -1159,7 +1159,7 @@ func TestExpandedRepoInfo(t *testing.T) { ctlr := api.NewController(conf) imageStore := local.NewImageStore(tempDir, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), nil, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), nil, nil, nil, nil) storeController := storage.StoreController{ DefaultStore: imageStore, @@ -1279,7 +1279,7 @@ func TestExpandedRepoInfo(t *testing.T) { err = UploadImage(uploadedImage, baseURL, "a/zot-test", "0.0.1") So(err, ShouldBeNil) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) testStorage := local.NewImageStore(rootDir, false, false, log, metrics, nil, nil, nil, nil) @@ -1637,7 +1637,7 @@ func TestExpandedRepoInfo(t *testing.T) { ctlr := api.NewController(conf) imageStore := local.NewImageStore(conf.Storage.RootDirectory, false, false, - log.NewLogger("debug", ""), monitoring.NewMetricsServer(false, log.NewLogger("debug", "")), nil, nil, nil, nil) + log.NewTestLogger(), monitoring.NewMetricsServer(false, log.NewTestLogger()), nil, nil, nil, nil) storeController := storage.StoreController{ DefaultStore: imageStore, @@ -1797,7 +1797,7 @@ func TestExpandedRepoInfo(t *testing.T) { err = UploadImage(uploadedImage, baseURL, "a/zot-test", "0.0.1") So(err, ShouldBeNil) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) testStorage := local.NewImageStore(rootDir, false, false, log, metrics, nil, nil, nil, nil) @@ -2453,7 +2453,7 @@ func TestGetImageManifest(t *testing.T) { storeController := storage.StoreController{ DefaultStore: mockImageStore, } - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) _, _, err := olu.GetImageManifest("nonexistent-repo", "latest") So(err, ShouldNotBeNil) @@ -2469,7 +2469,7 @@ func TestGetImageManifest(t *testing.T) { storeController := storage.StoreController{ DefaultStore: mockImageStore, } - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) _, _, err := olu.GetImageManifest("test-repo", "latest") //nolint:goconst So(err, ShouldNotBeNil) @@ -3103,7 +3103,7 @@ func TestGetRepositories(t *testing.T) { DefaultStore: mockImageStore, SubStore: map[string]storageTypes.ImageStore{"test": mockImageStore}, } - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) repoList, err := olu.GetRepositories() So(repoList, ShouldBeEmpty) @@ -3113,7 +3113,7 @@ func TestGetRepositories(t *testing.T) { DefaultStore: mocks.MockedImageStore{}, SubStore: map[string]storageTypes.ImageStore{"test": mockImageStore}, } - olu = ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu = ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) repoList, err = olu.GetRepositories() So(repoList, ShouldBeEmpty) @@ -3400,7 +3400,7 @@ func TestGlobalSearch(t *testing.T) { //nolint: gocyclo err = UploadImage(image3, baseURL, "repo2", "1.0.0") So(err, ShouldBeNil) - olu := ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewTestLogger()) // Initialize the objects containing the expected data repos, err := olu.GetRepositories() @@ -3636,7 +3636,7 @@ func TestGlobalSearch(t *testing.T) { //nolint: gocyclo writers := io.MultiWriter(os.Stdout, logFile) ctlr := api.NewController(conf) - ctlr.Log.Logger = ctlr.Log.Output(writers) + ctlr.Log = log.NewLoggerWithWriter("debug", writers) if err := ctlr.Init(); err != nil { panic(err) @@ -3749,7 +3749,7 @@ func TestGlobalSearch(t *testing.T) { //nolint: gocyclo err = UploadImage(image3, baseURL, "repo2", "1.0.0") So(err, ShouldBeNil) - olu := ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewTestLogger()) // Initialize the objects containing the expected data repos, err := olu.GetRepositories() @@ -3950,7 +3950,7 @@ func TestGlobalSearch(t *testing.T) { //nolint: gocyclo }) Convey("global searching by digest", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() rootDir := t.TempDir() port := GetFreePort() baseURL := GetBaseURL(port) @@ -4015,7 +4015,7 @@ func TestGlobalSearch(t *testing.T) { //nolint: gocyclo }) Convey("global searching by tag cross repo", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() rootDir := t.TempDir() port := GetFreePort() baseURL := GetBaseURL(port) @@ -4158,7 +4158,7 @@ func TestGlobalSearch(t *testing.T) { //nolint: gocyclo }) Convey("test nested indexes CVE scanning disabled", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() rootDir := t.TempDir() port := GetFreePort() baseURL := GetBaseURL(port) @@ -4321,7 +4321,7 @@ func TestGlobalSearch(t *testing.T) { //nolint: gocyclo }) Convey("test nested indexes CVE scanning enabled", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() rootDir := t.TempDir() port := GetFreePort() baseURL := GetBaseURL(port) @@ -6052,7 +6052,7 @@ func TestMetaDBWhenDeletingImages(t *testing.T) { So(responseStruct.Images[0].IsSigned, ShouldBeTrue) // get signatur digest - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) storage := local.NewImageStore(dir, false, false, log, metrics, nil, nil, nil, nil) @@ -6126,7 +6126,7 @@ func TestMetaDBWhenDeletingImages(t *testing.T) { So(responseStruct.Images[0].IsSigned, ShouldBeTrue) // get signatur digest - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) storage := local.NewImageStore(dir, false, false, log, metrics, nil, nil, nil, nil) diff --git a/pkg/extensions/search/userprefs_test.go b/pkg/extensions/search/userprefs_test.go index 75c1d064..42a4f798 100644 --- a/pkg/extensions/search/userprefs_test.go +++ b/pkg/extensions/search/userprefs_test.go @@ -525,7 +525,7 @@ func TestChangingRepoState(t *testing.T) { ctlr := api.NewController(conf) img := CreateRandomImage() - storeCtlr := GetDefaultStoreController(conf.Storage.RootDirectory, log.NewLogger("debug", "")) + storeCtlr := GetDefaultStoreController(conf.Storage.RootDirectory, log.NewTestLogger()) err := WriteImageToFileSystem(img, accesibleRepo, "tag", storeCtlr) if err != nil { diff --git a/pkg/extensions/sync/content_test.go b/pkg/extensions/sync/content_test.go index f44ced07..63a5c4c2 100644 --- a/pkg/extensions/sync/content_test.go +++ b/pkg/extensions/sync/content_test.go @@ -68,7 +68,7 @@ func TestContentManager(t *testing.T) { Convey("Test GetRepoDestination()", t, func() { for _, test := range testCases { - cm := sync.NewContentManager([]syncconf.Content{test.content}, log.Logger{}) + cm := sync.NewContentManager([]syncconf.Content{test.content}, log.NewTestLogger()) actualResult := cm.GetRepoDestination(test.expected) So(actualResult, ShouldEqual, test.repo) } @@ -77,7 +77,7 @@ func TestContentManager(t *testing.T) { // this is the inverse function of getRepoDestination() Convey("Test GetRepoSource()", t, func() { for _, test := range testCases { - cm := sync.NewContentManager([]syncconf.Content{test.content}, log.Logger{}) + cm := sync.NewContentManager([]syncconf.Content{test.content}, log.NewTestLogger()) actualResult := cm.GetRepoSource(test.repo) So(actualResult, ShouldEqual, test.expected) } @@ -85,7 +85,7 @@ func TestContentManager(t *testing.T) { Convey("Test MatchesContent() error", t, func() { content := syncconf.Content{Prefix: "[repo%^&"} - cm := sync.NewContentManager([]syncconf.Content{content}, log.Logger{}) + cm := sync.NewContentManager([]syncconf.Content{content}, log.NewTestLogger()) So(cm.MatchesContent("repo"), ShouldEqual, false) }) } @@ -148,7 +148,7 @@ func TestGetContentByLocalRepo(t *testing.T) { Convey("Test getContentByLocalRepo()", t, func() { for _, test := range testCases { - cm := sync.NewContentManager(test.content, log.Logger{}) + cm := sync.NewContentManager(test.content, log.NewTestLogger()) actualResult := cm.GetContentByLocalRepo(test.repo) if test.expected == -1 { @@ -163,7 +163,7 @@ func TestGetContentByLocalRepo(t *testing.T) { Convey("Test getContentByLocalRepo() error", t, func() { content := syncconf.Content{Prefix: "[repo%^&"} - cm := sync.NewContentManager([]syncconf.Content{content}, log.Logger{}) + cm := sync.NewContentManager([]syncconf.Content{content}, log.NewTestLogger()) So(cm.GetContentByLocalRepo("repo"), ShouldBeNil) }) } @@ -267,7 +267,7 @@ func TestFilterTags(t *testing.T) { Convey("Test FilterTags()", t, func() { for _, test := range testCases { - cm := sync.NewContentManager(test.content, log.NewLogger("debug", "")) + cm := sync.NewContentManager(test.content, log.NewTestLogger()) actualResult, err := cm.FilterTags(test.repo, test.tags) So(actualResult, ShouldResemble, test.filteredTags) diff --git a/pkg/extensions/sync/sync_internal_test.go b/pkg/extensions/sync/sync_internal_test.go index 06969241..5b983f72 100644 --- a/pkg/extensions/sync/sync_internal_test.go +++ b/pkg/extensions/sync/sync_internal_test.go @@ -38,7 +38,7 @@ func TestService(t *testing.T) { URLs: []string{"http://localhost"}, } - service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) err = service.SyncRepo(context.Background(), "repo") @@ -50,7 +50,7 @@ func TestService(t *testing.T) { URLs: []string{"http://localhost"}, } - service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) // Create a context that's already cancelled @@ -67,7 +67,7 @@ func TestService(t *testing.T) { URLs: []string{"http://localhost"}, } - service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) // Create a mock remote that returns tags so we can reach the loop @@ -92,7 +92,7 @@ func TestService(t *testing.T) { URLs: []string{"http://localhost"}, } - service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) // Create a minimal mock remote that only returns tags @@ -129,7 +129,7 @@ func TestService(t *testing.T) { OnlySigned: &onlySigned, } - service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) // Create a mock remote that returns necessary data @@ -168,10 +168,10 @@ func TestService(t *testing.T) { RetryDelay: &retryDelay, } - service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) - onDemand := NewOnDemand(log.Logger{}) + onDemand := NewOnDemand(log.NewTestLogger()) onDemand.Add(service) ctx := context.Background() @@ -290,7 +290,7 @@ func TestService(t *testing.T) { }}, } - service1, err := New(conf1, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service1, err := New(conf1, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) // Create second service for normal processing @@ -303,10 +303,10 @@ func TestService(t *testing.T) { }}, } - service2, err := New(conf2, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service2, err := New(conf2, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) - onDemand := NewOnDemand(log.Logger{}) + onDemand := NewOnDemand(log.NewTestLogger()) onDemand.Add(service1) // First service will return ErrSyncImageFilteredOut onDemand.Add(service2) // Second service will process normally but error on network @@ -335,10 +335,10 @@ func TestService(t *testing.T) { }}, } - service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) - onDemand := NewOnDemand(log.Logger{}) + onDemand := NewOnDemand(log.NewTestLogger()) onDemand.Add(service) return service, onDemand } @@ -375,10 +375,10 @@ func TestService(t *testing.T) { }}, } - service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.Logger{}) + service, err := New(conf, "", nil, os.TempDir(), storage.StoreController{}, mocks.MetaDBMock{}, log.NewTestLogger()) So(err, ShouldBeNil) - onDemand := NewOnDemand(log.Logger{}) + onDemand := NewOnDemand(log.NewTestLogger()) onDemand.Add(service) return service, onDemand, retryDelay } @@ -471,7 +471,7 @@ func TestService(t *testing.T) { // This ensures the "waiting on channel" message is logged and the channel receive happens Convey("SyncImage assured channel waiting", func() { - onDemand := NewOnDemand(log.Logger{}) + onDemand := NewOnDemand(log.NewTestLogger()) // Create request and pre-populate with a channel that we control req := request{ @@ -505,7 +505,7 @@ func TestService(t *testing.T) { }) Convey("SyncReferrers assured channel waiting", func() { - onDemand := NewOnDemand(log.Logger{}) + onDemand := NewOnDemand(log.NewTestLogger()) // Create request and pre-populate with a channel that we control req := request{ @@ -544,7 +544,7 @@ func TestDestinationRegistry(t *testing.T) { Convey("make StoreController", t, func() { dir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, diff --git a/pkg/extensions/sync/sync_test.go b/pkg/extensions/sync/sync_test.go index c0aac087..89da59c7 100644 --- a/pkg/extensions/sync/sync_test.go +++ b/pkg/extensions/sync/sync_test.go @@ -149,7 +149,7 @@ func makeUpstreamServer( srcConfig.Storage.GC = false srcDir := t.TempDir() - srcStorageCtrl := ociutils.GetDefaultStoreController(srcDir, log.NewLogger("debug", "")) + srcStorageCtrl := ociutils.GetDefaultStoreController(srcDir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateDefaultImage(), "zot-test", "0.0.1", srcStorageCtrl) if err != nil { @@ -3828,7 +3828,7 @@ func TestSubPaths(t *testing.T) { srcDir := t.TempDir() subpath := "/subpath" - srcStorageCtlr := ociutils.GetDefaultStoreController(path.Join(srcDir, subpath), log.NewLogger("debug", "")) + srcStorageCtlr := ociutils.GetDefaultStoreController(path.Join(srcDir, subpath), log.NewTestLogger()) err := WriteImageToFileSystem(CreateDefaultImage(), "zot-test", "0.0.1", srcStorageCtlr) So(err, ShouldBeNil) @@ -5360,7 +5360,7 @@ func TestOnDemandRetryGoroutine(t *testing.T) { srcDir := t.TempDir() - srcStorageCtlr := ociutils.GetDefaultStoreController(srcDir, log.NewLogger("debug", "")) + srcStorageCtlr := ociutils.GetDefaultStoreController(srcDir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateDefaultImage(), "zot-test", "0.0.1", srcStorageCtlr) So(err, ShouldBeNil) @@ -5583,7 +5583,7 @@ func TestOnDemandMultipleImage(t *testing.T) { srcDir := t.TempDir() - srcStorageCtlr := ociutils.GetDefaultStoreController(srcDir, log.NewLogger("debug", "")) + srcStorageCtlr := ociutils.GetDefaultStoreController(srcDir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateDefaultImage(), "zot-test", "0.0.1", srcStorageCtlr) So(err, ShouldBeNil) @@ -6379,7 +6379,7 @@ func TestSyncOnlyDiff(t *testing.T) { destDir := t.TempDir() // copy images so we have them before syncing, sync should not pull them again - destStorageCtrl := ociutils.GetDefaultStoreController(destDir, log.NewLogger("debug", "")) + destStorageCtrl := ociutils.GetDefaultStoreController(destDir, log.NewTestLogger()) err := WriteImageToFileSystem(CreateDefaultImage(), "zot-test", "0.0.1", destStorageCtrl) So(err, ShouldBeNil) @@ -6467,7 +6467,7 @@ func TestSyncWithDiffDigest(t *testing.T) { destDir := t.TempDir() // copy images so we have them before syncing, sync should not pull them again - srcStorageCtlr := ociutils.GetDefaultStoreController(destDir, log.NewLogger("debug", "")) + srcStorageCtlr := ociutils.GetDefaultStoreController(destDir, log.NewTestLogger()) // both default images are present in both upstream and downstream image := CreateDefaultImage() @@ -7405,7 +7405,7 @@ func TestSyncImageIndex(t *testing.T) { func TestECRCredentialsHelper(t *testing.T) { Convey("Test ECR Credentials Helper", t, func() { // use getMockECRCredentials for testing purposes - credentialHelper := sync.NewECRCredentialHelper(log.NewLogger("debug", ""), sync.GetMockECRCredentials) + credentialHelper := sync.NewECRCredentialHelper(log.NewTestLogger(), sync.GetMockECRCredentials) url := "https://mockAccount.dkr.ecr.mockRegion.amazonaws.com" remoteAddress := sync.StripRegistryTransport(url) diff --git a/pkg/log/log.go b/pkg/log/log.go index 40520558..a8ed148f 100644 --- a/pkg/log/log.go +++ b/pkg/log/log.go @@ -1,84 +1,308 @@ package log import ( + "context" + "fmt" + "io" + "log/slog" "os" "runtime" "strconv" "strings" - "sync" "time" - "github.com/rs/zerolog" + "zotregistry.dev/zot/errors" ) -const defaultPerms = 0o0600 +const ( + defaultPerms = 0o0600 + messageKey = "message" + callerSkipFrameCount = 5 +) -//nolint:gochecknoglobals -var loggerSetTimeFormat sync.Once - -// Logger extends zerolog's Logger. +// Logger extends slog's Logger with zerolog-compatible API. type Logger struct { - zerolog.Logger + *slog.Logger } -func (l Logger) Println(v ...interface{}) { - l.Logger.Error().Msg("panic recovered") //nolint: check-logs +// Event represents a log event, mimicking zerolog.Event. +type Event struct { + logger *Logger + level slog.Level + attrs []slog.Attr + isPanic bool +} + +// Info returns an event for info level logging. +func (l Logger) Info() *Event { + return &Event{logger: &l, level: slog.LevelInfo, attrs: []slog.Attr{}} +} + +// Debug returns an event for debug level logging. +func (l Logger) Debug() *Event { + return &Event{logger: &l, level: slog.LevelDebug, attrs: []slog.Attr{}} +} + +// Error returns an event for error level logging. +func (l Logger) Error() *Event { + return &Event{logger: &l, level: slog.LevelError, attrs: []slog.Attr{}} +} + +// Warn returns an event for warn level logging. +func (l Logger) Warn() *Event { + return &Event{logger: &l, level: slog.LevelWarn, attrs: []slog.Attr{}} +} + +// Panic returns an event for panic level logging (maps to error + panic). +func (l Logger) Panic() *Event { + return &Event{logger: &l, level: slog.LevelError, attrs: []slog.Attr{}, isPanic: true} +} + +// Fatal returns an event for fatal level logging (maps to error + panic). +func (l Logger) Fatal() *Event { + return &Event{logger: &l, level: slog.LevelError, attrs: []slog.Attr{}, isPanic: true} +} + +// Err logs an error directly on the logger (convenience method). +func (l Logger) Err(err error) *Event { + event := l.Error() + if err != nil { + event.attrs = append(event.attrs, slog.String("error", err.Error())) + } + + return event +} + +// With returns a logger with additional context. +func (l Logger) With() *Event { + return &Event{logger: &l, level: slog.LevelInfo, attrs: []slog.Attr{}} +} + +// Logger returns the logger from an event (for method chaining). +func (e *Event) Logger() Logger { + // Create a new logger with the accumulated attributes + handler := e.logger.Handler() + if len(e.attrs) > 0 { + handler = handler.WithAttrs(e.attrs) + } + + return Logger{Logger: slog.New(handler)} +} + +// Str adds a string field to the event. +func (e *Event) Str(key, val string) *Event { + e.attrs = append(e.attrs, slog.String(key, val)) + + return e +} + +// Int adds an int field to the event. +func (e *Event) Int(key string, val int) *Event { + e.attrs = append(e.attrs, slog.Int(key, val)) + + return e +} + +// Int64 adds an int64 field to the event. +func (e *Event) Int64(key string, val int64) *Event { + e.attrs = append(e.attrs, slog.Int64(key, val)) + + return e +} + +// Uint64 adds a uint64 field to the event. +func (e *Event) Uint64(key string, val uint64) *Event { + e.attrs = append(e.attrs, slog.Uint64(key, val)) + + return e +} + +// Bool adds a bool field to the event. +func (e *Event) Bool(key string, val bool) *Event { + e.attrs = append(e.attrs, slog.Bool(key, val)) + + return e +} + +// Err adds an error field to the event. +func (e *Event) Err(err error) *Event { + if err != nil { + e.attrs = append(e.attrs, slog.String("error", err.Error())) + } + + return e +} + +// Interface adds any interface field to the event. +func (e *Event) Interface(key string, val interface{}) *Event { + e.attrs = append(e.attrs, slog.Any(key, val)) + + return e +} + +// Any adds any interface field to the event (alias for Interface). +func (e *Event) Any(key string, val interface{}) *Event { + return e.Interface(key, val) +} + +// Strs adds a slice of strings field to the event. +func (e *Event) Strs(key string, vals []string) *Event { + e.attrs = append(e.attrs, slog.Any(key, vals)) + + return e +} + +// IPAddr adds an IP address field to the event. +func (e *Event) IPAddr(key string, ip interface{}) *Event { + e.attrs = append(e.attrs, slog.String(key, fmt.Sprintf("%v", ip))) + + return e +} + +// RawJSON adds a raw JSON field to the event. +func (e *Event) RawJSON(key string, data []byte) *Event { + e.attrs = append(e.attrs, slog.String(key, string(data))) + + return e +} + +// Dur adds a duration field to the event. +func (e *Event) Dur(key string, d time.Duration) *Event { + e.attrs = append(e.attrs, slog.Duration(key, d)) + + return e +} + +// NewTestLogger creates a logger for testing purposes (replaces zerolog.New(os.Stdout)). +func NewTestLogger() Logger { + return NewLogger("debug", "") +} + +// NewTestLoggerPtr creates a pointer to a logger for testing purposes. +func NewTestLoggerPtr() *Logger { + logger := NewLogger("debug", "") + + return &logger +} + +// Msgf logs the event with a formatted message. +func (e *Event) Msgf(format string, args ...interface{}) { + msg := fmt.Sprintf(format, args...) + e.logger.LogAttrs(nil, e.level, msg, e.attrs...) + + if e.isPanic { + panic(msg) + } +} + +// Msg logs the event with a simple message. +func (e *Event) Msg(msg string) { + e.logger.LogAttrs(nil, e.level, msg, e.attrs...) + + if e.isPanic { + panic(msg) + } +} + +// parseLevel converts string level to slog.Level. +func parseLevel(level string) (slog.Level, error) { + switch strings.ToLower(level) { + case "debug": + return slog.LevelDebug, nil + case "info": + return slog.LevelInfo, nil + case "warn", "warning": + return slog.LevelWarn, nil + case "error": + return slog.LevelError, nil + default: + return slog.LevelInfo, errors.ErrBadConfig + } } func NewLogger(level, output string) Logger { - loggerSetTimeFormat.Do(func() { - zerolog.TimeFieldFormat = time.RFC3339Nano - }) - - lvl, err := zerolog.ParseLevel(level) - if err != nil { - panic(err) - } - - zerolog.SetGlobalLevel(lvl) - - var log zerolog.Logger - + // Determine output writer + var writer io.Writer if output == "" { - log = zerolog.New(os.Stdout) + writer = os.Stdout } else { file, err := os.OpenFile(output, os.O_APPEND|os.O_WRONLY|os.O_CREATE, defaultPerms) if err != nil { panic(err) } - - log = zerolog.New(file) + writer = file } - return Logger{Logger: log.Hook(goroutineHook{}).With().Caller().Timestamp().Logger()} + return NewLoggerWithWriter(level, writer) } func NewAuditLogger(level, output string) *Logger { - loggerSetTimeFormat.Do(func() { - zerolog.TimeFieldFormat = time.RFC3339Nano - }) - - lvl, err := zerolog.ParseLevel(level) + // Parse log level + lvl, err := parseLevel(level) if err != nil { panic(err) } - zerolog.SetGlobalLevel(lvl) - - var auditLog zerolog.Logger - + // Determine output writer + var writer io.Writer if output == "" { - auditLog = zerolog.New(os.Stdout) + writer = os.Stdout } else { auditFile, err := os.OpenFile(output, os.O_APPEND|os.O_WRONLY|os.O_CREATE, defaultPerms) if err != nil { panic(err) } - - auditLog = zerolog.New(auditFile) + writer = auditFile } - return &Logger{Logger: auditLog.With().Timestamp().Logger()} + logger := slog.New(defaultJSONHandler(lvl, writer)) + + return &Logger{Logger: logger} +} + +func defaultJSONHandler(lvl slog.Leveler, writer io.Writer) *slog.JSONHandler { + // Create JSON handler with RFC3339Nano time format + opts := &slog.HandlerOptions{ + Level: lvl, + ReplaceAttr: func(groups []string, attr slog.Attr) slog.Attr { + // Format timestamp as RFC3339Nano to match zerolog + if attr.Key == slog.TimeKey { + return slog.String("time", attr.Value.Time().Format(time.RFC3339Nano)) + } + // Rename the level field to match zerolog + if attr.Key == slog.LevelKey { + return slog.String("level", strings.ToLower(attr.Value.String())) + } + // Rename "msg" to "message" to match zerolog + if attr.Key == slog.MessageKey { + attr.Key = messageKey + } + + return attr + }, + } + + handler := slog.NewJSONHandler(writer, opts) + + return handler +} + +func NewLoggerWithWriter(level string, writer io.Writer) Logger { + // Parse log level + lvl, err := parseLevel(level) + if err != nil { + panic(err) + } + + // Add caller info handler wrapper + callerHandler := &CallerHandler{handler: defaultJSONHandler(lvl, writer)} + + // Add goroutine hook handler wrapper + goroutineHandler := &GoroutineHandler{handler: callerHandler} + + logger := slog.New(goroutineHandler) + + return Logger{Logger: logger} } // GoroutineID adds goroutine-id to logs to help debug concurrency issues. @@ -95,10 +319,59 @@ func GoroutineID() int { return id } -type goroutineHook struct{} - -func (h goroutineHook) Run(e *zerolog.Event, level zerolog.Level, _ string) { - if level != zerolog.NoLevel { - e.Int("goroutine", GoroutineID()) - } +// CallerHandler adds caller information to log records. +type CallerHandler struct { + handler slog.Handler +} + +func (h *CallerHandler) Enabled(ctx context.Context, level slog.Level) bool { + return h.handler.Enabled(ctx, level) +} + +func (h *CallerHandler) Handle(ctx context.Context, record slog.Record) error { + // Add caller information + if pc, file, line, ok := runtime.Caller(callerSkipFrameCount); ok { // Adjust stack depth as needed + frame := runtime.CallersFrames([]uintptr{pc}) + f, _ := frame.Next() + + record.Add("caller", fmt.Sprintf("%s:%d", file, line)) + + if f.Function != "" { + record.Add("func", f.Function) + } + } + + return h.handler.Handle(ctx, record) +} + +func (h *CallerHandler) WithAttrs(attrs []slog.Attr) slog.Handler { + return &CallerHandler{handler: h.handler.WithAttrs(attrs)} +} + +func (h *CallerHandler) WithGroup(name string) slog.Handler { + return &CallerHandler{handler: h.handler.WithGroup(name)} +} + +// GoroutineHandler adds goroutine ID to log records. +type GoroutineHandler struct { + handler slog.Handler +} + +func (h *GoroutineHandler) Enabled(ctx context.Context, level slog.Level) bool { + return h.handler.Enabled(ctx, level) +} + +func (h *GoroutineHandler) Handle(ctx context.Context, record slog.Record) error { + // Add goroutine ID + record.Add("goroutine", GoroutineID()) + + return h.handler.Handle(ctx, record) +} + +func (h *GoroutineHandler) WithAttrs(attrs []slog.Attr) slog.Handler { + return &GoroutineHandler{handler: h.handler.WithAttrs(attrs)} +} + +func (h *GoroutineHandler) WithGroup(name string) slog.Handler { + return &GoroutineHandler{handler: h.handler.WithGroup(name)} } diff --git a/pkg/log/log_test.go b/pkg/log/log_test.go index a6b8f7aa..8822241b 100644 --- a/pkg/log/log_test.go +++ b/pkg/log/log_test.go @@ -16,7 +16,6 @@ import ( "time" godigest "github.com/opencontainers/go-digest" - "github.com/rs/zerolog" . "github.com/smartystreets/goconvey/convey" "gopkg.in/resty.v1" @@ -321,7 +320,7 @@ func TestLogErrors(t *testing.T) { err := os.WriteFile(logPath, []byte{}, 0o000) So(err, ShouldBeNil) So(func() { - _ = log.NewLogger(zerolog.DebugLevel.String(), logPath) + _ = log.NewLogger("debug", logPath) }, ShouldPanic) }) } @@ -337,7 +336,7 @@ func TestNewAuditLogger(t *testing.T) { err := os.WriteFile(logPath, []byte{}, 0o000) So(err, ShouldBeNil) So(func() { - _ = log.NewAuditLogger(zerolog.DebugLevel.String(), logPath) + _ = log.NewAuditLogger("debug", logPath) }, ShouldPanic) }) } diff --git a/pkg/meta/boltdb/boltdb_test.go b/pkg/meta/boltdb/boltdb_test.go index 067925f3..56a66a57 100644 --- a/pkg/meta/boltdb/boltdb_test.go +++ b/pkg/meta/boltdb/boltdb_test.go @@ -50,7 +50,7 @@ func TestWrapperErrors(t *testing.T) { boltDriver, err := boltdb.GetBoltDriver(boltDBParams) So(err, ShouldBeNil) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() boltdbWrapper, err := boltdb.New(boltDriver, log) So(boltdbWrapper, ShouldNotBeNil) diff --git a/pkg/meta/dynamodb/dynamodb_internal_test.go b/pkg/meta/dynamodb/dynamodb_internal_test.go index 5dc26d58..dbd37364 100644 --- a/pkg/meta/dynamodb/dynamodb_internal_test.go +++ b/pkg/meta/dynamodb/dynamodb_internal_test.go @@ -9,7 +9,6 @@ import ( "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/dynamodb" guuid "github.com/gofrs/uuid" - "github.com/rs/zerolog" . "github.com/smartystreets/goconvey/convey" "zotregistry.dev/zot/pkg/log" @@ -59,7 +58,7 @@ func TestWrapperErrors(t *testing.T) { UserDataTablename: userDataTablename, APIKeyTablename: apiKeyTablename, Patches: version.GetDynamoDBPatches(), - Log: log.Logger{Logger: zerolog.New(os.Stdout)}, + Log: log.NewTestLogger(), } // The table creation should fail as the endpoint is not configured correctly @@ -94,7 +93,7 @@ func TestWrapperErrors(t *testing.T) { VersionTablename: versionTablename, UserDataTablename: userDataTablename, Patches: version.GetDynamoDBPatches(), - Log: log.Logger{Logger: zerolog.New(os.Stdout)}, + Log: log.NewTestLogger(), } // The tables were not created so delete calls fail, but dynamoWrapper should not error diff --git a/pkg/meta/dynamodb/dynamodb_test.go b/pkg/meta/dynamodb/dynamodb_test.go index adb45308..b987a220 100644 --- a/pkg/meta/dynamodb/dynamodb_test.go +++ b/pkg/meta/dynamodb/dynamodb_test.go @@ -14,7 +14,6 @@ import ( guuid "github.com/gofrs/uuid" godigest "github.com/opencontainers/go-digest" ispec "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/rs/zerolog" . "github.com/smartystreets/goconvey/convey" "zotregistry.dev/zot/pkg/extensions/imagetrust" @@ -47,7 +46,7 @@ func TestIterator(t *testing.T) { userDataTablename := "UserDataTable" + uuid.String() apiKeyTablename := "ApiKeyTable" + uuid.String() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("TestIterator", t, func() { params := mdynamodb.DBDriverParameters{ @@ -124,7 +123,7 @@ func TestIteratorErrors(t *testing.T) { "RepoMetadataTable", "RepoMeta", 1, - log.Logger{Logger: zerolog.New(os.Stdout)}, + log.NewTestLogger(), ) _, err = repoMetaAttributeIterator.First(context.Background()) @@ -152,7 +151,7 @@ func TestWrapperErrors(t *testing.T) { imageMetaTablename := "ImageMeta" + uuid.String() repoBlobsTablename := "RepoBlobs" + uuid.String() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() testDigest := godigest.FromString("str") image := CreateDefaultImage() multi := CreateMultiarchWith().Images([]Image{image}).Build() diff --git a/pkg/meta/hooks_test.go b/pkg/meta/hooks_test.go index ef40d246..75720ed9 100644 --- a/pkg/meta/hooks_test.go +++ b/pkg/meta/hooks_test.go @@ -24,7 +24,7 @@ func TestOnUpdateManifest(t *testing.T) { Convey("On UpdateManifest", t, func() { rootDir := t.TempDir() storeController := storage.StoreController{} - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) storeController.DefaultStore = local.NewImageStore(rootDir, true, true, log, metrics, nil, nil, nil, nil) @@ -58,7 +58,7 @@ func TestUpdateErrors(t *testing.T) { imageStore := mocks.MockedImageStore{} storeController := storage.StoreController{DefaultStore: &imageStore} metaDB := mocks.MetaDBMock{} - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("IsReferrersTag true update", func() { err := meta.OnUpdateManifest(context.Background(), "repo", "sha256-123", "digest", "media", []byte("bad"), diff --git a/pkg/meta/meta_test.go b/pkg/meta/meta_test.go index 46fe39dc..08764cdf 100644 --- a/pkg/meta/meta_test.go +++ b/pkg/meta/meta_test.go @@ -61,7 +61,7 @@ func TestBoltDB(t *testing.T) { boltDriver, err := boltdb.GetBoltDriver(boltDBParams) So(err, ShouldBeNil) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metaDB, err := boltdb.New(boltDriver, log) So(metaDB, ShouldNotBeNil) @@ -82,7 +82,7 @@ func TestBoltDB(t *testing.T) { boltDriver, err := boltdb.GetBoltDriver(boltDBParams) So(err, ShouldBeNil) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() imgTrustStore, err := imagetrust.NewLocalImageTrustStore(boltDBParams.RootDir) So(err, ShouldBeNil) @@ -134,7 +134,7 @@ func TestDynamoDBWrapper(t *testing.T) { dynamoClient, err := mdynamodb.GetDynamoClient(dynamoDBDriverParams) So(err, ShouldBeNil) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() dynamoDriver, err := mdynamodb.New(dynamoClient, dynamoDBDriverParams, log) So(dynamoDriver, ShouldNotBeNil) @@ -175,7 +175,7 @@ func TestRedisDB(t *testing.T) { Convey("RedisDB Wrapper", t, func() { rootDir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() params := redis.DBDriverParameters{KeyPrefix: "zot"} driverConfig := map[string]interface{}{"url": "redis://" + miniRedis.Addr()} @@ -2898,7 +2898,7 @@ func TestCreateBoltDB(t *testing.T) { conf := config.New() conf.Storage.RootDirectory = rootDir - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) Convey("Test New() with unspecified driver", func() { @@ -2938,7 +2938,7 @@ func TestCreateRedisDB(t *testing.T) { conf := config.New() conf.Storage.RemoteCache = true - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) Convey("Succeeds with default key prefix", func() { diff --git a/pkg/meta/parse_test.go b/pkg/meta/parse_test.go index 9f9b2c10..fd728fa7 100644 --- a/pkg/meta/parse_test.go +++ b/pkg/meta/parse_test.go @@ -54,7 +54,7 @@ func TestParseStorageErrors(t *testing.T) { metaDB := mocks.MetaDBMock{} // sync repo fail - err := meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", "")) + err := meta.ParseStorage(metaDB, storeController, log.NewTestLogger()) So(err, ShouldBeNil) Convey("getAllRepos errors", func() { @@ -75,14 +75,14 @@ func TestParseStorageErrors(t *testing.T) { }, } - err := meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", "")) + err := meta.ParseStorage(metaDB, storeController, log.NewTestLogger()) So(err, ShouldNotBeNil) }) Convey("metaDB.GetAllRepoNames errors", func() { metaDB.GetAllRepoNamesFn = func() ([]string, error) { return nil, ErrTestError } - err := meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", "")) + err := meta.ParseStorage(metaDB, storeController, log.NewTestLogger()) So(err, ShouldNotBeNil) }) @@ -95,7 +95,7 @@ func TestParseStorageErrors(t *testing.T) { metaDB.GetAllRepoNamesFn = func() ([]string, error) { return []string{"deleted"}, nil } metaDB.DeleteRepoMetaFn = func(repo string) error { return ErrTestError } - err := meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", "")) + err := meta.ParseStorage(metaDB, storeController, log.NewTestLogger()) So(err, ShouldNotBeNil) }) @@ -109,7 +109,7 @@ func TestParseStorageErrors(t *testing.T) { storeController := storage.StoreController{DefaultStore: imageStore1} - err := meta.ParseStorage(metaDB, storeController, log.NewLogger("debug", "")) + err := meta.ParseStorage(metaDB, storeController, log.NewTestLogger()) So(err, ShouldBeNil) }) }) @@ -118,7 +118,7 @@ func TestParseStorageErrors(t *testing.T) { imageStore := mocks.MockedImageStore{} storeController := storage.StoreController{DefaultStore: &imageStore} metaDB := mocks.MetaDBMock{} - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("imageStore.GetIndexContent errors", func() { imageStore.GetIndexContentFn = func(repo string) ([]byte, error) { @@ -221,7 +221,7 @@ func TestParseStorageErrors(t *testing.T) { Convey("SetImageMetaFromInput errors", t, func() { mockImageStore := mocks.MockedImageStore{} mockedMetaDB := mocks.MetaDBMock{} - log := log.NewLogger("debug", "") + log := log.NewTestLogger() Convey("Image Manifest errors", func() { Convey("Get Config blob error", func() { @@ -310,7 +310,7 @@ func TestParseStorageWithRedisDB(t *testing.T) { miniRedis := miniredis.RunT(t) rootDir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() params := redis.DBDriverParameters{KeyPrefix: "zot"} driverConfig := map[string]interface{}{"url": "redis://" + miniRedis.Addr()} @@ -660,7 +660,7 @@ func RunParseStorageTests(rootDir string, metaDB mTypes.MetaDB, log log.Logger) func TestGetSignatureLayersInfo(t *testing.T) { Convey("wrong signature type", t, func() { layers, err := meta.GetSignatureLayersInfo("repo", "tag", "123", "wrong signature type", []byte{}, - nil, log.NewLogger("debug", "")) + nil, log.NewTestLogger()) So(err, ShouldBeNil) So(layers, ShouldBeEmpty) }) @@ -673,7 +673,7 @@ func TestGetSignatureLayersInfo(t *testing.T) { notationIndexBlob, err := json.Marshal(notationIndex) So(err, ShouldBeNil) layers, err := meta.GetSignatureLayersInfo("repo", "tag", "123", zcommon.NotationSignature, notationIndexBlob, - nil, log.NewLogger("debug", "")) + nil, log.NewTestLogger()) So(err, ShouldBeNil) So(layers, ShouldBeEmpty) }) @@ -686,7 +686,7 @@ func TestGetSignatureLayersInfo(t *testing.T) { image := CreateRandomImage() layers, err := meta.GetSignatureLayersInfo("repo", "tag", "123", zcommon.CosignSignature, - image.ManifestDescriptor.Data, mockImageStore, log.NewLogger("debug", "")) + image.ManifestDescriptor.Data, mockImageStore, log.NewTestLogger()) So(err, ShouldNotBeNil) So(layers, ShouldBeEmpty) }) @@ -696,7 +696,7 @@ func TestGetSignatureLayersInfo(t *testing.T) { image := CreateImageWith().RandomLayers(3, 10).RandomConfig().Build() layers, err := meta.GetSignatureLayersInfo("repo", "tag", "123", zcommon.NotationSignature, - image.ManifestDescriptor.Data, mockImageStore, log.NewLogger("debug", "")) + image.ManifestDescriptor.Data, mockImageStore, log.NewTestLogger()) So(err, ShouldNotBeNil) So(layers, ShouldBeEmpty) }) @@ -709,18 +709,18 @@ func TestGetSignatureLayersInfo(t *testing.T) { image := CreateImageWith().RandomLayers(1, 10).RandomConfig().Build() layers, err := meta.GetSignatureLayersInfo("repo", "tag", "123", zcommon.NotationSignature, - image.ManifestDescriptor.Data, mockImageStore, log.NewLogger("debug", "")) + image.ManifestDescriptor.Data, mockImageStore, log.NewTestLogger()) So(err, ShouldNotBeNil) So(layers, ShouldBeEmpty) }) Convey("error while unmarshaling manifest content", t, func() { _, err := meta.GetSignatureLayersInfo("repo", "tag", "123", zcommon.CosignSignature, []byte("bad manifest"), - nil, log.NewLogger("debug", "")) + nil, log.NewTestLogger()) So(err, ShouldNotBeNil) _, err = meta.GetSignatureLayersInfo("repo", "tag", "123", zcommon.NotationSignature, []byte("bad manifest"), - nil, log.NewLogger("debug", "")) + nil, log.NewTestLogger()) So(err, ShouldNotBeNil) }) } diff --git a/pkg/meta/redis/redis_internal_test.go b/pkg/meta/redis/redis_internal_test.go index 2c9d9981..3cc795ad 100644 --- a/pkg/meta/redis/redis_internal_test.go +++ b/pkg/meta/redis/redis_internal_test.go @@ -14,7 +14,7 @@ func Test(t *testing.T) { Convey("Test redis metadb key generation", t, func() { miniRedis := miniredis.RunT(t) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) opts, err := redis.ParseURL("redis://" + miniRedis.Addr()) diff --git a/pkg/meta/redis/redis_test.go b/pkg/meta/redis/redis_test.go index 36c27089..311d0072 100644 --- a/pkg/meta/redis/redis_test.go +++ b/pkg/meta/redis/redis_test.go @@ -40,7 +40,7 @@ func (its imgTrustStore) VerifySignature( func TestRedisMocked(t *testing.T) { Convey("Test redis metadb implementation", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) client, mock := redismock.NewClientMock() @@ -228,7 +228,7 @@ func TestRedisRepoMeta(t *testing.T) { miniRedis := miniredis.RunT(t) Convey("Test repometa implementation", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) opts, err := goredis.ParseURL("redis://" + miniRedis.Addr()) @@ -397,7 +397,7 @@ func TestRedisUnreachable(t *testing.T) { Convey("Redis unreachable", t, func() { miniRedis := miniredis.RunT(t) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) connOpts, err := goredis.ParseURL("redis://" + miniRedis.Addr()) @@ -570,7 +570,7 @@ func TestWrapperErrors(t *testing.T) { Convey("Errors", t, func() { miniRedis := miniredis.RunT(t) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) opts, err := goredis.ParseURL("redis://" + miniRedis.Addr()) diff --git a/pkg/meta/version/version_test.go b/pkg/meta/version/version_test.go index 38bcd92b..0d782909 100644 --- a/pkg/meta/version/version_test.go +++ b/pkg/meta/version/version_test.go @@ -35,7 +35,7 @@ func TestVersioningBoltDB(t *testing.T) { boltDriver, err := boltdb.GetBoltDriver(boltDBParams) So(err, ShouldBeNil) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() boltdbWrapper, err := boltdb.New(boltDriver, log) @@ -142,7 +142,7 @@ func TestVersioningDynamoDB(t *testing.T) { dynamoClient, err := mdynamodb.GetDynamoClient(params) So(err, ShouldBeNil) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() dynamoWrapper, err := mdynamodb.New(dynamoClient, params, log) So(err, ShouldBeNil) @@ -226,7 +226,7 @@ func TestVersioningRedisDB(t *testing.T) { client := goredis.NewClient(opts) defer dumpRedisKeys(t, client) // Troubleshoot test failures - log := log.NewLogger("debug", "") + log := log.NewTestLogger() params := redis.DBDriverParameters{KeyPrefix: "zot"} diff --git a/pkg/scheduler/scheduler.go b/pkg/scheduler/scheduler.go index bf165898..83a358d0 100644 --- a/pkg/scheduler/scheduler.go +++ b/pkg/scheduler/scheduler.go @@ -107,7 +107,7 @@ func NewScheduler(cfg *config.Config, ms monitoring.MetricServer, logC log.Logge tasksLock: new(sync.Mutex), generators: generatorPQ, generatorsLock: new(sync.Mutex), - log: log.Logger{Logger: sublogger}, + log: sublogger, // default value metricServer: ms, RateLimit: rateLimit, diff --git a/pkg/storage/cache/boltdb_internal_test.go b/pkg/storage/cache/boltdb_internal_test.go index 8d1690d8..917c6dd4 100644 --- a/pkg/storage/cache/boltdb_internal_test.go +++ b/pkg/storage/cache/boltdb_internal_test.go @@ -1,6 +1,7 @@ package cache import ( + "io" "path/filepath" "testing" @@ -8,6 +9,7 @@ import ( . "github.com/smartystreets/goconvey/convey" "go.etcd.io/bbolt" + "zotregistry.dev/zot/pkg/log" "zotregistry.dev/zot/pkg/storage/constants" ) @@ -19,7 +21,8 @@ func TestBoltDriverErrors(t *testing.T) { So(err, ShouldBeNil) driver := BoltDBDriver{ - db: boltDB, + db: boltDB, + log: log.NewLoggerWithWriter("debug", io.Discard), } Convey("Empty boltdb", func() { diff --git a/pkg/storage/cache/boltdb_test.go b/pkg/storage/cache/boltdb_test.go index 7c6a9a39..8160c72a 100644 --- a/pkg/storage/cache/boltdb_test.go +++ b/pkg/storage/cache/boltdb_test.go @@ -16,7 +16,7 @@ func TestBoltDBCache(t *testing.T) { Convey("Make a new cache", t, func() { dir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) _, err := storage.Create("boltdb", "failTypeAssertion", log) @@ -126,7 +126,7 @@ func TestBoltDBCache(t *testing.T) { Convey("Test cache.GetAllBlos()", t, func() { dir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) _, err := storage.Create("boltdb", "failTypeAssertion", log) diff --git a/pkg/storage/cache/dynamodb_test.go b/pkg/storage/cache/dynamodb_test.go index 91166b7d..b587ea18 100644 --- a/pkg/storage/cache/dynamodb_test.go +++ b/pkg/storage/cache/dynamodb_test.go @@ -17,7 +17,7 @@ import ( func TestDynamoDB(t *testing.T) { tskip.SkipDynamo(t) Convey("Test dynamoDB", t, func(c C) { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() dir := t.TempDir() // bad params @@ -146,7 +146,7 @@ func TestDynamoDB(t *testing.T) { }) Convey("Test dynamoDB", t, func(c C) { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() cacheDriver, err := storage.Create("dynamodb", cache.DynamoDBDriverParameters{ Endpoint: os.Getenv("DYNAMODBMOCK_ENDPOINT"), @@ -191,7 +191,7 @@ func TestDynamoDB(t *testing.T) { func TestDynamoDBError(t *testing.T) { tskip.SkipDynamo(t) Convey("Test dynamoDB", t, func(c C) { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() cacheDriver, err := cache.NewDynamoDBCache(cache.DynamoDBDriverParameters{ Endpoint: os.Getenv("DYNAMODBMOCK_ENDPOINT"), diff --git a/pkg/storage/cache/redis_test.go b/pkg/storage/cache/redis_test.go index e242cfb6..2cfbe38a 100644 --- a/pkg/storage/cache/redis_test.go +++ b/pkg/storage/cache/redis_test.go @@ -28,7 +28,7 @@ func TestRedisCache(t *testing.T) { Convey("Make a new cache", t, func() { dir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) cacheDriver, err := storage.Create("redis", "failTypeAssertion", log) @@ -149,7 +149,7 @@ func TestRedisCache(t *testing.T) { Convey("Test cache.GetAllBlos()", t, func() { dir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) connOpts, _ := redis.ParseURL("redis://" + miniRedis.Addr()) @@ -207,7 +207,7 @@ func TestRedisCacheError(t *testing.T) { connOpts, _ := redis.ParseURL(redisURL) brokenClient := redis.NewClient(connOpts) - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) // redis server is not running @@ -221,7 +221,7 @@ func TestRedisCacheError(t *testing.T) { miniRedis := miniredis.RunT(t) dir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) connOpts, _ := redis.ParseURL("redis://" + miniRedis.Addr()) @@ -260,7 +260,7 @@ func TestRedisMocked(t *testing.T) { Convey("Redis tests using mocks", t, func() { dir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) tests := []cache.RedisDriverParameters{ diff --git a/pkg/storage/cache_test.go b/pkg/storage/cache_test.go index ae1534fc..79106673 100644 --- a/pkg/storage/cache_test.go +++ b/pkg/storage/cache_test.go @@ -16,7 +16,7 @@ func TestCache(t *testing.T) { Convey("Make a new cache", t, func() { dir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) _, err := storage.Create("boltdb", "failTypeAssertion", log) @@ -74,7 +74,7 @@ func TestCache(t *testing.T) { }) Convey("Invalid cache driver dbtype", t, func() { - log := log.NewLogger("debug", "") + log := log.NewTestLogger() So(log, ShouldNotBeNil) cacheDriver, err := storage.Create("sometype", map[string]interface{}{}, log) diff --git a/pkg/storage/common/common_test.go b/pkg/storage/common/common_test.go index f20aff1a..2a6c436c 100644 --- a/pkg/storage/common/common_test.go +++ b/pkg/storage/common/common_test.go @@ -9,7 +9,6 @@ import ( godigest "github.com/opencontainers/go-digest" ispec "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/rs/zerolog" . "github.com/smartystreets/goconvey/convey" zerr "zotregistry.dev/zot/errors" @@ -30,7 +29,7 @@ func TestValidateManifest(t *testing.T) { Convey("Make manifest", t, func(c C) { dir := t.TempDir() - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -191,7 +190,7 @@ func TestGetReferrersErrors(t *testing.T) { Convey("make storage", t, func(c C) { dir := t.TempDir() - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -371,7 +370,7 @@ func TestGetReferrersErrors(t *testing.T) { } func TestGetImageIndexErrors(t *testing.T) { - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() Convey("Trigger invalid digest error", t, func(c C) { imgStore := &mocks.MockedImageStore{} @@ -408,7 +407,7 @@ func TestGetImageIndexErrors(t *testing.T) { } func TestGetBlobDescriptorFromRepo(t *testing.T) { - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) tdir := t.TempDir() @@ -498,7 +497,7 @@ func TestIsSignature(t *testing.T) { } func TestDedupeGeneratorErrors(t *testing.T) { - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() // Ideally this would be covered by the end-to-end test, // but the coverage for the error is unpredictable, prone to race conditions diff --git a/pkg/storage/gc/gc_internal_test.go b/pkg/storage/gc/gc_internal_test.go index 3ed1b359..a104ba09 100644 --- a/pkg/storage/gc/gc_internal_test.go +++ b/pkg/storage/gc/gc_internal_test.go @@ -37,7 +37,7 @@ func TestGarbageCollectManifestErrors(t *testing.T) { Convey("Make imagestore and upload manifest", t, func(c C) { dir := t.TempDir() - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") metrics := monitoring.NewMetricsServer(false, log) @@ -162,7 +162,7 @@ func TestGarbageCollectIndexErrors(t *testing.T) { Convey("Make imagestore and upload manifest", t, func(c C) { dir := t.TempDir() - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") metrics := monitoring.NewMetricsServer(false, log) @@ -285,7 +285,7 @@ func TestGarbageCollectWithMockedImageStore(t *testing.T) { ctx := context.Background() Convey("Cover gc error paths", t, func(c C) { - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") gcOptions := Options{ diff --git a/pkg/storage/gc/gc_test.go b/pkg/storage/gc/gc_test.go index 6a0866aa..ac59e85b 100644 --- a/pkg/storage/gc/gc_test.go +++ b/pkg/storage/gc/gc_test.go @@ -59,7 +59,7 @@ var testCases = []struct { } func TestGarbageCollectAndRetentionMetaDB(t *testing.T) { - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "/dev/null") metrics := monitoring.NewMetricsServer(false, log) @@ -1313,7 +1313,7 @@ func TestGarbageCollectAndRetentionMetaDB(t *testing.T) { func TestGarbageCollectDeletion(t *testing.T) { Convey("setup store", t, func() { - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "/dev/null") metrics := monitoring.NewMetricsServer(false, log) @@ -1751,7 +1751,7 @@ func readTagsFromStorage(rootDir, repoName string, digest godigest.Digest) ([]st } func TestGarbageCollectAndRetentionNoMetaDB(t *testing.T) { - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "/dev/null") metrics := monitoring.NewMetricsServer(false, log) diff --git a/pkg/storage/local/local_elevated_test.go b/pkg/storage/local/local_elevated_test.go index c4ef5d4b..ca8cd333 100644 --- a/pkg/storage/local/local_elevated_test.go +++ b/pkg/storage/local/local_elevated_test.go @@ -13,7 +13,6 @@ import ( "testing" godigest "github.com/opencontainers/go-digest" - "github.com/rs/zerolog" . "github.com/smartystreets/goconvey/convey" "zotregistry.dev/zot/pkg/extensions/monitoring" @@ -27,7 +26,7 @@ func TestElevatedPrivilegesInvalidDedupe(t *testing.T) { Convey("Invalid dedupe scenarios", t, func() { dir := t.TempDir() - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ diff --git a/pkg/storage/local/local_test.go b/pkg/storage/local/local_test.go index fb35ee30..d49429a3 100644 --- a/pkg/storage/local/local_test.go +++ b/pkg/storage/local/local_test.go @@ -21,7 +21,6 @@ import ( godigest "github.com/opencontainers/go-digest" imeta "github.com/opencontainers/image-spec/specs-go" ispec "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/rs/zerolog" . "github.com/smartystreets/goconvey/convey" zerr "zotregistry.dev/zot/errors" @@ -62,7 +61,7 @@ var DeleteReferrers = config.ImageRetention{ //nolint: gochecknoglobals var errCache = errors.New("new cache error") func runAndGetScheduler() *scheduler.Scheduler { - log := zlog.Logger{} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(true, log) taskScheduler := scheduler.NewScheduler(config.New(), metrics, log) taskScheduler.RateLimit = 50 * time.Millisecond @@ -75,7 +74,7 @@ func runAndGetScheduler() *scheduler.Scheduler { func TestStorageFSAPIs(t *testing.T) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -209,7 +208,7 @@ func FuzzNewBlobUpload(f *testing.F) { defer os.RemoveAll(dir) t.Logf("Input argument is %s", data) - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -236,7 +235,7 @@ func FuzzPutBlobChunk(f *testing.F) { defer os.RemoveAll(dir) t.Logf("Input argument is %s", data) - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ @@ -273,7 +272,7 @@ func FuzzPutBlobChunkStreamed(f *testing.F) { defer os.RemoveAll(dir) t.Logf("Input argument is %s", data) - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -306,7 +305,7 @@ func FuzzGetBlobUpload(f *testing.F) { f.Fuzz(func(t *testing.T, data1 string, data2 string) { dir := t.TempDir() defer os.RemoveAll(dir) - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -329,7 +328,7 @@ func FuzzGetBlobUpload(f *testing.F) { func FuzzTestPutGetImageManifest(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) dir := t.TempDir() @@ -385,7 +384,7 @@ func FuzzTestPutGetImageManifest(f *testing.F) { func FuzzTestPutDeleteImageManifest(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) dir := t.TempDir() @@ -446,7 +445,7 @@ func FuzzTestPutDeleteImageManifest(f *testing.F) { // no integration with PutImageManifest, just throw fuzz data. func FuzzTestDeleteImageManifest(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) dir := t.TempDir() @@ -483,7 +482,7 @@ func FuzzDirExists(f *testing.F) { func FuzzInitRepo(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) dir := t.TempDir() @@ -509,7 +508,7 @@ func FuzzInitRepo(f *testing.F) { func FuzzInitValidateRepo(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) dir := t.TempDir() @@ -544,7 +543,7 @@ func FuzzInitValidateRepo(f *testing.F) { func FuzzGetImageTags(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) dir := t.TempDir() @@ -570,7 +569,7 @@ func FuzzGetImageTags(f *testing.F) { func FuzzBlobUploadPath(f *testing.F) { f.Fuzz(func(t *testing.T, repo, uuid string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) dir := t.TempDir() @@ -589,7 +588,7 @@ func FuzzBlobUploadPath(f *testing.F) { func FuzzBlobUploadInfo(f *testing.F) { f.Fuzz(func(t *testing.T, data string, uuid string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) dir := t.TempDir() @@ -619,7 +618,7 @@ func FuzzTestGetImageManifest(f *testing.F) { dir := t.TempDir() defer os.RemoveAll(dir) - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -648,7 +647,7 @@ func FuzzFinishBlobUpload(f *testing.F) { dir := t.TempDir() defer os.RemoveAll(dir) - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -695,7 +694,7 @@ func FuzzFinishBlobUpload(f *testing.F) { func FuzzFullBlobUpload(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) repoName := "test" @@ -727,7 +726,7 @@ func FuzzFullBlobUpload(f *testing.F) { func TestStorageCacheErrors(t *testing.T) { Convey("get error in DedupeBlob() when cache.Put() deduped blob", t, func() { - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) dir := t.TempDir() @@ -769,7 +768,7 @@ func TestStorageCacheErrors(t *testing.T) { func FuzzDedupeBlob(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) dir := t.TempDir() @@ -809,7 +808,7 @@ func FuzzDedupeBlob(f *testing.F) { func FuzzDeleteBlobUpload(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) repoName := data @@ -841,7 +840,7 @@ func FuzzDeleteBlobUpload(f *testing.F) { func FuzzBlobPath(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) repoName := data @@ -862,7 +861,7 @@ func FuzzBlobPath(f *testing.F) { func FuzzCheckBlob(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) repoName := data @@ -895,7 +894,7 @@ func FuzzCheckBlob(f *testing.F) { func FuzzGetBlob(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) repoName := data @@ -936,7 +935,7 @@ func FuzzGetBlob(f *testing.F) { func FuzzDeleteBlob(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) repoName := data @@ -973,7 +972,7 @@ func FuzzDeleteBlob(f *testing.F) { func FuzzGetIndexContent(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) repoName := data @@ -1010,7 +1009,7 @@ func FuzzGetIndexContent(f *testing.F) { func FuzzGetBlobContent(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := &zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLoggerPtr() metrics := monitoring.NewMetricsServer(false, *log) repoName := data @@ -1047,7 +1046,7 @@ func FuzzGetBlobContent(f *testing.F) { func FuzzRunGCRepo(f *testing.F) { f.Fuzz(func(t *testing.T, data string) { - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") metrics := monitoring.NewMetricsServer(false, log) @@ -1088,7 +1087,7 @@ func TestDedupeLinks(t *testing.T) { }, } - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) for _, testCase := range testCases { @@ -1485,7 +1484,7 @@ func TestDedupe(t *testing.T) { Convey("Valid ImageStore", func() { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -1505,7 +1504,7 @@ func TestNegativeCases(t *testing.T) { Convey("Invalid root dir", t, func(c C) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -1529,7 +1528,7 @@ func TestNegativeCases(t *testing.T) { Convey("Invalid init repo", t, func(c C) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -1579,7 +1578,7 @@ func TestNegativeCases(t *testing.T) { Convey("Invalid validate repo", t, func(c C) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -1693,7 +1692,7 @@ func TestNegativeCases(t *testing.T) { Convey("Invalid get image tags", t, func(c C) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -1720,7 +1719,7 @@ func TestNegativeCases(t *testing.T) { Convey("Invalid get image manifest", t, func(c C) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -1768,7 +1767,7 @@ func TestNegativeCases(t *testing.T) { Convey("Invalid new blob upload", t, func(c C) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -1946,7 +1945,7 @@ func TestInjectWriteFile(t *testing.T) { Convey("writeFile without commit", t, func() { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -2062,7 +2061,7 @@ func TestGarbageCollectForImageStore(t *testing.T) { }) Convey("Garbage collect - the manifest which the reference points to can be found", func() { - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") metrics := monitoring.NewMetricsServer(false, log) @@ -2214,7 +2213,7 @@ func TestGarbageCollectImageUnknownManifest(t *testing.T) { dir := t.TempDir() - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") metrics := monitoring.NewMetricsServer(false, log) @@ -2397,7 +2396,7 @@ func TestGarbageCollectErrors(t *testing.T) { dir := t.TempDir() - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") metrics := monitoring.NewMetricsServer(false, log) @@ -2646,7 +2645,7 @@ func TestInitRepo(t *testing.T) { Convey("Get error when creating BlobUploadDir subdir on initRepo", t, func() { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -2668,7 +2667,7 @@ func TestValidateRepo(t *testing.T) { Convey("Get error when unable to read directory", t, func() { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -2688,7 +2687,7 @@ func TestValidateRepo(t *testing.T) { Convey("Get error when repo name is not compliant with repo spec", t, func() { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -2733,7 +2732,7 @@ func TestGetRepositories(t *testing.T) { Convey("Verify errors and repos returned by GetRepositories()", t, func() { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -2828,7 +2827,7 @@ func TestGetRepositories(t *testing.T) { Convey("Verify GetRepositories() doesn't return '.' when having an oci layout as root directory ", t, func() { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -2874,7 +2873,7 @@ func TestGetRepositories(t *testing.T) { err := os.Mkdir(rootDir, 0o755) So(err, ShouldBeNil) - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: rootDir, @@ -2918,7 +2917,7 @@ func TestGetRepositories(t *testing.T) { func TestGetNextRepository(t *testing.T) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -2995,7 +2994,7 @@ func TestPutBlobChunkStreamed(t *testing.T) { Convey("Get error on opening file", t, func() { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, @@ -3023,7 +3022,7 @@ func TestPullRange(t *testing.T) { Convey("Repo layout", t, func(c C) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) Convey("Negative cases", func() { @@ -3073,7 +3072,7 @@ func TestPullRange(t *testing.T) { func TestStatIndex(t *testing.T) { Convey("NewImageStore", t, func() { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) imgStore := local.NewImageStore(dir, true, true, log, metrics, nil, nil, nil, nil) @@ -3091,7 +3090,7 @@ func TestStatIndex(t *testing.T) { func TestStorageDriverErr(t *testing.T) { dir := t.TempDir() - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: dir, diff --git a/pkg/storage/s3/s3_test.go b/pkg/storage/s3/s3_test.go index a1d4ba25..05d927fb 100644 --- a/pkg/storage/s3/s3_test.go +++ b/pkg/storage/s3/s3_test.go @@ -21,7 +21,6 @@ import ( guuid "github.com/gofrs/uuid" godigest "github.com/opencontainers/go-digest" ispec "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/rs/zerolog" . "github.com/smartystreets/goconvey/convey" "gopkg.in/resty.v1" @@ -60,7 +59,7 @@ func cleanupStorage(store driver.StorageDriver, name string) { func createMockStorage(rootDir string, cacheDir string, dedupe bool, store driver.StorageDriver, ) storageTypes.ImageStore { - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(true, log) var cacheDriver storageTypes.Cache @@ -83,7 +82,7 @@ func createMockStorage(rootDir string, cacheDir string, dedupe bool, store drive func createMockStorageWithMockCache(rootDir string, dedupe bool, store driver.StorageDriver, cacheDriver storageTypes.Cache, ) storageTypes.ImageStore { - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) il := s3.NewImageStore(rootDir, "", dedupe, false, log, metrics, nil, store, cacheDriver, nil, nil) @@ -130,7 +129,7 @@ func createObjectsStore(rootDir string, cacheDir string, dedupe bool) ( ) { store := createStoreDriver(rootDir) - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) var cacheDriver storageTypes.Cache @@ -160,7 +159,7 @@ func createObjectsStoreDynamo(rootDir string, cacheDir string, dedupe bool, tabl ) { store := createStoreDriver(rootDir) - log := log.Logger{Logger: zerolog.New(os.Stdout)} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) var cacheDriver storageTypes.Cache @@ -188,7 +187,7 @@ func createObjectsStoreDynamo(rootDir string, cacheDir string, dedupe bool, tabl } func runAndGetScheduler() *scheduler.Scheduler { - log := log.Logger{} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) taskScheduler := scheduler.NewScheduler(config.New(), metrics, log) taskScheduler.RateLimit = 50 * time.Millisecond @@ -2020,7 +2019,7 @@ func TestRebuildDedupeIndex(t *testing.T) { Convey("Intrerrupt rebuilding and restart, checking idempotency", func() { for i := 0; i < 10; i++ { - log := log.Logger{} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) taskScheduler := scheduler.NewScheduler(config.New(), metrics, log) taskScheduler.RateLimit = 1 * time.Millisecond @@ -2062,7 +2061,7 @@ func TestRebuildDedupeIndex(t *testing.T) { // now from dedupe false to true for i := 0; i < 10; i++ { - log := log.Logger{} + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) taskScheduler := scheduler.NewScheduler(config.New(), metrics, log) taskScheduler.RateLimit = 1 * time.Millisecond diff --git a/pkg/storage/scrub_test.go b/pkg/storage/scrub_test.go index fbe8d59f..2b5c3019 100644 --- a/pkg/storage/scrub_test.go +++ b/pkg/storage/scrub_test.go @@ -42,7 +42,7 @@ var errUnexpectedError = errors.New("unexpected err") func TestLocalCheckAllBlobsIntegrity(t *testing.T) { Convey("test with local storage", t, func() { tdir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDriver, _ := storage.Create("boltdb", cache.BoltDBDriverParameters{ RootDir: tdir, @@ -61,7 +61,7 @@ func TestRedisCheckAllBlobsIntegrity(t *testing.T) { Convey("test with local storage", t, func() { tdir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) @@ -90,7 +90,7 @@ func TestS3CheckAllBlobsIntegrity(t *testing.T) { testDir := path.Join("/oci-repo-test", uuid.String()) tdir := t.TempDir() - log := log.NewLogger("debug", "") + log := log.NewTestLogger() opts := createObjectStoreOpts{ rootDir: testDir, diff --git a/pkg/storage/storage_test.go b/pkg/storage/storage_test.go index 12eca9a6..c6d26486 100644 --- a/pkg/storage/storage_test.go +++ b/pkg/storage/storage_test.go @@ -23,7 +23,6 @@ import ( godigest "github.com/opencontainers/go-digest" ispec "github.com/opencontainers/image-spec/specs-go/v1" "github.com/redis/go-redis/v9" - "github.com/rs/zerolog" . "github.com/smartystreets/goconvey/convey" "gopkg.in/resty.v1" @@ -79,7 +78,7 @@ func createObjectsStore(options createObjectStoreOpts) ( useRelPaths bool ) - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() if options.storageType == storageConstants.S3StorageDriverName { useRelPaths = false @@ -183,7 +182,7 @@ func TestStorageNew(t *testing.T) { conf.Storage.RootDirectory = "dir" conf.Storage.StorageDriver = map[string]interface{}{} - _, err := storage.New(conf, nil, nil, zlog.NewLogger("debug", ""), nil) + _, err := storage.New(conf, nil, nil, zlog.NewTestLogger(), nil) So(err, ShouldNotBeNil) }) } @@ -1014,7 +1013,7 @@ func TestMandatoryAnnotations(t *testing.T) { testDir string ) - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() metrics := monitoring.NewMetricsServer(false, log) cacheDir := t.TempDir() @@ -1151,7 +1150,7 @@ func TestStorageSubpaths(t *testing.T) { }, } - _, err := storage.New(config, nil, nil, zlog.NewLogger("debug", ""), nil) + _, err := storage.New(config, nil, nil, zlog.NewTestLogger(), nil) So(err, ShouldBeNil) }) @@ -1176,7 +1175,7 @@ func TestStorageSubpaths(t *testing.T) { err := os.WriteFile(dbPath, []byte(""), 0o000) So(err, ShouldBeNil) - _, err = storage.New(config, nil, nil, zlog.NewLogger("debug", ""), nil) + _, err = storage.New(config, nil, nil, zlog.NewTestLogger(), nil) So(err, ShouldNotBeNil) err = os.Chmod(dbPath, 0o600) @@ -1200,7 +1199,7 @@ func TestStorageSubpaths(t *testing.T) { }, } - _, err := storage.New(config, nil, nil, zlog.NewLogger("debug", ""), nil) + _, err := storage.New(config, nil, nil, zlog.NewTestLogger(), nil) So(err, ShouldNotBeNil) }) } @@ -1211,7 +1210,7 @@ func TestDeleteBlobsInUse(t *testing.T) { t.Run(testcase.testCaseName, func(t *testing.T) { var imgStore storageTypes.ImageStore - log := zlog.Logger{Logger: zerolog.New(os.Stdout)} + log := zlog.NewTestLogger() cacheDir := t.TempDir() @@ -1767,7 +1766,7 @@ func TestGarbageCollectImageManifest(t *testing.T) { for _, testcase := range testCases { testcase := testcase t.Run(testcase.testCaseName, func(t *testing.T) { - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") ctx := context.Background() @@ -2451,7 +2450,7 @@ func TestGarbageCollectImageIndex(t *testing.T) { for _, testcase := range testCases { testcase := testcase t.Run(testcase.testCaseName, func(t *testing.T) { - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") ctx := context.Background() @@ -2859,7 +2858,7 @@ func TestGarbageCollectChainedImageIndexes(t *testing.T) { for _, testcase := range testCases { testcase := testcase t.Run(testcase.testCaseName, func(t *testing.T) { - log := zlog.NewLogger("debug", "") + log := zlog.NewTestLogger() audit := zlog.NewAuditLogger("debug", "") ctx := context.Background() diff --git a/pkg/test/oci-utils/oci_layout_test.go b/pkg/test/oci-utils/oci_layout_test.go index d68f4889..0f50f7f1 100644 --- a/pkg/test/oci-utils/oci_layout_test.go +++ b/pkg/test/oci-utils/oci_layout_test.go @@ -43,7 +43,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController := storage.StoreController{DefaultStore: mockStoreController} - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) size := olu.GetImageManifestSize("", "") So(size, ShouldBeZeroValue) @@ -57,7 +57,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController := storage.StoreController{DefaultStore: mockStoreController} - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) size := olu.GetImageConfigSize("", "") So(size, ShouldBeZeroValue) @@ -95,7 +95,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController := storage.StoreController{DefaultStore: mockStoreController} - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) size := olu.GetImageConfigSize("", "") So(size, ShouldBeZeroValue) @@ -109,7 +109,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController := storage.StoreController{DefaultStore: mockStoreController} - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) _, err := olu.GetRepoLastUpdated("") So(err, ShouldNotBeNil) @@ -135,7 +135,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController := storage.StoreController{DefaultStore: mockStoreController} - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) _, err = olu.GetImageTagsWithTimestamp("rep") So(err, ShouldNotBeNil) @@ -179,7 +179,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController := storage.StoreController{DefaultStore: mockStoreController} - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) _, err = olu.GetImageTagsWithTimestamp("repo") So(err, ShouldNotBeNil) @@ -222,7 +222,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController := storage.StoreController{DefaultStore: mockStoreController} - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) _, err = olu.GetExpandedRepoInfo("rep") So(err, ShouldNotBeNil) @@ -235,7 +235,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController = storage.StoreController{DefaultStore: mockStoreController} - olu = ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu = ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) _, err = olu.GetExpandedRepoInfo("rep") So(err, ShouldNotBeNil) @@ -252,7 +252,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController = storage.StoreController{DefaultStore: mockStoreController} - olu = ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu = ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) _, err = olu.GetExpandedRepoInfo("rep") So(err, ShouldBeNil) @@ -266,7 +266,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController := storage.StoreController{DefaultStore: mockStoreController} - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) _, err := olu.GetImageInfo("", "") So(err, ShouldNotBeNil) @@ -284,7 +284,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { } storeController := storage.StoreController{DefaultStore: mockStoreController} - olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(storeController, log.NewTestLogger()) check := olu.CheckManifestSignature("rep", godigest.FromString("")) So(check, ShouldBeFalse) @@ -318,7 +318,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { err := UploadImage(image, baseURL, repo, tag) So(err, ShouldBeNil) - olu = ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewLogger("debug", "")) + olu = ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewTestLogger()) manifestList, err := olu.GetImageManifests(repo) So(err, ShouldBeNil) So(len(manifestList), ShouldEqual, 1) @@ -364,7 +364,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { err := UploadImage(image, baseURL, repo, tag) So(err, ShouldBeNil) - olu := ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewTestLogger()) manifestList, err := olu.GetImageManifests(repo) So(err, ShouldBeNil) So(len(manifestList), ShouldEqual, 1) @@ -411,7 +411,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { err := UploadImage(image, baseURL, repo, tag) So(err, ShouldBeNil) - olu := ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewLogger("debug", "")) + olu := ociutils.NewBaseOciLayoutUtils(ctlr.StoreController, log.NewTestLogger()) manifestList, err := olu.GetImageManifests(repo) So(err, ShouldBeNil) So(len(manifestList), ShouldEqual, 1) @@ -431,7 +431,7 @@ func TestBaseOciLayoutUtils(t *testing.T) { func TestExtractImageDetails(t *testing.T) { Convey("extractImageDetails good workflow", t, func() { dir := t.TempDir() - testLogger := log.NewLogger("debug", "") + testLogger := log.NewTestLogger() imageStore := local.NewImageStore(dir, false, false, testLogger, monitoring.NewMetricsServer(false, testLogger), nil, nil, nil, nil) @@ -455,7 +455,7 @@ func TestExtractImageDetails(t *testing.T) { Convey("extractImageDetails bad ispec.ImageManifest", t, func() { dir := t.TempDir() - testLogger := log.NewLogger("debug", "") + testLogger := log.NewTestLogger() imageStore := local.NewImageStore(dir, false, false, testLogger, monitoring.NewMetricsServer(false, testLogger), nil, nil, nil, nil) @@ -475,7 +475,7 @@ func TestExtractImageDetails(t *testing.T) { Convey("extractImageDetails bad imageConfig", t, func() { dir := t.TempDir() - testLogger := log.NewLogger("debug", "") + testLogger := log.NewTestLogger() imageStore := local.NewImageStore(dir, false, false, testLogger, monitoring.NewMetricsServer(false, testLogger), nil, nil, nil, nil)