From c6f6205e4f8f0d014396f89d47b96963f1562997 Mon Sep 17 00:00:00 2001
From: SmallCoccinelle <89733524+SmallCoccinelle@users.noreply.github.com>
Date: Tue, 12 Oct 2021 05:03:08 +0200
Subject: [PATCH] Errorlint sweep + minor linter tweaks (#1796)

* Replace error assertions with Go 1.13 style

Use `errors.As(..)` over type assertions. This enables better use of
wrapped errors in the future, and lets us pass some errorlint checks
in the process.

The rewrite is entirely mechanical, and uses a standard idiom for
doing so.

* Use Go 1.13's errors.Is(..)

Rather than directly checking for error equality, use errors.Is(..).

This protects against error wrapping issues in the future.

Even though something like sql.ErrNoRows doesn't need the wrapping, do
so anyway, for the sake of consistency throughout the code base.

The change almost lets us pass the `errorlint` Go checker except for
a missing case in `js.go` which is to be handled separately; it isn't
mechanical, like these changes are.

* Remove goconst

goconst isn't a useful linter in many cases, because it's false positive
rate is high. It's 100% for the current code base.

* Avoid direct comparison of errors in recover()

Assert that we are catching an error from recover(). If we are,
check that the error caught matches errStop.

* Enable the "errorlint" checker

Configure the checker to avoid checking for errorf wraps. These are
often false positives since the suggestion is to blanket wrap errors
with %w, and that exposes the underlying API which you might not want
to do.

The other warnings are good however, and with the current patch stack,
the code base passes all these checks as well.

* Configure rowserrcheck

The project uses sqlx. Configure rowserrcheck to include said package.

* Mechanically rewrite a large set of errors

Mechanically search for errors that look like

    fmt.Errorf("...%s", err.Error())

and rewrite those into

    fmt.Errorf("...%v", err)

The `fmt` package is error-aware and knows how to call err.Error()
itself.

The rationale is that this is more idiomatic Go; it paves the
way for using error wrapping later with %w in some sites.

This patch only addresses the entirely mechanical rewriting caught by
a project-side search/replace. There are more individual sites not
addressed by this patch.
---
 .golangci.yml                         | 17 ++++++++++++++---
 pkg/api/authentication.go             | 17 ++++++++++-------
 pkg/api/server.go                     |  4 ++--
 pkg/api/session.go                    |  3 ++-
 pkg/database/custom_migrations.go     |  5 +++--
 pkg/database/database.go              |  6 +++---
 pkg/gallery/import.go                 | 14 +++++++-------
 pkg/image/export.go                   |  2 +-
 pkg/image/import.go                   | 18 +++++++++---------
 pkg/manager/config/init.go            |  4 +++-
 pkg/manager/import.go                 |  6 +++---
 pkg/manager/manager.go                | 10 +++++-----
 pkg/manager/manager_tasks.go          |  2 +-
 pkg/manager/scene.go                  |  2 +-
 pkg/manager/studio.go                 |  2 +-
 pkg/manager/task_autotag.go           | 12 ++++++------
 pkg/manager/task_import.go            |  9 ++++++---
 pkg/manager/task_scan.go              |  4 ++--
 pkg/movie/export.go                   |  6 +++---
 pkg/movie/import.go                   | 12 ++++++------
 pkg/performer/export.go               |  2 +-
 pkg/performer/import.go               | 12 ++++++------
 pkg/plugin/examples/common/graphql.go |  4 ++--
 pkg/plugin/js.go                      |  2 +-
 pkg/plugin/raw.go                     |  4 ++--
 pkg/scene/export.go                   | 16 ++++++++--------
 pkg/scene/import.go                   | 26 +++++++++++++-------------
 pkg/scene/marker_import.go            |  6 +++---
 pkg/scraper/mapped.go                 |  3 ++-
 pkg/sqlite/gallery.go                 |  3 ++-
 pkg/sqlite/image.go                   |  3 ++-
 pkg/sqlite/movies.go                  |  3 ++-
 pkg/sqlite/performer.go               |  3 ++-
 pkg/sqlite/repository.go              | 13 +++++++------
 pkg/sqlite/saved_filter.go            |  3 ++-
 pkg/sqlite/scene.go                   |  3 ++-
 pkg/sqlite/scene_marker.go            |  3 ++-
 pkg/sqlite/scraped_item.go            |  3 ++-
 pkg/sqlite/sql.go                     |  3 ++-
 pkg/sqlite/studio.go                  |  3 ++-
 pkg/sqlite/tag.go                     |  2 +-
 pkg/sqlite/transaction.go             |  6 +++---
 pkg/studio/export.go                  |  6 +++---
 pkg/studio/import.go                  | 12 ++++++------
 pkg/tag/export.go                     |  6 +++---
 pkg/tag/import.go                     | 14 +++++++-------
 46 files changed, 176 insertions(+), 143 deletions(-)

diff --git a/.golangci.yml b/.golangci.yml
index ca296c1dd..85f9247a3 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -20,13 +20,13 @@ linters:
     # Linters added by the stash project
     # - bodyclose
     - dogsled
-    # - errorlint
+    - errorlint
     # - exhaustive
     - exportloopref
-    # - goconst
     # - gocritic
     # - goerr113
     - gofmt
+    # - gomnd
     # - gosec
     # - ifshort
     - misspell
@@ -41,6 +41,13 @@ linters-settings:
   gofmt:
     simplify: false
 
+  errorlint:
+    # Disable errorf because there are false positives, where you don't want to wrap
+    #  an error.
+    errorf: false
+    asserts: true
+    comparison: true
+
   revive:
     ignore-generated-header: true
     severity: error
@@ -79,4 +86,8 @@ linters-settings:
       - name: unused-parameter
         disabled: true
       - name: unreachable-code
-      - name: redefines-builtin-id
\ No newline at end of file
+      - name: redefines-builtin-id
+
+  rowserrcheck:
+    packages:
+      - github.com/jmoiron/sqlx
diff --git a/pkg/api/authentication.go b/pkg/api/authentication.go
index ae6fb2952..17246badd 100644
--- a/pkg/api/authentication.go
+++ b/pkg/api/authentication.go
@@ -1,6 +1,7 @@
 package api
 
 import (
+	"errors"
 	"net"
 	"net/http"
 	"net/url"
@@ -39,7 +40,7 @@ func authenticateHandler() func(http.Handler) http.Handler {
 
 			userID, err := manager.GetInstance().SessionStore.Authenticate(w, r)
 			if err != nil {
-				if err != session.ErrUnauthorized {
+				if errors.Is(err, session.ErrUnauthorized) {
 					w.WriteHeader(http.StatusInternalServerError)
 					_, err = w.Write([]byte(err.Error()))
 					if err != nil {
@@ -55,16 +56,18 @@ func authenticateHandler() func(http.Handler) http.Handler {
 			}
 
 			if err := session.CheckAllowPublicWithoutAuth(c, r); err != nil {
-				switch err := err.(type) {
-				case session.ExternalAccessError:
-					securityActivateTripwireAccessedFromInternetWithoutAuth(c, err, w)
+				var externalAccess session.ExternalAccessError
+				var untrustedProxy session.UntrustedProxyError
+				switch {
+				case errors.As(err, &externalAccess):
+					securityActivateTripwireAccessedFromInternetWithoutAuth(c, externalAccess, w)
 					return
-				case session.UntrustedProxyError:
-					logger.Warnf("Rejected request from untrusted proxy: %s", net.IP(err).String())
+				case errors.As(err, &untrustedProxy):
+					logger.Warnf("Rejected request from untrusted proxy: %v", net.IP(untrustedProxy))
 					w.WriteHeader(http.StatusForbidden)
 					return
 				default:
-					logger.Errorf("Error checking external access security: %s", err.Error())
+					logger.Errorf("Error checking external access security: %v", err)
 					w.WriteHeader(http.StatusInternalServerError)
 					return
 				}
diff --git a/pkg/api/server.go b/pkg/api/server.go
index 58310b4e2..ef181a389 100644
--- a/pkg/api/server.go
+++ b/pkg/api/server.go
@@ -229,7 +229,7 @@ func Start(uiBox embed.FS, loginUIBox embed.FS) {
 	tlsConfig, err := makeTLSConfig(c)
 	if err != nil {
 		// assume we don't want to start with a broken TLS configuration
-		panic(fmt.Errorf("error loading TLS config: %s", err.Error()))
+		panic(fmt.Errorf("error loading TLS config: %v", err))
 	}
 
 	server := &http.Server{
@@ -296,7 +296,7 @@ func makeTLSConfig(c *config.Instance) (*tls.Config, error) {
 	certs := make([]tls.Certificate, 1)
 	certs[0], err = tls.X509KeyPair(cert, key)
 	if err != nil {
-		return nil, fmt.Errorf("error parsing key pair: %s", err.Error())
+		return nil, fmt.Errorf("error parsing key pair: %v", err)
 	}
 	tlsConfig := &tls.Config{
 		Certificates: certs,
diff --git a/pkg/api/session.go b/pkg/api/session.go
index 71fa15136..c31845755 100644
--- a/pkg/api/session.go
+++ b/pkg/api/session.go
@@ -2,6 +2,7 @@ package api
 
 import (
 	"embed"
+	"errors"
 	"fmt"
 	"html/template"
 	"net/http"
@@ -60,7 +61,7 @@ func handleLogin(loginUIBox embed.FS) http.HandlerFunc {
 		}
 
 		err := manager.GetInstance().SessionStore.Login(w, r)
-		if err == session.ErrInvalidCredentials {
+		if errors.Is(err, session.ErrInvalidCredentials) {
 			// redirect back to the login page with an error
 			redirectToLogin(loginUIBox, w, url, "Username or password is invalid")
 			return
diff --git a/pkg/database/custom_migrations.go b/pkg/database/custom_migrations.go
index 9e343a515..340ffba55 100644
--- a/pkg/database/custom_migrations.go
+++ b/pkg/database/custom_migrations.go
@@ -2,6 +2,7 @@ package database
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"strings"
 
@@ -21,7 +22,7 @@ func createImagesChecksumIndex() error {
 	return WithTxn(func(tx *sqlx.Tx) error {
 		row := tx.QueryRow("SELECT 1 AS found FROM sqlite_master WHERE type = 'index' AND name = 'images_checksum_unique'")
 		err := row.Err()
-		if err != nil && err != sql.ErrNoRows {
+		if err != nil && !errors.Is(err, sql.ErrNoRows) {
 			return err
 		}
 
@@ -55,7 +56,7 @@ func createImagesChecksumIndex() error {
 		}
 
 		err = tx.Select(&result, "SELECT checksum FROM images GROUP BY checksum HAVING COUNT(1) > 1")
-		if err != nil && err != sql.ErrNoRows {
+		if err != nil && !errors.Is(err, sql.ErrNoRows) {
 			logger.Errorf("Unable to determine non-unique image checksums: %s", err)
 			return nil
 		}
diff --git a/pkg/database/database.go b/pkg/database/database.go
index f84207b65..190db6c9b 100644
--- a/pkg/database/database.go
+++ b/pkg/database/database.go
@@ -63,13 +63,13 @@ func Initialize(databasePath string) error {
 	dbPath = databasePath
 
 	if err := getDatabaseSchemaVersion(); err != nil {
-		return fmt.Errorf("error getting database schema version: %s", err.Error())
+		return fmt.Errorf("error getting database schema version: %v", err)
 	}
 
 	if databaseSchemaVersion == 0 {
 		// new database, just run the migrations
 		if err := RunMigrations(); err != nil {
-			return fmt.Errorf("error running initial schema migrations: %s", err.Error())
+			return fmt.Errorf("error running initial schema migrations: %v", err)
 		}
 		// RunMigrations calls Initialise. Just return
 		return nil
@@ -298,7 +298,7 @@ func registerCustomDriver() {
 				})
 
 				if err != nil {
-					return fmt.Errorf("error registering natural sort collation: %s", err.Error())
+					return fmt.Errorf("error registering natural sort collation: %v", err)
 				}
 
 				return nil
diff --git a/pkg/gallery/import.go b/pkg/gallery/import.go
index 7ad87cdbe..e568d5bbd 100644
--- a/pkg/gallery/import.go
+++ b/pkg/gallery/import.go
@@ -78,7 +78,7 @@ func (i *Importer) populateStudio() error {
 	if i.Input.Studio != "" {
 		studio, err := i.StudioWriter.FindByName(i.Input.Studio, false)
 		if err != nil {
-			return fmt.Errorf("error finding studio by name: %s", err.Error())
+			return fmt.Errorf("error finding studio by name: %v", err)
 		}
 
 		if studio == nil {
@@ -147,7 +147,7 @@ func (i *Importer) populatePerformers() error {
 			if i.MissingRefBehaviour == models.ImportMissingRefEnumCreate {
 				createdPerformers, err := i.createPerformers(missingPerformers)
 				if err != nil {
-					return fmt.Errorf("error creating gallery performers: %s", err.Error())
+					return fmt.Errorf("error creating gallery performers: %v", err)
 				}
 
 				performers = append(performers, createdPerformers...)
@@ -203,7 +203,7 @@ func (i *Importer) populateTags() error {
 			if i.MissingRefBehaviour == models.ImportMissingRefEnumCreate {
 				createdTags, err := i.createTags(missingTags)
 				if err != nil {
-					return fmt.Errorf("error creating gallery tags: %s", err.Error())
+					return fmt.Errorf("error creating gallery tags: %v", err)
 				}
 
 				tags = append(tags, createdTags...)
@@ -242,7 +242,7 @@ func (i *Importer) PostImport(id int) error {
 		}
 
 		if err := i.ReaderWriter.UpdatePerformers(id, performerIDs); err != nil {
-			return fmt.Errorf("failed to associate performers: %s", err.Error())
+			return fmt.Errorf("failed to associate performers: %v", err)
 		}
 	}
 
@@ -252,7 +252,7 @@ func (i *Importer) PostImport(id int) error {
 			tagIDs = append(tagIDs, t.ID)
 		}
 		if err := i.ReaderWriter.UpdateTags(id, tagIDs); err != nil {
-			return fmt.Errorf("failed to associate tags: %s", err.Error())
+			return fmt.Errorf("failed to associate tags: %v", err)
 		}
 	}
 
@@ -280,7 +280,7 @@ func (i *Importer) FindExistingID() (*int, error) {
 func (i *Importer) Create() (*int, error) {
 	created, err := i.ReaderWriter.Create(i.gallery)
 	if err != nil {
-		return nil, fmt.Errorf("error creating gallery: %s", err.Error())
+		return nil, fmt.Errorf("error creating gallery: %v", err)
 	}
 
 	id := created.ID
@@ -292,7 +292,7 @@ func (i *Importer) Update(id int) error {
 	gallery.ID = id
 	_, err := i.ReaderWriter.Update(gallery)
 	if err != nil {
-		return fmt.Errorf("error updating existing gallery: %s", err.Error())
+		return fmt.Errorf("error updating existing gallery: %v", err)
 	}
 
 	return nil
diff --git a/pkg/image/export.go b/pkg/image/export.go
index e02a505c4..b70bbe7f2 100644
--- a/pkg/image/export.go
+++ b/pkg/image/export.go
@@ -75,7 +75,7 @@ func GetStudioName(reader models.StudioReader, image *models.Image) (string, err
 // func GetGalleryChecksum(reader models.GalleryReader, image *models.Image) (string, error) {
 // 	gallery, err := reader.FindByImageID(image.ID)
 // 	if err != nil {
-// 		return "", fmt.Errorf("error getting image gallery: %s", err.Error())
+// 		return "", fmt.Errorf("error getting image gallery: %v", err)
 // 	}
 
 // 	if gallery != nil {
diff --git a/pkg/image/import.go b/pkg/image/import.go
index 7b0640595..b6ebe5b05 100644
--- a/pkg/image/import.go
+++ b/pkg/image/import.go
@@ -86,7 +86,7 @@ func (i *Importer) populateStudio() error {
 	if i.Input.Studio != "" {
 		studio, err := i.StudioWriter.FindByName(i.Input.Studio, false)
 		if err != nil {
-			return fmt.Errorf("error finding studio by name: %s", err.Error())
+			return fmt.Errorf("error finding studio by name: %v", err)
 		}
 
 		if studio == nil {
@@ -131,7 +131,7 @@ func (i *Importer) populateGalleries() error {
 	for _, checksum := range i.Input.Galleries {
 		gallery, err := i.GalleryWriter.FindByChecksum(checksum)
 		if err != nil {
-			return fmt.Errorf("error finding gallery: %s", err.Error())
+			return fmt.Errorf("error finding gallery: %v", err)
 		}
 
 		if gallery == nil {
@@ -179,7 +179,7 @@ func (i *Importer) populatePerformers() error {
 			if i.MissingRefBehaviour == models.ImportMissingRefEnumCreate {
 				createdPerformers, err := i.createPerformers(missingPerformers)
 				if err != nil {
-					return fmt.Errorf("error creating image performers: %s", err.Error())
+					return fmt.Errorf("error creating image performers: %v", err)
 				}
 
 				performers = append(performers, createdPerformers...)
@@ -232,7 +232,7 @@ func (i *Importer) PostImport(id int) error {
 		}
 
 		if err := i.ReaderWriter.UpdateGalleries(id, galleryIDs); err != nil {
-			return fmt.Errorf("failed to associate galleries: %s", err.Error())
+			return fmt.Errorf("failed to associate galleries: %v", err)
 		}
 	}
 
@@ -243,7 +243,7 @@ func (i *Importer) PostImport(id int) error {
 		}
 
 		if err := i.ReaderWriter.UpdatePerformers(id, performerIDs); err != nil {
-			return fmt.Errorf("failed to associate performers: %s", err.Error())
+			return fmt.Errorf("failed to associate performers: %v", err)
 		}
 	}
 
@@ -253,7 +253,7 @@ func (i *Importer) PostImport(id int) error {
 			tagIDs = append(tagIDs, t.ID)
 		}
 		if err := i.ReaderWriter.UpdateTags(id, tagIDs); err != nil {
-			return fmt.Errorf("failed to associate tags: %s", err.Error())
+			return fmt.Errorf("failed to associate tags: %v", err)
 		}
 	}
 
@@ -284,7 +284,7 @@ func (i *Importer) FindExistingID() (*int, error) {
 func (i *Importer) Create() (*int, error) {
 	created, err := i.ReaderWriter.Create(i.image)
 	if err != nil {
-		return nil, fmt.Errorf("error creating image: %s", err.Error())
+		return nil, fmt.Errorf("error creating image: %v", err)
 	}
 
 	id := created.ID
@@ -298,7 +298,7 @@ func (i *Importer) Update(id int) error {
 	i.ID = id
 	_, err := i.ReaderWriter.UpdateFull(image)
 	if err != nil {
-		return fmt.Errorf("error updating existing image: %s", err.Error())
+		return fmt.Errorf("error updating existing image: %v", err)
 	}
 
 	return nil
@@ -327,7 +327,7 @@ func importTags(tagWriter models.TagReaderWriter, names []string, missingRefBeha
 		if missingRefBehaviour == models.ImportMissingRefEnumCreate {
 			createdTags, err := createTags(tagWriter, missingTags)
 			if err != nil {
-				return nil, fmt.Errorf("error creating tags: %s", err.Error())
+				return nil, fmt.Errorf("error creating tags: %v", err)
 			}
 
 			tags = append(tags, createdTags...)
diff --git a/pkg/manager/config/init.go b/pkg/manager/config/init.go
index 7117a18af..27e57baf1 100644
--- a/pkg/manager/config/init.go
+++ b/pkg/manager/config/init.go
@@ -1,6 +1,7 @@
 package config
 
 import (
+	"errors"
 	"fmt"
 	"net"
 	"os"
@@ -85,7 +86,8 @@ func initConfig(flags flagStruct) error {
 
 	err := viper.ReadInConfig() // Find and read the config file
 	// if not found, assume its a new system
-	if _, isMissing := err.(viper.ConfigFileNotFoundError); isMissing {
+	var notFoundErr viper.ConfigFileNotFoundError
+	if errors.As(err, &notFoundErr) {
 		instance.isNewSystem = true
 		return nil
 	} else if err != nil {
diff --git a/pkg/manager/import.go b/pkg/manager/import.go
index d5f61bcf2..c2f2820c7 100644
--- a/pkg/manager/import.go
+++ b/pkg/manager/import.go
@@ -25,7 +25,7 @@ func performImport(i importer, duplicateBehaviour models.ImportDuplicateEnum) er
 	name := i.Name()
 	existing, err := i.FindExistingID()
 	if err != nil {
-		return fmt.Errorf("error finding existing objects: %s", err.Error())
+		return fmt.Errorf("error finding existing objects: %v", err)
 	}
 
 	var id int
@@ -41,13 +41,13 @@ func performImport(i importer, duplicateBehaviour models.ImportDuplicateEnum) er
 		// must be overwriting
 		id = *existing
 		if err := i.Update(id); err != nil {
-			return fmt.Errorf("error updating existing object: %s", err.Error())
+			return fmt.Errorf("error updating existing object: %v", err)
 		}
 	} else {
 		// creating
 		createdID, err := i.Create()
 		if err != nil {
-			return fmt.Errorf("error creating object: %s", err.Error())
+			return fmt.Errorf("error creating object: %v", err)
 		}
 
 		id = *createdID
diff --git a/pkg/manager/manager.go b/pkg/manager/manager.go
index 03f0fe260..3ee27d445 100644
--- a/pkg/manager/manager.go
+++ b/pkg/manager/manager.go
@@ -302,19 +302,19 @@ func (s *singleton) Setup(input models.SetupInput) error {
 	configDir := filepath.Dir(input.ConfigLocation)
 	if exists, _ := utils.DirExists(configDir); !exists {
 		if err := os.Mkdir(configDir, 0755); err != nil {
-			return fmt.Errorf("abc: %s", err.Error())
+			return fmt.Errorf("abc: %v", err)
 		}
 	}
 
 	// create the generated directory if it does not exist
 	if exists, _ := utils.DirExists(input.GeneratedLocation); !exists {
 		if err := os.Mkdir(input.GeneratedLocation, 0755); err != nil {
-			return fmt.Errorf("error creating generated directory: %s", err.Error())
+			return fmt.Errorf("error creating generated directory: %v", err)
 		}
 	}
 
 	if err := utils.Touch(input.ConfigLocation); err != nil {
-		return fmt.Errorf("error creating config file: %s", err.Error())
+		return fmt.Errorf("error creating config file: %v", err)
 	}
 
 	s.Config.SetConfigFile(input.ConfigLocation)
@@ -324,12 +324,12 @@ func (s *singleton) Setup(input models.SetupInput) error {
 	s.Config.Set(config.Database, input.DatabaseFile)
 	s.Config.Set(config.Stash, input.Stashes)
 	if err := s.Config.Write(); err != nil {
-		return fmt.Errorf("error writing configuration file: %s", err.Error())
+		return fmt.Errorf("error writing configuration file: %v", err)
 	}
 
 	// initialise the database
 	if err := s.PostInit(); err != nil {
-		return fmt.Errorf("error initializing the database: %s", err.Error())
+		return fmt.Errorf("error initializing the database: %v", err)
 	}
 
 	s.Config.FinalizeSetup()
diff --git a/pkg/manager/manager_tasks.go b/pkg/manager/manager_tasks.go
index ae64e016b..4bc69dde6 100644
--- a/pkg/manager/manager_tasks.go
+++ b/pkg/manager/manager_tasks.go
@@ -663,7 +663,7 @@ func (s *singleton) StashBoxBatchPerformerTag(ctx context.Context, input models.
 					performers, err = performerQuery.FindByStashIDStatus(false, box.Endpoint)
 				}
 				if err != nil {
-					return fmt.Errorf("error querying performers: %s", err.Error())
+					return fmt.Errorf("error querying performers: %v", err)
 				}
 
 				for _, performer := range performers {
diff --git a/pkg/manager/scene.go b/pkg/manager/scene.go
index 58ce2e65d..2a2ce4ab9 100644
--- a/pkg/manager/scene.go
+++ b/pkg/manager/scene.go
@@ -194,7 +194,7 @@ func GetSceneFileContainer(scene *models.Scene) (ffmpeg.Container, error) {
 		// shouldn't happen, fallback to ffprobe
 		tmpVideoFile, err := ffmpeg.NewVideoFile(GetInstance().FFProbePath, scene.Path, false)
 		if err != nil {
-			return ffmpeg.Container(""), fmt.Errorf("error reading video file: %s", err.Error())
+			return ffmpeg.Container(""), fmt.Errorf("error reading video file: %v", err)
 		}
 
 		container = ffmpeg.MatchContainer(tmpVideoFile.Container, scene.Path)
diff --git a/pkg/manager/studio.go b/pkg/manager/studio.go
index 9602f50b6..3b0d81ceb 100644
--- a/pkg/manager/studio.go
+++ b/pkg/manager/studio.go
@@ -24,7 +24,7 @@ func ValidateModifyStudio(studio models.StudioPartial, qb models.StudioReader) e
 
 		currentStudio, err := qb.Find(int(currentParentID.Int64))
 		if err != nil {
-			return fmt.Errorf("error finding parent studio: %s", err.Error())
+			return fmt.Errorf("error finding parent studio: %v", err)
 		}
 
 		currentParentID = currentStudio.ParentID
diff --git a/pkg/manager/task_autotag.go b/pkg/manager/task_autotag.go
index 3f6298ef8..195f9f54a 100644
--- a/pkg/manager/task_autotag.go
+++ b/pkg/manager/task_autotag.go
@@ -73,19 +73,19 @@ func (j *autoTagJob) autoTagSpecific(ctx context.Context, progress *job.Progress
 		if performerCount == 1 && performerIds[0] == wildcard {
 			performerCount, err = performerQuery.Count()
 			if err != nil {
-				return fmt.Errorf("error getting performer count: %s", err.Error())
+				return fmt.Errorf("error getting performer count: %v", err)
 			}
 		}
 		if studioCount == 1 && studioIds[0] == wildcard {
 			studioCount, err = studioQuery.Count()
 			if err != nil {
-				return fmt.Errorf("error getting studio count: %s", err.Error())
+				return fmt.Errorf("error getting studio count: %v", err)
 			}
 		}
 		if tagCount == 1 && tagIds[0] == wildcard {
 			tagCount, err = tagQuery.Count()
 			if err != nil {
-				return fmt.Errorf("error getting tag count: %s", err.Error())
+				return fmt.Errorf("error getting tag count: %v", err)
 			}
 		}
 
@@ -122,7 +122,7 @@ func (j *autoTagJob) autoTagPerformers(ctx context.Context, progress *job.Progre
 				var err error
 				performers, err = performerQuery.All()
 				if err != nil {
-					return fmt.Errorf("error querying performers: %s", err.Error())
+					return fmt.Errorf("error querying performers: %v", err)
 				}
 			} else {
 				performerIdInt, err := strconv.Atoi(performerId)
@@ -188,7 +188,7 @@ func (j *autoTagJob) autoTagStudios(ctx context.Context, progress *job.Progress,
 				var err error
 				studios, err = studioQuery.All()
 				if err != nil {
-					return fmt.Errorf("error querying studios: %s", err.Error())
+					return fmt.Errorf("error querying studios: %v", err)
 				}
 			} else {
 				studioIdInt, err := strconv.Atoi(studioId)
@@ -259,7 +259,7 @@ func (j *autoTagJob) autoTagTags(ctx context.Context, progress *job.Progress, pa
 				var err error
 				tags, err = tagQuery.All()
 				if err != nil {
-					return fmt.Errorf("error querying tags: %s", err.Error())
+					return fmt.Errorf("error querying tags: %v", err)
 				}
 			} else {
 				tagIdInt, err := strconv.Atoi(tagId)
diff --git a/pkg/manager/task_import.go b/pkg/manager/task_import.go
index 4d9b535ae..4437043f4 100644
--- a/pkg/manager/task_import.go
+++ b/pkg/manager/task_import.go
@@ -4,6 +4,7 @@ import (
 	"archive/zip"
 	"context"
 	"database/sql"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -239,7 +240,7 @@ func (t *ImportTask) ImportStudios(ctx context.Context) {
 		if err := t.txnManager.WithTxn(ctx, func(r models.Repository) error {
 			return t.ImportStudio(studioJSON, pendingParent, r.Studio())
 		}); err != nil {
-			if err == studio.ErrParentStudioNotExist {
+			if errors.Is(err, studio.ErrParentStudioNotExist) {
 				// add to the pending parent list so that it is created after the parent
 				s := pendingParent[studioJSON.ParentStudio]
 				s = append(s, studioJSON)
@@ -391,7 +392,8 @@ func (t *ImportTask) ImportTags(ctx context.Context) {
 		if err := t.txnManager.WithTxn(ctx, func(r models.Repository) error {
 			return t.ImportTag(tagJSON, pendingParent, false, r.Tag())
 		}); err != nil {
-			if parentError, ok := err.(tag.ParentTagNotExistError); ok {
+			var parentError tag.ParentTagNotExistError
+			if errors.As(err, &parentError) {
 				pendingParent[parentError.MissingParent()] = append(pendingParent[parentError.MissingParent()], tagJSON)
 				continue
 			}
@@ -433,7 +435,8 @@ func (t *ImportTask) ImportTag(tagJSON *jsonschema.Tag, pendingParent map[string
 
 	for _, childTagJSON := range pendingParent[tagJSON.Name] {
 		if err := t.ImportTag(childTagJSON, pendingParent, fail, readerWriter); err != nil {
-			if parentError, ok := err.(tag.ParentTagNotExistError); ok {
+			var parentError tag.ParentTagNotExistError
+			if errors.As(err, &parentError) {
 				pendingParent[parentError.MissingParent()] = append(pendingParent[parentError.MissingParent()], tagJSON)
 				continue
 			}
diff --git a/pkg/manager/task_scan.go b/pkg/manager/task_scan.go
index bec812a7b..76bf5a646 100644
--- a/pkg/manager/task_scan.go
+++ b/pkg/manager/task_scan.go
@@ -128,7 +128,7 @@ func (j *ScanJob) Execute(ctx context.Context, progress *job.Progress) {
 			return nil
 		})
 
-		if err == stoppingErr {
+		if errors.Is(err, stoppingErr) {
 			logger.Info("Stopping due to user request")
 			break
 		}
@@ -206,7 +206,7 @@ func (j *ScanJob) neededScan(ctx context.Context, paths []*models.StashConfig) (
 			return nil
 		})
 
-		if err == timeoutErr {
+		if errors.Is(err, timeoutErr) {
 			// timeout should return nil counts
 			return nil, nil
 		}
diff --git a/pkg/movie/export.go b/pkg/movie/export.go
index 9ffd31a2f..74d3c892c 100644
--- a/pkg/movie/export.go
+++ b/pkg/movie/export.go
@@ -46,7 +46,7 @@ func ToJSON(reader models.MovieReader, studioReader models.StudioReader, movie *
 	if movie.StudioID.Valid {
 		studio, err := studioReader.Find(int(movie.StudioID.Int64))
 		if err != nil {
-			return nil, fmt.Errorf("error getting movie studio: %s", err.Error())
+			return nil, fmt.Errorf("error getting movie studio: %v", err)
 		}
 
 		if studio != nil {
@@ -56,7 +56,7 @@ func ToJSON(reader models.MovieReader, studioReader models.StudioReader, movie *
 
 	frontImage, err := reader.GetFrontImage(movie.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting movie front image: %s", err.Error())
+		return nil, fmt.Errorf("error getting movie front image: %v", err)
 	}
 
 	if len(frontImage) > 0 {
@@ -65,7 +65,7 @@ func ToJSON(reader models.MovieReader, studioReader models.StudioReader, movie *
 
 	backImage, err := reader.GetBackImage(movie.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting movie back image: %s", err.Error())
+		return nil, fmt.Errorf("error getting movie back image: %v", err)
 	}
 
 	if len(backImage) > 0 {
diff --git a/pkg/movie/import.go b/pkg/movie/import.go
index 7108944fb..97a5c7e33 100644
--- a/pkg/movie/import.go
+++ b/pkg/movie/import.go
@@ -31,13 +31,13 @@ func (i *Importer) PreImport() error {
 	if len(i.Input.FrontImage) > 0 {
 		_, i.frontImageData, err = utils.ProcessBase64Image(i.Input.FrontImage)
 		if err != nil {
-			return fmt.Errorf("invalid front_image: %s", err.Error())
+			return fmt.Errorf("invalid front_image: %v", err)
 		}
 	}
 	if len(i.Input.BackImage) > 0 {
 		_, i.backImageData, err = utils.ProcessBase64Image(i.Input.BackImage)
 		if err != nil {
-			return fmt.Errorf("invalid back_image: %s", err.Error())
+			return fmt.Errorf("invalid back_image: %v", err)
 		}
 	}
 
@@ -74,7 +74,7 @@ func (i *Importer) populateStudio() error {
 	if i.Input.Studio != "" {
 		studio, err := i.StudioWriter.FindByName(i.Input.Studio, false)
 		if err != nil {
-			return fmt.Errorf("error finding studio by name: %s", err.Error())
+			return fmt.Errorf("error finding studio by name: %v", err)
 		}
 
 		if studio == nil {
@@ -118,7 +118,7 @@ func (i *Importer) createStudio(name string) (int, error) {
 func (i *Importer) PostImport(id int) error {
 	if len(i.frontImageData) > 0 {
 		if err := i.ReaderWriter.UpdateImages(id, i.frontImageData, i.backImageData); err != nil {
-			return fmt.Errorf("error setting movie images: %s", err.Error())
+			return fmt.Errorf("error setting movie images: %v", err)
 		}
 	}
 
@@ -147,7 +147,7 @@ func (i *Importer) FindExistingID() (*int, error) {
 func (i *Importer) Create() (*int, error) {
 	created, err := i.ReaderWriter.Create(i.movie)
 	if err != nil {
-		return nil, fmt.Errorf("error creating movie: %s", err.Error())
+		return nil, fmt.Errorf("error creating movie: %v", err)
 	}
 
 	id := created.ID
@@ -159,7 +159,7 @@ func (i *Importer) Update(id int) error {
 	movie.ID = id
 	_, err := i.ReaderWriter.UpdateFull(movie)
 	if err != nil {
-		return fmt.Errorf("error updating existing movie: %s", err.Error())
+		return fmt.Errorf("error updating existing movie: %v", err)
 	}
 
 	return nil
diff --git a/pkg/performer/export.go b/pkg/performer/export.go
index 555abe58d..85dee179c 100644
--- a/pkg/performer/export.go
+++ b/pkg/performer/export.go
@@ -84,7 +84,7 @@ func ToJSON(reader models.PerformerReader, performer *models.Performer) (*jsonsc
 
 	image, err := reader.GetImage(performer.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting performers image: %s", err.Error())
+		return nil, fmt.Errorf("error getting performers image: %v", err)
 	}
 
 	if len(image) > 0 {
diff --git a/pkg/performer/import.go b/pkg/performer/import.go
index db32e1286..37b1868ca 100644
--- a/pkg/performer/import.go
+++ b/pkg/performer/import.go
@@ -34,7 +34,7 @@ func (i *Importer) PreImport() error {
 	if len(i.Input.Image) > 0 {
 		_, i.imageData, err = utils.ProcessBase64Image(i.Input.Image)
 		if err != nil {
-			return fmt.Errorf("invalid image: %s", err.Error())
+			return fmt.Errorf("invalid image: %v", err)
 		}
 	}
 
@@ -78,7 +78,7 @@ func importTags(tagWriter models.TagReaderWriter, names []string, missingRefBeha
 		if missingRefBehaviour == models.ImportMissingRefEnumCreate {
 			createdTags, err := createTags(tagWriter, missingTags)
 			if err != nil {
-				return nil, fmt.Errorf("error creating tags: %s", err.Error())
+				return nil, fmt.Errorf("error creating tags: %v", err)
 			}
 
 			tags = append(tags, createdTags...)
@@ -113,13 +113,13 @@ func (i *Importer) PostImport(id int) error {
 			tagIDs = append(tagIDs, t.ID)
 		}
 		if err := i.ReaderWriter.UpdateTags(id, tagIDs); err != nil {
-			return fmt.Errorf("failed to associate tags: %s", err.Error())
+			return fmt.Errorf("failed to associate tags: %v", err)
 		}
 	}
 
 	if len(i.imageData) > 0 {
 		if err := i.ReaderWriter.UpdateImage(id, i.imageData); err != nil {
-			return fmt.Errorf("error setting performer image: %s", err.Error())
+			return fmt.Errorf("error setting performer image: %v", err)
 		}
 	}
 
@@ -148,7 +148,7 @@ func (i *Importer) FindExistingID() (*int, error) {
 func (i *Importer) Create() (*int, error) {
 	created, err := i.ReaderWriter.Create(i.performer)
 	if err != nil {
-		return nil, fmt.Errorf("error creating performer: %s", err.Error())
+		return nil, fmt.Errorf("error creating performer: %v", err)
 	}
 
 	id := created.ID
@@ -160,7 +160,7 @@ func (i *Importer) Update(id int) error {
 	performer.ID = id
 	_, err := i.ReaderWriter.UpdateFull(performer)
 	if err != nil {
-		return fmt.Errorf("error updating existing performer: %s", err.Error())
+		return fmt.Errorf("error updating existing performer: %v", err)
 	}
 
 	return nil
diff --git a/pkg/plugin/examples/common/graphql.go b/pkg/plugin/examples/common/graphql.go
index 624c0d5d8..212792717 100644
--- a/pkg/plugin/examples/common/graphql.go
+++ b/pkg/plugin/examples/common/graphql.go
@@ -190,7 +190,7 @@ func AddTag(client *graphql.Client) error {
 	log.Infof("Adding tag to scene %v", scene.ID)
 	err = client.Mutate(context.Background(), &m, vars)
 	if err != nil {
-		return fmt.Errorf("Error mutating scene: %s", err.Error())
+		return fmt.Errorf("Error mutating scene: %v", err)
 	}
 
 	return nil
@@ -225,7 +225,7 @@ func RemoveTag(client *graphql.Client) error {
 
 	err = client.Mutate(context.Background(), &m, vars)
 	if err != nil {
-		return fmt.Errorf("Error destroying tag: %s", err.Error())
+		return fmt.Errorf("Error destroying tag: %v", err)
 	}
 
 	return nil
diff --git a/pkg/plugin/js.go b/pkg/plugin/js.go
index 1c8f18a32..4c918c686 100644
--- a/pkg/plugin/js.go
+++ b/pkg/plugin/js.go
@@ -97,7 +97,7 @@ func (t *jsPluginTask) Start() error {
 			t.waitGroup.Done()
 
 			if caught := recover(); caught != nil {
-				if caught == errStop {
+				if err, ok := caught.(error); ok && errors.Is(err, errStop) {
 					// TODO - log this
 					return
 				}
diff --git a/pkg/plugin/raw.go b/pkg/plugin/raw.go
index 03d084ccd..780772d80 100644
--- a/pkg/plugin/raw.go
+++ b/pkg/plugin/raw.go
@@ -43,7 +43,7 @@ func (t *rawPluginTask) Start() error {
 
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
-		return fmt.Errorf("error getting plugin process stdin: %s", err.Error())
+		return fmt.Errorf("error getting plugin process stdin: %v", err)
 	}
 
 	go func() {
@@ -68,7 +68,7 @@ func (t *rawPluginTask) Start() error {
 	t.waitGroup.Add(1)
 	t.done = make(chan bool, 1)
 	if err = cmd.Start(); err != nil {
-		return fmt.Errorf("error running plugin: %s", err.Error())
+		return fmt.Errorf("error running plugin: %v", err)
 	}
 
 	go t.handlePluginStderr(t.plugin.Name, stderr)
diff --git a/pkg/scene/export.go b/pkg/scene/export.go
index 5f723cdf5..8a1197698 100644
--- a/pkg/scene/export.go
+++ b/pkg/scene/export.go
@@ -58,7 +58,7 @@ func ToBasicJSON(reader models.SceneReader, scene *models.Scene) (*jsonschema.Sc
 
 	cover, err := reader.GetCover(scene.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting scene cover: %s", err.Error())
+		return nil, fmt.Errorf("error getting scene cover: %v", err)
 	}
 
 	if len(cover) > 0 {
@@ -136,7 +136,7 @@ func GetStudioName(reader models.StudioReader, scene *models.Scene) (string, err
 func GetTagNames(reader models.TagReader, scene *models.Scene) ([]string, error) {
 	tags, err := reader.FindBySceneID(scene.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting scene tags: %s", err.Error())
+		return nil, fmt.Errorf("error getting scene tags: %v", err)
 	}
 
 	return getTagNames(tags), nil
@@ -175,7 +175,7 @@ func GetDependentTagIDs(tags models.TagReader, markerReader models.SceneMarkerRe
 		ret = utils.IntAppendUnique(ret, smm.PrimaryTagID)
 		smmt, err := tags.FindBySceneMarkerID(smm.ID)
 		if err != nil {
-			return nil, fmt.Errorf("invalid tags for scene marker: %s", err.Error())
+			return nil, fmt.Errorf("invalid tags for scene marker: %v", err)
 		}
 
 		for _, smmtt := range smmt {
@@ -191,14 +191,14 @@ func GetDependentTagIDs(tags models.TagReader, markerReader models.SceneMarkerRe
 func GetSceneMoviesJSON(movieReader models.MovieReader, sceneReader models.SceneReader, scene *models.Scene) ([]jsonschema.SceneMovie, error) {
 	sceneMovies, err := sceneReader.GetMovies(scene.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting scene movies: %s", err.Error())
+		return nil, fmt.Errorf("error getting scene movies: %v", err)
 	}
 
 	var results []jsonschema.SceneMovie
 	for _, sceneMovie := range sceneMovies {
 		movie, err := movieReader.Find(sceneMovie.MovieID)
 		if err != nil {
-			return nil, fmt.Errorf("error getting movie: %s", err.Error())
+			return nil, fmt.Errorf("error getting movie: %v", err)
 		}
 
 		if movie.Name.Valid {
@@ -234,7 +234,7 @@ func GetDependentMovieIDs(sceneReader models.SceneReader, scene *models.Scene) (
 func GetSceneMarkersJSON(markerReader models.SceneMarkerReader, tagReader models.TagReader, scene *models.Scene) ([]jsonschema.SceneMarker, error) {
 	sceneMarkers, err := markerReader.FindBySceneID(scene.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting scene markers: %s", err.Error())
+		return nil, fmt.Errorf("error getting scene markers: %v", err)
 	}
 
 	var results []jsonschema.SceneMarker
@@ -242,12 +242,12 @@ func GetSceneMarkersJSON(markerReader models.SceneMarkerReader, tagReader models
 	for _, sceneMarker := range sceneMarkers {
 		primaryTag, err := tagReader.Find(sceneMarker.PrimaryTagID)
 		if err != nil {
-			return nil, fmt.Errorf("invalid primary tag for scene marker: %s", err.Error())
+			return nil, fmt.Errorf("invalid primary tag for scene marker: %v", err)
 		}
 
 		sceneMarkerTags, err := tagReader.FindBySceneMarkerID(sceneMarker.ID)
 		if err != nil {
-			return nil, fmt.Errorf("invalid tags for scene marker: %s", err.Error())
+			return nil, fmt.Errorf("invalid tags for scene marker: %v", err)
 		}
 
 		sceneMarkerJSON := jsonschema.SceneMarker{
diff --git a/pkg/scene/import.go b/pkg/scene/import.go
index a1cad8808..5cd56ccfb 100644
--- a/pkg/scene/import.go
+++ b/pkg/scene/import.go
@@ -59,7 +59,7 @@ func (i *Importer) PreImport() error {
 	if len(i.Input.Cover) > 0 {
 		_, i.coverImageData, err = utils.ProcessBase64Image(i.Input.Cover)
 		if err != nil {
-			return fmt.Errorf("invalid cover image: %s", err.Error())
+			return fmt.Errorf("invalid cover image: %v", err)
 		}
 	}
 
@@ -138,7 +138,7 @@ func (i *Importer) populateStudio() error {
 	if i.Input.Studio != "" {
 		studio, err := i.StudioWriter.FindByName(i.Input.Studio, false)
 		if err != nil {
-			return fmt.Errorf("error finding studio by name: %s", err.Error())
+			return fmt.Errorf("error finding studio by name: %v", err)
 		}
 
 		if studio == nil {
@@ -238,7 +238,7 @@ func (i *Importer) populatePerformers() error {
 			if i.MissingRefBehaviour == models.ImportMissingRefEnumCreate {
 				createdPerformers, err := i.createPerformers(missingPerformers)
 				if err != nil {
-					return fmt.Errorf("error creating scene performers: %s", err.Error())
+					return fmt.Errorf("error creating scene performers: %v", err)
 				}
 
 				performers = append(performers, createdPerformers...)
@@ -274,7 +274,7 @@ func (i *Importer) populateMovies() error {
 		for _, inputMovie := range i.Input.Movies {
 			movie, err := i.MovieWriter.FindByName(inputMovie.MovieName, false)
 			if err != nil {
-				return fmt.Errorf("error finding scene movie: %s", err.Error())
+				return fmt.Errorf("error finding scene movie: %v", err)
 			}
 
 			if movie == nil {
@@ -285,7 +285,7 @@ func (i *Importer) populateMovies() error {
 				if i.MissingRefBehaviour == models.ImportMissingRefEnumCreate {
 					movie, err = i.createMovie(inputMovie.MovieName)
 					if err != nil {
-						return fmt.Errorf("error creating scene movie: %s", err.Error())
+						return fmt.Errorf("error creating scene movie: %v", err)
 					}
 				}
 
@@ -341,7 +341,7 @@ func (i *Importer) populateTags() error {
 func (i *Importer) PostImport(id int) error {
 	if len(i.coverImageData) > 0 {
 		if err := i.ReaderWriter.UpdateCover(id, i.coverImageData); err != nil {
-			return fmt.Errorf("error setting scene images: %s", err.Error())
+			return fmt.Errorf("error setting scene images: %v", err)
 		}
 	}
 
@@ -352,7 +352,7 @@ func (i *Importer) PostImport(id int) error {
 		}
 
 		if err := i.ReaderWriter.UpdateGalleries(id, galleryIDs); err != nil {
-			return fmt.Errorf("failed to associate galleries: %s", err.Error())
+			return fmt.Errorf("failed to associate galleries: %v", err)
 		}
 	}
 
@@ -363,7 +363,7 @@ func (i *Importer) PostImport(id int) error {
 		}
 
 		if err := i.ReaderWriter.UpdatePerformers(id, performerIDs); err != nil {
-			return fmt.Errorf("failed to associate performers: %s", err.Error())
+			return fmt.Errorf("failed to associate performers: %v", err)
 		}
 	}
 
@@ -372,7 +372,7 @@ func (i *Importer) PostImport(id int) error {
 			i.movies[index].SceneID = id
 		}
 		if err := i.ReaderWriter.UpdateMovies(id, i.movies); err != nil {
-			return fmt.Errorf("failed to associate movies: %s", err.Error())
+			return fmt.Errorf("failed to associate movies: %v", err)
 		}
 	}
 
@@ -382,7 +382,7 @@ func (i *Importer) PostImport(id int) error {
 			tagIDs = append(tagIDs, t.ID)
 		}
 		if err := i.ReaderWriter.UpdateTags(id, tagIDs); err != nil {
-			return fmt.Errorf("failed to associate tags: %s", err.Error())
+			return fmt.Errorf("failed to associate tags: %v", err)
 		}
 	}
 
@@ -419,7 +419,7 @@ func (i *Importer) FindExistingID() (*int, error) {
 func (i *Importer) Create() (*int, error) {
 	created, err := i.ReaderWriter.Create(i.scene)
 	if err != nil {
-		return nil, fmt.Errorf("error creating scene: %s", err.Error())
+		return nil, fmt.Errorf("error creating scene: %v", err)
 	}
 
 	id := created.ID
@@ -433,7 +433,7 @@ func (i *Importer) Update(id int) error {
 	i.ID = id
 	_, err := i.ReaderWriter.UpdateFull(scene)
 	if err != nil {
-		return fmt.Errorf("error updating existing scene: %s", err.Error())
+		return fmt.Errorf("error updating existing scene: %v", err)
 	}
 
 	return nil
@@ -462,7 +462,7 @@ func importTags(tagWriter models.TagReaderWriter, names []string, missingRefBeha
 		if missingRefBehaviour == models.ImportMissingRefEnumCreate {
 			createdTags, err := createTags(tagWriter, missingTags)
 			if err != nil {
-				return nil, fmt.Errorf("error creating tags: %s", err.Error())
+				return nil, fmt.Errorf("error creating tags: %v", err)
 			}
 
 			tags = append(tags, createdTags...)
diff --git a/pkg/scene/marker_import.go b/pkg/scene/marker_import.go
index d15563eb5..2258025fe 100644
--- a/pkg/scene/marker_import.go
+++ b/pkg/scene/marker_import.go
@@ -70,7 +70,7 @@ func (i *MarkerImporter) PostImport(id int) error {
 			tagIDs = append(tagIDs, t.ID)
 		}
 		if err := i.ReaderWriter.UpdateTags(id, tagIDs); err != nil {
-			return fmt.Errorf("failed to associate tags: %s", err.Error())
+			return fmt.Errorf("failed to associate tags: %v", err)
 		}
 	}
 
@@ -101,7 +101,7 @@ func (i *MarkerImporter) FindExistingID() (*int, error) {
 func (i *MarkerImporter) Create() (*int, error) {
 	created, err := i.ReaderWriter.Create(i.marker)
 	if err != nil {
-		return nil, fmt.Errorf("error creating marker: %s", err.Error())
+		return nil, fmt.Errorf("error creating marker: %v", err)
 	}
 
 	id := created.ID
@@ -113,7 +113,7 @@ func (i *MarkerImporter) Update(id int) error {
 	marker.ID = id
 	_, err := i.ReaderWriter.Update(marker)
 	if err != nil {
-		return fmt.Errorf("error updating existing marker: %s", err.Error())
+		return fmt.Errorf("error updating existing marker: %v", err)
 	}
 
 	return nil
diff --git a/pkg/scraper/mapped.go b/pkg/scraper/mapped.go
index 80d854341..cdba5b907 100644
--- a/pkg/scraper/mapped.go
+++ b/pkg/scraper/mapped.go
@@ -588,7 +588,8 @@ func (c *mappedScraperAttrConfig) UnmarshalYAML(unmarshal func(interface{}) erro
 	// try unmarshalling into a string first
 	if err := unmarshal(&c.Selector); err != nil {
 		// if it's a type error then we try to unmarshall to the full object
-		if _, ok := err.(*yaml.TypeError); !ok {
+		var typeErr *yaml.TypeError
+		if !errors.As(err, &typeErr) {
 			return err
 		}
 
diff --git a/pkg/sqlite/gallery.go b/pkg/sqlite/gallery.go
index 2564c068b..27c7585ad 100644
--- a/pkg/sqlite/gallery.go
+++ b/pkg/sqlite/gallery.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 
 	"github.com/stashapp/stash/pkg/models"
@@ -75,7 +76,7 @@ func (qb *galleryQueryBuilder) Destroy(id int) error {
 func (qb *galleryQueryBuilder) Find(id int) (*models.Gallery, error) {
 	var ret models.Gallery
 	if err := qb.get(id, &ret); err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
diff --git a/pkg/sqlite/image.go b/pkg/sqlite/image.go
index 01598c51a..8e1ecb243 100644
--- a/pkg/sqlite/image.go
+++ b/pkg/sqlite/image.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 
 	"github.com/stashapp/stash/pkg/models"
@@ -145,7 +146,7 @@ func (qb *imageQueryBuilder) FindMany(ids []int) ([]*models.Image, error) {
 func (qb *imageQueryBuilder) find(id int) (*models.Image, error) {
 	var ret models.Image
 	if err := qb.get(id, &ret); err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
diff --git a/pkg/sqlite/movies.go b/pkg/sqlite/movies.go
index 40340ac13..92936ecf5 100644
--- a/pkg/sqlite/movies.go
+++ b/pkg/sqlite/movies.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 
 	"github.com/stashapp/stash/pkg/models"
@@ -58,7 +59,7 @@ func (qb *movieQueryBuilder) Destroy(id int) error {
 func (qb *movieQueryBuilder) Find(id int) (*models.Movie, error) {
 	var ret models.Movie
 	if err := qb.get(id, &ret); err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
diff --git a/pkg/sqlite/performer.go b/pkg/sqlite/performer.go
index 212a706bb..e3c06a3e6 100644
--- a/pkg/sqlite/performer.go
+++ b/pkg/sqlite/performer.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"strings"
 
@@ -84,7 +85,7 @@ func (qb *performerQueryBuilder) Destroy(id int) error {
 func (qb *performerQueryBuilder) Find(id int) (*models.Performer, error) {
 	var ret models.Performer
 	if err := qb.get(id, &ret); err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
diff --git a/pkg/sqlite/repository.go b/pkg/sqlite/repository.go
index b6b107151..c9296fe54 100644
--- a/pkg/sqlite/repository.go
+++ b/pkg/sqlite/repository.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"reflect"
 	"strings"
@@ -132,7 +133,7 @@ func (r *repository) runCountQuery(query string, args []interface{}) (int, error
 	}{0}
 
 	// Perform query and fetch result
-	if err := r.tx.Get(&result, query, args...); err != nil && err != sql.ErrNoRows {
+	if err := r.tx.Get(&result, query, args...); err != nil && !errors.Is(err, sql.ErrNoRows) {
 		return 0, err
 	}
 
@@ -144,7 +145,7 @@ func (r *repository) runIdsQuery(query string, args []interface{}) ([]int, error
 		Int int `db:"id"`
 	}
 
-	if err := r.tx.Select(&result, query, args...); err != nil && err != sql.ErrNoRows {
+	if err := r.tx.Select(&result, query, args...); err != nil && !errors.Is(err, sql.ErrNoRows) {
 		return []int{}, err
 	}
 
@@ -162,7 +163,7 @@ func (r *repository) runSumQuery(query string, args []interface{}) (float64, err
 	}{0}
 
 	// Perform query and fetch result
-	if err := r.tx.Get(&result, query, args...); err != nil && err != sql.ErrNoRows {
+	if err := r.tx.Get(&result, query, args...); err != nil && !errors.Is(err, sql.ErrNoRows) {
 		return 0, err
 	}
 
@@ -172,7 +173,7 @@ func (r *repository) runSumQuery(query string, args []interface{}) (float64, err
 func (r *repository) queryFunc(query string, args []interface{}, f func(rows *sqlx.Rows) error) error {
 	rows, err := r.tx.Queryx(query, args...)
 
-	if err != nil && err != sql.ErrNoRows {
+	if err != nil && !errors.Is(err, sql.ErrNoRows) {
 		return err
 	}
 	defer rows.Close()
@@ -193,7 +194,7 @@ func (r *repository) queryFunc(query string, args []interface{}, f func(rows *sq
 func (r *repository) query(query string, args []interface{}, out objectList) error {
 	rows, err := r.tx.Queryx(query, args...)
 
-	if err != nil && err != sql.ErrNoRows {
+	if err != nil && !errors.Is(err, sql.ErrNoRows) {
 		return err
 	}
 	defer rows.Close()
@@ -216,7 +217,7 @@ func (r *repository) query(query string, args []interface{}, out objectList) err
 func (r *repository) querySimple(query string, args []interface{}, out interface{}) error {
 	rows, err := r.tx.Queryx(query, args...)
 
-	if err != nil && err != sql.ErrNoRows {
+	if err != nil && !errors.Is(err, sql.ErrNoRows) {
 		return err
 	}
 	defer rows.Close()
diff --git a/pkg/sqlite/saved_filter.go b/pkg/sqlite/saved_filter.go
index c4bbf0f8e..8630a14a7 100644
--- a/pkg/sqlite/saved_filter.go
+++ b/pkg/sqlite/saved_filter.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 
 	"github.com/stashapp/stash/pkg/models"
@@ -72,7 +73,7 @@ func (qb *savedFilterQueryBuilder) Destroy(id int) error {
 func (qb *savedFilterQueryBuilder) Find(id int) (*models.SavedFilter, error) {
 	var ret models.SavedFilter
 	if err := qb.get(id, &ret); err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
diff --git a/pkg/sqlite/scene.go b/pkg/sqlite/scene.go
index 5aa0d4722..c40f2f358 100644
--- a/pkg/sqlite/scene.go
+++ b/pkg/sqlite/scene.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"strconv"
 	"strings"
@@ -215,7 +216,7 @@ func (qb *sceneQueryBuilder) FindMany(ids []int) ([]*models.Scene, error) {
 func (qb *sceneQueryBuilder) find(id int) (*models.Scene, error) {
 	var ret models.Scene
 	if err := qb.get(id, &ret); err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
diff --git a/pkg/sqlite/scene_marker.go b/pkg/sqlite/scene_marker.go
index 7872b21c5..50218738b 100644
--- a/pkg/sqlite/scene_marker.go
+++ b/pkg/sqlite/scene_marker.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 
 	"github.com/stashapp/stash/pkg/database"
@@ -271,7 +272,7 @@ func (qb *sceneMarkerQueryBuilder) querySceneMarkers(query string, args []interf
 
 func (qb *sceneMarkerQueryBuilder) queryMarkerStringsResultType(query string, args []interface{}) ([]*models.MarkerStringsResultType, error) {
 	rows, err := database.DB.Queryx(query, args...)
-	if err != nil && err != sql.ErrNoRows {
+	if err != nil && !errors.Is(err, sql.ErrNoRows) {
 		return nil, err
 	}
 	defer rows.Close()
diff --git a/pkg/sqlite/scraped_item.go b/pkg/sqlite/scraped_item.go
index 30f772dc9..1eafc98a5 100644
--- a/pkg/sqlite/scraped_item.go
+++ b/pkg/sqlite/scraped_item.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 
 	"github.com/stashapp/stash/pkg/models"
 )
@@ -47,7 +48,7 @@ func (qb *scrapedItemQueryBuilder) Find(id int) (*models.ScrapedItem, error) {
 func (qb *scrapedItemQueryBuilder) find(id int) (*models.ScrapedItem, error) {
 	var ret models.ScrapedItem
 	if err := qb.get(id, &ret); err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
diff --git a/pkg/sqlite/sql.go b/pkg/sqlite/sql.go
index 827bdbda2..9834acb26 100644
--- a/pkg/sqlite/sql.go
+++ b/pkg/sqlite/sql.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"math/rand"
 	"regexp"
@@ -228,7 +229,7 @@ func getCountCriterionClause(primaryTable, joinTable, primaryFK string, criterio
 func getImage(tx dbi, query string, args ...interface{}) ([]byte, error) {
 	rows, err := tx.Queryx(query, args...)
 
-	if err != nil && err != sql.ErrNoRows {
+	if err != nil && !errors.Is(err, sql.ErrNoRows) {
 		return nil, err
 	}
 	defer rows.Close()
diff --git a/pkg/sqlite/studio.go b/pkg/sqlite/studio.go
index b46737385..7ba3ef884 100644
--- a/pkg/sqlite/studio.go
+++ b/pkg/sqlite/studio.go
@@ -2,6 +2,7 @@ package sqlite
 
 import (
 	"database/sql"
+	"errors"
 	"fmt"
 	"strings"
 
@@ -68,7 +69,7 @@ func (qb *studioQueryBuilder) Destroy(id int) error {
 func (qb *studioQueryBuilder) Find(id int) (*models.Studio, error) {
 	var ret models.Studio
 	if err := qb.get(id, &ret); err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
diff --git a/pkg/sqlite/tag.go b/pkg/sqlite/tag.go
index 59caa023c..5373088ae 100644
--- a/pkg/sqlite/tag.go
+++ b/pkg/sqlite/tag.go
@@ -87,7 +87,7 @@ func (qb *tagQueryBuilder) Destroy(id int) error {
 func (qb *tagQueryBuilder) Find(id int) (*models.Tag, error) {
 	var ret models.Tag
 	if err := qb.get(id, &ret); err != nil {
-		if err == sql.ErrNoRows {
+		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
diff --git a/pkg/sqlite/transaction.go b/pkg/sqlite/transaction.go
index 0eb45d5f9..50486d01e 100644
--- a/pkg/sqlite/transaction.go
+++ b/pkg/sqlite/transaction.go
@@ -36,7 +36,7 @@ func (t *transaction) Begin() error {
 	var err error
 	t.tx, err = database.DB.BeginTxx(t.Ctx, nil)
 	if err != nil {
-		return fmt.Errorf("error starting transaction: %s", err.Error())
+		return fmt.Errorf("error starting transaction: %v", err)
 	}
 
 	return nil
@@ -49,7 +49,7 @@ func (t *transaction) Rollback() error {
 
 	err := t.tx.Rollback()
 	if err != nil {
-		return fmt.Errorf("error rolling back transaction: %s", err.Error())
+		return fmt.Errorf("error rolling back transaction: %v", err)
 	}
 	t.tx = nil
 
@@ -63,7 +63,7 @@ func (t *transaction) Commit() error {
 
 	err := t.tx.Commit()
 	if err != nil {
-		return fmt.Errorf("error committing transaction: %s", err.Error())
+		return fmt.Errorf("error committing transaction: %v", err)
 	}
 	t.tx = nil
 
diff --git a/pkg/studio/export.go b/pkg/studio/export.go
index 46b92a07d..49dd8fc7a 100644
--- a/pkg/studio/export.go
+++ b/pkg/studio/export.go
@@ -30,7 +30,7 @@ func ToJSON(reader models.StudioReader, studio *models.Studio) (*jsonschema.Stud
 	if studio.ParentID.Valid {
 		parent, err := reader.Find(int(studio.ParentID.Int64))
 		if err != nil {
-			return nil, fmt.Errorf("error getting parent studio: %s", err.Error())
+			return nil, fmt.Errorf("error getting parent studio: %v", err)
 		}
 
 		if parent != nil {
@@ -44,14 +44,14 @@ func ToJSON(reader models.StudioReader, studio *models.Studio) (*jsonschema.Stud
 
 	aliases, err := reader.GetAliases(studio.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting studio aliases: %s", err.Error())
+		return nil, fmt.Errorf("error getting studio aliases: %v", err)
 	}
 
 	newStudioJSON.Aliases = aliases
 
 	image, err := reader.GetImage(studio.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting studio image: %s", err.Error())
+		return nil, fmt.Errorf("error getting studio image: %v", err)
 	}
 
 	if len(image) > 0 {
diff --git a/pkg/studio/import.go b/pkg/studio/import.go
index a3a35023d..67f9018c3 100644
--- a/pkg/studio/import.go
+++ b/pkg/studio/import.go
@@ -42,7 +42,7 @@ func (i *Importer) PreImport() error {
 	if len(i.Input.Image) > 0 {
 		_, i.imageData, err = utils.ProcessBase64Image(i.Input.Image)
 		if err != nil {
-			return fmt.Errorf("invalid image: %s", err.Error())
+			return fmt.Errorf("invalid image: %v", err)
 		}
 	}
 
@@ -53,7 +53,7 @@ func (i *Importer) populateParentStudio() error {
 	if i.Input.ParentStudio != "" {
 		studio, err := i.ReaderWriter.FindByName(i.Input.ParentStudio, false)
 		if err != nil {
-			return fmt.Errorf("error finding studio by name: %s", err.Error())
+			return fmt.Errorf("error finding studio by name: %v", err)
 		}
 
 		if studio == nil {
@@ -97,12 +97,12 @@ func (i *Importer) createParentStudio(name string) (int, error) {
 func (i *Importer) PostImport(id int) error {
 	if len(i.imageData) > 0 {
 		if err := i.ReaderWriter.UpdateImage(id, i.imageData); err != nil {
-			return fmt.Errorf("error setting studio image: %s", err.Error())
+			return fmt.Errorf("error setting studio image: %v", err)
 		}
 	}
 
 	if err := i.ReaderWriter.UpdateAliases(id, i.Input.Aliases); err != nil {
-		return fmt.Errorf("error setting tag aliases: %s", err.Error())
+		return fmt.Errorf("error setting tag aliases: %v", err)
 	}
 
 	return nil
@@ -130,7 +130,7 @@ func (i *Importer) FindExistingID() (*int, error) {
 func (i *Importer) Create() (*int, error) {
 	created, err := i.ReaderWriter.Create(i.studio)
 	if err != nil {
-		return nil, fmt.Errorf("error creating studio: %s", err.Error())
+		return nil, fmt.Errorf("error creating studio: %v", err)
 	}
 
 	id := created.ID
@@ -142,7 +142,7 @@ func (i *Importer) Update(id int) error {
 	studio.ID = id
 	_, err := i.ReaderWriter.UpdateFull(studio)
 	if err != nil {
-		return fmt.Errorf("error updating existing studio: %s", err.Error())
+		return fmt.Errorf("error updating existing studio: %v", err)
 	}
 
 	return nil
diff --git a/pkg/tag/export.go b/pkg/tag/export.go
index 54c64990e..dde39760c 100644
--- a/pkg/tag/export.go
+++ b/pkg/tag/export.go
@@ -18,14 +18,14 @@ func ToJSON(reader models.TagReader, tag *models.Tag) (*jsonschema.Tag, error) {
 
 	aliases, err := reader.GetAliases(tag.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting tag aliases: %s", err.Error())
+		return nil, fmt.Errorf("error getting tag aliases: %v", err)
 	}
 
 	newTagJSON.Aliases = aliases
 
 	image, err := reader.GetImage(tag.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting tag image: %s", err.Error())
+		return nil, fmt.Errorf("error getting tag image: %v", err)
 	}
 
 	if len(image) > 0 {
@@ -34,7 +34,7 @@ func ToJSON(reader models.TagReader, tag *models.Tag) (*jsonschema.Tag, error) {
 
 	parents, err := reader.FindByChildTagID(tag.ID)
 	if err != nil {
-		return nil, fmt.Errorf("error getting parents: %s", err.Error())
+		return nil, fmt.Errorf("error getting parents: %v", err)
 	}
 
 	newTagJSON.Parents = GetNames(parents)
diff --git a/pkg/tag/import.go b/pkg/tag/import.go
index 8fe0410d2..3fd793d0e 100644
--- a/pkg/tag/import.go
+++ b/pkg/tag/import.go
@@ -40,7 +40,7 @@ func (i *Importer) PreImport() error {
 	if len(i.Input.Image) > 0 {
 		_, i.imageData, err = utils.ProcessBase64Image(i.Input.Image)
 		if err != nil {
-			return fmt.Errorf("invalid image: %s", err.Error())
+			return fmt.Errorf("invalid image: %v", err)
 		}
 	}
 
@@ -50,12 +50,12 @@ func (i *Importer) PreImport() error {
 func (i *Importer) PostImport(id int) error {
 	if len(i.imageData) > 0 {
 		if err := i.ReaderWriter.UpdateImage(id, i.imageData); err != nil {
-			return fmt.Errorf("error setting tag image: %s", err.Error())
+			return fmt.Errorf("error setting tag image: %v", err)
 		}
 	}
 
 	if err := i.ReaderWriter.UpdateAliases(id, i.Input.Aliases); err != nil {
-		return fmt.Errorf("error setting tag aliases: %s", err.Error())
+		return fmt.Errorf("error setting tag aliases: %v", err)
 	}
 
 	parents, err := i.getParents()
@@ -64,7 +64,7 @@ func (i *Importer) PostImport(id int) error {
 	}
 
 	if err := i.ReaderWriter.UpdateParentTags(id, parents); err != nil {
-		return fmt.Errorf("error setting parents: %s", err.Error())
+		return fmt.Errorf("error setting parents: %v", err)
 	}
 
 	return nil
@@ -92,7 +92,7 @@ func (i *Importer) FindExistingID() (*int, error) {
 func (i *Importer) Create() (*int, error) {
 	created, err := i.ReaderWriter.Create(i.tag)
 	if err != nil {
-		return nil, fmt.Errorf("error creating tag: %s", err.Error())
+		return nil, fmt.Errorf("error creating tag: %v", err)
 	}
 
 	id := created.ID
@@ -104,7 +104,7 @@ func (i *Importer) Update(id int) error {
 	tag.ID = id
 	_, err := i.ReaderWriter.UpdateFull(tag)
 	if err != nil {
-		return fmt.Errorf("error updating existing tag: %s", err.Error())
+		return fmt.Errorf("error updating existing tag: %v", err)
 	}
 
 	return nil
@@ -115,7 +115,7 @@ func (i *Importer) getParents() ([]int, error) {
 	for _, parent := range i.Input.Parents {
 		tag, err := i.ReaderWriter.FindByName(parent, false)
 		if err != nil {
-			return nil, fmt.Errorf("error finding parent by name: %s", err.Error())
+			return nil, fmt.Errorf("error finding parent by name: %v", err)
 		}
 
 		if tag == nil {