normalize runner errors

Author: 1pkg

README.MD

@@ -130,6 +130,12 @@ thr := NewThrottlerAll( // throttles only if all children throttle
 )
 ```
 
+In gohalt v0.4.0 breaking change is introduced to replace all untyped errors with two major error types:
+- `ErrorThreshold` which defines error type that occurs if throttler reaches specified threshold.
+- `ErrorInternal` which defines error type that occurs if throttler internal error happens.
+You can find list of returning error types for all existing throttlers in throttlers table bellow or in documentation.
+**Note:** not every gohalt throttler must return error; some throttlers might cause different side effects like logging or call to `time.Sleep` instead.
+
 ## Throttlers
 
 | Throttler | Definition | Description |

context_test.go

@@ -3,7 +3,6 @@ package gohalt
 import (
 	"context"
 	"errors"
-	"fmt"
 	"testing"
 	"time"
 
@@ -28,18 +27,15 @@ func TestContext(t *testing.T) {
 	}{
 		"Context with throttler should be done on throttling": {
 			ctx: WithThrottler(context.Background(), tmock{aerr: testerr}, ms1_0),
-			err: fmt.Errorf("throttler error has happened %w", testerr),
+			err: testerr,
 		},
 		"Context with throttler should be done on throttling after": {
 			ctx: WithThrottler(context.Background(), NewThrottlerAfter(1), ms1_0),
-			err: fmt.Errorf(
-				"throttler error has happened %w",
-				ErrorThreshold{Throttler: "after", Threshold: strpair{current: 3, threshold: 1}},
-			),
+			err: ErrorThreshold{Throttler: "after", Threshold: strpair{current: 3, threshold: 1}},
 		},
 		"Context with throttler should be done with canceled context": {
 			ctx: WithThrottler(cctx, tmock{}, ms1_0),
-			err: fmt.Errorf("context error has happened %w", cctx.Err()),
+			err: cctx.Err(),
 		},
 		"Context with throttler should not be done after timeout": {
 			ctx: WithThrottler(ctx, tmock{}, ms1_0),

executors.go

@@ -96,7 +96,7 @@ func retried(retries uint64, run Runnable) Runnable {
 			if err == nil {
 				return
 			}
-			log("retry error happened: %v", err)
+			log("error happened in retry: %v", err)
 		}
 		return
 	}

runners.go

@@ -2,7 +2,6 @@ package gohalt
 
 import (
 	"context"
-	"fmt"
 	"sync"
 )
 
@@ -46,27 +45,27 @@ func NewRunnerSync(ctx context.Context, thr Throttler) Runner {
 func (r *rsync) Run(run Runnable) {
 	select {
 	case <-r.ctx.Done():
-		r.report(fmt.Errorf("context error has happened %w", r.ctx.Err()))
+		r.report(r.ctx.Err())
 		return
 	default:
 	}
 	defer func() {
 		if err := r.thr.Release(r.ctx); err != nil {
-			r.report(fmt.Errorf("throttler error has happened %w", err))
+			r.report(err)
 		}
 	}()
 	if err := r.thr.Acquire(r.ctx); err != nil {
-		r.report(fmt.Errorf("throttler error has happened %w", err))
+		r.report(err)
 		return
 	}
 	select {
 	case <-r.ctx.Done():
-		r.report(fmt.Errorf("context error has happened %w", r.ctx.Err()))
+		r.report(r.ctx.Err())
 		return
 	default:
 	}
 	if err := run(r.ctx); err != nil {
-		r.report(fmt.Errorf("runnable error has happened %w", err))
+		r.report(err)
 		return
 	}
 }
@@ -109,27 +108,27 @@ func (r *rasync) Run(run Runnable) {
 		defer r.wg.Done()
 		select {
 		case <-r.ctx.Done():
-			r.report(fmt.Errorf("context error happened %w", r.ctx.Err()))
+			r.report(r.ctx.Err())
 			return
 		default:
 		}
 		defer func() {
 			if err := r.thr.Release(r.ctx); err != nil {
-				r.report(fmt.Errorf("throttler error has happened %w", err))
+				r.report(err)
 			}
 		}()
 		if err := r.thr.Acquire(r.ctx); err != nil {
-			r.report(fmt.Errorf("throttler error has happened %w", err))
+			r.report(err)
 			return
 		}
 		select {
 		case <-r.ctx.Done():
-			r.report(fmt.Errorf("context error has happened %w", r.ctx.Err()))
+			r.report(r.ctx.Err())
 			return
 		default:
 		}
 		if err := run(r.ctx); err != nil {
-			r.report(fmt.Errorf("runnable error has happened %w", err))
+			r.report(err)
 			return
 		}
 	}()

runners_test.go

@@ -3,7 +3,6 @@ package gohalt
 import (
 	"context"
 	"errors"
-	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -21,42 +20,42 @@ func TestRunners(t *testing.T) {
 		"Runner sync should return error on throttling": {
 			r:   NewRunnerSync(context.Background(), tmock{aerr: testerr}),
 			run: nope,
-			err: fmt.Errorf("throttler error has happened %w", testerr),
+			err: testerr,
 		},
 		"Runner sync should return error on realising error": {
 			r:   NewRunnerSync(context.Background(), tmock{rerr: testerr}),
 			run: nope,
-			err: fmt.Errorf("throttler error has happened %w", testerr),
+			err: testerr,
 		},
 		"Runner sync should return error on runnable error": {
 			r:   NewRunnerSync(context.Background(), tmock{}),
 			run: use(testerr),
-			err: fmt.Errorf("runnable error has happened %w", testerr),
+			err: testerr,
 		},
 		"Runner sync should return error on canceled context": {
 			r:   NewRunnerSync(cctx, tmock{}),
 			run: nope,
-			err: fmt.Errorf("context error has happened %w", cctx.Err()),
+			err: cctx.Err(),
 		},
 		"Runner async should return error on throttling": {
 			r:   NewRunnerAsync(context.Background(), tmock{aerr: testerr}),
 			run: nope,
-			err: fmt.Errorf("throttler error has happened %w", testerr),
+			err: testerr,
 		},
 		"Runner async should return error on realising error": {
 			r:   NewRunnerAsync(context.Background(), tmock{rerr: testerr}),
 			run: nope,
-			err: fmt.Errorf("throttler error has happened %w", testerr),
+			err: testerr,
 		},
 		"Runner async should return error on runnable error": {
 			r:   NewRunnerAsync(context.Background(), tmock{}),
 			run: use(testerr),
-			err: fmt.Errorf("runnable error has happened %w", testerr),
+			err: testerr,
 		},
 		"Runner async should return error on canceled context": {
 			r:   NewRunnerAsync(cctx, tmock{}),
 			run: nope,
-			err: fmt.Errorf("context error happened %w", cctx.Err()),
+			err: cctx.Err(),
 		},
 	}
 	for tname, tcase := range table {