ICU-744/Refactor internal/target to new domain errors (#865)

* Refactor internal/target to new domain errors

internal/target/ids.go

@@ -1,9 +1,8 @@
 package target
 
 import (
-	"fmt"
-
 	"github.com/hashicorp/boundary/internal/db"
+	"github.com/hashicorp/boundary/internal/errors"
 )
 
 const (
@@ -11,9 +10,10 @@ const (
 )
 
 func newTcpTargetId() (string, error) {
+	const op = "target.newTcpTargetId"
 	id, err := db.NewPublicId(TcpTargetPrefix)
 	if err != nil {
-		return "", fmt.Errorf("new tcp target id: %w", err)
+		return "", errors.Wrap(err, op)
 	}
 	return id, nil
 }

internal/target/repository.go

@@ -2,7 +2,6 @@ package target
 
 import (
 	"context"
-	stderrors "errors"
 	"fmt"
 	"strings"
 
@@ -12,8 +11,6 @@ import (
 	"github.com/hashicorp/boundary/internal/oplog"
 )
 
-var ErrMetadataScopeNotFound = stderrors.New("scope not found for metadata")
-
 // Clonable provides a cloning interface
 type Cloneable interface {
 	Clone() interface{}
@@ -32,14 +29,15 @@ type Repository struct {
 // NewRepository creates a new target Repository. Supports the options: WithLimit
 // which sets a default limit on results returned by repo operations.
 func NewRepository(r db.Reader, w db.Writer, kms *kms.Kms, opt ...Option) (*Repository, error) {
+	const op = "target.NewRepository"
 	if r == nil {
-		return nil, stderrors.New("error creating db repository with nil reader")
+		return nil, errors.New(errors.InvalidParameter, op, "nil reader")
 	}
 	if w == nil {
-		return nil, stderrors.New("error creating db repository with nil writer")
+		return nil, errors.New(errors.InvalidParameter, op, "nil writer")
 	}
 	if kms == nil {
-		return nil, stderrors.New("error creating db repository with nil kms")
+		return nil, errors.New(errors.InvalidParameter, op, "nil kms")
 	}
 	opts := getOpts(opt...)
 	if opts.withLimit == 0 {
@@ -58,10 +56,11 @@ func NewRepository(r db.Reader, w db.Writer, kms *kms.Kms, opt ...Option) (*Repo
 // with its host set ids.  If the target is not found, it will return nil, nil, nil.
 // No options are currently supported.
 func (r *Repository) LookupTarget(ctx context.Context, publicIdOrName string, opt ...Option) (Target, []*TargetSet, error) {
+	const op = "target.(Repository).LookupTarget"
 	opts := getOpts(opt...)
 
 	if publicIdOrName == "" {
-		return nil, nil, fmt.Errorf("lookup target: missing private id: %w", errors.ErrInvalidParameter)
+		return nil, nil, errors.New(errors.InvalidParameter, op, "missing public id")
 	}
 
 	var where []string
@@ -71,27 +70,27 @@ func (r *Repository) LookupTarget(ctx context.Context, publicIdOrName string, op
 	scopeNameEmpty := opts.withScopeName == ""
 	if !nameEmpty {
 		if opts.withName != publicIdOrName {
-			return nil, nil, fmt.Errorf("lookup target: name passed in but does not match publicId: %w", errors.ErrInvalidParameter)
+			return nil, nil, errors.New(errors.InvalidParameter, op, "name passed in but does not match publicId")
 		}
 		where, whereArgs = append(where, "lower(name) = lower(?)"), append(whereArgs, opts.withName)
 		switch {
 		case scopeIdEmpty && scopeNameEmpty:
-			return nil, nil, fmt.Errorf("lookup target: using name but both scope ID and scope name are empty: %w", errors.ErrInvalidParameter)
+			return nil, nil, errors.New(errors.InvalidParameter, op, "using name but both scope ID and scope name are empty")
 		case !scopeIdEmpty && !scopeNameEmpty:
-			return nil, nil, fmt.Errorf("lookup target: using name but both scope ID and scope name are set: %w", errors.ErrInvalidParameter)
+			return nil, nil, errors.New(errors.InvalidParameter, op, "using name but both scope ID and scope name are set")
 		case !scopeIdEmpty:
 			where, whereArgs = append(where, "scope_id = ?"), append(whereArgs, opts.withScopeId)
 		case !scopeNameEmpty:
 			where, whereArgs = append(where, "scope_id = (select public_id from iam_scope where lower(name) = lower(?))"), append(whereArgs, opts.withScopeName)
 		default:
-			return nil, nil, fmt.Errorf("lookup target: unknown combination of parameters: %w", errors.ErrInvalidParameter)
+			return nil, nil, errors.New(errors.InvalidParameter, op, "unknown combination of parameters")
 		}
 	} else {
 		switch {
 		case !scopeIdEmpty:
-			return nil, nil, fmt.Errorf("lookup target: passed in scope ID when using target ID for lookup: %w", errors.ErrInvalidParameter)
+			return nil, nil, errors.New(errors.InvalidParameter, op, "passed in scope ID when using target ID for lookup")
 		case !scopeNameEmpty:
-			return nil, nil, fmt.Errorf("lookup target: passed in scope name when using target ID for lookup: %w", errors.ErrInvalidParameter)
+			return nil, nil, errors.New(errors.InvalidParameter, op, "passed in scope name when using target ID for lookup")
 		}
 	}
 
@@ -112,11 +111,11 @@ func (r *Repository) LookupTarget(ctx context.Context, publicIdOrName string, op
 				lookupErr = read.LookupWhere(ctx, &target, strings.Join(where, " and "), whereArgs...)
 			}
 			if lookupErr != nil {
-				return fmt.Errorf("failed %w for %s", lookupErr, publicIdOrName)
+				return errors.Wrap(lookupErr, op, errors.WithMsg(fmt.Sprintf("failed for %s", publicIdOrName)))
 			}
 			var err error
 			if hostSets, err = fetchSets(ctx, read, target.PublicId); err != nil {
-				return err
+				return errors.Wrap(err, op)
 			}
 			return nil
 		},
@@ -125,19 +124,20 @@ func (r *Repository) LookupTarget(ctx context.Context, publicIdOrName string, op
 		if errors.IsNotFoundError(err) {
 			return nil, nil, nil
 		}
-		return nil, nil, fmt.Errorf("lookup target: %w", err)
+		return nil, nil, errors.Wrap(err, op)
 	}
 	subType, err := target.targetSubType()
 	if err != nil {
-		return nil, nil, fmt.Errorf("lookup target: %w", err)
+		return nil, nil, errors.Wrap(err, op)
 	}
 	return subType, hostSets, nil
 }
 
 func fetchSets(ctx context.Context, r db.Reader, targetId string) ([]*TargetSet, error) {
+	const op = "target.fetchSets"
 	var hostSets []*TargetSet
 	if err := r.SearchWhere(ctx, &hostSets, "target_id = ?", []interface{}{targetId}); err != nil {
-		return nil, fmt.Errorf("fetch host sets: %w", err)
+		return nil, errors.Wrap(err, op)
 	}
 	if len(hostSets) == 0 {
 		return nil, nil
@@ -147,9 +147,10 @@ func fetchSets(ctx context.Context, r db.Reader, targetId string) ([]*TargetSet,
 
 // ListTargets in targets in a scope.  Supports the WithScopeId, WithLimit, WithTargetType options.
 func (r *Repository) ListTargets(ctx context.Context, opt ...Option) ([]Target, error) {
+	const op = "target.(Repository).ListTargets"
 	opts := getOpts(opt...)
 	if opts.withScopeId == "" && opts.withUserId == "" {
-		return nil, fmt.Errorf("list targets: must specify either a scope id or user id: %w", errors.ErrInvalidParameter)
+		return nil, errors.New(errors.InvalidParameter, op, "must specify either a scope id or user id")
 	}
 	// TODO (jimlambrt 8/2020) - implement WithUserId() optional filtering.
 	var where []string
@@ -164,7 +165,7 @@ func (r *Repository) ListTargets(ctx context.Context, opt ...Option) ([]Target,
 	var foundTargets []*targetView
 	err := r.list(ctx, &foundTargets, strings.Join(where, " and "), args, opt...)
 	if err != nil {
-		return nil, fmt.Errorf("list targets: %w", err)
+		return nil, errors.Wrap(err, op)
 	}
 
 	targets := make([]Target, 0, len(foundTargets))
@@ -172,7 +173,7 @@ func (r *Repository) ListTargets(ctx context.Context, opt ...Option) ([]Target,
 	for _, t := range foundTargets {
 		subType, err := t.targetSubType()
 		if err != nil {
-			return nil, fmt.Errorf("list targets: %w", err)
+			return nil, errors.Wrap(err, op)
 		}
 		targets = append(targets, subType)
 	}
@@ -182,6 +183,7 @@ func (r *Repository) ListTargets(ctx context.Context, opt ...Option) ([]Target,
 // list will return a listing of resources and honor the WithLimit option or the
 // repo defaultLimit
 func (r *Repository) list(ctx context.Context, resources interface{}, where string, args []interface{}, opt ...Option) error {
+	const op = "target.(Repository).list"
 	opts := getOpts(opt...)
 	limit := r.defaultLimit
 	var dbOpts []db.Option
@@ -190,18 +192,22 @@ func (r *Repository) list(ctx context.Context, resources interface{}, where stri
 		limit = opts.withLimit
 	}
 	dbOpts = append(dbOpts, db.WithLimit(limit))
-	return r.reader.SearchWhere(ctx, resources, where, args, dbOpts...)
+	if err := r.reader.SearchWhere(ctx, resources, where, args, dbOpts...); err != nil {
+		return errors.Wrap(err, op)
+	}
+	return nil
 }
 
 // DeleteTarget will delete a target from the repository.
-func (r *Repository) DeleteTarget(ctx context.Context, publicId string, opt ...Option) (int, error) {
+func (r *Repository) DeleteTarget(ctx context.Context, publicId string, _ ...Option) (int, error) {
+	const op = "target.(Repository).DeleteTarget"
 	if publicId == "" {
-		return db.NoRowsAffected, fmt.Errorf("delete target: missing public id %w", errors.ErrInvalidParameter)
+		return db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing public id")
 	}
 	t := allocTargetView()
 	t.PublicId = publicId
 	if err := r.reader.LookupByPublicId(ctx, &t); err != nil {
-		return db.NoRowsAffected, fmt.Errorf("delete target: failed %w for %s", err, publicId)
+		return db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg(fmt.Sprintf("failed for %s", publicId)))
 	}
 	var metadata oplog.Metadata
 	var deleteTarget interface{}
@@ -212,12 +218,12 @@ func (r *Repository) DeleteTarget(ctx context.Context, publicId string, opt ...O
 		deleteTarget = &tcpT
 		metadata = tcpT.oplog(oplog.OpType_OP_TYPE_DELETE)
 	default:
-		return db.NoRowsAffected, fmt.Errorf("delete target: %s is an unsupported target type %s", publicId, t.Type)
+		return db.NoRowsAffected, errors.New(errors.InvalidParameter, op, fmt.Sprintf("%s is an unsupported target type %s", publicId, t.Type))
 	}
 
 	oplogWrapper, err := r.kms.GetWrapper(ctx, t.ScopeId, kms.KeyPurposeOplog)
 	if err != nil {
-		return db.NoRowsAffected, fmt.Errorf("delete target: unable to get oplog wrapper: %w", err)
+		return db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg("unable to get oplog wrapper"))
 	}
 
 	var rowsDeleted int
@@ -233,28 +239,35 @@ func (r *Repository) DeleteTarget(ctx context.Context, publicId string, opt ...O
 				deleteResource,
 				db.WithOplog(oplogWrapper, metadata),
 			)
-			if err == nil && rowsDeleted > 1 {
-				// return err, which will result in a rollback of the delete
-				return errors.ErrMultipleRecords
+			if err != nil {
+				return errors.Wrap(err, op)
 			}
-			return err
+			if rowsDeleted > 1 {
+				// return err, which will result in a rollback of the delete
+				return errors.New(errors.MultipleRecords, op, "more than 1 resource would have been deleted")
+			}
+			return nil
 		},
 	)
-	return rowsDeleted, err
+	if err != nil {
+		return db.NoRowsAffected, errors.Wrap(err, op)
+	}
+	return rowsDeleted, nil
 }
 
 // update a target in the db repository with an oplog entry.
 // It currently supports no options.
-func (r *Repository) update(ctx context.Context, target Target, version uint32, fieldMaskPaths []string, setToNullPaths []string, opt ...Option) (Target, []*TargetSet, int, error) {
+func (r *Repository) update(ctx context.Context, target Target, version uint32, fieldMaskPaths []string, setToNullPaths []string, _ ...Option) (Target, []*TargetSet, int, error) {
+	const op = "target.(Repository).update"
 	if version == 0 {
-		return nil, nil, db.NoRowsAffected, fmt.Errorf("update: version cannot be zero: %w", errors.ErrInvalidParameter)
+		return nil, nil, db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing version")
 	}
 	if target == nil {
-		return nil, nil, db.NoRowsAffected, fmt.Errorf("update: target is nil: %w", errors.ErrInvalidParameter)
+		return nil, nil, db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "nil target")
 	}
 	cloner, ok := target.(Cloneable)
 	if !ok {
-		return nil, nil, db.NoRowsAffected, fmt.Errorf("update: target is not Cloneable: %w", errors.ErrInvalidParameter)
+		return nil, nil, db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "target is not cloneable")
 	}
 	dbOpts := []db.Option{
 		db.WithVersion(&version),
@@ -264,13 +277,13 @@ func (r *Repository) update(ctx context.Context, target Target, version uint32,
 		t := allocTargetView()
 		t.PublicId = target.GetPublicId()
 		if err := r.reader.LookupByPublicId(ctx, &t); err != nil {
-			return nil, nil, db.NoRowsAffected, fmt.Errorf("update: lookup failed %w for %s", err, t.PublicId)
+			return nil, nil, db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg(fmt.Sprintf("lookup failed for %s", t.PublicId)))
 		}
 		scopeId = t.ScopeId
 	}
 	oplogWrapper, err := r.kms.GetWrapper(ctx, scopeId, kms.KeyPurposeOplog)
 	if err != nil {
-		return nil, nil, db.NoRowsAffected, fmt.Errorf("unable to get oplog wrapper: %w", err)
+		return nil, nil, db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg("unable to get oplog wrapper"))
 	}
 	metadata := target.oplog(oplog.OpType_OP_TYPE_UPDATE)
 	dbOpts = append(dbOpts, db.WithOplog(oplogWrapper, metadata))
@@ -292,20 +305,23 @@ func (r *Repository) update(ctx context.Context, target Target, version uint32,
 				dbOpts...,
 			)
 			if err != nil {
-				return err
+				return errors.Wrap(err, op)
 			}
-			if err == nil && rowsUpdated > 1 {
+			if rowsUpdated > 1 {
 				// return err, which will result in a rollback of the update
-				return fmt.Errorf("error more than 1 target would have been updated: %w", errors.ErrMultipleRecords)
+				return errors.New(errors.MultipleRecords, op, "more than 1 resource would have been updated")
 			}
-			var err error
+
 			if hostSets, err = fetchSets(ctx, reader, target.GetPublicId()); err != nil {
-				return err
+				return errors.Wrap(err, op)
 			}
-			return err
+			return nil
 		},
 	)
-	return returnedTarget.(Target), hostSets, rowsUpdated, err
+	if err != nil {
+		return nil, nil, db.NoRowsAffected, errors.Wrap(err, op)
+	}
+	return returnedTarget.(Target), hostSets, rowsUpdated, nil
 }
 
 // AddTargetHostSets provides the ability to add host sets (hostSetIds) to a
@@ -313,28 +329,29 @@ func (r *Repository) update(ctx context.Context, target Target, version uint32,
 // targetVersion or an error will be returned.   The target and a list of
 // current host set ids will be returned on success. Zero is not a valid value
 // for the WithVersion option and will return an error.
-func (r *Repository) AddTargetHostSets(ctx context.Context, targetId string, targetVersion uint32, hostSetIds []string, opt ...Option) (Target, []*TargetSet, error) {
+func (r *Repository) AddTargetHostSets(ctx context.Context, targetId string, targetVersion uint32, hostSetIds []string, _ ...Option) (Target, []*TargetSet, error) {
+	const op = "target.(Repository).AddTargetHostSets"
 	if targetId == "" {
-		return nil, nil, fmt.Errorf("add target host sets: missing target id: %w", errors.ErrInvalidParameter)
+		return nil, nil, errors.New(errors.InvalidParameter, op, "missing target id")
 	}
 	if targetVersion == 0 {
-		return nil, nil, fmt.Errorf("add target host sets: version cannot be zero: %w", errors.ErrInvalidParameter)
+		return nil, nil, errors.New(errors.InvalidParameter, op, "missing version")
 	}
 	if len(hostSetIds) == 0 {
-		return nil, nil, fmt.Errorf("add target host sets: missing host set ids: %w", errors.ErrInvalidParameter)
+		return nil, nil, errors.New(errors.InvalidParameter, op, "missing host set ids")
 	}
 	newHostSets := make([]interface{}, 0, len(hostSetIds))
 	for _, id := range hostSetIds {
 		ths, err := NewTargetHostSet(targetId, id)
 		if err != nil {
-			return nil, nil, fmt.Errorf("add target host sets: unable to create in memory target host set: %w", err)
+			return nil, nil, errors.Wrap(err, op, errors.WithMsg("unable to create in memory target host set"))
 		}
 		newHostSets = append(newHostSets, ths)
 	}
 	t := allocTargetView()
 	t.PublicId = targetId
 	if err := r.reader.LookupByPublicId(ctx, &t); err != nil {
-		return nil, nil, fmt.Errorf("add target host sets: failed %w for %s", err, targetId)
+		return nil, nil, errors.Wrap(err, op, errors.WithMsg(fmt.Sprintf("failed for %s", targetId)))
 	}
 	var metadata oplog.Metadata
 	var target interface{}
@@ -347,11 +364,11 @@ func (r *Repository) AddTargetHostSets(ctx context.Context, targetId string, tar
 		metadata = tcpT.oplog(oplog.OpType_OP_TYPE_UPDATE)
 		metadata["op-type"] = append(metadata["op-type"], oplog.OpType_OP_TYPE_CREATE.String())
 	default:
-		return nil, nil, fmt.Errorf("delete target host sets: %s is an unsupported target type %s", t.PublicId, t.Type)
+		return nil, nil, errors.New(errors.InvalidParameter, op, fmt.Sprintf("%s is an unsupported target type %s", t.PublicId, t.Type))
 	}
 	oplogWrapper, err := r.kms.GetWrapper(ctx, t.GetScopeId(), kms.KeyPurposeOplog)
 	if err != nil {
-		return nil, nil, fmt.Errorf("add target host sets: unable to get oplog wrapper: %w", err)
+		return nil, nil, errors.Wrap(err, op, errors.WithMsg("unable to get oplog wrapper"))
 	}
 	var currentHostSets []*TargetSet
 	var updatedTarget interface{}
@@ -363,37 +380,37 @@ func (r *Repository) AddTargetHostSets(ctx context.Context, targetId string, tar
 			msgs := make([]*oplog.Message, 0, 2)
 			targetTicket, err := w.GetTicket(target)
 			if err != nil {
-				return fmt.Errorf("add target host sets: unable to get ticket: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to get ticket"))
 			}
 			updatedTarget = target.(Cloneable).Clone()
 			var targetOplogMsg oplog.Message
 			rowsUpdated, err := w.Update(ctx, updatedTarget, []string{"Version"}, nil, db.NewOplogMsg(&targetOplogMsg), db.WithVersion(&targetVersion))
 			if err != nil {
-				return fmt.Errorf("add target host sets: unable to update target version: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to update target version"))
 			}
 			if rowsUpdated != 1 {
-				return fmt.Errorf("add target host sets: updated target and %d rows updated", rowsUpdated)
+				return errors.New(errors.MultipleRecords, op, fmt.Sprintf("updated target and %d rows updated", rowsUpdated))
 			}
 			msgs = append(msgs, &targetOplogMsg)
 
 			hostSetsOplogMsgs := make([]*oplog.Message, 0, len(newHostSets))
 			if err := w.CreateItems(ctx, newHostSets, db.NewOplogMsgs(&hostSetsOplogMsgs)); err != nil {
-				return fmt.Errorf("add target host sets: unable to add target host sets: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to add target host sets"))
 			}
 			msgs = append(msgs, hostSetsOplogMsgs...)
 
 			if err := w.WriteOplogEntryWith(ctx, oplogWrapper, targetTicket, metadata, msgs); err != nil {
-				return fmt.Errorf("add target host sets: unable to write oplog: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to write oplog"))
 			}
 			currentHostSets, err = fetchSets(ctx, reader, targetId)
 			if err != nil {
-				return fmt.Errorf("add target host sets: unable to retrieve current host sets after adds: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to retrieve current host sets after adds"))
 			}
 			return nil
 		},
 	)
 	if err != nil {
-		return nil, nil, fmt.Errorf("add target host sets: error creating sets: %w", err)
+		return nil, nil, errors.Wrap(err, op, errors.WithMsg("error creating sets"))
 	}
 	return updatedTarget.(Target), currentHostSets, nil
 }
@@ -402,21 +419,22 @@ func (r *Repository) AddTargetHostSets(ctx context.Context, targetId string, tar
 // current db version must match the targetVersion or an error will be returned.
 // Zero is not a valid value for the WithVersion option and will return an
 // error.
-func (r *Repository) DeleteTargeHostSets(ctx context.Context, targetId string, targetVersion uint32, hostSetIds []string, opt ...Option) (int, error) {
+func (r *Repository) DeleteTargeHostSets(ctx context.Context, targetId string, targetVersion uint32, hostSetIds []string, _ ...Option) (int, error) {
+	const op = "target.(Repository).DeleteTargeHostSets"
 	if targetId == "" {
-		return db.NoRowsAffected, fmt.Errorf("delete target host sets: missing target id: %w", errors.ErrInvalidParameter)
+		return db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing target id")
 	}
 	if targetVersion == 0 {
-		return db.NoRowsAffected, fmt.Errorf("delete target host sets: version cannot be zero: %w", errors.ErrInvalidParameter)
+		return db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing version")
 	}
 	if len(hostSetIds) == 0 {
-		return db.NoRowsAffected, fmt.Errorf("delete target host sets: missing host set ids: %w", errors.ErrInvalidParameter)
+		return db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing host set ids")
 	}
 	deleteTargeHostSets := make([]interface{}, 0, len(hostSetIds))
 	for _, id := range hostSetIds {
 		ths, err := NewTargetHostSet(targetId, id)
 		if err != nil {
-			return db.NoRowsAffected, fmt.Errorf("delete target host sets: unable to create in memory target host set: %w", err)
+			return db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg("unable to create in memory target host set"))
 		}
 		deleteTargeHostSets = append(deleteTargeHostSets, ths)
 	}
@@ -424,7 +442,7 @@ func (r *Repository) DeleteTargeHostSets(ctx context.Context, targetId string, t
 	t := allocTargetView()
 	t.PublicId = targetId
 	if err := r.reader.LookupByPublicId(ctx, &t); err != nil {
-		return db.NoRowsAffected, fmt.Errorf("delete target host sets: failed %w for %s", err, targetId)
+		return db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg(fmt.Sprintf("failed for %s", targetId)))
 	}
 
 	var metadata oplog.Metadata
@@ -438,11 +456,11 @@ func (r *Repository) DeleteTargeHostSets(ctx context.Context, targetId string, t
 		metadata = tcpT.oplog(oplog.OpType_OP_TYPE_UPDATE)
 		metadata["op-type"] = append(metadata["op-type"], oplog.OpType_OP_TYPE_DELETE.String())
 	default:
-		return db.NoRowsAffected, fmt.Errorf("delete target host sets: %s is an unsupported target type %s", t.PublicId, t.Type)
+		return db.NoRowsAffected, errors.New(errors.InvalidParameter, op, fmt.Sprintf("%s is an unsupported target type %s", t.PublicId, t.Type))
 	}
 	oplogWrapper, err := r.kms.GetWrapper(ctx, t.GetScopeId(), kms.KeyPurposeOplog)
 	if err != nil {
-		return db.NoRowsAffected, fmt.Errorf("delete target host sets: unable to get oplog wrapper: %w", err)
+		return db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg("unable to get oplog wrapper"))
 	}
 
 	var totalRowsDeleted int
@@ -454,38 +472,38 @@ func (r *Repository) DeleteTargeHostSets(ctx context.Context, targetId string, t
 			msgs := make([]*oplog.Message, 0, 2)
 			targetTicket, err := w.GetTicket(target)
 			if err != nil {
-				return fmt.Errorf("delete target host sets: unable to get ticket: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to get ticket"))
 			}
 			updatedTarget := target.(Cloneable).Clone()
 			var targetOplogMsg oplog.Message
 			rowsUpdated, err := w.Update(ctx, updatedTarget, []string{"Version"}, nil, db.NewOplogMsg(&targetOplogMsg), db.WithVersion(&targetVersion))
 			if err != nil {
-				return fmt.Errorf("delete target host sets: unable to update target version: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to update target version"))
 			}
 			if rowsUpdated != 1 {
-				return fmt.Errorf("delete target host sets: updated target and %d rows updated", rowsUpdated)
+				return errors.New(errors.MultipleRecords, op, fmt.Sprintf("updated target and %d rows updated", rowsUpdated))
 			}
 			msgs = append(msgs, &targetOplogMsg)
 
 			hostSetsOplogMsgs := make([]*oplog.Message, 0, len(deleteTargeHostSets))
 			rowsDeleted, err := w.DeleteItems(ctx, deleteTargeHostSets, db.NewOplogMsgs(&hostSetsOplogMsgs))
 			if err != nil {
-				return fmt.Errorf("delete target host sets: unable to delete target host sets: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to delete target host sets"))
 			}
 			if rowsDeleted != len(deleteTargeHostSets) {
-				return fmt.Errorf("delete target host sets: target host sets deleted %d did not match request for %d", rowsDeleted, len(deleteTargeHostSets))
+				return errors.New(errors.MultipleRecords, op, fmt.Sprintf("target host sets deleted %d did not match request for %d", rowsDeleted, len(deleteTargeHostSets)))
 			}
 			totalRowsDeleted += rowsDeleted
 			msgs = append(msgs, hostSetsOplogMsgs...)
 
 			if err := w.WriteOplogEntryWith(ctx, oplogWrapper, targetTicket, metadata, msgs); err != nil {
-				return fmt.Errorf("delete target host sets: unable to write oplog: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to write oplog"))
 			}
 			return nil
 		},
 	)
 	if err != nil {
-		return db.NoRowsAffected, fmt.Errorf("delete target host sets: error deleting target host sets: %w", err)
+		return db.NoRowsAffected, errors.Wrap(err, op)
 	}
 	return totalRowsDeleted, nil
 }
@@ -494,17 +512,18 @@ func (r *Repository) DeleteTargeHostSets(ctx context.Context, targetId string, t
 // target host sets as need to reconcile the existing sets with the sets
 // requested. If hostSetIds is empty, the target host sets will be cleared. Zero
 // is not a valid value for the WithVersion option and will return an error.
-func (r *Repository) SetTargetHostSets(ctx context.Context, targetId string, targetVersion uint32, hostSetIds []string, opt ...Option) ([]*TargetSet, int, error) {
+func (r *Repository) SetTargetHostSets(ctx context.Context, targetId string, targetVersion uint32, hostSetIds []string, _ ...Option) ([]*TargetSet, int, error) {
+	const op = "target.(Repository).SetTargetHostSets"
 	if targetId == "" {
-		return nil, db.NoRowsAffected, fmt.Errorf("set target host sets: missing target id: %w", errors.ErrInvalidParameter)
+		return nil, db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing target id")
 	}
 	if targetVersion == 0 {
-		return nil, db.NoRowsAffected, fmt.Errorf("set target host sets: version cannot be zero: %w", errors.ErrInvalidParameter)
+		return nil, db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing version")
 	}
 	t := allocTargetView()
 	t.PublicId = targetId
 	if err := r.reader.LookupByPublicId(ctx, &t); err != nil {
-		return nil, db.NoRowsAffected, fmt.Errorf("set target host sets: failed %w for %s", err, targetId)
+		return nil, db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg(fmt.Sprintf("failed for %s", targetId)))
 	}
 
 	// NOTE: calculating that to set can safely happen outside of the write
@@ -515,7 +534,7 @@ func (r *Repository) SetTargetHostSets(ctx context.Context, targetId string, tar
 	// TODO(mgaffney) 08/2020: Use SQL to calculate changes.
 	foundThs, err := fetchSets(ctx, r.reader, targetId)
 	if err != nil {
-		return nil, db.NoRowsAffected, fmt.Errorf("set target host sets: unable to search for existing target host sets: %w", err)
+		return nil, db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg("unable to search for existing target host sets"))
 	}
 	found := map[string]*TargetSet{}
 	for _, s := range foundThs {
@@ -531,7 +550,7 @@ func (r *Repository) SetTargetHostSets(ctx context.Context, targetId string, tar
 		}
 		hs, err := NewTargetHostSet(targetId, id)
 		if err != nil {
-			return nil, db.NoRowsAffected, fmt.Errorf("set target host set: unable to create in memory target host set: %w", err)
+			return nil, db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg("unable to create in memory target host set"))
 		}
 		addHostSets = append(addHostSets, hs)
 	}
@@ -540,7 +559,7 @@ func (r *Repository) SetTargetHostSets(ctx context.Context, targetId string, tar
 		for _, s := range found {
 			hs, err := NewTargetHostSet(targetId, s.PublicId)
 			if err != nil {
-				return nil, db.NoRowsAffected, fmt.Errorf("set target host set: unable to create in memory target host set: %w", err)
+				return nil, db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg(" unable to create in memory target host set"))
 			}
 			deleteHostSets = append(deleteHostSets, hs)
 		}
@@ -559,11 +578,11 @@ func (r *Repository) SetTargetHostSets(ctx context.Context, targetId string, tar
 		target = &tcpT
 		metadata = tcpT.oplog(oplog.OpType_OP_TYPE_UPDATE)
 	default:
-		return nil, db.NoRowsAffected, fmt.Errorf("set target host sets: %s is an unsupported target type %s", t.PublicId, t.Type)
+		return nil, db.NoRowsAffected, errors.New(errors.InvalidParameter, op, fmt.Sprintf("%s is an unsupported target type %s", t.PublicId, t.Type))
 	}
 	oplogWrapper, err := r.kms.GetWrapper(ctx, t.GetScopeId(), kms.KeyPurposeOplog)
 	if err != nil {
-		return nil, db.NoRowsAffected, fmt.Errorf("set target host sets: unable to get oplog wrapper: %w", err)
+		return nil, db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg("unable to get oplog wrapper"))
 	}
 
 	var totalRowsAffected int
@@ -576,16 +595,16 @@ func (r *Repository) SetTargetHostSets(ctx context.Context, targetId string, tar
 			msgs := make([]*oplog.Message, 0, 2)
 			targetTicket, err := w.GetTicket(target)
 			if err != nil {
-				return fmt.Errorf("set target host sets: unable to get ticket: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to get ticket"))
 			}
 			updatedTarget := target.(Cloneable).Clone()
 			var targetOplogMsg oplog.Message
 			rowsUpdated, err := w.Update(ctx, updatedTarget, []string{"Version"}, nil, db.NewOplogMsg(&targetOplogMsg), db.WithVersion(&targetVersion))
 			if err != nil {
-				return fmt.Errorf("set target host sets: unable to update target version: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to update target version"))
 			}
 			if rowsUpdated != 1 {
-				return fmt.Errorf("set target host sets: updated target and %d rows updated", rowsUpdated)
+				return errors.New(errors.MultipleRecords, op, fmt.Sprintf("set target host sets: updated target and %d rows updated", rowsUpdated))
 			}
 			msgs = append(msgs, &targetOplogMsg)
 
