quickwit-oss/quickwit · error

lambda function '{}' did not become ready within {} seconds

Error message

lambda function '{}' did not become ready within {} seconds

What it means

Thrown by wait_for_function_ready when the Lambda function does not reach a ready (Successful/Non-published) LastUpdateStatus within MAX_WAIT_ATTEMPTS * WAIT_INTERVAL seconds. The caller polls until the update completes; the bail fires on timeout.

Source

Thrown at quickwit/quickwit-lambda-client/src/deploy.rs:509

        if is_active && last_update_status == &LastUpdateStatus::Successful {
            info!(
                function_name = %function_name,
                attempts = attempt + 1,
                "lambda function is ready"
            );
            return Ok(());
        }

        info!(
            function_name = %function_name,
            state = ?config.state(),
            last_update_status = ?config.last_update_status(),
            attempt = attempt + 1,
            "waiting for Lambda function to be ready"
        );
    }

    anyhow::bail!(
        "lambda function '{}' did not become ready within {} seconds",
        function_name,
        MAX_WAIT_ATTEMPTS as u64 * WAIT_INTERVAL.as_secs()
    )
}

/// Garbage collect old Lambda versions, keeping the current + 5 most recent.
async fn garbage_collect_old_versions(
    client: &LambdaClient,
    function_name: &str,
    current_version: &str,
) -> anyhow::Result<()> {
    let mut quickwit_lambda_versions: Vec<(u64, String)> = Vec::new();
    let mut marker: Option<String> = None;

    // Collect all Quickwit-managed versions
    loop {
        let mut request = client

View on GitHub (pinned to a39730c5cd)

Solutions

1. Increase MAX_WAIT_ATTEMPTS or WAIT_INTERVAL in quickwit-lambda-client/src/deploy.rs and rebuild
2. Check the Lambda function's state in the AWS console; the update may complete after the timeout
3. Retry the deployment with a longer client-side wait
4. Reduce package size to speed up Lambda's publish step

Example fix

// before
const MAX_WAIT_ATTEMPTS: u32 = 60;
const WAIT_INTERVAL: Duration = Duration::from_secs(5);
// after
const MAX_WAIT_ATTEMPTS: u32 = 180;
const WAIT_INTERVAL: Duration = Duration::from_secs(5);

let start = std::time::Instant::now();
let timeout = Duration::from_secs(300);
// pass a wait budget >= expected publish time for your package size

for attempt in 0..3 {
    match update_and_wait(...).await {
        Err(e) if e.to_string().contains("did not become ready") => continue,
        other => break other,
    }
}

When it happens

Trigger: Calling update_function_code when Lambda takes longer than the hard-coded timeout (~MAX_WAIT_ATTEMPTS poll cycles) to finish publishing the new code, e.g. very large packages or slow Lambda-side processing.

Common situations: Deploying very large lambda artifacts over slow network/Lambda processing; temporary Lambda service slowness; the poll loop being too short for the deployment size.

Understand the failure class

Background: Request timed out: what client-side request timeouts mean across libraries (Request timed out, TIMED_OUT, APITimeoutError) — this error's family across 39 libraries.

Related errors

• lambda function '{}' last update failed: {}
• failed to list Lambda versions for '{}': {}
• created function has no version number
• failed to create Lambda function '{}': {}
• update_function_code response missing code_sha256

AI-assisted analysis of quickwit-oss/quickwit@a39730c5cd (2026-09-08). Data as JSON: /api/errors/9b3b19743357ed18. Report an issue: GitHub.