get rid of errors package in favour of fmt

auth.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/go-pkgz/rest"
-	"github.com/pkg/errors"
 
 	"github.com/go-pkgz/auth/avatar"
 	"github.com/go-pkgz/auth/logger"
@@ -121,7 +120,7 @@ func NewService(opts Opts) (res *Service) {
 
 	if opts.SecretReader == nil {
 		jwtService.SecretReader = token.SecretFunc(func(string) (string, error) {
-			return "", errors.New("secrets reader not available")
+			return "", fmt.Errorf("secrets reader not available")
 		})
 		res.logger.Logf("[WARN] no secret reader defined")
 	}
@@ -284,7 +283,7 @@ func (s *Service) AddAppleProvider(appleConfig provider.AppleConfig, privKeyLoad
 	// Error checking at create need for catch one when apple private key init
 	appleProvider, err := provider.NewApple(p, appleConfig, privKeyLoader)
 	if err != nil {
-		return errors.Wrap(err, "an AppleProvider creating failed")
+		return fmt.Errorf("an AppleProvider creating failed: %w", err)
 	}
 
 	s.providers = append(s.providers, provider.NewService(appleProvider))
@@ -365,7 +364,7 @@ func (s *Service) AddCustomHandler(handler provider.Provider) {
 func (s *Service) DevAuth() (*provider.DevAuthServer, error) {
 	p, err := s.Provider("dev") // peak dev provider
 	if err != nil {
-		return nil, errors.Wrap(err, "dev provider not registered")
+		return nil, fmt.Errorf("dev provider not registered: %w", err)
 	}
 	// make and start dev auth server
 	return &provider.DevAuthServer{Provider: p.Provider.(provider.Oauth2Handler), L: s.logger}, nil
@@ -378,7 +377,7 @@ func (s *Service) Provider(name string) (provider.Service, error) {
 			return p, nil
 		}
 	}
-	return provider.Service{}, errors.Errorf("provider %s not found", name)
+	return provider.Service{}, fmt.Errorf("provider %s not found", name)
 }
 
 // Providers gets all registered providers

avatar/avatar.go

@@ -17,7 +17,6 @@ import (
 
 	"github.com/go-pkgz/rest"
 	"github.com/nullrocks/identicon"
-	"github.com/pkg/errors"
 	"golang.org/x/image/draw"
 
 	"github.com/go-pkgz/auth/logger"
@@ -40,7 +39,7 @@ func (p *Proxy) Put(u token.User, client *http.Client) (avatarURL string, err er
 	genIdenticon := func(userID string) (avatarURL string, err error) {
 		b, e := GenerateAvatar(userID)
 		if e != nil {
-			return "", errors.Wrapf(e, "no picture for %s", userID)
+			return "", fmt.Errorf("no picture for %s: %w", userID, e)
 		}
 		// put returns avatar base name, like 123456.image
 		avatarID, e := p.Store.Put(userID, p.resize(bytes.NewBuffer(b), p.ResizeLimit))
@@ -88,12 +87,12 @@ func (p *Proxy) load(url string, client *http.Client) (rc io.ReadCloser, err err
 		return e
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to fetch avatar from the orig")
+		return nil, fmt.Errorf("failed to fetch avatar from the orig: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
 		_ = resp.Body.Close() // caller won't close on error
-		return nil, errors.Errorf("failed to get avatar from the orig, status %s", resp.Status)
+		return nil, fmt.Errorf("failed to get avatar from the orig, status %s", resp.Status)
 	}
 
 	return resp.Body, nil
@@ -193,12 +192,12 @@ func GenerateAvatar(user string) ([]byte, error) {
 
 	iconGen, err := identicon.New("pkgz/auth", 5, 5)
 	if err != nil {
-		return nil, errors.Wrap(err, "can't create identicon service")
+		return nil, fmt.Errorf("can't create identicon service: %w", err)
 	}
 
 	ii, err := iconGen.Draw(user) // generate an IdentIcon
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to draw avatar for %s", user)
+		return nil, fmt.Errorf("failed to draw avatar for %s: %w", user, err)
 	}
 
 	buf := &bytes.Buffer{}
@@ -220,7 +219,7 @@ func GetGravatarURL(email string) (res string, err error) {
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != 200 {
-		return "", errors.New(resp.Status)
+		return "", fmt.Errorf("%s", resp.Status)
 	}
 	return res, nil
 }
@@ -232,5 +231,8 @@ func retry(retries int, delay time.Duration, fn func() error) (err error) {
 		}
 		time.Sleep(delay)
 	}
-	return errors.Wrap(err, "retry failed")
+	if err != nil {
+		return fmt.Errorf("retry failed: %w", err)
+	}
+	return nil
 }

avatar/avatar_test.go

@@ -2,7 +2,6 @@ package avatar
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"image"
 	"io"
@@ -243,7 +242,7 @@ func TestAvatar_GetGravatarURL(t *testing.T) {
 		url   string
 	}{
 		{"eefretsoul@gmail.com", nil, "https://www.gravatar.com/avatar/c82739de14cf64affaf30856ca95b851.jpg"},
-		{"umputun-xyz@example.com", errors.New("404 Not Found"), ""},
+		{"umputun-xyz@example.com", fmt.Errorf("404 Not Found"), ""},
 	}
 
 	for i, tt := range tbl {
@@ -267,14 +266,14 @@ func TestAvatar_Retry(t *testing.T) {
 			return nil
 		}
 		i++
-		return errors.New("err")
+		return fmt.Errorf("err")
 	})
 	assert.Nil(t, err)
 	assert.Equal(t, 3, i)
 
 	st := time.Now()
 	err = retry(5, time.Millisecond, func() error {
-		return errors.New("err")
+		return fmt.Errorf("err")
 	})
 	assert.NotNil(t, err)
 	assert.True(t, time.Since(st) >= time.Microsecond*5)

avatar/bolt.go

@@ -6,7 +6,6 @@ import (
 	"io"
 	"log"
 
-	"github.com/pkg/errors"
 	bolt "go.etcd.io/bbolt"
 )
 
@@ -25,17 +24,19 @@ const metasBktName = "metas"
 func NewBoltDB(fileName string, options bolt.Options) (*BoltDB, error) {
 	db, err := bolt.Open(fileName, 0600, &options) //nolint
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to make boltdb for %s", fileName)
+		return nil, fmt.Errorf("failed to make boltdb for %s: %w", fileName, err)
 	}
 	err = db.Update(func(tx *bolt.Tx) error {
 		if _, e := tx.CreateBucketIfNotExists([]byte(avatarsBktName)); e != nil {
-			return errors.Wrapf(e, "failed to create top level bucket %s", avatarsBktName)
+			return fmt.Errorf("failed to create top level bucket %s: %w", avatarsBktName, e)
 		}
-		_, e := tx.CreateBucketIfNotExists([]byte(metasBktName))
-		return errors.Wrapf(e, "failed to create top metas bucket %s", metasBktName)
+		if _, e := tx.CreateBucketIfNotExists([]byte(metasBktName)); e != nil {
+			return fmt.Errorf("failed to create top metas bucket %s: %w", metasBktName, e)
+		}
+		return nil
 	})
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to initialize boltdb db %q buckets", fileName)
+		return nil, fmt.Errorf("failed to initialize boltdb db %q buckets: %w", fileName, err)
 	}
 	return &BoltDB{db: db, fileName: fileName}, nil
 }
@@ -48,11 +49,11 @@ func (b *BoltDB) Put(userID string, reader io.Reader) (avatar string, err error)
 	err = b.db.Update(func(tx *bolt.Tx) error {
 		buf := &bytes.Buffer{}
 		if _, err = io.Copy(buf, reader); err != nil {
-			return errors.Wrapf(err, "can't read avatar %s", avatarID)
+			return fmt.Errorf("can't read avatar %s: %w", avatarID, err)
 		}
 
 		if err = tx.Bucket([]byte(avatarsBktName)).Put([]byte(avatarID), buf.Bytes()); err != nil {
-			return errors.Wrapf(err, "can't put to bucket with %s", avatarID)
+			return fmt.Errorf("can't put to bucket with %s: %w", avatarID, err)
 		}
 		// store sha1 of the image
 		return tx.Bucket([]byte(metasBktName)).Put([]byte(avatarID), []byte(hash(buf.Bytes(), avatarID)))
@@ -66,10 +67,13 @@ func (b *BoltDB) Get(avatarID string) (reader io.ReadCloser, size int, err error
 	err = b.db.View(func(tx *bolt.Tx) error {
 		data := tx.Bucket([]byte(avatarsBktName)).Get([]byte(avatarID))
 		if data == nil {
-			return errors.Errorf("can't load avatar %s", avatarID)
+			return fmt.Errorf("can't load avatar %s", avatarID)
 		}
 		size, err = buf.Write(data)
-		return errors.Wrapf(err, "failed to write for %s", avatarID)
+		if err != nil {
+			return fmt.Errorf("failed to write for %s: %w", avatarID, err)
+		}
+		return nil
 	})
 	return io.NopCloser(buf), size, err
 }
@@ -79,7 +83,7 @@ func (b *BoltDB) ID(avatarID string) (id string) {
 	data := []byte{}
 	err := b.db.View(func(tx *bolt.Tx) error {
 		if data = tx.Bucket([]byte(metasBktName)).Get([]byte(avatarID)); data == nil {
-			return errors.Errorf("can't load avatar's id for %s", avatarID)
+			return fmt.Errorf("can't load avatar's id for %s", avatarID)
 		}
 		return nil
 	})
@@ -97,13 +101,15 @@ func (b *BoltDB) Remove(avatarID string) (err error) {
 	return b.db.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket([]byte(avatarsBktName))
 		if bkt.Get([]byte(avatarID)) == nil {
-			return errors.Errorf("avatar key not found, %s", avatarID)
+			return fmt.Errorf("avatar key not found, %s", avatarID)
 		}
 		if err = tx.Bucket([]byte(avatarsBktName)).Delete([]byte(avatarID)); err != nil {
-			return errors.Wrapf(err, "can't delete avatar object %s", avatarID)
+			return fmt.Errorf("can't delete avatar object %s: %w", avatarID, err)
+		}
+		if err = tx.Bucket([]byte(metasBktName)).Delete([]byte(avatarID)); err != nil {
+			return fmt.Errorf("can't delete meta object %s: %w", avatarID, err)
 		}
-		return errors.Wrapf(tx.Bucket([]byte(metasBktName)).Delete([]byte(avatarID)),
-			"can't delete meta object %s", avatarID)
+		return nil
 	})
 }
 
@@ -116,12 +122,18 @@ func (b *BoltDB) List() (ids []string, err error) {
 			return nil
 		})
 	})