@@ -593,7 +612,7 @@ func (r *Repository) SetTargetHostSets(ctx context.Context, targetId string, tar
 			if len(addHostSets) > 0 {
 				hostSetOplogMsgs := make([]*oplog.Message, 0, len(addHostSets))
 				if err := w.CreateItems(ctx, addHostSets, db.NewOplogMsgs(&hostSetOplogMsgs)); err != nil {
-					return fmt.Errorf("unable to add target host sets during set: %w", err)
+					return errors.Wrap(err, op, errors.WithMsg("unable to add target host sets"))
 				}
 				totalRowsAffected += len(addHostSets)
 				msgs = append(msgs, hostSetOplogMsgs...)
@@ -605,28 +624,28 @@ func (r *Repository) SetTargetHostSets(ctx context.Context, targetId string, tar
 				hostSetOplogMsgs := make([]*oplog.Message, 0, len(deleteHostSets))
 				rowsDeleted, err := w.DeleteItems(ctx, deleteHostSets, db.NewOplogMsgs(&hostSetOplogMsgs))
 				if err != nil {
-					return fmt.Errorf("set target host sets: unable to delete target host set: %w", err)
+					return errors.Wrap(err, op, errors.WithMsg("unable to delete target host set"))
 				}
 				if rowsDeleted != len(deleteHostSets) {
-					return fmt.Errorf("set target host sets: target host sets deleted %d did not match request for %d", rowsDeleted, len(deleteHostSets))
+					return errors.New(errors.MultipleRecords, op, fmt.Sprintf("target host sets deleted %d did not match request for %d", rowsDeleted, len(deleteHostSets)))
 				}
 				totalRowsAffected += rowsDeleted
 				msgs = append(msgs, hostSetOplogMsgs...)
 				metadata["op-type"] = append(metadata["op-type"], oplog.OpType_OP_TYPE_DELETE.String())
 			}
 			if err := w.WriteOplogEntryWith(ctx, oplogWrapper, targetTicket, metadata, msgs); err != nil {
-				return fmt.Errorf("set target host sets: unable to write oplog: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to write oplog"))
 			}
 
 			currentHostSets, err = fetchSets(ctx, reader, targetId)
 			if err != nil {
-				return fmt.Errorf("set target host sets: unable to retrieve current target host sets after set: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to retrieve current target host sets after set"))
 			}
 			return nil
 		},
 	)
 	if err != nil {
-		return nil, db.NoRowsAffected, fmt.Errorf("target host sets: error setting target host sets: %w", err)
+		return nil, db.NoRowsAffected, errors.Wrap(err, op)
 	}
 	return currentHostSets, totalRowsAffected, nil
 }

