Error handling
Dispatch retries the execution of a function whenever a failure occurs, whether it’s an exception, a loss of connection or power outage. However, not all failures are the same, so you might want to teach Dispatch how to handle exceptions specific to your application.
Temporary errors
When error is temporary, tell Dispatch that it’s safe to retry that function until it succeeds.
For example, when application is in maintenance mode, tell Dispatch to retry the function until application is back up again.
To treat an error as temporary, implement an interface { Temporary() bool } interface for that error.
package main
import ( "context" "log"
"github.com/dispatchrun/dispatch-go")
type MaintenanceError struct{}
func (error *MaintenanceError) Error() string { return "server is under maintenance"}
func (error *MaintenanceError) Temporary() bool { return true}
func main() { calls := 0
notifyUser := dispatch.Func("notifyUser", func(ctx context.Context, userId string) (any, error) { is_maintenance_on := calls < 2 calls++
if is_maintenance_on { return nil, &MaintenanceError{} }
// Send an email notification to the user return nil, nil })
endpoint, err := dispatch.New(notifyUser) if err != nil { log.Fatal(err) }
go func() { if _, err := notifyUser.Dispatch(context.Background(), "user_123"); err != nil { log.Fatal(err) }
}()
if err := endpoint.ListenAndServe(); err != nil { log.Fatal(err) }}When Temporary method of an error returns true, Dispatch treats it as a temporary error and retries the function that returns it.
In the example above, the notifyUser function is in maintanence mode for the first two calls and succeeds on the third one.
Permanent errors
When error is fatal, retrying doesn’t make sense, because the function will keep running into it.
Dispatch stops retrying a function when error’s Temporary method returns true.
For example, the user we wanted to send email to is now deactivated.
package main
import ( "context" "log"
"github.com/dispatchrun/dispatch-go")
type UserDeactivatedError struct{}
func (error *UserDeactivatedError) Error() string { return "user is deactivated"}
func (error *UserDeactivatedError) Temporary() bool { return false}
func main() { notifyUser := dispatch.Func("notifyUser", func(ctx context.Context, userId string) (any, error) { if userId == "user_123" { return nil, &UserDeactivatedError{} }
// Send an email notification to the user return nil, nil })
endpoint, err := dispatch.New(notifyUser) if err != nil { log.Fatal(err) }
go func() { if _, err := notifyUser.Dispatch(context.Background(), "user_123"); err != nil { log.Fatal(err) }
}()
if err := endpoint.ListenAndServe(); err != nil { log.Fatal(err) }}Built-in Go errors
Dispatch recognizes the most common Go errors out of the box and determines whether it’s safe to retry the function call.