chore: improve error reporting to help diagnose flaky test

gaultier · ory-bot · commit 661484fcf273 · 2025-11-20T11:58:30.000Z
GitOrigin-RevId: d08aa2c570dd17df5a5e14c2975cebe80aeb2e66
diff --git a/oryx/popx/match.go b/oryx/popx/match.go
@@ -4,9 +4,10 @@
 package popx
 
 import (
-	"fmt"
 	"regexp"
 
+	"github.com/pkg/errors"
+
 	"github.com/ory/pop/v6"
 )
 
@@ -43,18 +44,18 @@ func parseMigrationFilename(filename string) (*match, error) {
 	} else {
 		dbType = pop.CanonicalDialect(m[3][1:])
 		if !pop.DialectSupported(dbType) {
-			return nil, fmt.Errorf("unsupported dialect %s", dbType)
+			return nil, errors.Errorf("unsupported dialect %s", dbType)
 		}
 	}
 
 	if m[6] == "fizz" && dbType != "all" {
-		return nil, fmt.Errorf("invalid database type %q, expected \"all\" because fizz is database type independent", dbType)
+		return nil, errors.Errorf("invalid database type %q, expected \"all\" because fizz is database type independent", dbType)
 	}
 
 	if m[4] == ".autocommit" {
 		autocommit = true
 	} else if m[4] != "" {
-		return nil, fmt.Errorf("invalid autocommit flag %q", m[4])
+		return nil, errors.Errorf("invalid autocommit flag %q", m[4])
 	}
 
 	return &match{
diff --git a/oryx/popx/migration_box.go b/oryx/popx/migration_box.go
@@ -89,7 +89,7 @@ func WithTestdata(t *testing.T, testdata fs.FS) MigrationBoxOption {
 	return func(m *MigrationBox) {
 		require.NoError(t, fs.WalkDir(testdata, ".", func(path string, info fs.DirEntry, err error) error {
 			if err != nil {
-				return err
+				return errors.WithStack(err)
 			}
 			if !info.Type().IsRegular() {
 				t.Logf("skipping testdata entry that is not a file: %s", path)
@@ -120,13 +120,13 @@ func WithTestdata(t *testing.T, testdata fs.FS) MigrationBoxOption {
 				Runner: func(m Migration, c *pop.Connection) error {
 					b, err := fs.ReadFile(testdata, m.Path)
 					if err != nil {
-						return err
+						return errors.WithStack(err)
 					}
 					if isMigrationEmpty(string(b)) {
 						return nil
 					}
 					_, err = c.Store.SQLDB().Exec(string(b))
-					return err
+					return errors.WithStack(err)
 				},
 			})
 
@@ -230,7 +230,7 @@ func (mb *MigrationBox) findMigrations(
 		}
 
 		if details == nil {
-			return errors.WithStack(fmt.Errorf("Found a migration file that does not match the file pattern: filename=%s pattern=%s", info.Name(), MigrationFileRegexp))
+			return errors.Errorf("Found a migration file that does not match the file pattern: filename=%s pattern=%s", info.Name(), MigrationFileRegexp)
 		}
 
 		content, err := fs.ReadFile(dir, p)
@@ -269,7 +269,7 @@ func (mb *MigrationBox) findMigrations(
 	// Sort ascending.
 	sort.Sort(mb.migrationsUp)
 
-	return err
+	return errors.WithStack(err)
 }
 
 // hasDownMigrationWithVersion checks if there is a migration with the given
@@ -293,12 +293,12 @@ func (mb *MigrationBox) check() error {
 
 	for _, n := range mb.migrationsUp {
 		if err := n.Valid(); err != nil {
-			return err
+			return errors.WithStack(err)
 		}
 	}
 	for _, n := range mb.migrationsDown {
 		if err := n.Valid(); err != nil {
-			return err
+			return errors.WithStack(err)
 		}
 	}
 	return nil
diff --git a/oryx/popx/migrator.go b/oryx/popx/migrator.go
@@ -22,6 +22,7 @@ import (
 	"github.com/ory/x/cmdx"
 	"github.com/ory/x/logrusx"
 	"github.com/ory/x/otelx"
+	"github.com/ory/x/sqlcon"
 )
 
 const (
@@ -37,7 +38,7 @@ func (mb *MigrationBox) shouldNotUseTransaction(m Migration) bool {
 // Up runs pending "up" migrations and applies them to the database.
 func (mb *MigrationBox) Up(ctx context.Context) error {
 	_, err := mb.UpTo(ctx, 0)
-	return err
+	return errors.WithStack(err)
 }
 
 // UpTo runs up to step "up" migrations and applies them to the database.
@@ -83,21 +84,22 @@ func (mb *MigrationBox) UpTo(ctx context.Context, step int) (applied int, err er
 					err := conn.RawQuery(fmt.Sprintf("INSERT INTO %s (version) VALUES (?)", mtn), mi.Version).Exec()
 					return errors.Wrapf(err, "problem inserting migration version %s", mi.Version)
 				}); err != nil {
-					return err
+					return errors.WithStack(err)
 				}
 				continue
 			}
 
 			l.Info("Migration has not yet been applied, running migration.")
 
 			if err := mi.Valid(); err != nil {
-				return err
+				return errors.WithStack(err)
 			}
 
 			noTx := mb.shouldNotUseTransaction(mi)
 			if noTx {
+				l.Info("NOT running migrations inside a transaction")
 				if err := mi.Runner(mi, c); err != nil {
-					return err
+					return errors.WithStack(err)
 				}
 
 				// #nosec G201 - mtn is a system-wide const
@@ -107,7 +109,7 @@ func (mb *MigrationBox) UpTo(ctx context.Context, step int) (applied int, err er
 			} else {
 				if err := mb.isolatedTransaction(ctx, "up", func(conn *pop.Connection) error {
 					if err := mi.Runner(mi, conn); err != nil {
-						return err
+						return errors.WithStack(err)
 					}
 
 					// #nosec G201 - mtn is a system-wide const
@@ -116,7 +118,7 @@ func (mb *MigrationBox) UpTo(ctx context.Context, step int) (applied int, err er
 					}
 					return nil
 				}); err != nil {
-					return err
+					return errors.WithStack(err)
 				}
 			}
 
@@ -133,7 +135,7 @@ func (mb *MigrationBox) UpTo(ctx context.Context, step int) (applied int, err er
 		}
 		return nil
 	})
-	return
+	return applied, errors.WithStack(err)
 }
 
 // Down runs pending "down" migrations and rolls back the
@@ -148,7 +150,7 @@ func (mb *MigrationBox) Down(ctx context.Context, steps int) (err error) {
 	}
 
 	c := mb.c.WithContext(ctx)
-	return mb.exec(ctx, func() (err error) {
+	return errors.WithStack(mb.exec(ctx, func() (err error) {
 		mtn := sanitizedMigrationTableName(c)
 		count, err := c.Count(mtn)
 		if err != nil {
@@ -203,7 +205,7 @@ func (mb *MigrationBox) Down(ctx context.Context, steps int) (err error) {
 			if mb.shouldNotUseTransaction(mi) {
 				err := mi.Runner(mi, c)
 				if err != nil {
-					return err
+					return errors.WithStack(err)
 				}
 
 				// #nosec G201 - mtn is a system-wide const
@@ -232,7 +234,7 @@ func (mb *MigrationBox) Down(ctx context.Context, steps int) (err error) {
 			reverted++
 		}
 		return nil
-	})
+	}))
 }
 
 func (mb *MigrationBox) createTransactionalMigrationTable(ctx context.Context, c *pop.Connection, l *logrusx.Logger) error {
@@ -243,7 +245,7 @@ func (mb *MigrationBox) createTransactionalMigrationTable(ctx context.Context, c
 		fmt.Sprintf(`CREATE UNIQUE INDEX %s_version_idx ON %s (version)`, mtn, mtn),
 		fmt.Sprintf(`CREATE INDEX %s_version_self_idx ON %s (version_self)`, mtn, mtn),
 	}); err != nil {
-		return err
+		return errors.WithStack(err)
 	}
 
 	l.WithField("migration_table", mtn).Debug("Transactional migration table created successfully.")
@@ -277,7 +279,7 @@ func (mb *MigrationBox) migrateToTransactionalMigrationTable(ctx context.Context
 	}
 
 	if err := mb.createMigrationStatusTableTransaction(ctx, workload...); err != nil {
-		return err
+		return errors.WithStack(err)
 	}
 
 	l.WithField("migration_table", mtn).Debug("Successfully migrated legacy schema_migration to new transactional schema_migration table.")
@@ -296,7 +298,7 @@ func (mb *MigrationBox) isolatedTransaction(ctx context.Context, direction strin
 	}
 
 	return Transaction(ctx, mb.c.WithContext(ctx), func(ctx context.Context, connection *pop.Connection) error {
-		return fn(connection)
+		return errors.WithStack(fn(connection))
 	})
 }
 
@@ -319,7 +321,7 @@ func (mb *MigrationBox) createMigrationStatusTableTransaction(ctx context.Contex
 				}
 				return nil
 			}); err != nil {
-				return err
+				return errors.WithStack(err)
 			}
 		}
 	}
@@ -341,14 +343,14 @@ func (mb *MigrationBox) CreateSchemaMigrations(ctx context.Context) error {
 	if err != nil {
 		mb.l.WithError(err).WithField("migration_table", mtn).Debug("An error occurred while checking for the legacy migration table, maybe it does not exist yet? Trying to create.")
 		// This means that the legacy pop migrator has not yet been applied
-		return mb.createTransactionalMigrationTable(ctx, c, mb.l)
+		return errors.WithStack(mb.createTransactionalMigrationTable(ctx, c, mb.l))
 	}
 
 	mb.l.WithField("migration_table", mtn).Debug("A migration table exists, checking if it is a transactional migration table.")
 	_, err = c.Store.Exec(fmt.Sprintf("select version, version_self from %s", mtn))
 	if err != nil {
 		mb.l.WithError(err).WithField("migration_table", mtn).Debug("An error occurred while checking for the transactional migration table, maybe it does not exist yet? Trying to create.")
-		return mb.migrateToTransactionalMigrationTable(ctx, c, mb.l)
+		return errors.WithStack(mb.migrateToTransactionalMigrationTable(ctx, c, mb.l))
 	}
 
 	mb.l.WithField("migration_table", mtn).Debug("Migration tables exist and are up to date.")
@@ -436,7 +438,7 @@ func (mb *MigrationBox) Status(ctx context.Context) (MigrationStatuses, error) {
 			// It also means that we can ignore this state and act as if no migrations have been applied yet.
 		} else {
 			// On any other error, we fail.
-			return nil, errors.Wrapf(err, "problem with migration")
+			return nil, errors.Wrap(err, "problem with migration")
 		}
 	}
 
@@ -471,12 +473,12 @@ func (mb *MigrationBox) DumpMigrationSchema(ctx context.Context) error {
 	schema := "schema.sql"
 	f, err := os.Create(schema) //#nosec:G304) //#nosec:G304
 	if err != nil {
-		return err
+		return errors.WithStack(err)
 	}
 	err = c.Dialect.DumpSchema(f)
 	if err != nil {
 		_ = os.RemoveAll(schema)
-		return err
+		return errors.WithStack(err)
 	}
 	return nil
 }
@@ -501,24 +503,24 @@ func (mb *MigrationBox) exec(ctx context.Context, fn func() error) error {
 
 	if mb.c.Dialect.Name() == "sqlite3" {
 		if err := mb.c.RawQuery("PRAGMA foreign_keys=OFF").Exec(); err != nil {
-			return err
+			return sqlcon.HandleError(err)
 		}
 	}
 
 	if mb.c.Dialect.Name() == "cockroach" {
 		outer := fn
 		fn = func() error {
-			return crdb.Execute(outer)
+			return errors.WithStack(crdb.Execute(outer))
 		}
 	}
 
 	if err := fn(); err != nil {
-		return err
+		return errors.WithStack(err)
 	}
 
 	if mb.c.Dialect.Name() == "sqlite3" {
 		if err := mb.c.RawQuery("PRAGMA foreign_keys=ON").Exec(); err != nil {
-			return err
+			return sqlcon.HandleError(err)
 		}
 	}
 
diff --git a/oryx/popx/sql_template_funcs.go b/oryx/popx/sql_template_funcs.go
@@ -4,8 +4,9 @@
 package popx
 
 import (
-	"fmt"
 	"regexp"
+
+	"github.com/pkg/errors"
 )
 
 var SQLTemplateFuncs = map[string]interface{}{
@@ -16,7 +17,7 @@ var identifierPattern = regexp.MustCompile("^[a-zA-Z][a-zA-Z0-9_]*$")
 
 func Identifier(i string) (string, error) {
 	if !identifierPattern.MatchString(i) {
-		return "", fmt.Errorf("invalid SQL identifier '%s'", i)
+		return "", errors.Errorf("invalid SQL identifier '%s'", i)
 	}
 	return i, nil
 }
diff --git a/oryx/popx/transaction.go b/oryx/popx/transaction.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/cockroachdb/cockroach-go/v2/crdb"
 	"github.com/jmoiron/sqlx"
+	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 
 	"github.com/ory/pop/v6"
@@ -30,32 +31,32 @@ func Transaction(ctx context.Context, connection *pop.Connection, callback func(
 	c := ctx.Value(transactionKey)
 	if c != nil {
 		if conn, ok := c.(*pop.Connection); ok {
-			return callback(ctx, conn.WithContext(ctx))
+			return errors.WithStack(callback(ctx, conn.WithContext(ctx)))
 		}
 	}
 
 	if connection.Dialect.Name() == "cockroach" {
 		return connection.WithContext(ctx).Dialect.Lock(func() error {
 			transaction, err := connection.NewTransaction()
 			if err != nil {
-				return err
+				return errors.WithStack(err)
 			}
 
 			attempt := 0
-			return crdb.ExecuteInTx(ctx, sqlxTxAdapter{transaction.TX.Tx}, func() error {
+			return errors.WithStack(crdb.ExecuteInTx(ctx, sqlxTxAdapter{transaction.TX.Tx}, func() error {
 				attempt++
 				if attempt > 1 {
 					caller := caller()
 					transactionRetries.WithLabelValues(caller).Inc()
 				}
-				return callback(WithTransaction(ctx, transaction), transaction)
-			})
+				return errors.WithStack(callback(WithTransaction(ctx, transaction), transaction))
+			}))
 		})
 	}
 
-	return connection.WithContext(ctx).Transaction(func(tx *pop.Connection) error {
-		return callback(WithTransaction(ctx, tx), tx)
-	})
+	return errors.WithStack(connection.WithContext(ctx).Transaction(func(tx *pop.Connection) error {
+		return errors.WithStack(callback(WithTransaction(ctx, tx), tx))
+	}))
 }
 
 func GetConnection(ctx context.Context, connection *pop.Connection) *pop.Connection {
@@ -76,15 +77,15 @@ var _ crdb.Tx = sqlxTxAdapter{}
 
 func (s sqlxTxAdapter) Exec(ctx context.Context, query string, args ...interface{}) error {
 	_, err := s.Tx.ExecContext(ctx, query, args...)
-	return err
+	return errors.WithStack(err)
 }
 
 func (s sqlxTxAdapter) Commit(ctx context.Context) error {
-	return s.Tx.Commit()
+	return errors.WithStack(s.Tx.Commit())
 }
 
 func (s sqlxTxAdapter) Rollback(ctx context.Context) error {
-	return s.Tx.Rollback()
+	return errors.WithStack(s.Tx.Rollback())
 }
 
 var (
diff --git a/oryx/sqlcon/error.go b/oryx/sqlcon/error.go

Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,10 @@`
`4`	`4`	`package popx`
`5`	`5`
`6`	`6`	`import (`
`7`		`- "fmt"`
`8`	`7`	`"regexp"`
`9`	`8`
	`9`	`+ "github.com/pkg/errors"`
	`10`	`+`
`10`	`11`	`"github.com/ory/pop/v6"`
`11`	`12`	`)`
`12`	`13`
`@@ -43,18 +44,18 @@ func parseMigrationFilename(filename string) (*match, error) {`
`43`	`44`	`} else {`
`44`	`45`	`dbType = pop.CanonicalDialect(m[3][1:])`
`45`	`46`	`if !pop.DialectSupported(dbType) {`
`46`		`- return nil, fmt.Errorf("unsupported dialect %s", dbType)`
	`47`	`+ return nil, errors.Errorf("unsupported dialect %s", dbType)`
`47`	`48`	`}`
`48`	`49`	`}`
`49`	`50`
`50`	`51`	`if m[6] == "fizz" && dbType != "all" {`
`51`		`- return nil, fmt.Errorf("invalid database type %q, expected \"all\" because fizz is database type independent", dbType)`
	`52`	`+ return nil, errors.Errorf("invalid database type %q, expected \"all\" because fizz is database type independent", dbType)`
`52`	`53`	`}`
`53`	`54`
`54`	`55`	`if m[4] == ".autocommit" {`
`55`	`56`	`autocommit = true`
`56`	`57`	`} else if m[4] != "" {`
`57`		`- return nil, fmt.Errorf("invalid autocommit flag %q", m[4])`
	`58`	`+ return nil, errors.Errorf("invalid autocommit flag %q", m[4])`
`58`	`59`	`}`
`59`	`60`
`60`	`61`	`return &match{`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ func WithTestdata(t *testing.T, testdata fs.FS) MigrationBoxOption {`
`89`	`89`	`return func(m *MigrationBox) {`
`90`	`90`	`require.NoError(t, fs.WalkDir(testdata, ".", func(path string, info fs.DirEntry, err error) error {`
`91`	`91`	`if err != nil {`
`92`		`- return err`
	`92`	`+ return errors.WithStack(err)`
`93`	`93`	`}`
`94`	`94`	`if !info.Type().IsRegular() {`
`95`	`95`	`t.Logf("skipping testdata entry that is not a file: %s", path)`
`@@ -120,13 +120,13 @@ func WithTestdata(t *testing.T, testdata fs.FS) MigrationBoxOption {`
`120`	`120`	`Runner: func(m Migration, c *pop.Connection) error {`
`121`	`121`	`b, err := fs.ReadFile(testdata, m.Path)`
`122`	`122`	`if err != nil {`
`123`		`- return err`
	`123`	`+ return errors.WithStack(err)`
`124`	`124`	`}`
`125`	`125`	`if isMigrationEmpty(string(b)) {`
`126`	`126`	`return nil`
`127`	`127`	`}`
`128`	`128`	`_, err = c.Store.SQLDB().Exec(string(b))`
`129`		`- return err`
	`129`	`+ return errors.WithStack(err)`
`130`	`130`	`},`
`131`	`131`	`})`
`132`	`132`
`@@ -230,7 +230,7 @@ func (mb *MigrationBox) findMigrations(`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`if details == nil {`
`233`		`- return errors.WithStack(fmt.Errorf("Found a migration file that does not match the file pattern: filename=%s pattern=%s", info.Name(), MigrationFileRegexp))`
	`233`	`+ return errors.Errorf("Found a migration file that does not match the file pattern: filename=%s pattern=%s", info.Name(), MigrationFileRegexp)`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`content, err := fs.ReadFile(dir, p)`
`@@ -269,7 +269,7 @@ func (mb *MigrationBox) findMigrations(`
`269`	`269`	`// Sort ascending.`
`270`	`270`	`sort.Sort(mb.migrationsUp)`
`271`	`271`
`272`		`- return err`
	`272`	`+ return errors.WithStack(err)`
`273`	`273`	`}`
`274`	`274`
`275`	`275`	`// hasDownMigrationWithVersion checks if there is a migration with the given`
`@@ -293,12 +293,12 @@ func (mb *MigrationBox) check() error {`
`293`	`293`
`294`	`294`	`for _, n := range mb.migrationsUp {`
`295`	`295`	`if err := n.Valid(); err != nil {`
`296`		`- return err`
	`296`	`+ return errors.WithStack(err)`
`297`	`297`	`}`
`298`	`298`	`}`
`299`	`299`	`for _, n := range mb.migrationsDown {`
`300`	`300`	`if err := n.Valid(); err != nil {`
`301`		`- return err`
	`301`	`+ return errors.WithStack(err)`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ import (`
`22`	`22`	`"github.com/ory/x/cmdx"`
`23`	`23`	`"github.com/ory/x/logrusx"`
`24`	`24`	`"github.com/ory/x/otelx"`
	`25`	`+ "github.com/ory/x/sqlcon"`
`25`	`26`	`)`
`26`	`27`
`27`	`28`	`const (`
`@@ -37,7 +38,7 @@ func (mb *MigrationBox) shouldNotUseTransaction(m Migration) bool {`
`37`	`38`	`// Up runs pending "up" migrations and applies them to the database.`
`38`	`39`	`func (mb *MigrationBox) Up(ctx context.Context) error {`
`39`	`40`	`_, err := mb.UpTo(ctx, 0)`
`40`		`- return err`
	`41`	`+ return errors.WithStack(err)`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`// UpTo runs up to step "up" migrations and applies them to the database.`
`@@ -83,21 +84,22 @@ func (mb *MigrationBox) UpTo(ctx context.Context, step int) (applied int, err er`
`83`	`84`	`err := conn.RawQuery(fmt.Sprintf("INSERT INTO %s (version) VALUES (?)", mtn), mi.Version).Exec()`
`84`	`85`	`return errors.Wrapf(err, "problem inserting migration version %s", mi.Version)`
`85`	`86`	`}); err != nil {`
`86`		`- return err`
	`87`	`+ return errors.WithStack(err)`
`87`	`88`	`}`
`88`	`89`	`continue`
`89`	`90`	`}`
`90`	`91`
`91`	`92`	`l.Info("Migration has not yet been applied, running migration.")`
`92`	`93`
`93`	`94`	`if err := mi.Valid(); err != nil {`
`94`		`- return err`
	`95`	`+ return errors.WithStack(err)`
`95`	`96`	`}`
`96`	`97`
`97`	`98`	`noTx := mb.shouldNotUseTransaction(mi)`
`98`	`99`	`if noTx {`
	`100`	`+ l.Info("NOT running migrations inside a transaction")`
`99`	`101`	`if err := mi.Runner(mi, c); err != nil {`
`100`		`- return err`
	`102`	`+ return errors.WithStack(err)`
`101`	`103`	`}`
`102`	`104`
`103`	`105`	`// #nosec G201 - mtn is a system-wide const`
`@@ -107,7 +109,7 @@ func (mb *MigrationBox) UpTo(ctx context.Context, step int) (applied int, err er`
`107`	`109`	`} else {`
`108`	`110`	`if err := mb.isolatedTransaction(ctx, "up", func(conn *pop.Connection) error {`
`109`	`111`	`if err := mi.Runner(mi, conn); err != nil {`
`110`		`- return err`
	`112`	`+ return errors.WithStack(err)`
`111`	`113`	`}`
`112`	`114`
`113`	`115`	`// #nosec G201 - mtn is a system-wide const`
`@@ -116,7 +118,7 @@ func (mb *MigrationBox) UpTo(ctx context.Context, step int) (applied int, err er`
`116`	`118`	`}`
`117`	`119`	`return nil`
`118`	`120`	`}); err != nil {`
`119`		`- return err`
	`121`	`+ return errors.WithStack(err)`
`120`	`122`	`}`
`121`	`123`	`}`
`122`	`124`
`@@ -133,7 +135,7 @@ func (mb *MigrationBox) UpTo(ctx context.Context, step int) (applied int, err er`
`133`	`135`	`}`
`134`	`136`	`return nil`
`135`	`137`	`})`
`136`		`- return`
	`138`	`+ return applied, errors.WithStack(err)`
`137`	`139`	`}`
`138`	`140`
`139`	`141`	`// Down runs pending "down" migrations and rolls back the`
`@@ -148,7 +150,7 @@ func (mb *MigrationBox) Down(ctx context.Context, steps int) (err error) {`
`148`	`150`	`}`
`149`	`151`
`150`	`152`	`c := mb.c.WithContext(ctx)`
`151`		`- return mb.exec(ctx, func() (err error) {`
	`153`	`+ return errors.WithStack(mb.exec(ctx, func() (err error) {`
`152`	`154`	`mtn := sanitizedMigrationTableName(c)`
`153`	`155`	`count, err := c.Count(mtn)`
`154`	`156`	`if err != nil {`
`@@ -203,7 +205,7 @@ func (mb *MigrationBox) Down(ctx context.Context, steps int) (err error) {`
`203`	`205`	`if mb.shouldNotUseTransaction(mi) {`
`204`	`206`	`err := mi.Runner(mi, c)`
`205`	`207`	`if err != nil {`
`206`		`- return err`
	`208`	`+ return errors.WithStack(err)`
`207`	`209`	`}`
`208`	`210`
`209`	`211`	`// #nosec G201 - mtn is a system-wide const`
`@@ -232,7 +234,7 @@ func (mb *MigrationBox) Down(ctx context.Context, steps int) (err error) {`
`232`	`234`	`reverted++`
`233`	`235`	`}`
`234`	`236`	`return nil`
`235`		`- })`
	`237`	`+ }))`
`236`	`238`	`}`
`237`	`239`
`238`	`240`	`func (mb MigrationBox) createTransactionalMigrationTable(ctx context.Context, c pop.Connection, l *logrusx.Logger) error {`
`@@ -243,7 +245,7 @@ func (mb *MigrationBox) createTransactionalMigrationTable(ctx context.Context, c`
`243`	`245`	fmt.Sprintf(`CREATE UNIQUE INDEX %s_version_idx ON %s (version)`, mtn, mtn),
`244`	`246`	fmt.Sprintf(`CREATE INDEX %s_version_self_idx ON %s (version_self)`, mtn, mtn),
`245`	`247`	`}); err != nil {`
`246`		`- return err`
	`248`	`+ return errors.WithStack(err)`
`247`	`249`	`}`
`248`	`250`
`249`	`251`	`l.WithField("migration_table", mtn).Debug("Transactional migration table created successfully.")`
`@@ -277,7 +279,7 @@ func (mb *MigrationBox) migrateToTransactionalMigrationTable(ctx context.Context`
`277`	`279`	`}`
`278`	`280`
`279`	`281`	`if err := mb.createMigrationStatusTableTransaction(ctx, workload...); err != nil {`
`280`		`- return err`
	`282`	`+ return errors.WithStack(err)`
`281`	`283`	`}`
`282`	`284`
`283`	`285`	`l.WithField("migration_table", mtn).Debug("Successfully migrated legacy schema_migration to new transactional schema_migration table.")`
`@@ -296,7 +298,7 @@ func (mb *MigrationBox) isolatedTransaction(ctx context.Context, direction strin`
`296`	`298`	`}`
`297`	`299`
`298`	`300`	`return Transaction(ctx, mb.c.WithContext(ctx), func(ctx context.Context, connection *pop.Connection) error {`
`299`		`- return fn(connection)`
	`301`	`+ return errors.WithStack(fn(connection))`
`300`	`302`	`})`
`301`	`303`	`}`
`302`	`304`
`@@ -319,7 +321,7 @@ func (mb *MigrationBox) createMigrationStatusTableTransaction(ctx context.Contex`
`319`	`321`	`}`
`320`	`322`	`return nil`
`321`	`323`	`}); err != nil {`
`322`		`- return err`
	`324`	`+ return errors.WithStack(err)`
`323`	`325`	`}`
`324`	`326`	`}`
`325`	`327`	`}`
`@@ -341,14 +343,14 @@ func (mb *MigrationBox) CreateSchemaMigrations(ctx context.Context) error {`
`341`	`343`	`if err != nil {`
`342`	`344`	`mb.l.WithError(err).WithField("migration_table", mtn).Debug("An error occurred while checking for the legacy migration table, maybe it does not exist yet? Trying to create.")`
`343`	`345`	`// This means that the legacy pop migrator has not yet been applied`
`344`		`- return mb.createTransactionalMigrationTable(ctx, c, mb.l)`
	`346`	`+ return errors.WithStack(mb.createTransactionalMigrationTable(ctx, c, mb.l))`
`345`	`347`	`}`
`346`	`348`
`347`	`349`	`mb.l.WithField("migration_table", mtn).Debug("A migration table exists, checking if it is a transactional migration table.")`
`348`	`350`	`_, err = c.Store.Exec(fmt.Sprintf("select version, version_self from %s", mtn))`
`349`	`351`	`if err != nil {`
`350`	`352`	`mb.l.WithError(err).WithField("migration_table", mtn).Debug("An error occurred while checking for the transactional migration table, maybe it does not exist yet? Trying to create.")`
`351`		`- return mb.migrateToTransactionalMigrationTable(ctx, c, mb.l)`
	`353`	`+ return errors.WithStack(mb.migrateToTransactionalMigrationTable(ctx, c, mb.l))`
`352`	`354`	`}`
`353`	`355`
`354`	`356`	`mb.l.WithField("migration_table", mtn).Debug("Migration tables exist and are up to date.")`
`@@ -436,7 +438,7 @@ func (mb *MigrationBox) Status(ctx context.Context) (MigrationStatuses, error) {`
`436`	`438`	`// It also means that we can ignore this state and act as if no migrations have been applied yet.`
`437`	`439`	`} else {`
`438`	`440`	`// On any other error, we fail.`
`439`		`- return nil, errors.Wrapf(err, "problem with migration")`
	`441`	`+ return nil, errors.Wrap(err, "problem with migration")`
`440`	`442`	`}`
`441`	`443`	`}`
`442`	`444`
`@@ -471,12 +473,12 @@ func (mb *MigrationBox) DumpMigrationSchema(ctx context.Context) error {`
`471`	`473`	`schema := "schema.sql"`
`472`	`474`	`f, err := os.Create(schema) //#nosec:G304) //#nosec:G304`
`473`	`475`	`if err != nil {`
`474`		`- return err`
	`476`	`+ return errors.WithStack(err)`
`475`	`477`	`}`
`476`	`478`	`err = c.Dialect.DumpSchema(f)`
`477`	`479`	`if err != nil {`
`478`	`480`	`_ = os.RemoveAll(schema)`
`479`		`- return err`
	`481`	`+ return errors.WithStack(err)`
`480`	`482`	`}`
`481`	`483`	`return nil`
`482`	`484`	`}`
`@@ -501,24 +503,24 @@ func (mb *MigrationBox) exec(ctx context.Context, fn func() error) error {`
`501`	`503`
`502`	`504`	`if mb.c.Dialect.Name() == "sqlite3" {`
`503`	`505`	`if err := mb.c.RawQuery("PRAGMA foreign_keys=OFF").Exec(); err != nil {`
`504`		`- return err`
	`506`	`+ return sqlcon.HandleError(err)`
`505`	`507`	`}`
`506`	`508`	`}`
`507`	`509`
`508`	`510`	`if mb.c.Dialect.Name() == "cockroach" {`
`509`	`511`	`outer := fn`
`510`	`512`	`fn = func() error {`
`511`		`- return crdb.Execute(outer)`
	`513`	`+ return errors.WithStack(crdb.Execute(outer))`
`512`	`514`	`}`
`513`	`515`	`}`
`514`	`516`
`515`	`517`	`if err := fn(); err != nil {`
`516`		`- return err`
	`518`	`+ return errors.WithStack(err)`
`517`	`519`	`}`
`518`	`520`
`519`	`521`	`if mb.c.Dialect.Name() == "sqlite3" {`
`520`	`522`	`if err := mb.c.RawQuery("PRAGMA foreign_keys=ON").Exec(); err != nil {`
`521`		`- return err`
	`523`	`+ return sqlcon.HandleError(err)`
`522`	`524`	`}`
`523`	`525`	`}`
`524`	`526`
Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,9 @@`
`4`	`4`	`package popx`
`5`	`5`
`6`	`6`	`import (`
`7`		`- "fmt"`
`8`	`7`	`"regexp"`
	`8`	`+`
	`9`	`+ "github.com/pkg/errors"`
`9`	`10`	`)`
`10`	`11`
`11`	`12`	`var SQLTemplateFuncs = map[string]interface{}{`
`@@ -16,7 +17,7 @@ var identifierPattern = regexp.MustCompile("^[a-zA-Z][a-zA-Z0-9_]*$")`
`16`	`17`
`17`	`18`	`func Identifier(i string) (string, error) {`
`18`	`19`	`if !identifierPattern.MatchString(i) {`
`19`		`- return "", fmt.Errorf("invalid SQL identifier '%s'", i)`
	`20`	`+ return "", errors.Errorf("invalid SQL identifier '%s'", i)`
`20`	`21`	`}`
`21`	`22`	`return i, nil`
`22`	`23`	`}`