Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

ep: Back off Zeta requests after Cloud timeout (#58394)

Oleksiy Syvokon9e4943200fb0
diff --git a/crates/edit_prediction/src/edit_prediction.rs b/crates/edit_prediction/src/edit_prediction.rs
index 5e48063cd6d..483916a15ea 100644
--- a/crates/edit_prediction/src/edit_prediction.rs
+++ b/crates/edit_prediction/src/edit_prediction.rs
@@ -131,6 +131,7 @@ const GIT_CHANGED_FILE_SETS_COMMIT_LIMIT: usize = 100;
const LAST_CHANGE_GROUPING_TIME: Duration = Duration::from_secs(1);
const ZED_PREDICT_DATA_COLLECTION_CHOICE: &str = "zed_predict_data_collection_choice";
const REJECT_REQUEST_DEBOUNCE: Duration = Duration::from_secs(15);
+const REQUEST_TIMEOUT_BACKOFF: Duration = Duration::from_secs(10);
const EDIT_PREDICTION_SETTLED_TTL: Duration = Duration::from_secs(60 * 5);
const EDIT_PREDICTION_SETTLED_QUIESCENCE: Duration = Duration::from_secs(10);
@@ -167,6 +168,7 @@ pub struct EditPredictionStore {
update_required: bool,
edit_prediction_model: EditPredictionModel,
zeta2_raw_config: Option<Zeta2RawConfig>,
+ request_backoff_until: Option<Instant>,
preferred_experiment: Option<String>,
available_experiments: Vec<String>,
pub mercury: Mercury,
@@ -927,6 +929,7 @@ impl EditPredictionStore {
update_required: false,
edit_prediction_model: EditPredictionModel::Zeta,
zeta2_raw_config: Self::zeta2_raw_config_from_env(),
+ request_backoff_until: None,
preferred_experiment: None,
available_experiments: Vec::new(),
mercury: Mercury::new(cx),
@@ -969,6 +972,27 @@ impl EditPredictionStore {
self.zeta2_raw_config.as_ref()
}
+ pub(crate) fn back_off_requests_after_timeout(&mut self, cx: &mut Context<Self>) {
+ self.request_backoff_until = Some(cx.background_executor().now() + REQUEST_TIMEOUT_BACKOFF);
+ log::info!(
+ "Backing off edit prediction requests for {:?} after Cloud timeout",
+ REQUEST_TIMEOUT_BACKOFF
+ );
+ }
+
+ fn request_backoff_active(&mut self, cx: &App) -> bool {
+ let Some(backoff_until) = self.request_backoff_until else {
+ return false;
+ };
+
+ if cx.background_executor().now() < backoff_until {
+ true
+ } else {
+ self.request_backoff_until = None;
+ false
+ }
+ }
+
pub fn preferred_experiment(&self) -> Option<&str> {
self.preferred_experiment.as_deref()
}
@@ -2657,6 +2681,13 @@ impl EditPredictionStore {
return Task::ready(Ok(None));
}
+ if is_cloud_zeta && self.request_backoff_active(cx) {
+ log::debug!(
+ "Skipping Zeta edit prediction request while backing off after Cloud timeout"
+ );
+ return Task::ready(Ok(None));
+ }
+
self.get_or_init_project(&project, cx);
let project_state = self.projects.get(&project.entity_id()).unwrap();
let stored_events = project_state.events(cx);
@@ -3031,6 +3062,9 @@ impl EditPredictionStore {
let status = response.status();
let mut body = String::new();
response.body_mut().read_to_string(&mut body).await?;
+ if status == http_client::http::StatusCode::REQUEST_TIMEOUT {
+ return Err(anyhow::Error::new(CloudRequestTimeoutError));
+ }
anyhow::bail!("Request failed with status: {status:?}\nBody: {body}");
}
}
@@ -3405,6 +3439,10 @@ pub struct ZedUpdateRequiredError {
minimum_version: Version,
}
+#[derive(Error, Debug)]
+#[error("Cloud request timed out")]
+pub(crate) struct CloudRequestTimeoutError;
+
struct ZedPredictUpsell;
fn is_upsell_dismissed(cx: &App) -> bool {
diff --git a/crates/edit_prediction/src/edit_prediction_tests.rs b/crates/edit_prediction/src/edit_prediction_tests.rs
index 52c6948cdc5..7d4a5f54c38 100644
--- a/crates/edit_prediction/src/edit_prediction_tests.rs
+++ b/crates/edit_prediction/src/edit_prediction_tests.rs
@@ -48,6 +48,7 @@ use zeta_prompt::ZetaPromptInput;
use crate::{
BufferEditPrediction, EDIT_PREDICTION_SETTLED_QUIESCENCE, EditPredictionId,
EditPredictionJumpsFeatureFlag, EditPredictionStore, REJECT_REQUEST_DEBOUNCE,
+ REQUEST_TIMEOUT_BACKOFF,
};
#[gpui::test]
@@ -2066,6 +2067,63 @@ async fn test_jump_and_edit_throttles_are_independent(cx: &mut TestAppContext) {
cx.run_until_parked();
}
+#[gpui::test]
+async fn test_cloud_timeout_backs_off_zeta_requests(cx: &mut TestAppContext) {
+ let (ep_store, mut requests) = init_test_with_fake_client(cx);
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ "/root",
+ json!({
+ "foo.md": "Hello!\nHow\nBye\n"
+ }),
+ )
+ .await;
+ let project = Project::test(fs, vec![path!("/root").as_ref()], cx).await;
+
+ let buffer = project
+ .update(cx, |project, cx| {
+ let path = project.find_project_path(path!("root/foo.md"), cx).unwrap();
+ project.open_buffer(path, cx)
+ })
+ .await
+ .unwrap();
+ let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot());
+ let position = snapshot.anchor_before(language::Point::new(1, 3));
+
+ ep_store.update(cx, |ep_store, cx| {
+ ep_store.register_project(&project, cx);
+ ep_store.register_buffer(&buffer, &project, cx);
+ });
+
+ ep_store.update(cx, |ep_store, cx| {
+ ep_store.refresh_prediction_from_buffer(project.clone(), buffer.clone(), position, cx);
+ });
+ let (_request, respond_tx) = requests.predict.next().await.unwrap();
+ respond_tx.send(request_timeout_response()).unwrap();
+ cx.run_until_parked();
+
+ ep_store.update(cx, |ep_store, cx| {
+ ep_store.refresh_prediction_from_buffer(project.clone(), buffer.clone(), position, cx);
+ });
+ cx.background_executor
+ .advance_clock(EditPredictionStore::THROTTLE_TIMEOUT);
+ cx.background_executor.run_until_parked();
+ cx.run_until_parked();
+ assert_no_predict_request_ready(&mut requests.predict);
+
+ cx.background_executor
+ .advance_clock(REQUEST_TIMEOUT_BACKOFF);
+ cx.background_executor.run_until_parked();
+ cx.run_until_parked();
+
+ ep_store.update(cx, |ep_store, cx| {
+ ep_store.refresh_prediction_from_buffer(project.clone(), buffer.clone(), position, cx);
+ });
+ let (_request, respond_tx) = requests.predict.next().await.unwrap();
+ respond_tx.send(empty_response()).unwrap();
+ cx.run_until_parked();
+}
+
#[gpui::test]
async fn test_same_frame_duplicate_requests_deduplicated(cx: &mut TestAppContext) {
let (ep_store, mut requests) = init_test_with_fake_client(cx);
@@ -2546,6 +2604,18 @@ fn empty_response() -> PredictEditsV3Response {
}
}
+const REQUEST_TIMEOUT_RESPONSE_ID: &str = "__request_timeout__";
+
+fn request_timeout_response() -> PredictEditsV3Response {
+ PredictEditsV3Response {
+ request_id: REQUEST_TIMEOUT_RESPONSE_ID.to_string(),
+ editable_range: 0..0,
+ output: String::new(),
+ cursor_offset: None,
+ model_version: None,
+ }
+}
+
fn prompt_from_request(request: &PredictEditsV3Request) -> String {
zeta_prompt::format_zeta_prompt(&request.input, zeta_prompt::ZetaFormat::default())
.expect("default zeta prompt formatting should succeed in edit prediction tests")
@@ -2659,9 +2729,20 @@ fn init_test_with_fake_client_and_legacy_data_collection(
let decompressed = zstd::decode_all(&buf[..]).unwrap();
let req = serde_json::from_slice(&decompressed).unwrap();
- let (res_tx, res_rx) = oneshot::channel();
+ let (res_tx, res_rx) = oneshot::channel::<PredictEditsV3Response>();
predict_req_tx.unbounded_send((req, res_tx)).unwrap();
- serde_json::to_string(&res_rx.await?).unwrap()
+ let response = res_rx.await?;
+ if response.request_id == REQUEST_TIMEOUT_RESPONSE_ID {
+ return Ok(Response::builder()
+ .status(http_client::http::StatusCode::REQUEST_TIMEOUT)
+ .body(
+ http_client::http::StatusCode::REQUEST_TIMEOUT
+ .as_str()
+ .into(),
+ )
+ .unwrap());
+ }
+ serde_json::to_string(&response).unwrap()
}
"/predict_edits/reject" => {
let mut buf = Vec::new();
diff --git a/crates/edit_prediction/src/zeta.rs b/crates/edit_prediction/src/zeta.rs
index ee2bcd62f04..72463392dad 100644
--- a/crates/edit_prediction/src/zeta.rs
+++ b/crates/edit_prediction/src/zeta.rs
@@ -1,7 +1,7 @@
use crate::{
- CurrentEditPrediction, DebugEvent, EditPredictionFinishedDebugEvent, EditPredictionId,
- EditPredictionModelInput, EditPredictionStartedDebugEvent, EditPredictionStore,
- ZedUpdateRequiredError, buffer_path_with_id_fallback,
+ CloudRequestTimeoutError, CurrentEditPrediction, DebugEvent, EditPredictionFinishedDebugEvent,
+ EditPredictionId, EditPredictionModelInput, EditPredictionStartedDebugEvent,
+ EditPredictionStore, ZedUpdateRequiredError, buffer_path_with_id_fallback,
cursor_excerpt::{self, compute_cursor_excerpt, compute_syntax_ranges},
data_collection::UncommittedDiffResult,
prediction::EditPredictionResult,
@@ -491,6 +491,11 @@ fn handle_api_response<T>(
Ok(data)
}
Err(err) => {
+ if err.is::<CloudRequestTimeoutError>() {
+ this.update(cx, |this, cx| this.back_off_requests_after_timeout(cx))
+ .ok();
+ }
+
if err.is::<ZedUpdateRequiredError>() {
cx.update(|cx| {
this.update(cx, |this, _cx| {