-	return ids, errors.Wrap(err, "failed to list")
+	if err != nil {
+		return nil, fmt.Errorf("failed to list: %w", err)
+	}
+	return ids, nil
 }
 
 // Close bolt store
 func (b *BoltDB) Close() error {
-	return errors.Wrapf(b.db.Close(), "failed to close %s", b.fileName)
+	if err := b.db.Close(); err != nil {
+		return fmt.Errorf("failed to close %s: %w", b.fileName, err)
+	}
+	return nil
 }
 
 func (b *BoltDB) String() string {

avatar/gridfs.go

@@ -7,7 +7,6 @@ import (
 	"io"
 	"time"
 
-	"github.com/pkg/errors"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -38,7 +37,7 @@ func (gf *GridFS) Put(userID string, reader io.Reader) (avatar string, err error
 
 	buf := &bytes.Buffer{}
 	if _, err = io.Copy(buf, reader); err != nil {
-		return "", errors.Wrapf(err, "can't read avatar for %s", userID)
+		return "", fmt.Errorf("can't read avatar for %s: %w", userID, err)
 	}
 
 	avaHash := hash(buf.Bytes(), id)
@@ -54,7 +53,10 @@ func (gf *GridFS) Get(avatar string) (reader io.ReadCloser, size int, err error)
 	}
 	buf := &bytes.Buffer{}
 	sz, e := bucket.DownloadToStreamByName(avatar, buf)
-	return io.NopCloser(buf), int(sz), errors.Wrapf(e, "can't read avatar %s", avatar)
+	if e != nil {
+		return nil, 0, fmt.Errorf("can't read avatar %s: %w", avatar, e)
+	}
+	return io.NopCloser(buf), int(sz), nil
 }
 
 //
@@ -112,7 +114,7 @@ func (gf *GridFS) Remove(avatar string) error {
 		}
 		return bucket.Delete(r.ID)
 	}
