On error callback

pool/context_pool.go

@@ -75,6 +75,13 @@ func (p *ContextPool) WithMaxGoroutines(n int) *ContextPool {
 	return p
 }
 
+// WithErrorCallback configures the pool to call f everytime a task returns error.
+func (p *ContextPool) WithErrorCallback(f func(err error)) *ContextPool {
+	p.panicIfInitialized()
+	p.errorPool.WithErrorCallback(f)
+	return p
+}
+
 func (p *ContextPool) panicIfInitialized() {
 	p.errorPool.panicIfInitialized()
 }

pool/error_pool.go

@@ -21,6 +21,8 @@ type ErrorPool struct {
 
 	mu   sync.Mutex
 	errs error
+
+	errorCallBack func(err error)
 }
 
 // Go submits a task to the pool. If all goroutines in the pool
@@ -68,6 +70,13 @@ func (p *ErrorPool) WithMaxGoroutines(n int) *ErrorPool {
 	return p
 }
 
+// WithErrorCallback configures the pool to call f everytime a task returns error.
+func (p *ErrorPool) WithErrorCallback(f func(err error)) *ErrorPool {
+	p.panicIfInitialized()
+	p.errorCallBack = f
+	return p
+}
+
 // deref is a helper that creates a shallow copy of the pool with the same
 // settings. We don't want to just dereference the pointer because that makes
 // the copylock lint angry.
@@ -93,5 +102,9 @@ func (p *ErrorPool) addErr(err error) {
 			p.errs = errors.Append(p.errs, err)
 		}
 		p.mu.Unlock()
+
+		if p.errorCallBack != nil {
+			p.errorCallBack(err)
+		}
 	}
 }

pool/error_pool_test.go

@@ -116,4 +116,40 @@ func TestErrorPool(t *testing.T) {
 			})
 		}
 	})
+
+	t.Run("on-error callback", func(t *testing.T) {
+		t.Parallel()
+
+		err1 := errors.New("err1")
+		err2 := errors.New("err2")
+
+		calledForErr1 := false
+		calledForErr2 := false
+
+		g := New().WithErrors().WithErrorCallback(func(err error) {
+			if errors.Is(err, err1) {
+				calledForErr1 = true
+			} else if errors.Is(err, err2) {
+				calledForErr2 = true
+			} else {
+				t.Fatal("callback called with invalid error")
+			}
+		})
+		g.Go(func() error {
+			return err1
+		})
+		g.Go(func() error {
+			return err2
+		})
+
+		_ = g.Wait()
+
+		if !calledForErr1 {
+			t.Fatal("call back is not called for err1")
+		}
+
+		if !calledForErr2 {
+			t.Fatal("call back is not called for err2")
+		}
+	})
 }