risingwavelabs/risingwave · critical

failed to execute on the compute node

Error message

failed to execute on the compute node

What it means

The frontend successfully chose a compute node, but the `fast_insert` gRPC call to it failed. This wraps tonic/RPC errors (transport failure, node died mid-call, or a compute-side execution error) and is surfaced as HTTP 500 INTERNAL_SERVER_ERROR. The insert did not complete on the compute node.

Source

Thrown at src/frontend/src/webhook/mod.rs:302

            })?;

        Ok(WebhookTableInsertContext {
            webhook_source_info,
            table_id,
            table_version_id,
            row_id_index,
            compute_client,
            payload_schema,
        })
    }

    async fn execute(
        request: FastInsertRequest,
        client: ComputeClient,
    ) -> Result<FastInsertResponse> {
        let response = client.fast_insert(request).await.map_err(|e| {
            err(
                anyhow!(e).context("failed to execute on the compute node"),
                StatusCode::INTERNAL_SERVER_ERROR,
            )
        })?;
        Ok(response)
    }
}

pub(crate) use handlers::acquire_table_info;

impl WebhookService {
    pub fn new(webhook_addr: SocketAddr, tls_config: Option<TlsConfig>) -> Self {
        Self {
            webhook_addr,
            tls_config,
            counter: AtomicU32::new(0),
        }
    }

View on GitHub (pinned to 6469eb736d)

Solutions

1. Retry the webhook request — a transient node restart will be healed on resend.
2. Check compute node logs at the request timestamp for the underlying fast_insert error.
3. Verify the target table still exists and is backed by a webhook source (SHOW SOURCES).
4. Check network connectivity/latency between frontend and compute nodes.
5. If persistent, restart the compute node and confirm the table's stream job is running.

Example fix

// before
await fetch(url, {method:'POST', body});
// after: treat 5xx as retryable
const res = await fetch(url, {method:'POST', body});
if (res.status >= 500) await sendWithRetry(url, body, attempt + 1);

// verify the table's webhook source is intact before sending
const src = await query(`SHOW SOURCES WHERE name LIKE '${table}'`);
if (src.length === 0) throw new Error('table is not webhook-backed');

try {
  const res = await fetch(url, { method: 'POST', body });
  if (!res.ok) throw new Error(await res.text());
} catch (e) {
  if (isRetryable(e)) return sendWithRetry(url, body, attempt + 1);
  throw e;
}

When it happens

Trigger: POST to a webhook endpoint when the compute node dies or restarts between client selection and RPC execution; network partition between frontend and compute; compute returns a status error while applying the FastInsertRequest (e.g. table dropped concurrently, write error).

Common situations: Compute crash mid-request; table dropped or migrated while webhooks still target it; network timeouts under load; connection pool exhaustion to the compute node.

Related errors

• Cannot open client to compute node {addr:?}
• Fast insert failed: {}
• Failed to choose a compute node for fast insert
• no chunk in IngestDmlPayloadRequest
• total_memory_bytes {} is larger than the total memory availa

AI-assisted analysis of risingwavelabs/risingwave@6469eb736d (2026-09-11). Data as JSON: /api/errors/ec24584590bfebd9. Report an issue: GitHub.