-	return errors.Errorf("avatar %s not found", avatar)
+	return fmt.Errorf("avatar %s not found", avatar)
 }
 
 // List all avatars (ids) on gfs

avatar/localfs.go

@@ -10,8 +10,6 @@ import (
 	"strconv"
 	"strings"
 	"sync"
-
-	"github.com/pkg/errors"
 )
 
 // LocalFS implements Store for local file system
@@ -30,28 +28,28 @@ func NewLocalFS(storePath string) *LocalFS {
 // userID can be avatarID as well, in this case encoding just strip .image prefix
 func (fs *LocalFS) Put(userID string, reader io.Reader) (avatar string, err error) {
 	if reader == nil {
-		return "", errors.New("empty reader")
+		return "", fmt.Errorf("empty reader")
 	}
 	id := encodeID(userID)
 	location := fs.location(id) // location adds partition to path
 
 	if e := os.MkdirAll(location, 0o750); e != nil {
-		return "", errors.Wrapf(e, "failed to mkdir avatar location %s", location)
+		return "", fmt.Errorf("failed to mkdir avatar location %s: %w", location, e)
 	}
 
 	avFile := path.Join(location, id+imgSfx)
 	fh, err := os.Create(avFile) //nolint
 	if err != nil {
-		return "", errors.Wrapf(err, "can't create file %s", avFile)
+		return "", fmt.Errorf("can't create file %s: %w", avFile, err)
 	}
 	defer func() { //nolint
 		if e := fh.Close(); e != nil {
-			err = errors.Wrapf(err, "can't close avatar file %s", avFile)
+			err = fmt.Errorf("can't close avatar file %s: %w", avFile, e)
 		}
 	}()
 
 	if _, err = io.Copy(fh, reader); err != nil {
-		return "", errors.Wrapf(err, "can't save file %s", avFile)
+		return "", fmt.Errorf("can't save file %s: %w", avFile, err)
 	}
 	return id + imgSfx, nil
 }
@@ -61,7 +59,7 @@ func (fs *LocalFS) Get(avatar string) (reader io.ReadCloser, size int, err error
 	location := fs.location(strings.TrimSuffix(avatar, imgSfx))
 	fh, err := os.Open(path.Join(location, avatar)) //nolint
 	if err != nil {
-		return nil, 0, errors.Wrapf(err, "can't load avatar %s, id", avatar)
+		return nil, 0, fmt.Errorf("can't load avatar %s, id: %w", avatar, err)
 	}
 	if fi, e := fh.Stat(); e == nil {
 		size = int(fi.Size())
@@ -100,7 +98,10 @@ func (fs *LocalFS) List() (ids []string, err error) {
 			}
 			return nil
 		})
-	return ids, errors.Wrap(err, "can't list avatars")
+	if err != nil {
+		return nil, fmt.Errorf("can't list avatars: %w", err)
+	}
+	return ids, nil
 }
 
 // Close gridfs does nothing but satisfies interface

avatar/localfs_test.go

@@ -68,7 +68,6 @@ func TestAvatarStoreFS_Get(t *testing.T) {
 
 	// file not exists
 	r, size, err := p.Get("some_random_name.image")
-	// nil, 0, errors.Wrapf(err, "can't load avatar %s, id")
 	assert.Nil(t, r)
 	assert.Equal(t, 0, size)
 	assert.EqualError(t, err, "can't load avatar some_random_name.image, id: open /tmp/avatars.test/91/some_random_name.image: no such file or directory")