diff --git a/pkg/crud/bcrypt.go b/pkg/crud/bcrypt.go
index f74787dd..cd45835d 100644
--- a/pkg/crud/bcrypt.go
+++ b/pkg/crud/bcrypt.go
@@ -13,7 +13,7 @@ func findBcryptBestCost(maxDuration time.Duration) (int, error) {
 	for i := bcrypt.MinCost + 1; i <= bcrypt.MaxCost; i++ {
 		hashedPassword, err := bcrypt.GenerateFromPassword(password, i)
 		if err != nil {
-			return i, fmt.Errorf("generate password: %s", err)
+			return i, fmt.Errorf("generate password: %w", err)
 		}
 
 		start := time.Now()
diff --git a/pkg/crud/crud.go b/pkg/crud/crud.go
index 92212236..01f41d44 100644
--- a/pkg/crud/crud.go
+++ b/pkg/crud/crud.go
@@ -95,7 +95,7 @@ func New(config Config, storage absto.Storage, rendererApp renderer.App, shareAp
 
 	if amqpClient != nil {
 		if err := amqpClient.SetupExclusive(app.amqpExclusiveRoutingKey); err != nil {
-			return app, fmt.Errorf("setup amqp exclusive: %s", err)
+			return app, fmt.Errorf("setup amqp exclusive: %w", err)
 		}
 	}
 
@@ -125,7 +125,7 @@ func New(config Config, storage absto.Storage, rendererApp renderer.App, shareAp
 
 	bcryptDuration, err := time.ParseDuration(strings.TrimSpace(*config.bcryptDuration))
 	if err != nil {
-		return app, fmt.Errorf("parse bcrypt duration: %s", err)
+		return app, fmt.Errorf("parse bcrypt duration: %w", err)
 	}
 
 	bcryptCost, err := findBcryptBestCost(bcryptDuration)
diff --git a/pkg/crud/list.go b/pkg/crud/list.go
index 28e2e9cf..18d39b0b 100644
--- a/pkg/crud/list.go
+++ b/pkg/crud/list.go
@@ -149,7 +149,7 @@ func (a App) zipItems(ctx context.Context, done <-chan struct{}, request provide
 			var nestedItems []absto.Item
 			nestedItems, err = a.storageApp.List(ctx, request.SubPath(relativeURL))
 			if err != nil {
-				err = fmt.Errorf("zip nested folder `%s`: %s", relativeURL, err)
+				err = fmt.Errorf("zip nested folder `%s`: %w", relativeURL, err)
 				return
 			}
 
@@ -174,7 +174,7 @@ func (a App) addFileToZip(ctx context.Context, zipWriter *zip.Writer, item absto
 	var writer io.Writer
 	writer, err = zipWriter.CreateHeader(header)
 	if err != nil {
-		return fmt.Errorf("create zip header: %s", err)
+		return fmt.Errorf("create zip header: %w", err)
 	}
 
 	var reader io.ReadCloser
diff --git a/pkg/crud/post.go b/pkg/crud/post.go
index 8487f4cf..94ee35bd 100644
--- a/pkg/crud/post.go
+++ b/pkg/crud/post.go
@@ -30,7 +30,7 @@ func parseMultipart(r *http.Request) (map[string]string, *multipart.Part, error)
 		}
 
 		if err != nil {
-			return nil, nil, fmt.Errorf("error while reader multipart: %s", err)
+			return nil, nil, fmt.Errorf("error while reader multipart: %w", err)
 		}
 
 		formName := part.FormName()
@@ -41,7 +41,7 @@ func parseMultipart(r *http.Request) (map[string]string, *multipart.Part, error)
 		default:
 			value, err := io.ReadAll(part)
 			if err != nil {
-				return nil, nil, fmt.Errorf("read form value `%s`: %s", formName, err)
+				return nil, nil, fmt.Errorf("read form value `%s`: %w", formName, err)
 			}
 
 			values[formName] = string(value)
@@ -88,7 +88,7 @@ func (a App) handleMultipart(w http.ResponseWriter, r *http.Request, request pro
 
 	values, file, err := parseMultipart(r)
 	if err != nil {
-		a.error(w, r, request, model.WrapInternal(fmt.Errorf("parse multipart request: %s", err)))
+		a.error(w, r, request, model.WrapInternal(fmt.Errorf("parse multipart request: %w", err)))
 		return
 	}
 
@@ -101,7 +101,7 @@ func (a App) handleMultipart(w http.ResponseWriter, r *http.Request, request pro
 		if chunkNumber := r.Header.Get("X-Chunk-Number"); len(chunkNumber) != 0 {
 			chunkNumberValue, err := strconv.ParseUint(chunkNumber, 10, 64)
 			if err != nil {
-				a.error(w, r, request, model.WrapInvalid(fmt.Errorf("parse chunk number: %s", err)))
+				a.error(w, r, request, model.WrapInvalid(fmt.Errorf("parse chunk number: %w", err)))
 			}
 
 			chunkNumber = fmt.Sprintf("%10d", chunkNumberValue)
diff --git a/pkg/crud/rename.go b/pkg/crud/rename.go
index b6e8b190..52ba9329 100644
--- a/pkg/crud/rename.go
+++ b/pkg/crud/rename.go
@@ -160,18 +160,18 @@ func (a App) checkFile(ctx context.Context, pathname string, shouldExist bool) (
 func (a App) updateCover(ctx context.Context, item absto.Item) error {
 	directory, err := a.storageApp.Info(ctx, item.Dir())
 	if err != nil {
-		return fmt.Errorf("get directory: %s", err)
+		return fmt.Errorf("get directory: %w", err)
 	}
 
 	aggregate, err := a.exifApp.GetAggregateFor(ctx, directory)
 	if err != nil && !absto.IsNotExist(err) {
-		return fmt.Errorf("get aggregate: %s", err)
+		return fmt.Errorf("get aggregate: %w", err)
 	}
 
 	aggregate.Cover = item.Name
 
 	if err := a.exifApp.SaveAggregateFor(ctx, directory, aggregate); err != nil {
-		return fmt.Errorf("save aggregate: %s", err)
+		return fmt.Errorf("save aggregate: %w", err)
 	}
 
 	return nil
diff --git a/pkg/crud/search.go b/pkg/crud/search.go
index a8dde5ce..a1e6cddf 100644
--- a/pkg/crud/search.go
+++ b/pkg/crud/search.go
@@ -233,7 +233,7 @@ func parseDate(raw string) (time.Time, error) {
 
 	value, err := time.Parse(isoDateLayout, raw)
 	if err != nil {
-		return time.Time{}, fmt.Errorf("parse date: %s", err)
+		return time.Time{}, fmt.Errorf("parse date: %w", err)
 	}
 
 	return value, nil
diff --git a/pkg/crud/stats.go b/pkg/crud/stats.go
index 0034084e..5de79787 100644
--- a/pkg/crud/stats.go
+++ b/pkg/crud/stats.go
@@ -56,7 +56,7 @@ func (a App) computeStats(ctx context.Context, pathname string) (map[string]uint
 		return nil
 	})
 	if err != nil {
-		return nil, fmt.Errorf("browse files: %s", err)
+		return nil, fmt.Errorf("browse files: %w", err)
 	}
 
 	err = a.rawStorageApp.Walk(ctx, provider.MetadataDirectoryName+pathname, func(item absto.Item) error {
@@ -68,7 +68,7 @@ func (a App) computeStats(ctx context.Context, pathname string) (map[string]uint
 	})
 
 	if err != nil {
-		return nil, fmt.Errorf("browse metadatas: %s", err)
+		return nil, fmt.Errorf("browse metadatas: %w", err)
 	}
 
 	return map[string]uint64{
diff --git a/pkg/crud/upload.go b/pkg/crud/upload.go
index 76e1d730..81123b01 100644
--- a/pkg/crud/upload.go
+++ b/pkg/crud/upload.go
@@ -21,13 +21,13 @@ func (a App) saveUploadedFile(ctx context.Context, request provider.Request, inp
 
 	fileName, filePath, err = getUploadNameAndPath(request, inputName, file)
 	if err != nil {
-		return "", fmt.Errorf("get upload name: %s", err)
+		return "", fmt.Errorf("get upload name: %w", err)
 	}
 
 	var size int64
 	size, err = getUploadSize(rawSize)
 	if err != nil {
-		return "", fmt.Errorf("get upload size: %s", err)
+		return "", fmt.Errorf("get upload size: %w", err)
 	}
 
 	err = provider.WriteToStorage(ctx, a.storageApp, filePath, size, file)
@@ -70,7 +70,7 @@ func getUploadSize(rawSize string) (int64, error) {
 
 	if len(rawSize) > 0 {
 		if size, err := strconv.ParseInt(rawSize, 10, 64); err != nil {
-			return size, fmt.Errorf("parse filesize: %s", err)
+			return size, fmt.Errorf("parse filesize: %w", err)
 		}
 	}
 
diff --git a/pkg/crud/upload_chunk.go b/pkg/crud/upload_chunk.go
index bdaf04e2..e99fb391 100644
--- a/pkg/crud/upload_chunk.go
+++ b/pkg/crud/upload_chunk.go
@@ -117,7 +117,7 @@ func (a App) mergeChunk(w http.ResponseWriter, r *http.Request, request provider
 func (a App) mergeChunkFiles(directory, destination string) error {
 	writer, err := os.OpenFile(destination, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o600)
 	if err != nil {
-		return fmt.Errorf("open destination file `%s`: %s", destination, err)
+		return fmt.Errorf("open destination file `%s`: %w", destination, err)
 	}
 
 	defer func() {
@@ -135,7 +135,7 @@ func (a App) mergeChunkFiles(directory, destination string) error {
 	}()
 
 	if err = browseChunkFiles(directory, destination, writer); err != nil {
-		return fmt.Errorf("walk chunks in `%s`: %s", directory, err)
+		return fmt.Errorf("walk chunks in `%s`: %w", directory, err)
 	}
 
 	return nil
@@ -153,7 +153,7 @@ func browseChunkFiles(directory, destination string, writer io.Writer) error {
 
 		reader, err := os.Open(path)
 		if err != nil {
-			return fmt.Errorf("open chunk `%s`: %s", path, err)
+			return fmt.Errorf("open chunk `%s`: %w", path, err)
 		}
 
 		defer func() {
@@ -163,7 +163,7 @@ func browseChunkFiles(directory, destination string, writer io.Writer) error {
 		}()
 
 		if _, err = io.Copy(writer, reader); err != nil {
-			return fmt.Errorf("copy chunk `%s`: %s", path, err)
+			return fmt.Errorf("copy chunk `%s`: %w", path, err)
 		}
 
 		return nil
diff --git a/pkg/crud/webhook.go b/pkg/crud/webhook.go
index cc6ae364..b65b74ac 100644
--- a/pkg/crud/webhook.go
+++ b/pkg/crud/webhook.go
@@ -20,7 +20,7 @@ func (a App) createWebhook(w http.ResponseWriter, r *http.Request, request provi
 	var err error
 	err = r.ParseForm()
 	if err != nil {
-		a.error(w, r, request, model.WrapInvalid(fmt.Errorf("parse form: %s", err)))
+		a.error(w, r, request, model.WrapInvalid(fmt.Errorf("parse form: %w", err)))
 		return
 	}
 
@@ -72,7 +72,7 @@ func checkWebhookForm(r *http.Request) (recursive bool, kind provider.WebhookKin
 
 	kind, err = provider.ParseWebhookKind(r.Form.Get("kind"))
 	if err != nil {
-		err = model.WrapInvalid(fmt.Errorf("parse kind: %s", err))
+		err = model.WrapInvalid(fmt.Errorf("parse kind: %w", err))
 		return
 	}
 
@@ -92,7 +92,7 @@ func checkWebhookForm(r *http.Request) (recursive bool, kind provider.WebhookKin
 		webhookURL = generateTelegramURL(webhookURL, chatID)
 	} else {
 		if _, err = url.Parse(webhookURL); err != nil {
-			err = model.WrapInvalid(fmt.Errorf("parse url: %s", err))
+			err = model.WrapInvalid(fmt.Errorf("parse url: %w", err))
 			return
 		}
 	}
diff --git a/pkg/exif/amqp.go b/pkg/exif/amqp.go
index 218aa880..2792698d 100644
--- a/pkg/exif/amqp.go
+++ b/pkg/exif/amqp.go
@@ -15,7 +15,7 @@ func (a App) AMQPHandler(message amqp.Delivery) error {
 	var resp provider.ExifResponse
 
 	if err := json.Unmarshal(message.Body, &resp); err != nil {
-		return fmt.Errorf("decode: %s", err)
+		return fmt.Errorf("decode: %w", err)
 	}
 
 	if resp.Exif.IsZero() {
@@ -33,7 +33,7 @@ func (a App) AMQPHandler(message amqp.Delivery) error {
 	resp.Exif.Description = exif.Description
 
 	if err := a.SaveExifFor(ctx, resp.Item, resp.Exif); err != nil {
-		return fmt.Errorf("save: %s", err)
+		return fmt.Errorf("save: %w", err)
 	}
 
 	return a.processExif(ctx, resp.Item, resp.Exif, true)
diff --git a/pkg/exif/date.go b/pkg/exif/date.go
index 53b7812f..f908dd11 100644
--- a/pkg/exif/date.go
+++ b/pkg/exif/date.go
@@ -14,7 +14,7 @@ func (a App) updateDate(ctx context.Context, item absto.Item, data exas.Exif) er
 	}
 
 	if err := a.storageApp.UpdateDate(ctx, item.Pathname, data.Date); err != nil {
-		return fmt.Errorf("update date: %s", err)
+		return fmt.Errorf("update date: %w", err)
 	}
 
 	return nil
diff --git a/pkg/exif/event.go b/pkg/exif/event.go
index 28ab22af..408c42fd 100644
--- a/pkg/exif/event.go
+++ b/pkg/exif/event.go
@@ -46,7 +46,7 @@ func (a App) EventConsumer(ctx context.Context, e provider.Event) {
 
 func (a App) Rename(ctx context.Context, old, new absto.Item) error {
 	if err := a.storageApp.Rename(ctx, Path(old), Path(new)); err != nil && !absto.IsNotExist(err) {
-		return fmt.Errorf("rename exif: %s", err)
+		return fmt.Errorf("rename exif: %w", err)
 	}
 
 	return nil
@@ -88,7 +88,7 @@ func (a App) handleUploadEvent(ctx context.Context, item absto.Item, aggregate b
 
 	exif, err := a.extractAndSaveExif(ctx, item)
 	if err != nil {
-		return fmt.Errorf("extract and save exif: %s", err)
+		return fmt.Errorf("extract and save exif: %w", err)
 	}
 
 	if exif.IsZero() {
@@ -100,7 +100,7 @@ func (a App) handleUploadEvent(ctx context.Context, item absto.Item, aggregate b
 
 func (a App) processExif(ctx context.Context, item absto.Item, exif exas.Exif, aggregate bool) error {
 	if err := a.updateDate(ctx, item, exif); err != nil {
-		return fmt.Errorf("update date: %s", err)
+		return fmt.Errorf("update date: %w", err)
 	}
 
 	if !aggregate {
@@ -108,7 +108,7 @@ func (a App) processExif(ctx context.Context, item absto.Item, exif exas.Exif, a
 	}
 
 	if err := a.aggregate(ctx, item); err != nil {
-		return fmt.Errorf("aggregate folder: %s", err)
+		return fmt.Errorf("aggregate folder: %w", err)
 	}
 
 	return nil
@@ -117,12 +117,12 @@ func (a App) processExif(ctx context.Context, item absto.Item, exif exas.Exif, a
 func (a App) aggregateOnRename(ctx context.Context, old, new absto.Item) error {
 	oldDir, err := a.getDirOf(ctx, old)
 	if err != nil {
-		return fmt.Errorf("get old directory: %s", err)
+		return fmt.Errorf("get old directory: %w", err)
 	}
 
 	newDir, err := a.getDirOf(ctx, new)
 	if err != nil {
-		return fmt.Errorf("get new directory: %s", err)
+		return fmt.Errorf("get new directory: %w", err)
 	}
 
 	if oldDir.Pathname == newDir.Pathname {
@@ -130,11 +130,11 @@ func (a App) aggregateOnRename(ctx context.Context, old, new absto.Item) error {
 	}
 
 	if err = a.aggregate(ctx, oldDir); err != nil {
-		return fmt.Errorf("aggregate old directory: %s", err)
+		return fmt.Errorf("aggregate old directory: %w", err)
 	}
 
 	if err = a.aggregate(ctx, newDir); err != nil {
-		return fmt.Errorf("aggregate new directory: %s", err)
+		return fmt.Errorf("aggregate new directory: %w", err)
 	}
 
 	return nil
@@ -142,12 +142,12 @@ func (a App) aggregateOnRename(ctx context.Context, old, new absto.Item) error {
 
 func (a App) delete(ctx context.Context, item absto.Item) error {
 	if err := a.storageApp.Remove(ctx, Path(item)); err != nil {
-		return fmt.Errorf("delete: %s", err)
+		return fmt.Errorf("delete: %w", err)
 	}
 
 	if !item.IsDir {
 		if err := a.aggregate(ctx, item); err != nil {
-			return fmt.Errorf("aggregate directory: %s", err)
+			return fmt.Errorf("aggregate directory: %w", err)
 		}
 	}
 
diff --git a/pkg/exif/exif.go b/pkg/exif/exif.go
index 19bacd34..05589929 100644
--- a/pkg/exif/exif.go
+++ b/pkg/exif/exif.go
@@ -73,7 +73,7 @@ func New(config Config, storageApp absto.Storage, prometheusRegisterer prometheu
 		amqpExchange = strings.TrimSpace(*config.amqpExchange)
 
 		if err := amqpClient.Publisher(amqpExchange, "direct", nil); err != nil {
-			return App{}, fmt.Errorf("configure amqp: %s", err)
+			return App{}, fmt.Errorf("configure amqp: %w", err)
 		}
 	}
 
@@ -118,7 +118,7 @@ func (a App) enabled() bool {
 func (a App) extractAndSaveExif(ctx context.Context, item absto.Item) (exif exas.Exif, err error) {
 	exif, err = a.extractExif(ctx, item)
 	if err != nil {
-		err = fmt.Errorf("extract exif: %s", err)
+		err = fmt.Errorf("extract exif: %w", err)
 		return
 	}
 
@@ -135,7 +135,7 @@ func (a App) extractAndSaveExif(ctx context.Context, item absto.Item) (exif exas
 	}
 
 	if err = a.SaveExifFor(ctx, item, exif); err != nil {
-		err = fmt.Errorf("save exif: %s", err)
+		err = fmt.Errorf("save exif: %w", err)
 	}
 
 	return
@@ -154,12 +154,12 @@ func (a App) extractExif(ctx context.Context, item absto.Item) (exif exas.Exif,
 
 	if err != nil {
 		a.increaseExif("error")
-		err = fmt.Errorf("fetch exif: %s", err)
+		err = fmt.Errorf("fetch exif: %w", err)
 		return
 	}
 
 	if err = httpjson.Read(resp, &exif); err != nil {
-		err = fmt.Errorf("read exif: %s", err)
+		err = fmt.Errorf("read exif: %w", err)
 	}
 
 	return
diff --git a/pkg/exif/util.go b/pkg/exif/util.go
index 0b7b48d5..81545cc3 100644
--- a/pkg/exif/util.go
+++ b/pkg/exif/util.go
@@ -56,16 +56,16 @@ func (a App) saveMetadata(ctx context.Context, item absto.Item, data any) error
 
 	if _, err := a.storageApp.Info(ctx, dirname); err != nil {
 		if !absto.IsNotExist(err) {
-			return fmt.Errorf("check directory existence: %s", err)
+			return fmt.Errorf("check directory existence: %w", err)
 		}
 
 		if err = a.storageApp.CreateDir(ctx, dirname); err != nil {
-			return fmt.Errorf("create directory: %s", err)
+			return fmt.Errorf("create directory: %w", err)
 		}
 	}
 
 	if err := provider.SaveJSON(ctx, a.storageApp, filename, data); err != nil {
-		return fmt.Errorf("save: %s", err)
+		return fmt.Errorf("save: %w", err)
 	}
 
 	if item.IsDir {
diff --git a/pkg/provider/event.go b/pkg/provider/event.go
index 3daa56be..bb6005aa 100644
--- a/pkg/provider/event.go
+++ b/pkg/provider/event.go
@@ -77,12 +77,12 @@ func (et *EventType) UnmarshalJSON(b []byte) error {
 	var strValue string
 	err := json.Unmarshal(b, &strValue)
 	if err != nil {
-		return fmt.Errorf("unmarshal event type: %s", err)
+		return fmt.Errorf("unmarshal event type: %w", err)
 	}
 
 	value, err := ParseEventType(strValue)
 	if err != nil {
-		return fmt.Errorf("parse event type: %s", err)
+		return fmt.Errorf("parse event type: %w", err)
 	}
 
 	*et = value
@@ -282,7 +282,7 @@ func NewEventBus(size uint, prometheusRegisterer prometheus.Registerer, tracerAp
 		}, []string{"type", "state"})
 
 		if err := prometheusRegisterer.Register(counter); err != nil {
-			return EventBus{}, fmt.Errorf("register event metric: %s", err)
+			return EventBus{}, fmt.Errorf("register event metric: %w", err)
 		}
 	}
 
diff --git a/pkg/provider/utils.go b/pkg/provider/utils.go
index aa3a1e89..c7ca9022 100644
--- a/pkg/provider/utils.go
+++ b/pkg/provider/utils.go
@@ -214,7 +214,7 @@ func SendLargeFile(ctx context.Context, storageApp absto.Storage, item absto.Ite
 
 	r, err := req.Build(ctx, reader)
 	if err != nil {
-		return nil, fmt.Errorf("create request: %s", err)
+		return nil, fmt.Errorf("create request: %w", err)
 	}
 
 	r.ContentLength = item.Size
@@ -224,7 +224,7 @@ func SendLargeFile(ctx context.Context, storageApp absto.Storage, item absto.Ite
 
 func HandleClose(closer io.Closer, err error) error {
 	if closeErr := closer.Close(); closeErr != nil {
-		return model.WrapError(err, fmt.Errorf("close: %s", closeErr))
+		return model.WrapError(err, fmt.Errorf("close: %w", closeErr))
 	}
 
 	return err
@@ -241,7 +241,7 @@ func WriteToStorage(ctx context.Context, storageApp absto.Storage, output string
 	directory := path.Dir(output)
 
 	if err = storageApp.CreateDir(ctx, directory); err != nil {
-		return fmt.Errorf("create directory: %s", err)
+		return fmt.Errorf("create directory: %w", err)
 	}
 
 	if size == -1 {
@@ -252,7 +252,7 @@ func WriteToStorage(ctx context.Context, storageApp absto.Storage, output string
 
 	if err != nil {
 		if removeErr := storageApp.Remove(ctx, output); removeErr != nil {
-			err = model.WrapError(err, fmt.Errorf("remove: %s", removeErr))
+			err = model.WrapError(err, fmt.Errorf("remove: %w", removeErr))
 		}
 	}
 
diff --git a/pkg/provider/webhook.go b/pkg/provider/webhook.go
index e06fd6b6..0fda0f17 100644
--- a/pkg/provider/webhook.go
+++ b/pkg/provider/webhook.go
@@ -54,12 +54,12 @@ func (r *WebhookKind) UnmarshalJSON(b []byte) error {
 	var strValue string
 	err := json.Unmarshal(b, &strValue)
 	if err != nil {
-		return fmt.Errorf("unmarshal event type: %s", err)
+		return fmt.Errorf("unmarshal event type: %w", err)
 	}
 
 	value, err := ParseWebhookKind(strValue)
 	if err != nil {
-		return fmt.Errorf("parse event type: %s", err)
+		return fmt.Errorf("parse event type: %w", err)
 	}
 
 	*r = value
diff --git a/pkg/share/amqp.go b/pkg/share/amqp.go
index 03ddc5b0..8414173c 100644
--- a/pkg/share/amqp.go
+++ b/pkg/share/amqp.go
@@ -12,7 +12,7 @@ func (a *App) AMQPHandler(message amqp.Delivery) error {
 	var share provider.Share
 
 	if err := json.Unmarshal(message.Body, &share); err != nil {
-		return fmt.Errorf("decode: %s", err)
+		return fmt.Errorf("decode: %w", err)
 	}
 
 	a.Lock()
diff --git a/pkg/share/crud.go b/pkg/share/crud.go
index 257f3c08..47b2d882 100644
--- a/pkg/share/crud.go
+++ b/pkg/share/crud.go
@@ -52,7 +52,7 @@ func (a *App) Create(ctx context.Context, filepath string, edit, story bool, pas
 		var err error
 		id, err = a.generateID()
 		if err != nil {
-			return fmt.Errorf("generate id: %s", err)
+			return fmt.Errorf("generate id: %w", err)
 		}
 
 		share := provider.Share{
@@ -70,12 +70,12 @@ func (a *App) Create(ctx context.Context, filepath string, edit, story bool, pas
 		a.shares[id] = share
 
 		if err = provider.SaveJSON(ctx, a.storageApp, shareFilename, a.shares); err != nil {
-			return fmt.Errorf("save shares: %s", err)
+			return fmt.Errorf("save shares: %w", err)
 		}
 
 		if a.amqpClient != nil {
 			if err = a.amqpClient.PublishJSON(share, a.amqpExchange, a.amqpRoutingKey); err != nil {
-				return fmt.Errorf("publish share creation: %s", err)
+				return fmt.Errorf("publish share creation: %w", err)
 			}
 		}
 
@@ -98,12 +98,12 @@ func (a *App) delete(ctx context.Context, id string) error {
 	delete(a.shares, id)
 
 	if err := provider.SaveJSON(ctx, a.storageApp, shareFilename, a.shares); err != nil {
-		return fmt.Errorf("save shares: %s", err)
+		return fmt.Errorf("save shares: %w", err)
 	}
 
 	if a.amqpClient != nil {
 		if err := a.amqpClient.PublishJSON(provider.Share{ID: id}, a.amqpExchange, a.amqpRoutingKey); err != nil {
-			return fmt.Errorf("publish share deletion: %s", err)
+			return fmt.Errorf("publish share deletion: %w", err)
 		}
 	}
 
diff --git a/pkg/share/event.go b/pkg/share/event.go
index 4883e0c6..37d8475f 100644
--- a/pkg/share/event.go
+++ b/pkg/share/event.go
@@ -33,7 +33,7 @@ func (a *App) renameItem(ctx context.Context, old, new absto.Item) error {
 
 				if a.amqpClient != nil {
 					if err := a.amqpClient.PublishJSON(share, a.amqpExchange, a.amqpRoutingKey); err != nil {
-						return fmt.Errorf("publish share rename: %s", err)
+						return fmt.Errorf("publish share rename: %w", err)
 					}
 				}
 			}
@@ -50,7 +50,7 @@ func (a *App) deleteItem(ctx context.Context, item absto.Item) error {
 		for id, share := range a.shares {
 			if strings.HasPrefix(share.Path, item.Pathname) {
 				if err := a.delete(ctx, id); err != nil {
-					return fmt.Errorf("delete share `%s`: %s", id, err)
+					return fmt.Errorf("delete share `%s`: %w", id, err)
 				}
 			}
 		}
diff --git a/pkg/share/share.go b/pkg/share/share.go
index e2482e91..dd8e9532 100644
--- a/pkg/share/share.go
+++ b/pkg/share/share.go
@@ -59,12 +59,12 @@ func New(config Config, storageApp absto.Storage, amqpClient *amqp.Client) (*App
 		amqpExclusiveRoutingKey = strings.TrimSpace(*config.amqpExclusiveRoutingKey)
 
 		if err := amqpClient.Publisher(amqpExchange, "fanout", nil); err != nil {
-			return &App{}, fmt.Errorf("configure amqp: %s", err)
+			return &App{}, fmt.Errorf("configure amqp: %w", err)
 		}
 
 		amqpExchange = strings.TrimSpace(*config.amqpExchange)
 		if err := amqpClient.SetupExclusive(amqpExclusiveRoutingKey); err != nil {
-			return &App{}, fmt.Errorf("setup amqp exclusive: %s", err)
+			return &App{}, fmt.Errorf("setup amqp exclusive: %w", err)
 		}
 	}
 
@@ -86,7 +86,7 @@ func (a *App) Exclusive(ctx context.Context, name string, duration time.Duration
 		defer a.Unlock()
 
 		if err := a.refresh(ctx); err != nil {
-			return fmt.Errorf("refresh shares: %s", err)
+			return fmt.Errorf("refresh shares: %w", err)
 		}
 
 		return action(ctx)
@@ -159,7 +159,7 @@ func (a *App) refresh(ctx context.Context) error {
 		}
 
 		if err := a.storageApp.CreateDir(ctx, provider.MetadataDirectoryName); err != nil {
-			return fmt.Errorf("create dir: %s", err)
+			return fmt.Errorf("create dir: %w", err)
 		}
 
 		return provider.SaveJSON(ctx, a.storageApp, shareFilename, &a.shares)
diff --git a/pkg/thumbnail/event.go b/pkg/thumbnail/event.go
index 7c4d23b4..cdf3b6cf 100644
--- a/pkg/thumbnail/event.go
+++ b/pkg/thumbnail/event.go
@@ -39,12 +39,12 @@ func (a App) Rename(ctx context.Context, old, new absto.Item) error {
 
 	for _, size := range a.sizes {
 		if err := a.storageApp.Rename(ctx, a.PathForScale(old, size), a.PathForScale(new, size)); err != nil && !absto.IsNotExist(err) {
-			return fmt.Errorf("rename thumbnail: %s", err)
+			return fmt.Errorf("rename thumbnail: %w", err)
 		}
 
 		if provider.VideoExtensions[old.Extension] != "" && a.HasStream(ctx, old) {
 			if err := a.renameStream(ctx, old, new); err != nil {
-				return fmt.Errorf("rename stream: %s", err)
+				return fmt.Errorf("rename stream: %w", err)
 			}
 		}
 	}
diff --git a/pkg/thumbnail/generate.go b/pkg/thumbnail/generate.go
index a8874454..741e7dc0 100644
--- a/pkg/thumbnail/generate.go
+++ b/pkg/thumbnail/generate.go
@@ -27,7 +27,7 @@ func (a App) generate(ctx context.Context, item absto.Item, scale uint64) (err e
 	resp, err = a.requestVith(ctx, item, scale)
 	if err != nil {
 		a.increaseMetric(itemType.String(), "error")
-		return fmt.Errorf("request thumbnailer: %s", err)
+		return fmt.Errorf("request thumbnailer: %w", err)
 	}
 
 	if resp == nil {
@@ -36,7 +36,7 @@ func (a App) generate(ctx context.Context, item absto.Item, scale uint64) (err e
 
 	defer func() {
 		if closeErr := request.DiscardBody(resp.Body); closeErr != nil {
-			err = httpModel.WrapError(err, fmt.Errorf("close: %s", closeErr))
+			err = httpModel.WrapError(err, fmt.Errorf("close: %w", closeErr))
 		}
 	}()
 
diff --git a/pkg/thumbnail/stream.go b/pkg/thumbnail/stream.go
index 7fb58618..8a463122 100644
--- a/pkg/thumbnail/stream.go
+++ b/pkg/thumbnail/stream.go
@@ -23,11 +23,11 @@ func (a App) HasStream(ctx context.Context, item absto.Item) bool {
 func (a App) handleVithResponse(err error, body io.ReadCloser) error {
 	if err != nil {
 		a.increaseMetric("stream", "error")
-		return fmt.Errorf("send request: %s", err)
+		return fmt.Errorf("send request: %w", err)
 	}
 
 	if err := request.DiscardBody(body); err != nil {
-		return fmt.Errorf("discard body: %s", err)
+		return fmt.Errorf("discard body: %w", err)
 	}
 
 	return nil
@@ -43,7 +43,7 @@ func (a App) shouldGenerateStream(ctx context.Context, item absto.Item) (bool, e
 	resp, err := a.vithRequest.Method(http.MethodHead).Path(fmt.Sprintf("%s?type=%s", item.Pathname, typeOfItem(item))).Send(ctx, nil)
 	if err != nil {
 		a.increaseMetric("stream", "error")
-		return false, fmt.Errorf("retrieve metadata: %s", err)
+		return false, fmt.Errorf("retrieve metadata: %w", err)
 	}
 
 	rawBitrate := resp.Header.Get("X-Vith-Bitrate")
@@ -54,11 +54,11 @@ func (a App) shouldGenerateStream(ctx context.Context, item absto.Item) (bool, e
 	bitrate, err := strconv.ParseUint(rawBitrate, 10, 64)
 	if err != nil {
 		a.increaseMetric("stream", "error")
-		return false, fmt.Errorf("parse bitrate: %s", err)
+		return false, fmt.Errorf("parse bitrate: %w", err)
 	}
 
 	if err := request.DiscardBody(resp.Body); err != nil {
-		return false, fmt.Errorf("discard body: %s", err)
+		return false, fmt.Errorf("discard body: %w", err)
 	}
 
 	logger.WithField("item", item.Pathname).Debug("Bitrate is %d", bitrate)
diff --git a/pkg/thumbnail/thumbnail.go b/pkg/thumbnail/thumbnail.go
index 014ac10b..888e3980 100644
--- a/pkg/thumbnail/thumbnail.go
+++ b/pkg/thumbnail/thumbnail.go
@@ -92,7 +92,7 @@ func New(config Config, storage absto.Storage, prometheusRegisterer prometheus.R
 		amqpExchange = strings.TrimSpace(*config.amqpExchange)
 
 		if err := amqpClient.Publisher(amqpExchange, "direct", nil); err != nil {
-			return App{}, fmt.Errorf("configure amqp: %s", err)
+			return App{}, fmt.Errorf("configure amqp: %w", err)
 		}
 	}
 
diff --git a/pkg/webhook/amqp.go b/pkg/webhook/amqp.go
index bc5ae065..7a1cb55d 100644
--- a/pkg/webhook/amqp.go
+++ b/pkg/webhook/amqp.go
@@ -13,7 +13,7 @@ func (a *App) AMQPHandler(message amqp.Delivery) error {
 	var webhook provider.Webhook
 
 	if err := json.Unmarshal(message.Body, &webhook); err != nil {
-		return fmt.Errorf("decode: %s", err)
+		return fmt.Errorf("decode: %w", err)
 	}
 
 	a.Lock()
diff --git a/pkg/webhook/crud.go b/pkg/webhook/crud.go
index f155458f..43451b25 100644
--- a/pkg/webhook/crud.go
+++ b/pkg/webhook/crud.go
@@ -49,7 +49,7 @@ func (a *App) Create(ctx context.Context, pathname string, recursive bool, kind
 	return id, a.Exclusive(ctx, a.amqpExclusiveRoutingKey, semaphoreDuration, func(ctx context.Context) (err error) {
 		id, err = a.generateID()
 		if err != nil {
-			return fmt.Errorf("generate id: %s", err)
+			return fmt.Errorf("generate id: %w", err)
 		}
 
 		webhook := provider.Webhook{
@@ -64,12 +64,12 @@ func (a *App) Create(ctx context.Context, pathname string, recursive bool, kind
 		a.webhooks[id] = webhook
 
 		if err = provider.SaveJSON(ctx, a.storageApp, webhookFilename, a.webhooks); err != nil {
-			return fmt.Errorf("save webhooks: %s", err)
+			return fmt.Errorf("save webhooks: %w", err)
 		}
 
 		if a.amqpClient != nil {
 			if err = a.amqpClient.PublishJSON(webhook, a.amqpExchange, a.amqpRoutingKey); err != nil {
-				return fmt.Errorf("publish webhook creation: %s", err)
+				return fmt.Errorf("publish webhook creation: %w", err)
 			}
 		}
 
@@ -88,12 +88,12 @@ func (a *App) delete(ctx context.Context, id string) error {
 	delete(a.webhooks, id)
 
 	if err := provider.SaveJSON(ctx, a.storageApp, webhookFilename, a.webhooks); err != nil {
-		return fmt.Errorf("save webhooks: %s", err)
+		return fmt.Errorf("save webhooks: %w", err)
 	}
 
 	if a.amqpClient != nil {
 		if err := a.amqpClient.PublishJSON(provider.Webhook{ID: id}, a.amqpExchange, a.amqpRoutingKey); err != nil {
-			return fmt.Errorf("publish webhook deletion: %s", err)
+			return fmt.Errorf("publish webhook deletion: %w", err)
 		}
 	}
 
diff --git a/pkg/webhook/event.go b/pkg/webhook/event.go
index 93037703..3322f771 100644
--- a/pkg/webhook/event.go
+++ b/pkg/webhook/event.go
@@ -64,11 +64,11 @@ func (a *App) EventConsumer(ctx context.Context, event provider.Event) {
 func send(ctx context.Context, id string, req request.Request, payload any) (int, error) {
 	resp, err := req.JSON(ctx, payload)
 	if err != nil {
-		return 0, fmt.Errorf("send webhook with id `%s`: %s", id, err)
+		return 0, fmt.Errorf("send webhook with id `%s`: %w", id, err)
 	}
 
 	if err = request.DiscardBody(resp.Body); err != nil {
-		return resp.StatusCode, fmt.Errorf("discard body for webhook with id `%s`: %s", id, err)
+		return resp.StatusCode, fmt.Errorf("discard body for webhook with id `%s`: %w", id, err)
 	}
 
 	return resp.StatusCode, nil
@@ -215,7 +215,7 @@ func (a *App) deleteItem(ctx context.Context, item absto.Item) error {
 		for id, webhook := range a.webhooks {
 			if webhook.Pathname == item.Pathname {
 				if err := a.delete(ctx, id); err != nil {
-					return fmt.Errorf("delete webhook `%s`: %s", id, err)
+					return fmt.Errorf("delete webhook `%s`: %w", id, err)
 				}
 			}
 		}
diff --git a/pkg/webhook/webhook.go b/pkg/webhook/webhook.go
index 1964f20f..ec4bcfcb 100644
--- a/pkg/webhook/webhook.go
+++ b/pkg/webhook/webhook.go
@@ -69,12 +69,12 @@ func New(config Config, storageApp absto.Storage, prometheusRegisterer prometheu
 		amqpExclusiveRoutingKey = strings.TrimSpace(*config.amqpExclusiveRoutingKey)
 
 		if err := amqpClient.Publisher(amqpExchange, "fanout", nil); err != nil {
-			return &App{}, fmt.Errorf("configure amqp: %s", err)
+			return &App{}, fmt.Errorf("configure amqp: %w", err)
 		}
 
 		amqpExchange = strings.TrimSpace(*config.amqpExchange)
 		if err := amqpClient.SetupExclusive(amqpExclusiveRoutingKey); err != nil {
-			return &App{}, fmt.Errorf("setup amqp exclusive: %s", err)
+			return &App{}, fmt.Errorf("setup amqp exclusive: %w", err)
 		}
 	}
 
@@ -100,7 +100,7 @@ func (a *App) Exclusive(ctx context.Context, name string, duration time.Duration
 		defer a.Unlock()
 
 		if err := a.loadWebhooks(ctx); err != nil {
-			return fmt.Errorf("refresh webhooks: %s", err)
+			return fmt.Errorf("refresh webhooks: %w", err)
 		}
 
 		return action(ctx)
@@ -143,7 +143,7 @@ func (a *App) loadWebhooks(ctx context.Context) error {
 		}
 
 		if err := a.storageApp.CreateDir(ctx, provider.MetadataDirectoryName); err != nil {
-			return fmt.Errorf("create dir: %s", err)
+			return fmt.Errorf("create dir: %w", err)
 		}
 
 		return provider.SaveJSON(ctx, a.storageApp, webhookFilename, &a.webhooks)