Rust Wait Until

Rust waitUntil

This example demonstrates waitUntil support in the Edgenivo Rust runtime (vercel_runtime 2.4.0+). waitUntil lets you schedule background work that keeps running after the HTTP response has already been sent to the client — the Rust analog of waitUntil in the Node.js runtime.

This is ideal for fire-and-forget side effects the client shouldn't have to wait for, such as flushing analytics, warming a cache, sending a webhook, or writing to a database.

Here, every request to /api/wait-until records itself — timestamp, method, user agent, and the visitor's country (with a flag emoji) — into Upstash Redis after the response is sent. The front-end then reads the last 10 records from /api/recent.

The country comes from Edgenivo's x-vercel-ip-country request header (an ISO 3166-1 alpha-2 code injected at the edge), which is converted to a flag emoji in country_to_flag. The IP itself is never stored.

How it works

api/wait-until.rs defines a handler that receives the runtime's AppState. AppState::wait_until registers a future that is:

1. Spawned immediately, so it makes progress between requests.
2. Decoupled from the response — the handler returns right away and the client gets its response without waiting for the background task.
3. Drained at process shutdown (bounded by a 30s timeout), matching the Node.js runtime's behavior. A panic in the background task is isolated and never affects the response or other background work.

1
// Capture request details before moving into the background task.
2
let record = json!({ "timestamp": ts, "method": method, "userAgent": ua, "country": country, "flag": flag });
3

4
state.wait_until(async move {
5
    // Runs after the response has been sent. The client never waits for this.
6
    if let Err(e) = store_request(&record).await {
7
        eprintln!("[waitUntil] Failed to store request record: {e}");
8
    }
9
});

The write uses the Upstash REST /pipeline endpoint to run LPUSH followed by LTRIM key 0 9, keeping only the 10 most recent records (newest first).

api/recent.rs reads them back with LRANGE key 0 9 using the read-only token and returns them as JSON for the front-end to render.

Data flow

1. GET /api/wait-until → responds immediately, schedules the Redis write via waitUntil.
2. Background task → LPUSH + LTRIM to Upstash (write token).
3. GET /api/recent → LRANGE the last 10 records (read-only token).
4. index.html → "Fire a request", then renders the recent list.

Logging from background work

The example logs from the background task with println!/eprintln! (stdout/stderr) rather than the request-scoped state.log_context. This is intentional:

• log_context attaches each line to the current invocation's id.
• The runtime sends the per-request end message as soon as the handler returns the response, which closes that invocation's log stream.
• waitUntil work is drained later (at process shutdown, bounded by a 30s timeout). By then the originating request context is closed, so a log_context line emitted from the background task would not be attributed to the request and may be dropped.

stdout/stderr is captured independently of request context, so it reliably shows up in the function logs — making the background work observable. Use log_context for synchronous, in-handler logging and println!/eprintln! (or an external sink like a database/Blob) for waitUntil work.

Project Structure

• api/wait-until.rs — records the request to Upstash in the background via waitUntil
• api/recent.rs — reads the last 10 records back with the read-only token
• index.html — fires requests and renders the recent list
• Cargo.toml — Rust dependencies and binary configuration
• vercel.json — Edgenivo project configuration

Environment variables

This example uses an Upstash Redis (Edgenivo KV) database. Add the integration from the Edgenivo dashboard, or set these variables on your project:

For local development, copy these into a .env.local file (gitignored).

Development

Clone the repository:

1
git clone https://github.com/vercel/examples.git
2
cd examples/rust/wait-until

Install Rust if you haven't already:

1
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Pull your project's environment variables (or create .env.local manually):

1
vercel env pull .env.local

Test locally:

1
vc dev

Open the printed URL, click Fire a request, and watch the recent list update. The response returns instantly while the record is written to Upstash in the background.