feat: remove usage of zerolog.Logger.Msgf() from zot code (#1382)

Signed-off-by: Nicol Draghici <idraghic@cisco.com>

pkg/extensions/sync/on_demand.go

@@ -69,7 +69,8 @@ func OneImage(ctx context.Context, cfg syncconf.Config, repoDB repodb.RepoDB,
 	imageChannel, found := demandedImgs.loadOrStoreChan(demandedImage, make(chan error))
 	// if value found wait on channel receive or close
 	if found {
-		log.Info().Msgf("image %s already demanded by another client, waiting on imageChannel", demandedImage)
+		log.Info().Str("demandedImage", demandedImage).
+			Msg("image already demanded by another client, waiting on imageChannel")
 
 		err, ok := <-imageChannel
 		// if channel closed exit
@@ -105,7 +106,7 @@ func syncOneImage(ctx context.Context, imageChannel chan error, cfg syncconf.Con
 		credentialsFile, err = getFileCredentials(cfg.CredentialsFile)
 		if err != nil {
 			log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get registry credentials from %s", cfg.CredentialsFile)
+				Err(err).Str("credentialsFile", cfg.CredentialsFile).Msg("couldn't get registry credentials from file")
 
 			imageChannel <- err
 
@@ -123,7 +124,8 @@ func syncOneImage(ctx context.Context, imageChannel chan error, cfg syncconf.Con
 	for _, registryCfg := range cfg.Registries {
 		regCfg := registryCfg
 		if !regCfg.OnDemand {
-			log.Info().Msgf("skipping syncing on demand from %v, onDemand flag is false", regCfg.URLs)
+			log.Info().Strs("registry", regCfg.URLs).
+				Msg("skipping syncing on demand from registry, onDemand flag is false")
 
 			continue
 		}
@@ -134,8 +136,8 @@ func syncOneImage(ctx context.Context, imageChannel chan error, cfg syncconf.Con
 		if len(regCfg.Content) != 0 {
 			contentID, err := findRepoMatchingContentID(localRepo, regCfg.Content)
 			if err != nil {
-				log.Info().Msgf("skipping syncing on demand %s from %v registry because it's filtered out by content config",
-					localRepo, regCfg.URLs)
+				log.Info().Str("localRepo", localRepo).Strs("registry",
+					regCfg.URLs).Msg("skipping syncing on demand repo from registry because it's filtered out by content config")
 
 				continue
 			}
@@ -152,7 +154,7 @@ func syncOneImage(ctx context.Context, imageChannel chan error, cfg syncconf.Con
 			}
 		}
 
-		log.Info().Msgf("syncing on demand with %v", regCfg.URLs)
+		log.Info().Strs("registry", regCfg.URLs).Msg("syncing on demand with registry")
 
 		for _, regCfgURL := range regCfg.URLs {
 			upstreamURL := regCfgURL
@@ -233,7 +235,7 @@ func syncOneImage(ctx context.Context, imageChannel chan error, cfg syncconf.Con
 
 				_, found := demandedImgs.loadOrStoreStr(demandedImageRef, "")
 				if found {
-					log.Info().Msgf("image %s already demanded in background", demandedImageRef)
+					log.Info().Str("demandedImageRef", demandedImageRef).Msg("image already demanded in background")
 					/* we already have a go routine spawned for this image
 					or retryOptions is not configured */
 					continue
@@ -244,11 +246,11 @@ func syncOneImage(ctx context.Context, imageChannel chan error, cfg syncconf.Con
 					// remove image after syncing
 					defer func() {
 						demandedImgs.delete(demandedImageRef)
-						log.Info().Msgf("sync routine: %s exited", demandedImageRef)
+						log.Info().Str("demandedImageRef", demandedImageRef).Msg("sync routine: demanded image exited")
 					}()
 
-					log.Info().Msgf("sync routine: starting routine to copy image %s, cause err: %v",
-						demandedImageRef, copyErr)
+					log.Info().Str("demandedImageRef", demandedImageRef).Str("copyErr", copyErr.Error()).
+						Msg("sync routine: starting routine to copy image, err encountered")
 					time.Sleep(retryOptions.Delay)
 
 					if err = retry.RetryIfNecessary(ctx, func() error {
@@ -256,8 +258,8 @@ func syncOneImage(ctx context.Context, imageChannel chan error, cfg syncconf.Con
 
 						return err
 					}, retryOptions); err != nil {
-						log.Error().Str("errorType", common.TypeOf(err)).
-							Err(err).Msgf("sync routine: error while copying image %s", demandedImageRef)
+						log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+							Str("demandedImageRef", demandedImageRef).Msg("sync routine: error while copying image")
 					}
 				}()
 			} else {
@@ -276,9 +278,9 @@ func syncRun(localRepo, upstreamRepo, reference string, utils syncContextUtils,
 ) (bool, error) {
 	upstreamImageRef, err := getImageRef(utils.upstreamAddr, upstreamRepo, reference)
 	if err != nil {
-		log.Error().Str("errorType", common.TypeOf(err)).
-			Err(err).Msgf("error creating docker reference for repository %s/%s:%s",
-			utils.upstreamAddr, upstreamRepo, reference)
+		log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+			Str("repository", utils.upstreamAddr+"/"+upstreamRepo+":"+reference).
+			Msg("error creating docker reference for repository")
 
 		return false, err
 	}
@@ -287,7 +289,7 @@ func syncRun(localRepo, upstreamRepo, reference string, utils syncContextUtils,
 
 	localCachePath, err := getLocalCachePath(imageStore, localRepo)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't get localCachePath for %s", localRepo)
+		log.Error().Err(err).Str("repository", localRepo).Msg("couldn't get localCachePath for repository")
 
 		return false, err
 	}
@@ -306,16 +308,16 @@ func syncSignaturesArtifacts(sig *signaturesCopier, localRepo, upstreamRepo, ref
 		// is cosign signature
 		cosignManifest, err := sig.getCosignManifest(upstreamRepo, reference)
 		if err != nil {
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get upstream image %s:%s:%s cosign manifest", upstreamURL, upstreamRepo, reference)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("image", upstreamURL+"/"+upstreamRepo+":"+reference).Msg("couldn't get upstream image cosign manifest")
 
 			return err
 		}
 
 		err = sig.syncCosignSignature(localRepo, upstreamRepo, reference, cosignManifest)
 		if err != nil {
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't copy upstream image cosign signature %s/%s:%s", upstreamURL, upstreamRepo, reference)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("image", upstreamURL+"/"+upstreamRepo+":"+reference).Msg("couldn't copy upstream image cosign signature")
 
 			return err
 		}
@@ -323,16 +325,16 @@ func syncSignaturesArtifacts(sig *signaturesCopier, localRepo, upstreamRepo, ref
 		// is oras artifact
 		refs, err := sig.getORASRefs(upstreamRepo, reference)
 		if err != nil {
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get upstream image %s/%s:%s ORAS references", upstreamURL, upstreamRepo, reference)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("image", upstreamURL+"/"+upstreamRepo+":"+reference).Msg("couldn't get upstream image ORAS references")
 
 			return err
 		}
 
 		err = sig.syncORASRefs(localRepo, upstreamRepo, reference, refs)
 		if err != nil {
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't copy image ORAS references %s/%s:%s", upstreamURL, upstreamRepo, reference)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("image", upstreamURL+"/"+upstreamRepo+":"+reference).Msg("couldn't copy image ORAS references")
 
 			return err
 		}
@@ -340,16 +342,16 @@ func syncSignaturesArtifacts(sig *signaturesCopier, localRepo, upstreamRepo, ref
 		// this contains notary signatures
 		index, err := sig.getOCIRefs(upstreamRepo, reference)
 		if err != nil {
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get OCI references %s/%s:%s", upstreamURL, upstreamRepo, reference)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("image", upstreamURL+"/"+upstreamRepo+":"+reference).Msg("couldn't get OCI references")
 
 			return err
 		}
 
 		err = sig.syncOCIRefs(localRepo, upstreamRepo, reference, index)
 		if err != nil {
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't copy OCI references %s/%s:%s", upstreamURL, upstreamRepo, reference)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("image", upstreamURL+"/"+upstreamRepo+":"+reference).Msg("couldn't copy OCI references")
 
 			return err
 		}

pkg/extensions/sync/signatures.go

@@ -64,14 +64,14 @@ func (sig *signaturesCopier) getCosignManifest(repo, digestStr string) (*ispec.M
 		getCosignManifestURL.String(), ispec.MediaTypeImageManifest, sig.log)
 	if err != nil {
 		if statusCode == http.StatusNotFound {
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't find any cosign manifest: %s", getCosignManifestURL.String())
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("manifest", getCosignManifestURL.String()).Msg("couldn't find any cosign manifest")
 
 			return nil, zerr.ErrSyncReferrerNotFound
 		}
 
-		sig.log.Error().Str("errorType", common.TypeOf(err)).
-			Err(err).Msgf("couldn't get cosign manifest: %s", getCosignManifestURL.String())
+		sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+			Str("manifest", getCosignManifestURL.String()).Msg("couldn't get cosign manifest")
 
 		return nil, err
 	}
@@ -122,15 +122,15 @@ func (sig *signaturesCopier) getOCIRefs(repo, digestStr string) (ispec.Index, er
 		getReferrersURL.String(), "application/json", sig.log)
 	if err != nil {
 		if statusCode == http.StatusNotFound {
-			sig.log.Info().Msgf("couldn't find any oci reference from %s, status code: %d, skipping",
-				getReferrersURL.String(), statusCode)
+			sig.log.Info().Str("referrers", getReferrersURL.String()).Int("statusCode", statusCode).
+				Msg("couldn't find any oci reference from referrers, skipping")
 
 			return index, zerr.ErrSyncReferrerNotFound
 		}
 
-		sig.log.Error().Str("errorType", common.TypeOf(zerr.ErrSyncReferrer)).
-			Err(zerr.ErrSyncReferrer).Msgf("couldn't get oci reference from %s, status code: %d skipping",
-			getReferrersURL.String(), statusCode)
+		sig.log.Error().Str("errorType", common.TypeOf(zerr.ErrSyncReferrer)).Err(zerr.ErrSyncReferrer).
+			Str("referrers", getReferrersURL.String()).Int("statusCode", statusCode).
+			Msg("couldn't get oci reference from referrers, skipping")
 
 		return index, zerr.ErrSyncReferrer
 	}
@@ -150,8 +150,8 @@ func (sig *signaturesCopier) syncCosignSignature(localRepo, remoteRepo, digestSt
 
 	skipCosignSig, err := sig.canSkipCosignSignature(localRepo, digestStr, cosignManifest)
 	if err != nil {
-		sig.log.Error().Err(err).Msgf("couldn't check if the upstream image %s:%s cosign signature can be skipped",
-			remoteRepo, digestStr)
+		sig.log.Error().Err(err).Str("repository", remoteRepo).Str("reference", digestStr).
+			Msg("couldn't check if the upstream image cosign signature can be skipped")
 	}
 
 	if skipCosignSig {
@@ -190,7 +190,8 @@ func (sig *signaturesCopier) syncCosignSignature(localRepo, remoteRepo, digestSt
 	}
 
 	if sig.repoDB != nil {
-		sig.log.Debug().Msgf("trying to sync cosign signature for repo %s digest %s", localRepo, digestStr)
+		sig.log.Debug().Str("repository", localRepo).Str("digest", digestStr).
+			Msg("trying to sync cosign signature for repo digest")
 
 		err = repodb.SetMetadataFromInput(localRepo, cosignTag, ispec.MediaTypeImageManifest,
 			godigest.FromBytes(cosignManifestBuf), cosignManifestBuf, sig.storeController.GetImageStore(localRepo),
@@ -199,7 +200,8 @@ func (sig *signaturesCopier) syncCosignSignature(localRepo, remoteRepo, digestSt
 			return fmt.Errorf("failed to set metadata for cosign signature '%s@%s': %w", localRepo, digestStr, err)
 		}
 
-		sig.log.Info().Msgf("successfully added cosign signature to RepoDB for repo %s digest %s", localRepo, digestStr)
+		sig.log.Info().Str("repository", localRepo).Str("digest", digestStr).
+			Msg("successfully added cosign signature to RepoDB for repo digest")
 	}
 
 	return nil
@@ -213,8 +215,8 @@ func (sig *signaturesCopier) syncORASRefs(localRepo, remoteRepo, digestStr strin
 
 	skipORASRefs, err := sig.canSkipORASRefs(localRepo, digestStr, referrers)
 	if err != nil {
-		sig.log.Error().Err(err).Msgf("couldn't check if the upstream image %s:%s ORAS artifact can be skipped",
-			remoteRepo, digestStr)
+		sig.log.Error().Err(err).Str("repository", remoteRepo).Str("reference", digestStr).
+			Msg("couldn't check if the upstream image ORAS artifact can be skipped")
 	}
 
 	if skipORASRefs {
@@ -238,14 +240,14 @@ func (sig *signaturesCopier) syncORASRefs(localRepo, remoteRepo, digestStr strin
 			getRefManifestURL.String(), ref.MediaType, sig.log)
 		if err != nil {
 			if statusCode == http.StatusNotFound {
-				sig.log.Error().Str("errorType", common.TypeOf(err)).
-					Err(err).Msgf("couldn't find any ORAS manifest: %s", getRefManifestURL.String())
+				sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+					Str("manifest", getRefManifestURL.String()).Msg("couldn't find any ORAS manifest")
 
 				return zerr.ErrSyncReferrerNotFound
 			}
 
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get ORAS manifest: %s", getRefManifestURL.String())
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("manifest", getRefManifestURL.String()).Msg("couldn't get ORAS manifest")
 
 			return err
 		}
@@ -267,7 +269,8 @@ func (sig *signaturesCopier) syncORASRefs(localRepo, remoteRepo, digestStr strin
 
 		// this is for notation signatures
 		if sig.repoDB != nil {
-			sig.log.Debug().Msgf("trying to sync oras artifact for repo %s digest %s", localRepo, digestStr)
+			sig.log.Debug().Str("repository", localRepo).Str("digest", digestStr).
+				Msg("trying to sync oras artifact for digest")
 
 			err = repodb.SetMetadataFromInput(localRepo, ref.Digest.String(), ref.MediaType,
 				ref.Digest, body, sig.storeController.GetImageStore(localRepo), sig.repoDB, sig.log)
@@ -275,11 +278,13 @@ func (sig *signaturesCopier) syncORASRefs(localRepo, remoteRepo, digestStr strin
 				return fmt.Errorf("failed to set metadata for oras artifact '%s@%s': %w", localRepo, digestStr, err)
 			}
 
-			sig.log.Info().Msgf("successfully added oras artifacts to RepoDB for repo %s digest %s", localRepo, digestStr)
+			sig.log.Info().Str("repository", localRepo).Str("digest", digestStr).
+				Msg("successfully added oras artifacts to RepoDB for digest")
 		}
 	}
 
-	sig.log.Info().Msgf("successfully synced ORAS artifacts for repo %s digest %s", localRepo, digestStr)
+	sig.log.Info().Str("repository", localRepo).Str("digest", digestStr).
+		Msg("successfully synced ORAS artifacts for digest")
 
 	return nil
 }
@@ -292,8 +297,8 @@ func (sig *signaturesCopier) syncOCIRefs(localRepo, remoteRepo, digestStr string
 
 	skipOCIRefs, err := sig.canSkipOCIRefs(localRepo, digestStr, index)
 	if err != nil {
-		sig.log.Error().Err(err).Msgf("couldn't check if the upstream image %s:%s oci references can be skipped",
-			remoteRepo, digestStr)
+		sig.log.Error().Err(err).Str("repository", remoteRepo).Str("reference", digestStr).
+			Msg("couldn't check if the upstream image oci references can be skipped")
 	}
 
 	if skipOCIRefs {
@@ -316,14 +321,14 @@ func (sig *signaturesCopier) syncOCIRefs(localRepo, remoteRepo, digestStr string
 			getRefManifestURL.String(), ref.MediaType, sig.log)
 		if err != nil {
 			if statusCode == http.StatusNotFound {
-				sig.log.Error().Str("errorType", common.TypeOf(err)).
-					Err(err).Msgf("couldn't find any oci reference manifest: %s", getRefManifestURL.String())
+				sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+					Str("manifest", getRefManifestURL.String()).Msg("couldn't find any oci reference manifest")
 
 				return zerr.ErrSyncReferrerNotFound
 			}
 
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get oci reference manifest: %s", getRefManifestURL.String())
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("manifest", getRefManifestURL.String()).Msg("couldn't get oci reference manifest")
 
 			return err
 		}
@@ -334,8 +339,8 @@ func (sig *signaturesCopier) syncOCIRefs(localRepo, remoteRepo, digestStr string
 
 			err = json.Unmarshal(OCIRefBody, &manifest)
 			if err != nil {
-				sig.log.Error().Str("errorType", common.TypeOf(err)).
-					Err(err).Msgf("couldn't unmarshal oci reference manifest: %s", getRefManifestURL.String())
+				sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+					Str("manifest", getRefManifestURL.String()).Msg("couldn't unmarshal oci reference manifest")
 
 				return err
 			}
@@ -356,8 +361,8 @@ func (sig *signaturesCopier) syncOCIRefs(localRepo, remoteRepo, digestStr string
 
 			err = json.Unmarshal(OCIRefBody, &manifest)
 			if err != nil {
-				sig.log.Error().Str("errorType", common.TypeOf(err)).
-					Err(err).Msgf("couldn't unmarshal oci reference manifest: %s", getRefManifestURL.String())
+				sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+					Str("manifest", getRefManifestURL.String()).Msg("couldn't unmarshal oci reference manifest")
 
 				return err
 			}
@@ -379,7 +384,7 @@ func (sig *signaturesCopier) syncOCIRefs(localRepo, remoteRepo, digestStr string
 		}
 
 		if sig.repoDB != nil {
-			sig.log.Debug().Msgf("trying to add OCI refs for repo %s digest %s", localRepo, digestStr)
+			sig.log.Debug().Str("repository", localRepo).Str("digest", digestStr).Msg("trying to add OCI refs for repo digest")
 
 			err = repodb.SetMetadataFromInput(localRepo, digestStr, ref.MediaType,
 				digest, OCIRefBody, sig.storeController.GetImageStore(localRepo),
@@ -388,11 +393,13 @@ func (sig *signaturesCopier) syncOCIRefs(localRepo, remoteRepo, digestStr string
 				return fmt.Errorf("failed to set metadata for OCI ref in '%s@%s': %w", localRepo, digestStr, err)
 			}
 
-			sig.log.Info().Msgf("successfully added OCI refs to RepoDB for repo %s digest %s", localRepo, digestStr)
+			sig.log.Info().Str("repository", localRepo).Str("digest", digestStr).
+				Msg("successfully added OCI refs to RepoDB for digest")
 		}
 	}
 
-	sig.log.Info().Msgf("successfully synced OCI refs for repo %s digest %s", localRepo, digestStr)
+	sig.log.Info().Str("repository", localRepo).Str("digest", digestStr).
+		Msg("successfully synced OCI refs for digest")
 
 	return nil
 }
@@ -404,15 +411,16 @@ func (sig *signaturesCopier) syncOCIArtifact(localRepo, remoteRepo, reference st
 
 	err := json.Unmarshal(ociArtifactBuf, &ociArtifact)
 	if err != nil {
-		sig.log.Error().Err(err).Msgf("couldn't unmarshal OCI artifact from %s:%s", remoteRepo, reference)
+		sig.log.Error().Err(err).Str("repository", remoteRepo).Str("reference", reference).
+			Msg("couldn't unmarshal OCI artifact")
 
 		return err
 	}
 
 	canSkipOCIArtifact, err := sig.canSkipOCIArtifact(localRepo, reference, ociArtifact)
 	if err != nil {
-		sig.log.Error().Err(err).Msgf("couldn't check if OCI artifact %s:%s can be skipped",
-			remoteRepo, reference)
+		sig.log.Error().Err(err).Str("repository", remoteRepo).Str("reference", reference).
+			Msg("couldn't check if OCI artifact can be skipped")
 	}
 
 	if canSkipOCIArtifact {
@@ -448,7 +456,8 @@ func (sig *signaturesCopier) syncOCIArtifact(localRepo, remoteRepo, reference st
 	}
 
 	if sig.repoDB != nil {
-		sig.log.Debug().Msgf("trying to OCI refs for repo %s digest %s", localRepo, digest.String())
+		sig.log.Debug().Str("repository", localRepo).Str("digest", digest.String()).
+			Msg("trying to OCI refs for repo digest")
 
 		err = repodb.SetMetadataFromInput(localRepo, reference, ispec.MediaTypeArtifactManifest,
 			digest, artifactManifestBuf, sig.storeController.GetImageStore(localRepo),
@@ -457,11 +466,12 @@ func (sig *signaturesCopier) syncOCIArtifact(localRepo, remoteRepo, reference st
 			return fmt.Errorf("failed to set metadata for OCI Artifact '%s@%s': %w", localRepo, digest.String(), err)
 		}
 
-		sig.log.Info().Msgf("successfully added oci artifacts to RepoDB for repo %s digest %s", localRepo,
-			digest.String())
+		sig.log.Info().Str("repository", localRepo).Str("digest", digest.String()).
+			Msg("successfully added oci artifacts to RepoDB for repo digest")
 	}
 
-	sig.log.Info().Msgf("successfully synced OCI artifact for repo %s tag %s", localRepo, reference)
+	sig.log.Info().Str("repository", localRepo).Str("tag", reference).
+		Msg("successfully synced OCI artifact for repo tag")
 
 	return nil
 }
@@ -479,20 +489,22 @@ func (sig *signaturesCopier) canSkipORASRefs(localRepo, digestStr string, refs R
 				return false, nil
 			}
 
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get local ORAS artifact %s:%s manifest", localRepo, digestStr)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("repository", localRepo).Str("reference", digestStr).Msg("couldn't get local ORAS artifact manifest")
 
 			return false, err
 		}
 
 		if !artifactDescriptorsEqual(localRefs, refs.References) {
-			sig.log.Info().Msgf("upstream ORAS artifacts %s:%s changed, syncing again", localRepo, digestStr)
+			sig.log.Info().Str("repository", localRepo).Str("reference", digestStr).
+				Msg("upstream ORAS artifacts changed, syncing again")
 
 			return false, nil
 		}
 	}
 
-	sig.log.Info().Msgf("skipping ORAS artifact %s:%s, already synced", localRepo, digestStr)
+	sig.log.Info().Str("repository", localRepo).Str("reference", digestStr).
+		Msg("skipping ORAS artifact, already synced")
 
 	return true, nil
 }
@@ -509,27 +521,31 @@ func (sig *signaturesCopier) canSkipOCIArtifact(localRepo, reference string, art
 			return false, nil
 		}
 
-		sig.log.Error().Str("errorType", common.TypeOf(err)).
-			Err(err).Msgf("couldn't get local OCI artifact %s:%s manifest", localRepo, reference)
+		sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+			Str("repository", localRepo).Str("reference", reference).
+			Msg("couldn't get local OCI artifact manifest")
 
 		return false, err
 	}
 
 	err = json.Unmarshal(localArtifactBuf, &localArtifactManifest)
 	if err != nil {
-		sig.log.Error().Str("errorType", common.TypeOf(err)).
-			Err(err).Msgf("couldn't unmarshal local OCI artifact %s:%s manifest", localRepo, reference)
+		sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+			Str("repository", localRepo).Str("reference", reference).
+			Msg("couldn't unmarshal local OCI artifact manifest")
 
 		return false, err
 	}
 
 	if !artifactsEqual(localArtifactManifest, artifact) {
-		sig.log.Info().Msgf("upstream OCI artifact %s:%s changed, syncing again", localRepo, reference)
+		sig.log.Info().Str("repository", localRepo).Str("reference", reference).
+			Msg("upstream OCI artifact changed, syncing again")
 
 		return false, nil
 	}
 
-	sig.log.Info().Msgf("skipping OCI artifact %s:%s, already synced", localRepo, reference)
+	sig.log.Info().Str("repository", localRepo).Str("reference", reference).
+		Msg("skipping OCI artifact, already synced")
 
 	return true, nil
 }
@@ -551,28 +567,32 @@ func (sig *signaturesCopier) canSkipCosignSignature(localRepo, digestStr string,
 				return false, nil
 			}
 
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get local cosign %s:%s manifest", localRepo, digestStr)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("repository", localRepo).Str("reference", digestStr).
+				Msg("couldn't get local cosign manifest")
 
 			return false, err
 		}
 
 		err = json.Unmarshal(localCosignManifestBuf, &localCosignManifest)
 		if err != nil {
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't unmarshal local cosign signature %s:%s manifest", localRepo, digestStr)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("repository", localRepo).Str("reference", digestStr).
+				Msg("couldn't unmarshal local cosign signature manifest")
 
 			return false, err
 		}
 
 		if !manifestsEqual(localCosignManifest, *cosignManifest) {
-			sig.log.Info().Msgf("upstream cosign signatures %s:%s changed, syncing again", localRepo, digestStr)
+			sig.log.Info().Str("repository", localRepo).Str("reference", digestStr).
+				Msg("upstream cosign signatures changed, syncing again")
 
 			return false, nil
 		}
 	}
 
-	sig.log.Info().Msgf("skipping cosign signature %s:%s, already synced", localRepo, digestStr)
+	sig.log.Info().Str("repository", localRepo).Str("reference", digestStr).
+		Msg("skipping cosign signature, already synced")
 
 	return true, nil
 }
@@ -590,20 +610,23 @@ func (sig *signaturesCopier) canSkipOCIRefs(localRepo, digestStr string, index i
 				return false, nil
 			}
 
-			sig.log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get local ocireferences for %s:%s manifest", localRepo, digestStr)
+			sig.log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("repository", localRepo).Str("reference", digestStr).
+				Msg("couldn't get local ocireferences for manifest")
 
 			return false, err
 		}
 
 		if !descriptorsEqual(localRefs.Manifests, index.Manifests) {
-			sig.log.Info().Msgf("upstream oci references for %s:%s changed, syncing again", localRepo, digestStr)
+			sig.log.Info().Str("repository", localRepo).Str("reference", digestStr).
+				Msg("upstream oci references for manifest changed, syncing again")
 
 			return false, nil
 		}
 	}
 
-	sig.log.Info().Msgf("skipping oci references %s:%s, already synced", localRepo, digestStr)
+	sig.log.Info().Str("repository", localRepo).Str("reference", digestStr).
+		Msg("skipping oci references, already synced")
 
 	return true, nil
 }
@@ -622,8 +645,8 @@ func syncBlob(sig *signaturesCopier, imageStore storage.ImageStore, remoteRepo,
 
 	resp, err := sig.client.Do(req)
 	if err != nil {
-		sig.log.Error().Str("errorType", common.TypeOf(err)).Str("url", getBlobURL.String()).
-			Err(err).Msgf("couldn't get blob: %s", getBlobURL.String())
+		sig.log.Error().Str("errorType", common.TypeOf(err)).Str("blob url", getBlobURL.String()).
+			Err(err).Msg("couldn't get blob from url")
 
 		return err
 	}
@@ -631,8 +654,8 @@ func syncBlob(sig *signaturesCopier, imageStore storage.ImageStore, remoteRepo,
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		sig.log.Info().Str("url", getBlobURL.String()).Msgf("couldn't find blob from %s, status code: %d",
-			getBlobURL.String(), resp.StatusCode)
+		sig.log.Info().Str("url", getBlobURL.String()).Str("blob url", getBlobURL.String()).
+			Int("statusCode", resp.StatusCode).Msg("couldn't find blob from url, status code")
 
 		return zerr.ErrSyncReferrer
 	}

pkg/extensions/sync/sync.go

@@ -53,8 +53,8 @@ func GetUpstreamCatalog(client *http.Client, upstreamURL, username, password str
 		password, &catalog,
 		registryCatalogURL, "application/json", log)
 	if err != nil {
-		log.Error().Msgf("couldn't query %s, status code: %d, body: %s", registryCatalogURL,
-			statusCode, body)
+		log.Error().Str("catalog", registryCatalogURL).Int("statusCode", statusCode).
+			RawJSON("body", body).Msg("couldn't query catalog")
 
 		return catalog, err
 	}
@@ -67,19 +67,20 @@ func imagesToCopyFromUpstream(ctx context.Context, registryName string, repoName
 	upstreamCtx *types.SystemContext, content syncconf.Content, log log.Logger,
 ) ([]types.ImageReference, error) {
 	imageRefs := []types.ImageReference{}
+	repoRefName := fmt.Sprintf("%s/%s", registryName, repoName)
 
-	repoRef, err := parseRepositoryReference(fmt.Sprintf("%s/%s", registryName, repoName))
+	repoRef, err := parseRepositoryReference(repoRefName)
 	if err != nil {
-		log.Error().Str("errorType", common.TypeOf(err)).
-			Err(err).Msgf("couldn't parse repository reference: %s", repoRef)
+		log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+			Str("repository reference", repoRefName).Msg("couldn't parse repository reference")
 
 		return imageRefs, err
 	}
 
 	tags, err := getImageTags(ctx, upstreamCtx, repoRef)
 	if err != nil {
-		log.Error().Str("errorType", common.TypeOf(err)).
-			Err(err).Msgf("couldn't fetch tags for %s", repoRef)
+		log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+			Str("repository reference", repoRefName).Msg("couldn't fetch tags reference")
 
 		return imageRefs, err
 	}
@@ -98,7 +99,7 @@ func imagesToCopyFromUpstream(ctx context.Context, registryName string, repoName
 		}
 	}
 
-	log.Debug().Msgf("repo: %s - upstream tags to be copied: %v", repoName, tags)
+	log.Debug().Str("repository", repoName).Strs("tags", tags).Msg("upstream tags to be copied")
 
 	for _, tag := range tags {
 		// don't copy cosign signature, containers/image doesn't support it
@@ -109,15 +110,16 @@ func imagesToCopyFromUpstream(ctx context.Context, registryName string, repoName
 
 		taggedRef, err := reference.WithTag(repoRef, tag)
 		if err != nil {
-			log.Err(err).Msgf("error creating a reference for repository %s and tag %q", repoRef.Name(), tag)
+			log.Err(err).Str("repository", repoRef.Name()).Str("tag", tag).
+				Msg("error creating a reference for repository and tag")
 
 			return imageRefs, err
 		}
 
 		ref, err := docker.NewReference(taggedRef)
 		if err != nil {
-			log.Err(err).Msgf("cannot obtain a valid image reference for transport %q and reference %s",
-				docker.Transport.Name(), taggedRef.String())
+			log.Err(err).Str("transport", docker.Transport.Name()).Str("reference", taggedRef.String()).
+				Msg("cannot obtain a valid image reference for transport and reference")
 
 			return imageRefs, err
 		}
@@ -170,7 +172,7 @@ func syncRegistry(ctx context.Context, regCfg syncconf.RegistryConfig,
 	policyCtx *signature.PolicyContext, credentials syncconf.Credentials,
 	retryOptions *retry.RetryOptions, log log.Logger,
 ) error {
-	log.Info().Msgf("syncing registry: %s", upstreamURL)
+	log.Info().Str("registry", upstreamURL).Msg("syncing registry")
 
 	var err error
 
@@ -212,11 +214,11 @@ func syncRegistry(ctx context.Context, regCfg syncconf.RegistryConfig,
 		return err
 	}
 
-	log.Info().Msgf("filtering %d repos based on sync prefixes", len(catalog.Repositories))
+	log.Info().Int("repo count", len(catalog.Repositories)).Msg("filtering repos based on sync prefixes")
 
 	repos := filterRepos(catalog.Repositories, regCfg.Content, log)
 
-	log.Info().Msgf("got repos: %v", repos)
+	log.Info().Interface("repos", repos).Msg("got repos")
 
 	upstreamAddr := StripRegistryTransport(upstreamURL)
 
@@ -258,8 +260,8 @@ func syncRegistry(ctx context.Context, regCfg syncconf.RegistryConfig,
 
 		localCachePath, err := getLocalCachePath(imageStore, localRepo)
 		if err != nil {
-			log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get localCachePath for %s", localRepo)
+			log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("repository", localRepo).Msg("couldn't get localCachePath for repo")
 
 			return err
 		}
@@ -293,7 +295,7 @@ func syncRegistry(ctx context.Context, regCfg syncconf.RegistryConfig,
 		}
 	}
 
-	log.Info().Msgf("finished syncing %s", upstreamAddr)
+	log.Info().Str("upstreamAddr", upstreamAddr).Msg("finished syncing from upstream address")
 
 	return nil
 }
@@ -333,8 +335,8 @@ func Run(ctx context.Context, cfg syncconf.Config, repoDB repodb.RepoDB,
 	if cfg.CredentialsFile != "" {
 		credentialsFile, err = getFileCredentials(cfg.CredentialsFile)
 		if err != nil {
-			logger.Error().Str("errortype", common.TypeOf(err)).
-				Err(err).Msgf("couldn't get registry credentials from %s", cfg.CredentialsFile)
+			logger.Error().Str("errortype", common.TypeOf(err)).Err(err).
+				Str("credentialsFile", cfg.CredentialsFile).Msg("couldn't get registry credentials from credentials file")
 
 			return err
 		}
@@ -349,14 +351,16 @@ func Run(ctx context.Context, cfg syncconf.Config, repoDB repodb.RepoDB,
 	for _, regCfg := range cfg.Registries {
 		// if content not provided, don't run periodically sync
 		if len(regCfg.Content) == 0 {
-			logger.Info().Msgf("sync config content not configured for %v, will not run periodically sync", regCfg.URLs)
+			logger.Info().Strs("registry", regCfg.URLs).
+				Msg("sync config content not configured for registry, will not run periodically sync")
 
 			continue
 		}
 
 		// if pollInterval is not provided, don't run periodically sync
 		if regCfg.PollInterval == 0 {
-			logger.Warn().Msgf("sync config PollInterval not configured for %v, will not run periodically sync", regCfg.URLs)
+			logger.Warn().Strs("registry", regCfg.URLs).
+				Msg("sync config PollInterval not configured for registry, will not run periodically sync")
 
 			continue
 		}

pkg/extensions/sync/sync_test.go

@@ -1613,7 +1613,7 @@ func TestBasicAuth(t *testing.T) {
 			defer dcm.StopServer()
 
 			found, err := test.ReadLogFileAndSearchString(dctlr.Config.Log.Output,
-				"status code: 401", 15*time.Second)
+				"status code\":\"401", 15*time.Second)
 			if err != nil {
 				panic(err)
 			}

pkg/extensions/sync/utils.go

@@ -45,7 +45,8 @@ type ReferenceList struct {
 func getTagFromRef(ref types.ImageReference, log log.Logger) reference.Tagged {
 	tagged, isTagged := ref.DockerReference().(reference.Tagged)
 	if !isTagged {
-		log.Warn().Msgf("internal server error, reference %s does not have a tag, skipping", ref.DockerReference())
+		log.Warn().Str("reference", ref.DockerReference().String()).
+			Msg("internal server error, reference does not have a tag, skipping")
 	}
 
 	return tagged
@@ -76,7 +77,7 @@ func filterTagsByRegex(tags []string, regex string, log log.Logger) ([]string, e
 		return filteredTags, nil
 	}
 
-	log.Info().Msgf("start filtering using the regular expression: %s", regex)
+	log.Info().Str("regex", regex).Msg("start filtering using the regular expression")
 
 	tagReg, err := regexp.Compile(regex)
 	if err != nil {
@@ -267,7 +268,7 @@ func getFileCredentials(filepath string) (syncconf.CredentialsFile, error) {
 func pushSyncedLocalImage(localRepo, reference, localCachePath string,
 	repoDB repodb.RepoDB, imageStore storage.ImageStore, log log.Logger,
 ) error {
-	log.Info().Msgf("pushing synced local image %s/%s:%s to local registry", localCachePath, localRepo, reference)
+	log.Info().Str("image", localCachePath+"/"+localRepo+":"+reference).Msg("pushing synced local image to local registry")
 
 	var lockLatency time.Time
 
@@ -280,7 +281,7 @@ func pushSyncedLocalImage(localRepo, reference, localCachePath string,
 	if err != nil {
 		log.Error().Str("errorType", common.TypeOf(err)).
 			Err(err).Str("dir", path.Join(cacheImageStore.RootDir(), localRepo)).
-			Msgf("couldn't find %s manifest", reference)
+			Str("manifest", reference).Msg("couldn't find manifest")
 
 		return err
 	}
@@ -351,7 +352,8 @@ func pushSyncedLocalImage(localRepo, reference, localCachePath string,
 				return fmt.Errorf("failed to set metadata for image '%s %s': %w", localRepo, reference, err)
 			}
 
-			log.Debug().Msgf("successfully set metadata for %s:%s", localRepo, reference)
+			log.Debug().Str("repository", localRepo).Str("reference", reference).
+				Msg("successfully set metadata for image")
 		}
 	}
 
@@ -406,7 +408,8 @@ func copyManifest(localRepo string, manifestContent []byte, reference string, re
 			return err
 		}
 
-		log.Debug().Msgf("successfully set metadata for %s:%s", localRepo, reference)
+		log.Debug().Str("repository", localRepo).Str("reference", reference).
+			Msg("successfully set metadata for image")
 	}
 
 	return nil
@@ -543,13 +546,15 @@ func canSkipImage(repo, tag string, digest godigest.Digest, imageStore storage.I
 		}
 
 		log.Error().Str("errorType", common.TypeOf(err)).
-			Err(err).Msgf("couldn't get local image %s:%s manifest", repo, tag)
+			Err(err).Str("repository", repo).Str("tag", tag).
+			Msg("couldn't get local image manifest")
 
 		return false, err
 	}
 
 	if localImageManifestDigest != digest {
-		log.Info().Msgf("upstream image %s:%s digest changed, syncing again", repo, tag)
+		log.Info().Str("repository", repo).Str("tag", tag).
+			Msg("upstream image digest changed, syncing again")
 
 		return false, nil
 	}
@@ -646,7 +651,8 @@ func getImageRefManifest(ctx context.Context, upstreamCtx *types.SystemContext,
 ) ([]byte, string, error) {
 	imageSource, err := imageRef.NewImageSource(ctx, upstreamCtx)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't get upstream image %s manifest details", imageRef.DockerReference())
+		log.Error().Err(err).Str("image", imageRef.DockerReference().String()).
+			Msg("couldn't get upstream image manifest details")
 
 		return []byte{}, "", err
 	}
@@ -655,7 +661,8 @@ func getImageRefManifest(ctx context.Context, upstreamCtx *types.SystemContext,
 
 	manifestBuf, mediaType, err := imageSource.GetManifest(ctx, nil)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't get upstream image %s manifest mediaType", imageRef.DockerReference())
+		log.Error().Err(err).Str("image", imageRef.DockerReference().String()).
+			Msg("couldn't get upstream image manifest mediaType")
 
 		return []byte{}, "", err
 	}
@@ -682,8 +689,8 @@ func syncImageWithRefs(ctx context.Context, localRepo, upstreamRepo, reference s
 		if mediaType == ispec.MediaTypeArtifactManifest {
 			err = sig.syncOCIArtifact(localRepo, upstreamRepo, reference, manifestBuf) //nolint
 			if err != nil {
-				log.Error().Err(err).Msgf("couldn't sync oci artifact with artifact mediaType: %s",
-					upstreamImageRef.DockerReference())
+				log.Error().Err(err).Str("image", upstreamImageRef.DockerReference().String()).
+					Msg("couldn't sync oci artifact with artifact mediaType")
 
 				return skipped, err
 			}
@@ -695,12 +702,14 @@ func syncImageWithRefs(ctx context.Context, localRepo, upstreamRepo, reference s
 	// get upstream signatures
 	cosignManifest, err := sig.getCosignManifest(upstreamRepo, upstreamImageDigest.String())
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't get upstream image %s cosign manifest", upstreamImageRef.DockerReference())
+		log.Error().Err(err).Str("image", upstreamImageRef.DockerReference().String()).
+			Msg("couldn't get upstream imagecosign manifest")
 	}
 
 	index, err := sig.getOCIRefs(upstreamRepo, upstreamImageDigest.String())
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't get upstream image %s OCI references", upstreamImageRef.DockerReference())
+		log.Error().Err(err).Str("image", upstreamImageRef.DockerReference().String()).
+			Msg("couldn't get upstream image OCI references")
 	}
 
 	// check if upstream image is signed
@@ -708,7 +717,8 @@ func syncImageWithRefs(ctx context.Context, localRepo, upstreamRepo, reference s
 		// upstream image not signed
 		if utils.enforceSignatures {
 			// skip unsigned images
-			log.Info().Msgf("skipping image without signature %s", upstreamImageRef.DockerReference())
+			log.Info().Str("image", upstreamImageRef.DockerReference().String()).
+				Msg("skipping image without signature")
 			skipped = true
 
 			return skipped, nil
@@ -717,31 +727,32 @@ func syncImageWithRefs(ctx context.Context, localRepo, upstreamRepo, reference s
 
 	skipImage, err := canSkipImage(localRepo, upstreamImageDigest.String(), upstreamImageDigest, imageStore, log)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't check if the upstream image %s can be skipped",
-			upstreamImageRef.DockerReference())
+		log.Error().Err(err).Str("image", upstreamImageRef.DockerReference().String()).
+			Msg("couldn't check if the upstream image can be skipped")
 	}
 
 	if !skipImage {
 		// sync image
 		localImageRef, err := getLocalImageRef(localCachePath, localRepo, reference)
 		if err != nil {
-			log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("couldn't obtain a valid image reference for reference %s/%s:%s",
-				localCachePath, localRepo, reference)
+			log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("reference", localCachePath+"/"+localRepo+":"+reference).
+				Msg("couldn't obtain a valid image reference for reference")
 
 			return skipped, err
 		}
 
-		log.Info().Msgf("copying image %s to %s", upstreamImageRef.DockerReference(), localCachePath)
+		log.Info().Str("image", upstreamImageRef.DockerReference().String()).
+			Str("path", localCachePath).Msg("copying image to path")
 
 		if err = retry.RetryIfNecessary(ctx, func() error {
 			_, err = copy.Image(ctx, utils.policyCtx, localImageRef, upstreamImageRef, &utils.copyOptions)
 
 			return err
 		}, utils.retryOptions); err != nil {
-			log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("error while copying image %s to %s",
-				upstreamImageRef.DockerReference(), localCachePath)
+			log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("image", upstreamImageRef.DockerReference().String()).Str("path", localCachePath).
+				Msg("error while copying image to path")
 
 			return skipped, err
 		}
@@ -749,14 +760,14 @@ func syncImageWithRefs(ctx context.Context, localRepo, upstreamRepo, reference s
 		// push from cache to repo
 		err = pushSyncedLocalImage(localRepo, reference, localCachePath, sig.repoDB, imageStore, log)
 		if err != nil {
-			log.Error().Str("errorType", common.TypeOf(err)).
-				Err(err).Msgf("error while pushing synced cached image %s",
-				fmt.Sprintf("%s/%s:%s", localCachePath, localRepo, reference))
+			log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+				Str("image", localCachePath+"/"+localRepo+":"+reference).Msg("error while pushing synced cached image")
 
 			return skipped, err
 		}
 	} else {
-		log.Info().Msgf("already synced image %s, checking its signatures", upstreamImageRef.DockerReference())
+		log.Info().Str("image", upstreamImageRef.DockerReference().String()).
+			Msg("already synced image, checking its signatures")
 	}
 
 	// sync signatures
@@ -783,13 +794,13 @@ func syncImageWithRefs(ctx context.Context, localRepo, upstreamRepo, reference s
 
 		return nil
 	}, utils.retryOptions); err != nil {
-		log.Error().Str("errorType", common.TypeOf(err)).
-			Err(err).Msgf("couldn't copy referrer for %s", upstreamImageRef.DockerReference())
+		log.Error().Str("errorType", common.TypeOf(err)).Err(err).
+			Str("image", upstreamImageRef.DockerReference().String()).Msg("couldn't copy referrer for image")
 
 		return skipped, err
 	}
 
-	log.Info().Msgf("successfully synced image %s", upstreamImageRef.DockerReference())
+	log.Info().Str("image", upstreamImageRef.DockerReference().String()).Msg("successfully synced image")
 
 	return skipped, nil
 }