internal/target/repository_tcp_target.go

@@ -5,10 +5,9 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/hashicorp/boundary/internal/db"
 	dbcommon "github.com/hashicorp/boundary/internal/db/common"
 	"github.com/hashicorp/boundary/internal/errors"
-
-	"github.com/hashicorp/boundary/internal/db"
 	"github.com/hashicorp/boundary/internal/kms"
 	"github.com/hashicorp/boundary/internal/oplog"
 )
@@ -16,49 +15,50 @@ import (
 // CreateTcpTarget inserts into the repository and returns the new Target with
 // its list of host sets.  WithHostSets is currently the only supported option.
 func (r *Repository) CreateTcpTarget(ctx context.Context, target *TcpTarget, opt ...Option) (Target, []*TargetSet, error) {
+	const op = "target.(Repository).CreateTcpTarget"
 	opts := getOpts(opt...)
 	if target == nil {
-		return nil, nil, fmt.Errorf("create tcp target: missing target: %w", errors.ErrInvalidParameter)
+		return nil, nil, errors.New(errors.InvalidParameter, op, "missing target")
 	}
 	if target.TcpTarget == nil {
-		return nil, nil, fmt.Errorf("create tcp target: missing target store: %w", errors.ErrInvalidParameter)
+		return nil, nil, errors.New(errors.InvalidParameter, op, "missing target store")
 	}
 	if target.ScopeId == "" {
-		return nil, nil, fmt.Errorf("create tcp target: scope id empty: %w", errors.ErrInvalidParameter)
+		return nil, nil, errors.New(errors.InvalidParameter, op, "missing scope id")
 	}
 	if target.Name == "" {
-		return nil, nil, fmt.Errorf("create tcp target: name empty: %w", errors.ErrInvalidParameter)
+		return nil, nil, errors.New(errors.InvalidParameter, op, "missing name")
 	}
 	if target.PublicId != "" {
-		return nil, nil, fmt.Errorf("create tcp target: public id not empty: %w", errors.ErrInvalidParameter)
+		return nil, nil, errors.New(errors.InvalidParameter, op, "public id not empty")
 	}
 
 	t := target.Clone().(*TcpTarget)
 
 	if opts.withPublicId != "" {
 		if !strings.HasPrefix(opts.withPublicId, TcpTargetPrefix+"_") {
-			return nil, nil, fmt.Errorf("create tcp target: passed-in public ID %q has wrong prefix, should be %q: %w", opts.withPublicId, TcpTargetPrefix, errors.ErrInvalidPublicId)
+			return nil, nil, errors.New(errors.InvalidParameter, op, fmt.Sprintf("passed-in public ID %q has wrong prefix, should be %q", opts.withPublicId, TcpTargetPrefix))
 		}
 		t.PublicId = opts.withPublicId
 	} else {
 
 		id, err := newTcpTargetId()
 		if err != nil {
-			return nil, nil, fmt.Errorf("create tcp target: %w", err)
+			return nil, nil, errors.Wrap(err, op)
 		}
 		t.PublicId = id
 	}
 
 	oplogWrapper, err := r.kms.GetWrapper(ctx, target.ScopeId, kms.KeyPurposeOplog)
 	if err != nil {
-		return nil, nil, fmt.Errorf("create tcp target: unable to get oplog wrapper: %w", err)
+		return nil, nil, errors.Wrap(err, op, errors.WithMsg("unable to get oplog wrapper"))
 	}
 
 	newHostSets := make([]interface{}, 0, len(opts.withHostSets))
 	for _, hsId := range opts.withHostSets {
 		hostSet, err := NewTargetHostSet(t.PublicId, hsId)
 		if err != nil {
-			return nil, nil, fmt.Errorf("create tcp target: unable to create in memory target host set: %w", err)
+			return nil, nil, errors.Wrap(err, op, errors.WithMsg("unable to create in memory target host set"))
 		}
 		newHostSets = append(newHostSets, hostSet)
 	}
@@ -73,36 +73,36 @@ func (r *Repository) CreateTcpTarget(ctx context.Context, target *TcpTarget, opt
 		func(read db.Reader, w db.Writer) error {
 			targetTicket, err := w.GetTicket(t)
 			if err != nil {
-				return fmt.Errorf("create tcp target: unable to get ticket: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to get ticket"))
 			}
 			msgs := make([]*oplog.Message, 0, 2)
 			var targetOplogMsg oplog.Message
 			returnedTarget = t.Clone()
 			if err := w.Create(ctx, returnedTarget, db.NewOplogMsg(&targetOplogMsg)); err != nil {
-				return err
+				return errors.Wrap(err, op)
 			}
 			msgs = append(msgs, &targetOplogMsg)
 			if len(newHostSets) > 0 {
 				hostSetOplogMsgs := make([]*oplog.Message, 0, len(newHostSets))
 				if err := w.CreateItems(ctx, newHostSets, db.NewOplogMsgs(&hostSetOplogMsgs)); err != nil {
-					return fmt.Errorf("create tcp target: unable to add host sets: %w", err)
+					return errors.Wrap(err, op, errors.WithMsg("unable to add host sets"))
 				}
 				if returnedHostSet, err = fetchSets(ctx, read, t.PublicId); err != nil {
-					return fmt.Errorf("create tcp target: unable to read host sets: %w", err)
+					return errors.Wrap(err, op, errors.WithMsg("unable to read host sets"))
 				}
 				msgs = append(msgs, hostSetOplogMsgs...)
 			}
 			if err := w.WriteOplogEntryWith(ctx, oplogWrapper, targetTicket, metadata, msgs); err != nil {
-				return fmt.Errorf("create tcp target: unable to write oplog: %w", err)
+				return errors.Wrap(err, op, errors.WithMsg("unable to write oplog"))
 			}
 
 			return nil
 		},
 	)
 	if err != nil {
-		return nil, nil, fmt.Errorf("create tcp target: %w for %s target id id", err, t.PublicId)
+		return nil, nil, errors.Wrap(err, op, errors.WithMsg(fmt.Sprintf("failed for %s target id", t.PublicId)))
 	}
-	return returnedTarget.(*TcpTarget), returnedHostSet, err
+	return returnedTarget.(*TcpTarget), returnedHostSet, nil
 }
 
 // UpdateTcpTarget will update a target in the repository and return the written
