Skip to main content
Restate uses an execution log to replay operations after failures and suspensions. Non-deterministic operations (database calls, HTTP requests, UUID generation) must be wrapped to ensure deterministic replay.

​
Run

Use Run to safely wrap any non-deterministic operation, like HTTP calls or database responses, and have Restate store its result in the execution log. 
result, err := restate.Run(ctx, func(ctx restate.RunContext) (string, error) {
  return doDbRequest()
})
if err != nil {
  return err
}
Note that inside Run, you cannot use the Restate context (e.g., get, sleep, or nested Run). You should only use methods available on the RunContext provided to your function.
You can return any payload that can be serialized. By default, serialization is done with JSONCodec which uses encoding/json. If you don’t need to return anything, you can use restate.Void{} which serialises to a nil byte slice.
Failures in Run are treated the same as any other handler error. Restate will retry it unless configured otherwise or unless a TerminalError is thrown.You can customize how Run retries via:
result, err := restate.Run(ctx,
  func(ctx restate.RunContext) (string, error) {
    return doDbRequest()
  },
  // After 10 seconds, give up retrying
  restate.WithMaxRetryDuration(time.Second*10),
  // On the first retry, wait 100 milliseconds before next attempt
  restate.WithInitialRetryInterval(time.Millisecond*100),
  // Grow retry interval with factor 2
  restate.WithRetryIntervalFactor(2.0),
  // Optional: provide a name for the operation to be visible in the
  // observability tools.
  restate.WithName("my_db_request"),
)
if err != nil {
  return err
}
  • You can limit retries by time or count
  • When the policy is exhausted, a TerminalError is thrown
  • See the Error Handling Guide and the Sagas Guide for patterns like compensation
If Restate doesn’t receive new journal entries from a service for more than one minute (by default), it will automatically abort the invocation and retry it.However, some business logic can take longer to complete—for example, an LLM call that takes up to 3 minutes to respond.In such cases, you can adjust the service’s abort timeout and inactivity timeout settings to accommodate longer execution times.For more information, see the error handling guide.

​
Deterministic randoms

The SDK provides deterministic helpers for random values — seeded by the invocation ID — so they return the same result on retries.

​
UUIDs

To generate stable UUIDs for things like idempotency keys: 
uuid := restate.UUID(ctx)
Do not use this in cryptographic contexts.

​
Random numbers

Methods exist on restate.Rand(ctx) for generating float64 and uint64, or otherwise restate.Rand(ctx).Source() can be provided to math/rand/v2 as a source for any random operation: 
randomInt := restate.Rand(ctx).Uint64()
randomFloat := restate.Rand(ctx).Float64()
mathRandV2 := rand.New(restate.RandSource(ctx))