diff --git a/pkg/extensions/sync/on_demand.go b/pkg/extensions/sync/on_demand.go
index a6e378d9..9fa2a88d 100644
--- a/pkg/extensions/sync/on_demand.go
+++ b/pkg/extensions/sync/on_demand.go
@@ -98,7 +98,8 @@ func syncOneImage(imageChannel chan error, cfg Config, storeController storage.S
 
 		credentialsFile, err = getFileCredentials(cfg.CredentialsFile)
 		if err != nil {
-			log.Error().Err(err).Msgf("couldn't get registry credentials from %s", cfg.CredentialsFile)
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't get registry credentials from %s", cfg.CredentialsFile)
 
 			imageChannel <- err
 
@@ -171,14 +172,16 @@ func syncOneImage(imageChannel chan error, cfg Config, storeController storage.S
 				// is cosign signature
 				cosignManifest, err := getCosignManifest(httpClient, *registryURL, remoteRepo, tag, log)
 				if err != nil {
-					log.Error().Err(err).Msgf("couldn't get upstream image %s:%s:%s cosign manifest", upstreamURL, remoteRepo, tag)
+					log.Error().Str("errorType", TypeOf(err)).
+						Err(err).Msgf("couldn't get upstream image %s:%s:%s cosign manifest", upstreamURL, remoteRepo, tag)
 
 					continue
 				}
 
 				err = syncCosignSignature(httpClient, imageStore, *registryURL, localRepo, remoteRepo, tag, cosignManifest, log)
 				if err != nil {
-					log.Error().Err(err).Msgf("couldn't copy upstream image cosign signature %s/%s:%s", upstreamURL, remoteRepo, tag)
+					log.Error().Str("errorType", TypeOf(err)).
+						Err(err).Msgf("couldn't copy upstream image cosign signature %s/%s:%s", upstreamURL, remoteRepo, tag)
 
 					continue
 				}
@@ -190,14 +193,16 @@ func syncOneImage(imageChannel chan error, cfg Config, storeController storage.S
 				// is notary signature
 				refs, err := getNotaryRefs(httpClient, *registryURL, remoteRepo, tag, log)
 				if err != nil {
-					log.Error().Err(err).Msgf("couldn't get upstream image %s/%s:%s notary references", upstreamURL, remoteRepo, tag)
+					log.Error().Str("errorType", TypeOf(err)).
+						Err(err).Msgf("couldn't get upstream image %s/%s:%s notary references", upstreamURL, remoteRepo, tag)
 
 					continue
 				}
 
 				err = syncNotarySignature(httpClient, imageStore, *registryURL, localRepo, remoteRepo, tag, refs, log)
 				if err != nil {
-					log.Error().Err(err).Msgf("couldn't copy image signature %s/%s:%s", upstreamURL, remoteRepo, tag)
+					log.Error().Str("errorType", TypeOf(err)).
+						Err(err).Msgf("couldn't copy image signature %s/%s:%s", upstreamURL, remoteRepo, tag)
 
 					continue
 				}
@@ -258,7 +263,8 @@ func syncOneImage(imageChannel chan error, cfg Config, storeController storage.S
 
 						return err
 					}, retryOptions); err != nil {
-						log.Error().Err(err).Msgf("sync routine: error while copying image %s", demandedImageRef)
+						log.Error().Str("errorType", TypeOf(err)).
+							Err(err).Msgf("sync routine: error while copying image %s", demandedImageRef)
 					}
 				}()
 			}
@@ -273,7 +279,8 @@ func syncRun(regCfg RegistryConfig, localRepo, remoteRepo, tag string, utils syn
 ) (bool, error) {
 	upstreamImageRef, err := getImageRef(utils.upstreamAddr, remoteRepo, tag)
 	if err != nil {
-		log.Error().Err(err).Msgf("error creating docker reference for repository %s/%s:%s",
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("error creating docker reference for repository %s/%s:%s",
 			utils.upstreamAddr, remoteRepo, tag)
 
 		return false, err
@@ -281,7 +288,8 @@ func syncRun(regCfg RegistryConfig, localRepo, remoteRepo, tag string, utils syn
 
 	upstreamImageDigest, err := docker.GetDigest(context.Background(), utils.upstreamCtx, upstreamImageRef)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't get upstream image %s manifest", upstreamImageRef.DockerReference())
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("couldn't get upstream image %s manifest", upstreamImageRef.DockerReference())
 
 		return false, err
 	}
@@ -290,12 +298,14 @@ func syncRun(regCfg RegistryConfig, localRepo, remoteRepo, tag string, utils syn
 	cosignManifest, err := getCosignManifest(utils.client, *utils.url, remoteRepo,
 		upstreamImageDigest.String(), log)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't get upstream image %s cosign manifest", upstreamImageRef.DockerReference())
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("couldn't get upstream image %s cosign manifest", upstreamImageRef.DockerReference())
 	}
 
 	refs, err := getNotaryRefs(utils.client, *utils.url, remoteRepo, upstreamImageDigest.String(), log)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't get upstream image %s notary references", upstreamImageRef.DockerReference())
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("couldn't get upstream image %s notary references", upstreamImageRef.DockerReference())
 	}
 
 	// check if upstream image is signed
@@ -316,7 +326,8 @@ func syncRun(regCfg RegistryConfig, localRepo, remoteRepo, tag string, utils syn
 
 	localImageRef, err := getLocalImageRef(localCachePath, localRepo, tag)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't obtain a valid image reference for reference %s/%s:%s",
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("couldn't obtain a valid image reference for reference %s/%s:%s",
 			localCachePath, localRepo, tag)
 
 		return false, err
@@ -328,7 +339,8 @@ func syncRun(regCfg RegistryConfig, localRepo, remoteRepo, tag string, utils syn
 
 	_, err = copy.Image(context.Background(), utils.policyCtx, localImageRef, upstreamImageRef, &utils.copyOptions)
 	if err != nil {
-		log.Error().Err(err).Msgf("error encountered while syncing on demand %s to %s",
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("error encountered while syncing on demand %s to %s",
 			upstreamImageRef.DockerReference(), localCachePath)
 
 		return false, err
@@ -336,7 +348,8 @@ func syncRun(regCfg RegistryConfig, localRepo, remoteRepo, tag string, utils syn
 
 	err = pushSyncedLocalImage(localRepo, tag, localCachePath, utils.imageStore, log)
 	if err != nil {
-		log.Error().Err(err).Msgf("error while pushing synced cached image %s",
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("error while pushing synced cached image %s",
 			fmt.Sprintf("%s/%s:%s", localCachePath, localRepo, tag))
 
 		return false, err
@@ -345,7 +358,8 @@ func syncRun(regCfg RegistryConfig, localRepo, remoteRepo, tag string, utils syn
 	err = syncCosignSignature(utils.client, utils.imageStore, *utils.url, localRepo, remoteRepo,
 		upstreamImageDigest.String(), cosignManifest, log)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't copy image cosign signature %s/%s:%s", utils.upstreamAddr, remoteRepo, tag)
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("couldn't copy image cosign signature %s/%s:%s", utils.upstreamAddr, remoteRepo, tag)
 
 		return false, err
 	}
@@ -353,7 +367,8 @@ func syncRun(regCfg RegistryConfig, localRepo, remoteRepo, tag string, utils syn
 	err = syncNotarySignature(utils.client, utils.imageStore, *utils.url, localRepo, remoteRepo,
 		upstreamImageDigest.String(), refs, log)
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't copy image notary signature %s/%s:%s", utils.upstreamAddr, remoteRepo, tag)
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("couldn't copy image notary signature %s/%s:%s", utils.upstreamAddr, remoteRepo, tag)
 
 		return false, err
 	}
diff --git a/pkg/extensions/sync/signatures.go b/pkg/extensions/sync/signatures.go
index c8d6b0b9..11fa936b 100644
--- a/pkg/extensions/sync/signatures.go
+++ b/pkg/extensions/sync/signatures.go
@@ -36,7 +36,8 @@ func getCosignManifest(client *resty.Client, regURL url.URL, repo, digest string
 		SetHeader("Content-Type", "application/vnd.oci.image.manifest.v1+json").
 		Get(getCosignManifestURL.String())
 	if err != nil {
-		log.Error().Err(err).Str("url", getCosignManifestURL.String()).
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Str("url", getCosignManifestURL.String()).
 			Msgf("couldn't get cosign manifest: %s", cosignTag)
 
 		return nil, err
@@ -48,7 +49,8 @@ func getCosignManifest(client *resty.Client, regURL url.URL, repo, digest string
 
 		return nil, zerr.ErrSyncSignatureNotFound
 	} else if resp.IsError() {
-		log.Error().Err(zerr.ErrSyncSignature).Msgf("couldn't get cosign signature from %s, status code: %d skipping",
+		log.Error().Str("errorType", TypeOf(zerr.ErrSyncSignature)).
+			Err(zerr.ErrSyncSignature).Msgf("couldn't get cosign signature from %s, status code: %d skipping",
 			getCosignManifestURL.String(), resp.StatusCode())
 
 		return nil, zerr.ErrSyncSignature
@@ -56,7 +58,8 @@ func getCosignManifest(client *resty.Client, regURL url.URL, repo, digest string
 
 	err = json.Unmarshal(resp.Body(), &cosignManifest)
 	if err != nil {
-		log.Error().Err(err).Str("url", getCosignManifestURL.String()).
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Str("url", getCosignManifestURL.String()).
 			Msgf("couldn't unmarshal cosign manifest %s", cosignTag)
 
 		return nil, err
@@ -81,7 +84,8 @@ func getNotaryRefs(client *resty.Client, regURL url.URL, repo, digest string, lo
 		SetQueryParam("artifactType", notreg.ArtifactTypeNotation).
 		Get(getReferrersURL.String())
 	if err != nil {
-		log.Error().Err(err).Str("url", getReferrersURL.String()).Msg("couldn't get referrers")
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Str("url", getReferrersURL.String()).Msg("couldn't get referrers")
 
 		return referrers, err
 	}
@@ -92,7 +96,8 @@ func getNotaryRefs(client *resty.Client, regURL url.URL, repo, digest string, lo
 
 		return ReferenceList{}, zerr.ErrSyncSignatureNotFound
 	} else if resp.IsError() {
-		log.Error().Err(zerr.ErrSyncSignature).Msgf("couldn't get notary signature from %s, status code: %d skipping",
+		log.Error().Str("errorType", TypeOf(zerr.ErrSyncSignature)).
+			Err(zerr.ErrSyncSignature).Msgf("couldn't get notary signature from %s, status code: %d skipping",
 			getReferrersURL.String(), resp.StatusCode())
 
 		return ReferenceList{}, zerr.ErrSyncSignature
@@ -100,7 +105,8 @@ func getNotaryRefs(client *resty.Client, regURL url.URL, repo, digest string, lo
 
 	err = json.Unmarshal(resp.Body(), &referrers)
 	if err != nil {
-		log.Error().Err(err).Str("url", getReferrersURL.String()).
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Str("url", getReferrersURL.String()).
 			Msgf("couldn't unmarshal notary signature")
 
 		return referrers, err
@@ -129,7 +135,8 @@ func syncCosignSignature(client *resty.Client, imageStore storage.ImageStore,
 
 		resp, err := client.R().SetDoNotParseResponse(true).Get(getBlobURL.String())
 		if err != nil {
-			log.Error().Err(err).Msgf("couldn't get cosign blob: %s", blob.Digest.String())
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't get cosign blob: %s", blob.Digest.String())
 
 			return err
 		}
@@ -145,7 +152,8 @@ func syncCosignSignature(client *resty.Client, imageStore storage.ImageStore,
 		// push blob
 		_, _, err = imageStore.FullBlobUpload(localRepo, resp.RawBody(), blob.Digest.String())
 		if err != nil {
-			log.Error().Err(err).Msg("couldn't upload cosign blob")
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msg("couldn't upload cosign blob")
 
 			return err
 		}
@@ -158,7 +166,8 @@ func syncCosignSignature(client *resty.Client, imageStore storage.ImageStore,
 
 	resp, err := client.R().SetDoNotParseResponse(true).Get(getBlobURL.String())
 	if err != nil {
-		log.Error().Err(err).Msgf("couldn't get cosign config blob: %s", getBlobURL.String())
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("couldn't get cosign config blob: %s", getBlobURL.String())
 
 		return err
 	}
@@ -174,20 +183,23 @@ func syncCosignSignature(client *resty.Client, imageStore storage.ImageStore,
 	// push config blob
 	_, _, err = imageStore.FullBlobUpload(localRepo, resp.RawBody(), cosignManifest.Config.Digest.String())
 	if err != nil {
-		log.Error().Err(err).Msg("couldn't upload cosign config blob")
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msg("couldn't upload cosign config blob")
 
 		return err
 	}
 
 	cosignManifestBuf, err := json.Marshal(cosignManifest)
 	if err != nil {
-		log.Error().Err(err).Msg("couldn't marshal cosign manifest")
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msg("couldn't marshal cosign manifest")
 	}
 
 	// push manifest
 	_, err = imageStore.PutImageManifest(localRepo, cosignTag, ispec.MediaTypeImageManifest, cosignManifestBuf)
 	if err != nil {
-		log.Error().Err(err).Msg("couldn't upload cosign manifest")
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msg("couldn't upload cosign manifest")
 
 		return err
 	}
@@ -215,7 +227,8 @@ func syncNotarySignature(client *resty.Client, imageStore storage.ImageStore,
 		resp, err := client.R().
 			Get(getRefManifestURL.String())
 		if err != nil {
-			log.Error().Err(err).Msgf("couldn't get notary manifest: %s", getRefManifestURL.String())
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't get notary manifest: %s", getRefManifestURL.String())
 
 			return err
 		}
@@ -225,7 +238,8 @@ func syncNotarySignature(client *resty.Client, imageStore storage.ImageStore,
 
 		err = json.Unmarshal(resp.Body(), &artifactManifest)
 		if err != nil {
-			log.Error().Err(err).Msgf("couldn't unmarshal notary manifest: %s", getRefManifestURL.String())
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't unmarshal notary manifest: %s", getRefManifestURL.String())
 
 			return err
 		}
@@ -237,7 +251,8 @@ func syncNotarySignature(client *resty.Client, imageStore storage.ImageStore,
 
 			resp, err := client.R().SetDoNotParseResponse(true).Get(getBlobURL.String())
 			if err != nil {
-				log.Error().Err(err).Msgf("couldn't get notary blob: %s", getBlobURL.String())
+				log.Error().Str("errorType", TypeOf(err)).
+					Err(err).Msgf("couldn't get notary blob: %s", getBlobURL.String())
 
 				return err
 			}
@@ -253,7 +268,8 @@ func syncNotarySignature(client *resty.Client, imageStore storage.ImageStore,
 
 			_, _, err = imageStore.FullBlobUpload(localRepo, resp.RawBody(), blob.Digest.String())
 			if err != nil {
-				log.Error().Err(err).Msg("couldn't upload notary sig blob")
+				log.Error().Str("errorType", TypeOf(err)).
+					Err(err).Msg("couldn't upload notary sig blob")
 
 				return err
 			}
@@ -262,7 +278,8 @@ func syncNotarySignature(client *resty.Client, imageStore storage.ImageStore,
 		_, err = imageStore.PutImageManifest(localRepo, ref.Digest.String(),
 			artifactspec.MediaTypeArtifactManifest, resp.Body())
 		if err != nil {
-			log.Error().Err(err).Msg("couldn't upload notary sig manifest")
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msg("couldn't upload notary sig manifest")
 
 			return err
 		}
@@ -284,7 +301,8 @@ func canSkipNotarySignature(repo, tag, digest string, refs ReferenceList, imageS
 				return false, nil
 			}
 
-			log.Error().Err(err).Msgf("couldn't get local notary signature %s:%s manifest", repo, tag)
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't get local notary signature %s:%s manifest", repo, tag)
 
 			return false, err
 		}
@@ -318,14 +336,16 @@ func canSkipCosignSignature(repo, tag, digest string, cosignManifest *ispec.Mani
 				return false, nil
 			}
 
-			log.Error().Err(err).Msgf("couldn't get local cosign %s:%s manifest", repo, tag)
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't get local cosign %s:%s manifest", repo, tag)
 
 			return false, err
 		}
 
 		err = json.Unmarshal(localCosignManifestBuf, &localCosignManifest)
 		if err != nil {
-			log.Error().Err(err).Msgf("couldn't unmarshal local cosign signature %s:%s manifest", repo, tag)
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't unmarshal local cosign signature %s:%s manifest", repo, tag)
 
 			return false, err
 		}
diff --git a/pkg/extensions/sync/sync.go b/pkg/extensions/sync/sync.go
index 195ea21c..c602237b 100644
--- a/pkg/extensions/sync/sync.go
+++ b/pkg/extensions/sync/sync.go
@@ -200,14 +200,16 @@ func imagesToCopyFromUpstream(ctx context.Context, registryName string, repos []
 
 		repoRef, err := parseRepositoryReference(fmt.Sprintf("%s/%s", registryName, repoName))
 		if err != nil {
-			log.Error().Err(err).Msgf("couldn't parse repository reference: %s", repoRef)
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't parse repository reference: %s", repoRef)
 
 			return nil, err
 		}
 
 		tags, err := getImageTags(ctx, upstreamCtx, repoRef)
 		if err != nil {
-			log.Error().Err(err).Msgf("couldn't fetch tags for %s", repoRef)
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't fetch tags for %s", repoRef)
 
 			return nil, err
 		}
@@ -320,7 +322,8 @@ func syncRegistry(ctx context.Context, regCfg RegistryConfig, upstreamURL string
 
 		return err
 	}, retryOptions); err != nil {
-		log.Error().Err(err).Msg("error while getting upstream catalog, retrying...")
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msg("error while getting upstream catalog, retrying...")
 
 		return err
 	}
@@ -362,7 +365,8 @@ func syncRegistry(ctx context.Context, regCfg RegistryConfig, upstreamURL string
 
 			return nil
 		}, retryOptions); err != nil {
-			log.Error().Err(err).Msg("error while getting images references from upstream, retrying...")
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msg("error while getting images references from upstream, retrying...")
 
 			return err
 		}
@@ -381,7 +385,8 @@ func syncRegistry(ctx context.Context, regCfg RegistryConfig, upstreamURL string
 
 		localCachePath, err := getLocalCachePath(imageStore, remoteRepoCopy)
 		if err != nil {
-			log.Error().Err(err).Msgf("couldn't get localCachePath for %s", remoteRepoCopy)
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msgf("couldn't get localCachePath for %s", remoteRepoCopy)
 
 			return err
 		}
@@ -482,7 +487,8 @@ func syncRegistry(ctx context.Context, regCfg RegistryConfig, upstreamURL string
 
 			localImageRef, err := getLocalImageRef(localCachePath, localRepo, tag)
 			if err != nil {
-				log.Error().Err(err).Msgf("couldn't obtain a valid image reference for reference %s/%s:%s",
+				log.Error().Str("errorType", TypeOf(err)).
+					Err(err).Msgf("couldn't obtain a valid image reference for reference %s/%s:%s",
 					localCachePath, localRepo, tag)
 
 				return err
@@ -495,7 +501,8 @@ func syncRegistry(ctx context.Context, regCfg RegistryConfig, upstreamURL string
 
 				return err
 			}, retryOptions); err != nil {
-				log.Error().Err(err).Msgf("error while copying image %s to %s",
+				log.Error().Str("errorType", TypeOf(err)).
+					Err(err).Msgf("error while copying image %s to %s",
 					upstreamImageRef.DockerReference(), localCachePath)
 
 				return err
@@ -504,7 +511,8 @@ func syncRegistry(ctx context.Context, regCfg RegistryConfig, upstreamURL string
 			err = pushSyncedLocalImage(localRepo, tag, localCachePath, imageStore, log)
 
 			if err != nil {
-				log.Error().Err(err).Msgf("error while pushing synced cached image %s",
+				log.Error().Str("errorType", TypeOf(err)).
+					Err(err).Msgf("error while pushing synced cached image %s",
 					fmt.Sprintf("%s/%s:%s", localCachePath, localRepo, tag))
 
 				return err
@@ -517,7 +525,8 @@ func syncRegistry(ctx context.Context, regCfg RegistryConfig, upstreamURL string
 
 				return err
 			}, retryOptions); err != nil {
-				log.Error().Err(err).Msgf("couldn't copy notary signature for %s", upstreamImageRef.DockerReference())
+				log.Error().Str("errorType", TypeOf(err)).
+					Err(err).Msgf("couldn't copy notary signature for %s", upstreamImageRef.DockerReference())
 			}
 
 			cosignManifest, err = getCosignManifest(httpClient, *registryURL, remoteRepoCopy,
@@ -528,7 +537,8 @@ func syncRegistry(ctx context.Context, regCfg RegistryConfig, upstreamURL string
 
 				return err
 			}, retryOptions); err != nil {
-				log.Error().Err(err).Msgf("couldn't copy cosign signature for %s", upstreamImageRef.DockerReference())
+				log.Error().Str("errorType", TypeOf(err)).
+					Err(err).Msgf("couldn't copy cosign signature for %s", upstreamImageRef.DockerReference())
 			}
 		}
 	}
@@ -554,7 +564,8 @@ func getLocalContexts(log log.Logger) (*types.SystemContext, *signature.PolicyCo
 
 	policyContext, err := signature.NewPolicyContext(policy)
 	if err := test.Error(err); err != nil {
-		log.Error().Err(err).Msg("couldn't create policy context")
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msg("couldn't create policy context")
 
 		return &types.SystemContext{}, &signature.PolicyContext{}, err
 	}
@@ -572,7 +583,8 @@ func Run(ctx context.Context, cfg Config, storeController storage.StoreControlle
 	if cfg.CredentialsFile != "" {
 		credentialsFile, err = getFileCredentials(cfg.CredentialsFile)
 		if err != nil {
-			logger.Error().Err(err).Msgf("couldn't get registry credentials from %s", cfg.CredentialsFile)
+			logger.Error().Str("errortype", TypeOf(err)).
+				Err(err).Msgf("couldn't get registry credentials from %s", cfg.CredentialsFile)
 
 			return err
 		}
@@ -624,7 +636,8 @@ func Run(ctx context.Context, cfg Config, storeController storage.StoreControlle
 					// first try syncing main registry
 					if err := syncRegistry(ctx, regCfg, upstreamURL, storeController, localCtx, policyCtx,
 						credentialsFile[upstreamAddr], retryOptions, logger); err != nil {
-						logger.Error().Err(err).Str("registry", upstreamURL).
+						logger.Error().Str("errortype", TypeOf(err)).
+							Err(err).Str("registry", upstreamURL).
 							Msg("sync exited with error, falling back to auxiliary registries if any")
 					} else {
 						// if success fall back to main registry
diff --git a/pkg/extensions/sync/utils.go b/pkg/extensions/sync/utils.go
index b5795388..1b009bc3 100644
--- a/pkg/extensions/sync/utils.go
+++ b/pkg/extensions/sync/utils.go
@@ -34,6 +34,10 @@ type ReferenceList struct {
 	References []artifactspec.Descriptor `json:"references"`
 }
 
+func TypeOf(v interface{}) string {
+	return fmt.Sprintf("%T", v)
+}
+
 // getTagFromRef returns a tagged reference from an image reference.
 func getTagFromRef(ref types.ImageReference, log log.Logger) reference.Tagged {
 	tagged, isTagged := ref.DockerReference().(reference.Tagged)
@@ -74,7 +78,8 @@ func filterRepos(repos []string, contentList []Content, log log.Logger) map[int]
 
 			matched, err := glob.Match(prefix, repo)
 			if err != nil {
-				log.Error().Err(err).Str("pattern",
+				log.Error().Str("errorType", TypeOf(err)).
+					Err(err).Str("pattern",
 					prefix).Msg("error while parsing glob pattern, skipping it...")
 
 				continue
@@ -208,7 +213,8 @@ func getHTTPClient(regCfg *RegistryConfig, upstreamURL string, credentials Crede
 
 	registryURL, err := url.Parse(upstreamURL)
 	if err != nil {
-		log.Error().Err(err).Str("url", upstreamURL).Msg("couldn't parse url")
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Str("url", upstreamURL).Msg("couldn't parse url")
 
 		return nil, nil, err
 	}
@@ -221,7 +227,8 @@ func getHTTPClient(regCfg *RegistryConfig, upstreamURL string, credentials Crede
 
 		caCert, err := ioutil.ReadFile(caCertPath)
 		if err != nil {
-			log.Error().Err(err).Msg("couldn't read CA certificate")
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msg("couldn't read CA certificate")
 
 			return nil, nil, err
 		}
@@ -233,7 +240,8 @@ func getHTTPClient(regCfg *RegistryConfig, upstreamURL string, credentials Crede
 
 		cert, err := tls.LoadX509KeyPair(clientCert, clientKey)
 		if err != nil {
-			log.Error().Err(err).Msg("couldn't read certificates key pairs")
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Msg("couldn't read certificates key pairs")
 
 			return nil, nil, err
 		}
@@ -266,7 +274,8 @@ func pushSyncedLocalImage(localRepo, tag, localCachePath string,
 
 	manifestContent, _, _, err := cacheImageStore.GetImageManifest(localRepo, tag)
 	if err != nil {
-		log.Error().Err(err).Str("dir", path.Join(cacheImageStore.RootDir(), localRepo)).
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Str("dir", path.Join(cacheImageStore.RootDir(), localRepo)).
 			Msg("couldn't find index.json")
 
 		return err
@@ -275,7 +284,8 @@ func pushSyncedLocalImage(localRepo, tag, localCachePath string,
 	var manifest ispec.Manifest
 
 	if err := json.Unmarshal(manifestContent, &manifest); err != nil {
-		log.Error().Err(err).Str("dir", path.Join(cacheImageStore.RootDir(), localRepo)).
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Str("dir", path.Join(cacheImageStore.RootDir(), localRepo)).
 			Msg("invalid JSON")
 
 		return err
@@ -284,7 +294,8 @@ func pushSyncedLocalImage(localRepo, tag, localCachePath string,
 	for _, blob := range manifest.Layers {
 		blobReader, _, err := cacheImageStore.GetBlob(localRepo, blob.Digest.String(), blob.MediaType)
 		if err != nil {
-			log.Error().Err(err).Str("dir", path.Join(cacheImageStore.RootDir(),
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Str("dir", path.Join(cacheImageStore.RootDir(),
 				localRepo)).Str("blob digest", blob.Digest.String()).Msg("couldn't read blob")
 
 			return err
@@ -293,7 +304,8 @@ func pushSyncedLocalImage(localRepo, tag, localCachePath string,
 		if found, _, _ := imageStore.CheckBlob(localRepo, blob.Digest.String()); !found {
 			_, _, err = imageStore.FullBlobUpload(localRepo, blobReader, blob.Digest.String())
 			if err != nil {
-				log.Error().Err(err).Str("blob digest", blob.Digest.String()).Msg("couldn't upload blob")
+				log.Error().Str("errorType", TypeOf(err)).
+					Err(err).Str("blob digest", blob.Digest.String()).Msg("couldn't upload blob")
 
 				return err
 			}
@@ -302,7 +314,8 @@ func pushSyncedLocalImage(localRepo, tag, localCachePath string,
 
 	blobReader, _, err := cacheImageStore.GetBlob(localRepo, manifest.Config.Digest.String(), manifest.Config.MediaType)
 	if err != nil {
-		log.Error().Err(err).Str("dir", path.Join(cacheImageStore.RootDir(),
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Str("dir", path.Join(cacheImageStore.RootDir(),
 			localRepo)).Str("blob digest", manifest.Config.Digest.String()).Msg("couldn't read config blob")
 
 		return err
@@ -311,7 +324,8 @@ func pushSyncedLocalImage(localRepo, tag, localCachePath string,
 	if found, _, _ := imageStore.CheckBlob(localRepo, manifest.Config.Digest.String()); !found {
 		_, _, err = imageStore.FullBlobUpload(localRepo, blobReader, manifest.Config.Digest.String())
 		if err != nil {
-			log.Error().Err(err).Str("blob digest", manifest.Config.Digest.String()).Msg("couldn't upload config blob")
+			log.Error().Str("errorType", TypeOf(err)).
+				Err(err).Str("blob digest", manifest.Config.Digest.String()).Msg("couldn't upload config blob")
 
 			return err
 		}
@@ -319,7 +333,8 @@ func pushSyncedLocalImage(localRepo, tag, localCachePath string,
 
 	_, err = imageStore.PutImageManifest(localRepo, tag, ispec.MediaTypeImageManifest, manifestContent)
 	if err != nil {
-		log.Error().Err(err).Msg("couldn't upload manifest")
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msg("couldn't upload manifest")
 
 		return err
 	}
@@ -411,7 +426,8 @@ func canSkipImage(repo, tag, digest string, imageStore storage.ImageStore, log l
 			return false, nil
 		}
 
-		log.Error().Err(err).Msgf("couldn't get local image %s:%s manifest", repo, tag)
+		log.Error().Str("errorType", TypeOf(err)).
+			Err(err).Msgf("couldn't get local image %s:%s manifest", repo, tag)
 
 		return false, err
 	}