@@ -111,15 +111,16 @@ func (r *Repository) CreateTcpTarget(ctx context.Context, target *TcpTarget, opt
 // included in fieldMask. Name, Description, and WorkerFilter are the only
 // updatable fields. If no updatable fields are included in the fieldMaskPaths,
 // then an error is returned.
-func (r *Repository) UpdateTcpTarget(ctx context.Context, target *TcpTarget, version uint32, fieldMaskPaths []string, opt ...Option) (Target, []*TargetSet, int, error) {
+func (r *Repository) UpdateTcpTarget(ctx context.Context, target *TcpTarget, version uint32, fieldMaskPaths []string, _ ...Option) (Target, []*TargetSet, int, error) {
+	const op = "target.(Repository).UpdateTcpTarget"
 	if target == nil {
-		return nil, nil, db.NoRowsAffected, fmt.Errorf("update tcp target: missing target %w", errors.ErrInvalidParameter)
+		return nil, nil, db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing target")
 	}
 	if target.TcpTarget == nil {
-		return nil, nil, db.NoRowsAffected, fmt.Errorf("update tcp target: missing target store %w", errors.ErrInvalidParameter)
+		return nil, nil, db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing target store")
 	}
 	if target.PublicId == "" {
-		return nil, nil, db.NoRowsAffected, fmt.Errorf("update tcp target: missing target public id %w", errors.ErrInvalidParameter)
+		return nil, nil, db.NoRowsAffected, errors.New(errors.InvalidParameter, op, "missing target public id")
 	}
 	for _, f := range fieldMaskPaths {
 		switch {
@@ -130,7 +131,7 @@ func (r *Repository) UpdateTcpTarget(ctx context.Context, target *TcpTarget, ver
 		case strings.EqualFold("sessionconnectionlimit", f):
 		case strings.EqualFold("workerfilter", f):
 		default:
-			return nil, nil, db.NoRowsAffected, fmt.Errorf("update tcp target: field: %s: %w", f, errors.ErrInvalidFieldMask)
+			return nil, nil, db.NoRowsAffected, errors.New(errors.InvalidFieldMask, op, fmt.Sprintf("invalid field mask: %s", f))
 		}
 	}
 	var dbMask, nullFields []string
@@ -147,7 +148,7 @@ func (r *Repository) UpdateTcpTarget(ctx context.Context, target *TcpTarget, ver
 		[]string{"SessionMaxSeconds", "SessionConnectionLimit"},
 	)
 	if len(dbMask) == 0 && len(nullFields) == 0 {
-		return nil, nil, db.NoRowsAffected, fmt.Errorf("update tcp target: %w", errors.ErrEmptyFieldMask)
+		return nil, nil, db.NoRowsAffected, errors.New(errors.EmptyFieldMask, op, "empty field mask")
 	}
 	var returnedTarget Target
 	var rowsUpdated int
@@ -161,16 +162,16 @@ func (r *Repository) UpdateTcpTarget(ctx context.Context, target *TcpTarget, ver
 			t := target.Clone().(*TcpTarget)
 			returnedTarget, targetSets, rowsUpdated, err = r.update(ctx, t, version, dbMask, nullFields)
 			if err != nil {
-				return err
+				return errors.Wrap(err, op)
 			}
 			return nil
 		},
 	)
 	if err != nil {
 		if errors.IsUniqueError(err) {
-			return nil, nil, db.NoRowsAffected, fmt.Errorf("update tcp target: target %s already exists in scope %s: %w", target.Name, target.ScopeId, errors.ErrNotUnique)
+			return nil, nil, db.NoRowsAffected, errors.New(errors.NotUnique, op, fmt.Sprintf("target %s already exists in scope %s", target.Name, target.ScopeId))
 		}
-		return nil, nil, db.NoRowsAffected, fmt.Errorf("update tcp target: %w for %s", err, target.PublicId)
+		return nil, nil, db.NoRowsAffected, errors.Wrap(err, op, errors.WithMsg(fmt.Sprintf("failed for %s", target.PublicId)))
 	}
-	return returnedTarget.(Target), targetSets, rowsUpdated, err
+	return returnedTarget.(Target), targetSets, rowsUpdated, nil
 }

internal/target/repository_tcp_target_test.go

@@ -43,7 +43,7 @@ func TestRepository_CreateTcpTarget(t *testing.T) {
 		args         args
 		wantHostSets []string
 		wantErr      bool
-		wantIsError  error
+		wantIsError  errors.Code
 	}{
 		{
 			name: "valid-org",
@@ -67,7 +67,7 @@ func TestRepository_CreateTcpTarget(t *testing.T) {
 				target: nil,
 			},
 			wantErr:     true,
-			wantIsError: errors.ErrInvalidParameter,
+			wantIsError: errors.InvalidParameter,
 		},
 		{
 			name: "nil-target-store",
@@ -78,7 +78,7 @@ func TestRepository_CreateTcpTarget(t *testing.T) {
 				}(),
 			},
 			wantErr:     true,
-			wantIsError: errors.ErrInvalidParameter,
+			wantIsError: errors.InvalidParameter,
 		},
 		{
 			name: "public-id-not-empty",
@@ -93,7 +93,7 @@ func TestRepository_CreateTcpTarget(t *testing.T) {
 				}(),
 			},
 			wantErr:     true,
-			wantIsError: errors.ErrInvalidParameter,
+			wantIsError: errors.InvalidParameter,
 		},
 		{
 			name: "empty-scope-id",
@@ -106,7 +106,7 @@ func TestRepository_CreateTcpTarget(t *testing.T) {
 				}(),
 			},
 			wantErr:     true,
-			wantIsError: errors.ErrInvalidParameter,
+			wantIsError: errors.InvalidParameter,
 		},
 	}
 	for _, tt := range tests {
@@ -116,7 +116,7 @@ func TestRepository_CreateTcpTarget(t *testing.T) {
 			if tt.wantErr {
 				assert.Error(err)
 				assert.Nil(target)
-				assert.True(errors.Is(err, tt.wantIsError))
+				assert.True(errors.Match(errors.T(tt.wantIsError), err))
 				return
 			}
 			require.NoError(err)
@@ -217,7 +217,7 @@ func TestRepository_UpdateTcpTarget(t *testing.T) {
 			newScopeId:     proj.PublicId,
 			wantErr:        true,
 			wantRowsUpdate: 0,
-			wantErrMsg:     "update tcp target: db.DoTx: db.DoTx: db.Update: db.lookupAfterWrite: db.LookupById: record not found",
+			wantErrMsg:     "target.(Repository).UpdateTcpTarget: failed for 1: db.DoTx: target.(Repository).UpdateTcpTarget: target.(Repository).update: db.DoTx: target.(Repository).update: db.Update: db.lookupAfterWrite: db.LookupById: record not found, search issue: error #1100",
 			wantIsError:    errors.RecordNotFound,
 		},
 		{
@@ -231,7 +231,7 @@ func TestRepository_UpdateTcpTarget(t *testing.T) {
 			newName:        "null-name" + id,
 			wantErr:        true,
 			wantRowsUpdate: 0,
-			wantErrMsg:     "update tcp target: db.DoTx: db.DoTx: db.Update: name must not be empty: not null constraint violated",
+			wantErrMsg:     "db.DoTx: target.(Repository).UpdateTcpTarget: target.(Repository).update: db.DoTx: target.(Repository).update: db.Update: name must not be empty: not null constraint violated: integrity violation: error #1001",
 		},
 		{
 			name: "null-description",
@@ -255,7 +255,7 @@ func TestRepository_UpdateTcpTarget(t *testing.T) {
 			newScopeId:     proj.PublicId,
 			wantErr:        true,
 			wantRowsUpdate: 0,
-			wantErrMsg:     "update tcp target: empty field mask",
+			wantErrMsg:     "target.(Repository).UpdateTcpTarget: empty field mask: parameter violation: error #104",
 			wantIsError:    errors.EmptyFieldMask,
 		},
 		{
@@ -268,7 +268,7 @@ func TestRepository_UpdateTcpTarget(t *testing.T) {
 			newScopeId:     proj.PublicId,
 			wantErr:        true,
 			wantRowsUpdate: 0,
-			wantErrMsg:     "update tcp target: empty field mask",
+			wantErrMsg:     "target.(Repository).UpdateTcpTarget: empty field mask: parameter violation: error #104",
 			wantIsError:    errors.EmptyFieldMask,
 		},
 		{
@@ -281,7 +281,7 @@ func TestRepository_UpdateTcpTarget(t *testing.T) {
 			newScopeId:     proj.PublicId,
 			wantErr:        true,
 			wantRowsUpdate: 0,
-			wantErrMsg:     "update tcp target: field: CreateTime: invalid field mask",
+			wantErrMsg:     "target.(Repository).UpdateTcpTarget: invalid field mask: CreateTime: parameter violation: error #103",
 			wantIsError:    errors.InvalidFieldMask,
 		},
 		{
@@ -294,7 +294,7 @@ func TestRepository_UpdateTcpTarget(t *testing.T) {
 			newScopeId:     proj.PublicId,
 			wantErr:        true,
 			wantRowsUpdate: 0,
-			wantErrMsg:     "update tcp target: field: Alice: invalid field mask",
+			wantErrMsg:     "target.(Repository).UpdateTcpTarget: invalid field mask: Alice: parameter violation: error #103",
 			wantIsError:    errors.InvalidFieldMask,
 		},
 		{
@@ -307,7 +307,7 @@ func TestRepository_UpdateTcpTarget(t *testing.T) {
 			},
 			newScopeId:     proj.PublicId,
 			wantErr:        true,
-			wantErrMsg:     "update tcp target: missing target public id invalid parameter",
+			wantErrMsg:     "target.(Repository).UpdateTcpTarget: missing target public id: parameter violation: error #100",
 			wantIsError:    errors.InvalidParameter,
 			wantRowsUpdate: 0,
 		},
@@ -319,7 +319,7 @@ func TestRepository_UpdateTcpTarget(t *testing.T) {
 			},
 			newScopeId:  proj.PublicId,
 			wantErr:     true,
-			wantErrMsg:  "update tcp target: empty field mask",
+			wantErrMsg:  "target.(Repository).UpdateTcpTarget: empty field mask: parameter violation: error #104",
 			wantIsError: errors.EmptyFieldMask,
 		},
 		{

internal/target/repository_test.go

@@ -60,7 +60,7 @@ func TestNewRepository(t *testing.T) {
 			},
 			want:          nil,
 			wantErr:       true,
-			wantErrString: "error creating db repository with nil kms",
+			wantErrString: "target.NewRepository: nil kms: parameter violation: error #100",
 		},
 		{
 			name: "nil-writer",
@@ -71,7 +71,7 @@ func TestNewRepository(t *testing.T) {
 			},
 			want:          nil,
 			wantErr:       true,
-			wantErrString: "error creating db repository with nil writer",
+			wantErrString: "target.NewRepository: nil writer: parameter violation: error #100",
 		},
 		{
 			name: "nil-reader",
@@ -82,7 +82,7 @@ func TestNewRepository(t *testing.T) {
 			},
 			want:          nil,
 			wantErr:       true,
-			wantErrString: "error creating db repository with nil reader",
+			wantErrString: "target.NewRepository: nil reader: parameter violation: error #100",
 		},
 	}
 	for _, tt := range tests {
@@ -358,7 +358,7 @@ func TestRepository_DeleteTarget(t *testing.T) {
 			},
 			wantRowsDeleted: 0,
 			wantErr:         true,
-			wantErrMsg:      "delete target: missing public id invalid parameter",
+			wantErrMsg:      "target.(Repository).DeleteTarget: missing public id: parameter violation: error #100",
 		},
 		{
 			name: "not-found",
@@ -373,7 +373,7 @@ func TestRepository_DeleteTarget(t *testing.T) {
 			},
 			wantRowsDeleted: 0,
 			wantErr:         true,
-			wantErrMsg:      "delete target: failed db.LookupById: record not found",
+			wantErrMsg:      "db.LookupById: record not found, search issue: error #1100",
 		},
 	}
 	for _, tt := range tests {
@@ -565,7 +565,7 @@ func TestRepository_DeleteTargetHosts(t *testing.T) {
 		args            args
 		wantRowsDeleted int
 		wantErr         bool
-		wantIsErr       error
+		wantIsErr       errors.Code
 	}{
 		{
 			name: "valid",
@@ -595,7 +595,7 @@ func TestRepository_DeleteTargetHosts(t *testing.T) {
 			},
 			wantRowsDeleted: 0,
 			wantErr:         true,
-			wantIsErr:       errors.ErrInvalidParameter,
+			wantIsErr:       errors.InvalidParameter,
 		},
 		{
 			name: "not-found",
@@ -618,7 +618,7 @@ func TestRepository_DeleteTargetHosts(t *testing.T) {
 			},
 			wantRowsDeleted: 0,
 			wantErr:         true,
-			wantIsErr:       errors.ErrInvalidParameter,
+			wantIsErr:       errors.InvalidParameter,
 		},
 		{
 			name: "zero-version",
@@ -630,7 +630,7 @@ func TestRepository_DeleteTargetHosts(t *testing.T) {
 			},
 			wantRowsDeleted: 0,
 			wantErr:         true,
-			wantIsErr:       errors.ErrInvalidParameter,
+			wantIsErr:       errors.InvalidParameter,
 		},
 		{
 			name: "bad-version",
@@ -681,9 +681,7 @@ func TestRepository_DeleteTargetHosts(t *testing.T) {
 			if tt.wantErr {
 				assert.Error(err)
 				assert.Equal(0, deletedRows)
-				if tt.wantIsErr != nil {
-					assert.Truef(errors.Is(err, tt.wantIsErr), "unexpected error %s", err.Error())
-				}
+				assert.Truef(errors.Match(errors.T(tt.wantIsErr), err), "unexpected error %s", err.Error())
 				// TODO (jimlambrt 9/2020) - unfortunately, we can currently
 				// test to make sure that the oplog entry for a target update
 				// doesn't exist because the db.TestVerifyOplog doesn't really

internal/target/target.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/hashicorp/boundary/internal/db/timestamp"
+	"github.com/hashicorp/boundary/internal/errors"
 	"github.com/hashicorp/boundary/internal/oplog"
 	"github.com/hashicorp/boundary/internal/target/store"
 )
@@ -80,6 +81,7 @@ func (t *targetView) SetTableName(n string) {
 
 // targetSubType converts the target view to the concrete subtype
 func (t *targetView) targetSubType() (Target, error) {
+	const op = "target.targetView.targetSubType"
 	switch t.Type {
 	case TcpTargetType.String():
 		tcpTarget := allocTcpTarget()
@@ -96,5 +98,5 @@ func (t *targetView) targetSubType() (Target, error) {
 		tcpTarget.WorkerFilter = t.WorkerFilter
 		return &tcpTarget, nil
 	}
-	return nil, fmt.Errorf("%s is an unknown target subtype of %s", t.PublicId, t.Type)
+	return nil, errors.New(errors.InvalidParameter, op, fmt.Sprintf("%s is an unknown target subtype of %s", t.PublicId, t.Type))
 }

internal/target/target_host_set.go

@@ -25,12 +25,13 @@ var _ db.VetForWriter = (*TargetHostSet)(nil)
 
 // TargetHostSet creates a new in memory target host set. No options are
 // currently supported.
-func NewTargetHostSet(targetId, hostSetId string, opt ...Option) (*TargetHostSet, error) {
+func NewTargetHostSet(targetId, hostSetId string, _ ...Option) (*TargetHostSet, error) {
+	const op = "target.NewTargetHostSet"
 	if targetId == "" {
-		return nil, fmt.Errorf("new target host set: missing target id: %w", errors.ErrInvalidParameter)
+		return nil, errors.New(errors.InvalidParameter, op, "missing target id")
 	}
 	if hostSetId == "" {
-		return nil, fmt.Errorf("new target host set: missing hostSetId id: %w", errors.ErrInvalidParameter)
+		return nil, errors.New(errors.InvalidParameter, op, "missing hostSetId id")
 	}
 	t := &TargetHostSet{
 		TargetHostSet: &store.TargetHostSet{
@@ -58,13 +59,14 @@ func (t *TargetHostSet) Clone() interface{} {
 
 // VetForWrite implements db.VetForWrite() interface and validates the target
 // host set before it's written.
-func (t *TargetHostSet) VetForWrite(ctx context.Context, r db.Reader, opType db.OpType, opt ...db.Option) error {
+func (t *TargetHostSet) VetForWrite(_ context.Context, _ db.Reader, opType db.OpType, _ ...db.Option) error {
+	const op = "target.(TargetHostSet).VetForWrite"
 	if opType == db.CreateOp {
 		if t.TargetId == "" {
-			return fmt.Errorf("target host set: vet for write: missing target id: %w", errors.ErrInvalidParameter)
+			return errors.New(errors.InvalidParameter, op, "missing target id")
 		}
 		if t.HostSetId == "" {
-			return fmt.Errorf("target host set: vet for write: missing host set id: %w", errors.ErrInvalidParameter)
+			return errors.New(errors.InvalidParameter, op, "missing host set id")
 		}
 	}
 	return nil

internal/target/tcp_target.go

@@ -2,7 +2,6 @@ package target
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/hashicorp/boundary/internal/db"
 	"github.com/hashicorp/boundary/internal/errors"
@@ -29,9 +28,10 @@ var (
 // NewTcpTarget creates a new in memory tcp target.  WithName, WithDescription and
 // WithDefaultPort options are supported
 func NewTcpTarget(scopeId string, opt ...Option) (*TcpTarget, error) {
+	const op = "target.NewTcpTarget"
 	opts := getOpts(opt...)
 	if scopeId == "" {
-		return nil, fmt.Errorf("new tcp target: missing scope id: %w", errors.ErrInvalidParameter)
+		return nil, errors.New(errors.InvalidParameter, op, "missing scope id")
 	}
 	t := &TcpTarget{
 		TcpTarget: &store.TcpTarget{
@@ -64,16 +64,17 @@ func (t *TcpTarget) Clone() interface{} {
 
 // VetForWrite implements db.VetForWrite() interface and validates the tcp target
 // before it's written.
-func (t *TcpTarget) VetForWrite(ctx context.Context, r db.Reader, opType db.OpType, opt ...db.Option) error {
+func (t *TcpTarget) VetForWrite(_ context.Context, _ db.Reader, opType db.OpType, _ ...db.Option) error {
+	const op = "target.(TcpTarget).VetForWrite"
 	if t.PublicId == "" {
-		return fmt.Errorf("tcp target vet for write: missing public id: %w", errors.ErrInvalidParameter)
+		return errors.New(errors.InvalidParameter, op, "missing public id")
 	}
 	if opType == db.CreateOp {
 		if t.ScopeId == "" {
-			return fmt.Errorf("tcp target vet for write: missing scope id: %w", errors.ErrInvalidParameter)
+			return errors.New(errors.InvalidParameter, op, "missing scope id")
 		}
 		if t.Name == "" {
-			return fmt.Errorf("tcp target vet for write: missing name id: %w", errors.ErrInvalidParameter)
+			return errors.New(errors.InvalidParameter, op, "missing name")
 		}
 	}
 	return nil

internal/target/tcp_target_test.go

@@ -29,7 +29,7 @@ func TestTcpTarget_Create(t *testing.T) {
 		args          args
 		want          *TcpTarget
 		wantErr       bool
-		wantIsErr     error
+		wantIsErr     errors.Code
 		create        bool
 		wantCreateErr bool
 	}{
@@ -37,7 +37,7 @@ func TestTcpTarget_Create(t *testing.T) {
 			name:      "empty-scopeId",
 			args:      args{},
 			wantErr:   true,
-			wantIsErr: errors.ErrInvalidParameter,
+			wantIsErr: errors.InvalidParameter,
 		},
 		{
 			name: "valid-proj-scope",
@@ -62,7 +62,7 @@ func TestTcpTarget_Create(t *testing.T) {
 			got, err := NewTcpTarget(tt.args.scopeId, tt.args.opt...)
 			if tt.wantErr {
 				require.Error(err)
-				assert.True(errors.Is(err, tt.wantIsErr))
+				assert.True(errors.Match(errors.T(tt.wantIsErr), err))
 				return
 			}
 			require.NoError(err)