Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
git: Add `dev: show git job queue` (#55904)
Cameron Mcloughlin68256f2e1da5
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rsindex 0b6316c4adc..61423e39b78 100644--- a/crates/git_ui/src/git_panel.rs+++ b/crates/git_ui/src/git_panel.rs@@ -120,6 +120,14 @@ actions!(]);+actions!(+ dev,+ [+ /// Shows the current git job queue debug state for the active repository.+ ShowGitJobQueue,+ ]+);+actions!(git_graph,[@@ -259,6 +267,13 @@ pub fn register(workspace: &mut Workspace) {panel.update(cx, |panel, cx| panel.git_init(window, cx));}});+ workspace.register_action(|workspace, _: &ShowGitJobQueue, window, cx| {+ if let Some(panel) = workspace.panel::<GitPanel>(cx) {+ panel.update(cx, |panel, cx| {+ panel.show_git_job_queue(window, cx);+ });+ }+ });}#[derive(Debug, Clone)]@@ -3880,6 +3895,74 @@ impl GitPanel {show_error_toast(workspace, action, e, cx)}+ fn show_git_job_queue(&mut self, window: &mut Window, cx: &mut Context<Self>) {+ let Some(repo) = self.active_repository.as_ref() else {+ let workspace = self.workspace.clone();+ cx.defer(move |cx| {+ if let Some(workspace) = workspace.upgrade() {+ workspace.update(cx, |workspace, cx| {+ struct GitJobQueueToast;+ workspace.show_toast(+ workspace::Toast::new(+ NotificationId::unique::<GitJobQueueToast>(),+ "No active repository",+ )+ .autohide(),+ cx,+ );+ });+ }+ });+ return;+ };++ let repo_path = repo.read(cx).work_directory_abs_path.display().to_string();+ let text = repo.read(cx).job_debug_queue().to_debug_string();+ let title = format!("Git Job Queue: {repo_path}");++ let json_language = self.project.read(cx).languages().language_for_name("JSON");+ let project = self.project.clone();+ let workspace = self.workspace.clone();++ window+ .spawn(cx, async move |cx| {+ let json_language = json_language.await.ok();++ let buffer = project+ .update(cx, |project, cx| {+ project.create_buffer(json_language, false, cx)+ })+ .await?;++ buffer.update(cx, |buffer, cx| {+ buffer.set_text(text, cx);+ buffer.set_capability(language::Capability::ReadWrite, cx);+ });++ workspace.update_in(cx, |workspace, window, cx| {+ let buffer =+ cx.new(|cx| MultiBuffer::singleton(buffer, cx).with_title(title.clone()));++ workspace.add_item_to_active_pane(+ Box::new(cx.new(|cx| {+ let mut editor =+ Editor::for_multibuffer(buffer, Some(project.clone()), window, cx);+ editor.set_breadcrumb_header(title);+ editor.disable_mouse_wheel_zoom();+ editor+ })),+ None,+ true,+ window,+ cx,+ );+ })?;++ anyhow::Ok(())+ })+ .detach_and_log_err(cx);+ }+fn show_commit_message_error<E>(weak_this: &WeakEntity<Self>, err: &E, cx: &mut AsyncApp)whereE: std::fmt::Debug + std::fmt::Display,diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rsindex 61cca22ff77..52c16e8a2ba 100644--- a/crates/project/src/git_store.rs+++ b/crates/project/src/git_store.rs@@ -1,6 +1,7 @@pub mod branch_diff;mod conflict_set;pub mod git_traversal;+pub mod job_debug_queue;pub mod pending_op;use crate::{@@ -380,6 +381,7 @@ pub struct Repository {paths_needing_status_update: Vec<Vec<RepoPath>>,job_sender: mpsc::UnboundedSender<GitJob>,active_jobs: HashMap<JobId, JobInfo>,+ job_debug_queue: job_debug_queue::GitJobDebugQueue,pending_ops: SumTree<PendingOps>,job_id: JobId,askpass_delegates: Arc<Mutex<HashMap<u64, AskPassDelegate>>>,@@ -507,6 +509,7 @@ impl EventEmitter<JobsUpdated> for Repository {}impl EventEmitter<GitStoreEvent> for GitStore {}pub struct GitJob {+ id: JobId,job: Box<dyn FnOnce(RepositoryState, &mut AsyncApp) -> Task<()>>,key: Option<GitJobKey>,}@@ -1384,7 +1387,7 @@ impl GitStore {.to_string();let rx = repo.update(cx, |repo, _| {- repo.send_job(None, move |state, cx| async move {+ repo.send_job("get_permalink_to_line", None, move |state, cx| async move {match state {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {let origin_url = backend@@ -4523,6 +4526,7 @@ impl Repository {job_sender,job_id: 0,active_jobs: Default::default(),+ job_debug_queue: job_debug_queue::GitJobDebugQueue::new(),initial_graph_data: Default::default(),commit_data: Default::default(),commit_data_handler: CommitDataHandlerState::Closed,@@ -4574,6 +4578,7 @@ impl Repository {askpass_delegates: Default::default(),latest_askpass_id: 0,active_jobs: Default::default(),+ job_debug_queue: job_debug_queue::GitJobDebugQueue::new(),job_id: 0,initial_graph_data: Default::default(),commit_data: Default::default(),@@ -4609,6 +4614,7 @@ impl Repository {let this = cx.weak_entity();let git_store = self.git_store.clone();let _ = self.send_keyed_job(+ "reload_buffer_diff_bases",Some(GitJobKey::ReloadBufferDiffBases),None,|state, mut cx| async move {@@ -4768,6 +4774,7 @@ impl Repository {pub fn send_job<F, Fut, R>(&mut self,+ description: &'static str,status: Option<SharedString>,job: F,) -> oneshot::Receiver<R>@@ -4776,11 +4783,12 @@ impl Repository {Fut: Future<Output = R> + 'static,R: Send + 'static,{- self.send_keyed_job(None, status, job)+ self.send_keyed_job(description, None, status, job)}fn send_keyed_job<F, Fut, R>(&mut self,+ description: &'static str,key: Option<GitJobKey>,status: Option<SharedString>,job: F,@@ -4793,29 +4801,39 @@ impl Repository {let (result_tx, result_rx) = futures::channel::oneshot::channel();let job_id = post_inc(&mut self.job_id);let this = self.this.clone();++ let key_label = key.as_ref().map(format_job_key);+ self.job_debug_queue.add(job_id, description, key_label);+self.job_sender.unbounded_send(GitJob {+ id: job_id,key,job: Box::new(move |state, cx: &mut AsyncApp| {let job = job(state, cx.clone());cx.spawn(async move |cx| {- if let Some(s) = status.clone() {- this.update(cx, |this, cx| {+ this.update(cx, |this, cx| {+ this.job_debug_queue.mark_running(job_id);+ if let Some(s) = status {this.active_jobs.insert(job_id,JobInfo {start: Instant::now(),- message: s.clone(),+ message: s,},);+ }+ cx.notify();+ })+ .ok();- cx.notify();- })- .ok();- }let result = job.await;this.update(cx, |this, cx| {+ this.job_debug_queue.mark_complete(+ job_id,+ job_debug_queue::CompletedJobStatus::Finished,+ );this.active_jobs.remove(&job_id);cx.notify();})@@ -4898,43 +4916,47 @@ impl Repository {}let this = cx.weak_entity();- let rx = self.send_job(None, move |state, mut cx| async move {- let Some(this) = this.upgrade() else {- bail!("git store was dropped");- };- match state {- RepositoryState::Local(..) => {- this.update(&mut cx, |_, cx| {- Self::open_local_commit_buffer(languages, buffer_store, cx)- })- .await- }- RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {- let request = client.request(proto::OpenCommitMessageBuffer {- project_id: project_id.0,- repository_id: id.to_proto(),- });- let response = request.await.context("requesting to open commit buffer")?;- let buffer_id = BufferId::new(response.buffer_id)?;- let buffer = buffer_store- .update(&mut cx, |buffer_store, cx| {- buffer_store.wait_for_remote_buffer(buffer_id, cx)+ let rx = self.send_job(+ "open_commit_buffer",+ None,+ move |state, mut cx| async move {+ let Some(this) = this.upgrade() else {+ bail!("git store was dropped");+ };+ match state {+ RepositoryState::Local(..) => {+ this.update(&mut cx, |_, cx| {+ Self::open_local_commit_buffer(languages, buffer_store, cx)})- .await?;- if let Some(language_registry) = languages {- let git_commit_language =- language_registry.language_for_name("Git Commit").await?;- buffer.update(&mut cx, |buffer, cx| {- buffer.set_language(Some(git_commit_language), cx);+ .await+ }+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ let request = client.request(proto::OpenCommitMessageBuffer {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ });+ let response = request.await.context("requesting to open commit buffer")?;+ let buffer_id = BufferId::new(response.buffer_id)?;+ let buffer = buffer_store+ .update(&mut cx, |buffer_store, cx| {+ buffer_store.wait_for_remote_buffer(buffer_id, cx)+ })+ .await?;+ if let Some(language_registry) = languages {+ let git_commit_language =+ language_registry.language_for_name("Git Commit").await?;+ buffer.update(&mut cx, |buffer, cx| {+ buffer.set_language(Some(git_commit_language), cx);+ });+ }+ this.update(&mut cx, |this, _| {+ this.commit_message_buffer = Some(buffer.clone());});+ Ok(buffer)}- this.update(&mut cx, |this, _| {- this.commit_message_buffer = Some(buffer.clone());- });- Ok(buffer)}- }- });+ },+ );cx.spawn(|_, _: &mut AsyncApp| async move { rx.await? })}@@ -4980,6 +5002,7 @@ impl Repository {async move |this, cx| {this.update(cx, |this, _cx| {this.send_job(+ "checkout_files",Some(format!("git checkout {}", commit).into()),move |git_repo, _| async move {match git_repo {@@ -5027,7 +5050,7 @@ impl Repository {) -> oneshot::Receiver<Result<()>> {let id = self.id;- self.send_job(None, move |git_repo, _| async move {+ self.send_job("reset", None, move |git_repo, _| async move {match git_repo {RepositoryState::Local(LocalRepositoryState {backend,@@ -5055,7 +5078,7 @@ impl Repository {pub fn show(&mut self, commit: String) -> oneshot::Receiver<Result<CommitDetails>> {let id = self.id;- self.send_job(None, move |git_repo, _cx| async move {+ self.send_job("show", None, move |git_repo, _cx| async move {match git_repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.show(commit).await@@ -5083,7 +5106,7 @@ impl Repository {pub fn load_commit_diff(&mut self, commit: String) -> oneshot::Receiver<Result<CommitDiff>> {let id = self.id;- self.send_job(None, move |git_repo, cx| async move {+ self.send_job("load_commit_diff", None, move |git_repo, cx| async move {match git_repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.load_commit(commit, cx).await@@ -5869,6 +5892,7 @@ impl Repository {this.update(cx, |this, cx| {let weak_this = cx.weak_entity();this.send_keyed_job(+ "stage_or_unstage_entries",Some(job_key),Some(status.into()),move |git_repo, mut cx| async move {@@ -6095,7 +6119,7 @@ impl Repository {cx.spawn(async move |this, cx| {this.update(cx, |this, _| {- this.send_job(None, move |git_repo, _cx| async move {+ this.send_job("stash_entries", None, move |git_repo, _cx| async move {match git_repo {RepositoryState::Local(LocalRepositoryState {backend,@@ -6131,7 +6155,7 @@ impl Repository {let id = self.id;cx.spawn(async move |this, cx| {this.update(cx, |this, _| {- this.send_job(None, move |git_repo, _cx| async move {+ this.send_job("stash_pop", None, move |git_repo, _cx| async move {match git_repo {RepositoryState::Local(LocalRepositoryState {backend,@@ -6165,7 +6189,7 @@ impl Repository {let id = self.id;cx.spawn(async move |this, cx| {this.update(cx, |this, _| {- this.send_job(None, move |git_repo, _cx| async move {+ this.send_job("stash_apply", None, move |git_repo, _cx| async move {match git_repo {RepositoryState::Local(LocalRepositoryState {backend,@@ -6204,40 +6228,44 @@ impl Repository {path_display.to_string()};- self.send_job(None, move |git_repo, _cx| async move {- match git_repo {- RepositoryState::Local(LocalRepositoryState { fs, .. }) => {- let gitignore_path = work_dir.join(".gitignore");+ self.send_job(+ "add_path_to_gitignore",+ None,+ move |git_repo, _cx| async move {+ match git_repo {+ RepositoryState::Local(LocalRepositoryState { fs, .. }) => {+ let gitignore_path = work_dir.join(".gitignore");- let existing_content = fs.load(&gitignore_path).await.unwrap_or_default();+ let existing_content = fs.load(&gitignore_path).await.unwrap_or_default();- if existing_content- .lines()- .any(|line| line.trim() == file_path_str)- {- return Ok(());- }+ if existing_content+ .lines()+ .any(|line| line.trim() == file_path_str)+ {+ return Ok(());+ }- let new_content = if existing_content.is_empty() {- format!("{}\n", file_path_str)- } else if existing_content.ends_with('\n') {- format!("{}{}\n", existing_content, file_path_str)- } else {- format!("{}\n{}\n", existing_content, file_path_str)- };+ let new_content = if existing_content.is_empty() {+ format!("{}\n", file_path_str)+ } else if existing_content.ends_with('\n') {+ format!("{}{}\n", existing_content, file_path_str)+ } else {+ format!("{}\n{}\n", existing_content, file_path_str)+ };- fs.save(- &gitignore_path,- &text::Rope::from(new_content.as_str()),- text::LineEnding::Unix,- )- .await+ fs.save(+ &gitignore_path,+ &text::Rope::from(new_content.as_str()),+ text::LineEnding::Unix,+ )+ .await+ }+ RepositoryState::Remote(_) => Err(anyhow::anyhow!(+ "Cannot modify .gitignore on remote repository"+ )),}- RepositoryState::Remote(_) => Err(anyhow::anyhow!(- "Cannot modify .gitignore on remote repository"- )),- }- })+ },+ )}pub fn stash_drop(@@ -6255,7 +6283,7 @@ impl Repository {_ => None,});let this = cx.weak_entity();- self.send_job(None, move |git_repo, mut cx| async move {+ self.send_job("stash_drop", None, move |git_repo, mut cx| async move {match git_repo {RepositoryState::Local(LocalRepositoryState {backend,@@ -6299,6 +6327,7 @@ impl Repository {pub fn run_hook(&mut self, hook: RunHook, _cx: &mut App) -> oneshot::Receiver<Result<()>> {let id = self.id;self.send_job(+ "run_hook",Some(format!("git hook {}", hook.as_str()).into()),move |git_repo, _cx| async move {match git_repo {@@ -6337,46 +6366,50 @@ impl Repository {let rx = self.run_hook(RunHook::PreCommit, cx);- self.send_job(Some("git commit".into()), move |git_repo, _cx| async move {- rx.await??;+ self.send_job(+ "commit",+ Some("git commit".into()),+ move |git_repo, _cx| async move {+ rx.await??;- match git_repo {- RepositoryState::Local(LocalRepositoryState {- backend,- environment,- ..- }) => {- backend- .commit(message, name_and_email, options, askpass, environment)- .await- }- RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {- askpass_delegates.lock().insert(askpass_id, askpass);- let _defer = util::defer(|| {- let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);- debug_assert!(askpass_delegate.is_some());- });- let (name, email) = name_and_email.unzip();- client- .request(proto::Commit {- project_id: project_id.0,- repository_id: id.to_proto(),- message: String::from(message),- name: name.map(String::from),- email: email.map(String::from),- options: Some(proto::commit::CommitOptions {- amend: options.amend,- signoff: options.signoff,- allow_empty: options.allow_empty,- }),- askpass_id,- })- .await?;+ match git_repo {+ RepositoryState::Local(LocalRepositoryState {+ backend,+ environment,+ ..+ }) => {+ backend+ .commit(message, name_and_email, options, askpass, environment)+ .await+ }+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ askpass_delegates.lock().insert(askpass_id, askpass);+ let _defer = util::defer(|| {+ let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);+ debug_assert!(askpass_delegate.is_some());+ });+ let (name, email) = name_and_email.unzip();+ client+ .request(proto::Commit {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ message: String::from(message),+ name: name.map(String::from),+ email: email.map(String::from),+ options: Some(proto::commit::CommitOptions {+ amend: options.amend,+ signoff: options.signoff,+ allow_empty: options.allow_empty,+ }),+ askpass_id,+ })+ .await?;- Ok(())+ Ok(())+ }}- }- })+ },+ )}pub fn fetch(@@ -6389,36 +6422,40 @@ impl Repository {let askpass_id = util::post_inc(&mut self.latest_askpass_id);let id = self.id;- self.send_job(Some("git fetch".into()), move |git_repo, cx| async move {- match git_repo {- RepositoryState::Local(LocalRepositoryState {- backend,- environment,- ..- }) => backend.fetch(fetch_options, askpass, environment, cx).await,- RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {- askpass_delegates.lock().insert(askpass_id, askpass);- let _defer = util::defer(|| {- let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);- debug_assert!(askpass_delegate.is_some());- });+ self.send_job(+ "fetch",+ Some("git fetch".into()),+ move |git_repo, cx| async move {+ match git_repo {+ RepositoryState::Local(LocalRepositoryState {+ backend,+ environment,+ ..+ }) => backend.fetch(fetch_options, askpass, environment, cx).await,+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ askpass_delegates.lock().insert(askpass_id, askpass);+ let _defer = util::defer(|| {+ let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);+ debug_assert!(askpass_delegate.is_some());+ });- let response = client- .request(proto::Fetch {- project_id: project_id.0,- repository_id: id.to_proto(),- askpass_id,- remote: fetch_options.to_proto(),- })- .await?;+ let response = client+ .request(proto::Fetch {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ askpass_id,+ remote: fetch_options.to_proto(),+ })+ .await?;- Ok(RemoteCommandOutput {- stdout: response.stdout,- stderr: response.stderr,- })+ Ok(RemoteCommandOutput {+ stdout: response.stdout,+ stderr: response.stderr,+ })+ }}- }- })+ },+ )}pub fn push(@@ -6452,6 +6489,7 @@ impl Repository {let this = cx.weak_entity();self.send_job(+ "push",Some(format!("git push {} {} {}:{}", args, remote, branch, remote_branch).into()),move |git_repo, mut cx| async move {match git_repo {@@ -6544,48 +6582,52 @@ impl Repository {status.push_str(&format!(" {}", b));}- self.send_job(Some(status.into()), move |git_repo, cx| async move {- match git_repo {- RepositoryState::Local(LocalRepositoryState {- backend,- environment,- ..- }) => {- backend- .pull(- branch.as_ref().map(|b| b.to_string()),- remote.to_string(),- rebase,- askpass,- environment.clone(),- cx,- )- .await- }- RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {- askpass_delegates.lock().insert(askpass_id, askpass);- let _defer = util::defer(|| {- let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);- debug_assert!(askpass_delegate.is_some());- });- let response = client- .request(proto::Pull {- project_id: project_id.0,- repository_id: id.to_proto(),- askpass_id,- rebase,- branch_name: branch.as_ref().map(|b| b.to_string()),- remote_name: remote.to_string(),- })- .await?;+ self.send_job(+ "pull",+ Some(status.into()),+ move |git_repo, cx| async move {+ match git_repo {+ RepositoryState::Local(LocalRepositoryState {+ backend,+ environment,+ ..+ }) => {+ backend+ .pull(+ branch.as_ref().map(|b| b.to_string()),+ remote.to_string(),+ rebase,+ askpass,+ environment.clone(),+ cx,+ )+ .await+ }+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ askpass_delegates.lock().insert(askpass_id, askpass);+ let _defer = util::defer(|| {+ let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);+ debug_assert!(askpass_delegate.is_some());+ });+ let response = client+ .request(proto::Pull {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ askpass_id,+ rebase,+ branch_name: branch.as_ref().map(|b| b.to_string()),+ remote_name: remote.to_string(),+ })+ .await?;- Ok(RemoteCommandOutput {- stdout: response.stdout,- stderr: response.stderr,- })+ Ok(RemoteCommandOutput {+ stdout: response.stdout,+ stderr: response.stderr,+ })+ }}- }- })+ },+ )}fn spawn_set_index_text_job(@@ -6600,6 +6642,7 @@ impl Repository {let git_store = self.git_store.clone();let abs_path = self.snapshot.repo_path_to_abs_path(&path);self.send_keyed_job(+ "spawn_set_index_text_job",Some(GitJobKey::WriteIndex(vec![path.clone()])),None,move |git_repo, mut cx| async move {@@ -6674,6 +6717,7 @@ impl Repository {) -> oneshot::Receiver<Result<()>> {let id = self.id;self.send_job(+ "create_remote",Some(format!("git remote add {remote_name} {remote_url}").into()),move |repo, _cx| async move {match repo {@@ -6700,6 +6744,7 @@ impl Repository {pub fn remove_remote(&mut self, remote_name: String) -> oneshot::Receiver<Result<()>> {let id = self.id;self.send_job(+ "remove_remote",Some(format!("git remove remote {remote_name}").into()),move |repo, _cx| async move {match repo {@@ -6728,7 +6773,7 @@ impl Repository {is_push: bool,) -> oneshot::Receiver<Result<Vec<Remote>>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("get_remotes", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {let remote = if let Some(branch_name) = branch_name {@@ -6772,7 +6817,7 @@ impl Repository {pub fn branches(&mut self) -> oneshot::Receiver<Result<Vec<Branch>>> {let id = self.id;- self.send_job(None, move |repo, _| async move {+ self.send_job("branches", None, move |repo, _| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.branches().await@@ -6831,7 +6876,7 @@ impl Repository {pub fn worktrees(&mut self) -> oneshot::Receiver<Result<Vec<GitWorktree>>> {let id = self.id;- self.send_job(None, move |repo, _| async move {+ self.send_job("worktrees", None, move |repo, _| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.worktrees().await@@ -6866,38 +6911,42 @@ impl Repository {Some(branch_name) => format!("git worktree add: {branch_name}"),None => "git worktree add (detached)".to_string(),};- self.send_job(Some(job_description.into()), move |repo, _cx| async move {- match repo {- RepositoryState::Local(LocalRepositoryState { backend, .. }) => {- backend.create_worktree(target, path).await- }- RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {- let (name, commit, use_existing_branch) = match target {- CreateWorktreeTarget::ExistingBranch { branch_name } => {- (Some(branch_name), None, true)- }- CreateWorktreeTarget::NewBranch {- branch_name,- base_sha,- } => (Some(branch_name), base_sha, false),- CreateWorktreeTarget::Detached { base_sha } => (None, base_sha, false),- };+ self.send_job(+ "create_worktree",+ Some(job_description.into()),+ move |repo, _cx| async move {+ match repo {+ RepositoryState::Local(LocalRepositoryState { backend, .. }) => {+ backend.create_worktree(target, path).await+ }+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ let (name, commit, use_existing_branch) = match target {+ CreateWorktreeTarget::ExistingBranch { branch_name } => {+ (Some(branch_name), None, true)+ }+ CreateWorktreeTarget::NewBranch {+ branch_name,+ base_sha,+ } => (Some(branch_name), base_sha, false),+ CreateWorktreeTarget::Detached { base_sha } => (None, base_sha, false),+ };- client- .request(proto::GitCreateWorktree {- project_id: project_id.0,- repository_id: id.to_proto(),- name: name.unwrap_or_default(),- directory: path.to_string_lossy().to_string(),- commit,- use_existing_branch,- })- .await?;+ client+ .request(proto::GitCreateWorktree {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ name: name.unwrap_or_default(),+ directory: path.to_string_lossy().to_string(),+ commit,+ use_existing_branch,+ })+ .await?;- Ok(())+ Ok(())+ }}- }- })+ },+ )}pub fn create_worktree_detached(@@ -6924,24 +6973,30 @@ impl Repository {} else {format!("git checkout {branch_name}")};- self.send_job(Some(description.into()), move |repo, _cx| async move {- match repo {- RepositoryState::Local(LocalRepositoryState { backend, .. }) => {- backend- .checkout_branch_in_worktree(branch_name, worktree_path, create)- .await- }- RepositoryState::Remote(_) => {- log::warn!("checkout_branch_in_worktree not supported for remote repositories");- Ok(())+ self.send_job(+ "checkout_branch_in_worktree",+ Some(description.into()),+ move |repo, _cx| async move {+ match repo {+ RepositoryState::Local(LocalRepositoryState { backend, .. }) => {+ backend+ .checkout_branch_in_worktree(branch_name, worktree_path, create)+ .await+ }+ RepositoryState::Remote(_) => {+ log::warn!(+ "checkout_branch_in_worktree not supported for remote repositories"+ );+ Ok(())+ }}- }- })+ },+ )}pub fn head_sha(&mut self) -> oneshot::Receiver<Result<Option<String>>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("head_sha", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {Ok(backend.head_sha().await)@@ -6966,7 +7021,7 @@ impl Repository {commit: Option<String>,) -> oneshot::Receiver<Result<()>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("edit_ref", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => match commit {Some(commit) => backend.update_ref(ref_name, commit).await,@@ -7007,7 +7062,7 @@ impl Repository {pub fn repair_worktrees(&mut self) -> oneshot::Receiver<Result<()>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("repair_worktrees", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.repair_worktrees().await@@ -7027,22 +7082,26 @@ impl Repository {pub fn create_archive_checkpoint(&mut self) -> oneshot::Receiver<Result<(String, String)>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {- match repo {- RepositoryState::Local(LocalRepositoryState { backend, .. }) => {- backend.create_archive_checkpoint().await- }- RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {- let response = client- .request(proto::GitCreateArchiveCheckpoint {- project_id: project_id.0,- repository_id: id.to_proto(),- })- .await?;- Ok((response.staged_commit_sha, response.unstaged_commit_sha))+ self.send_job(+ "create_archive_checkpoint",+ None,+ move |repo, _cx| async move {+ match repo {+ RepositoryState::Local(LocalRepositoryState { backend, .. }) => {+ backend.create_archive_checkpoint().await+ }+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ let response = client+ .request(proto::GitCreateArchiveCheckpoint {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ })+ .await?;+ Ok((response.staged_commit_sha, response.unstaged_commit_sha))+ }}- }- })+ },+ )}pub fn restore_archive_checkpoint(@@ -7051,26 +7110,30 @@ impl Repository {unstaged_sha: String,) -> oneshot::Receiver<Result<()>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {- match repo {- RepositoryState::Local(LocalRepositoryState { backend, .. }) => {- backend- .restore_archive_checkpoint(staged_sha, unstaged_sha)- .await- }- RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {- client- .request(proto::GitRestoreArchiveCheckpoint {- project_id: project_id.0,- repository_id: id.to_proto(),- staged_commit_sha: staged_sha,- unstaged_commit_sha: unstaged_sha,- })- .await?;- Ok(())+ self.send_job(+ "restore_archive_checkpoint",+ None,+ move |repo, _cx| async move {+ match repo {+ RepositoryState::Local(LocalRepositoryState { backend, .. }) => {+ backend+ .restore_archive_checkpoint(staged_sha, unstaged_sha)+ .await+ }+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ client+ .request(proto::GitRestoreArchiveCheckpoint {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ staged_commit_sha: staged_sha,+ unstaged_commit_sha: unstaged_sha,+ })+ .await?;+ Ok(())+ }}- }- })+ },+ )}pub fn remove_worktree(&mut self, path: PathBuf, force: bool) -> oneshot::Receiver<Result<()>> {@@ -7081,6 +7144,7 @@ impl Repository {.unwrap_or(self.snapshot.common_dir_abs_path.as_ref()).into();self.send_job(+ "remove_worktree",Some(format!("git worktree remove: {}", path.display()).into()),move |repo, cx| async move {match repo {@@ -7165,6 +7229,7 @@ impl Repository {) -> oneshot::Receiver<Result<()>> {let id = self.id;self.send_job(+ "rename_worktree",Some(format!("git worktree move: {}", old_path.display()).into()),move |repo, _cx| async move {match repo {@@ -7193,7 +7258,7 @@ impl Repository {include_remote_name: bool,) -> oneshot::Receiver<Result<Option<SharedString>>> {let id = self.id;- self.send_job(None, move |repo, _| async move {+ self.send_job("default_branch", None, move |repo, _| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.default_branch(include_remote_name).await@@ -7218,7 +7283,7 @@ impl Repository {_cx: &App,) -> oneshot::Receiver<Result<TreeDiff>> {let repository_id = self.snapshot.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("diff_tree", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.diff_tree(diff_type).await@@ -7274,7 +7339,7 @@ impl Repository {pub fn diff(&mut self, diff_type: DiffType, _cx: &App) -> oneshot::Receiver<Result<String>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("diff", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.diff(diff_type).await@@ -7318,30 +7383,35 @@ impl Repository {} else {format!("git switch -c {branch_name}").into()};- self.send_job(Some(status_msg), move |repo, _cx| async move {- match repo {- RepositoryState::Local(LocalRepositoryState { backend, .. }) => {- backend.create_branch(branch_name, base_branch).await- }- RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {- client- .request(proto::GitCreateBranch {- project_id: project_id.0,- repository_id: id.to_proto(),- branch_name,- base_branch,- })- .await?;+ self.send_job(+ "create_branch",+ Some(status_msg),+ move |repo, _cx| async move {+ match repo {+ RepositoryState::Local(LocalRepositoryState { backend, .. }) => {+ backend.create_branch(branch_name, base_branch).await+ }+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ client+ .request(proto::GitCreateBranch {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ branch_name,+ base_branch,+ })+ .await?;- Ok(())+ Ok(())+ }}- }- })+ },+ )}pub fn change_branch(&mut self, branch_name: String) -> oneshot::Receiver<Result<()>> {let id = self.id;self.send_job(+ "change_branch",Some(format!("git switch {branch_name}").into()),move |repo, _cx| async move {match repo {@@ -7373,6 +7443,7 @@ impl Repository {let id = self.id;let flag = delete_branch_flag(is_remote, force);self.send_job(+ "delete_branch",Some(format!("git branch {flag} {branch_name}").into()),move |repo, _cx| async move {match repo {@@ -7407,6 +7478,7 @@ impl Repository {) -> oneshot::Receiver<Result<()>> {let id = self.id;self.send_job(+ "rename_branch",Some(format!("git branch -m {branch} {new_name}").into()),move |repo, _cx| async move {match repo {@@ -7432,30 +7504,34 @@ impl Repository {pub fn check_for_pushed_commits(&mut self) -> oneshot::Receiver<Result<Vec<SharedString>>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {- match repo {- RepositoryState::Local(LocalRepositoryState { backend, .. }) => {- backend.check_for_pushed_commit().await- }- RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {- let response = client- .request(proto::CheckForPushedCommits {- project_id: project_id.0,- repository_id: id.to_proto(),- })- .await?;+ self.send_job(+ "check_for_pushed_commits",+ None,+ move |repo, _cx| async move {+ match repo {+ RepositoryState::Local(LocalRepositoryState { backend, .. }) => {+ backend.check_for_pushed_commit().await+ }+ RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {+ let response = client+ .request(proto::CheckForPushedCommits {+ project_id: project_id.0,+ repository_id: id.to_proto(),+ })+ .await?;- let branches = response.pushed_to.into_iter().map(Into::into).collect();+ let branches = response.pushed_to.into_iter().map(Into::into).collect();- Ok(branches)+ Ok(branches)+ }}- }- })+ },+ )}pub fn checkpoint(&mut self) -> oneshot::Receiver<Result<GitRepositoryCheckpoint>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("checkpoint", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.checkpoint().await@@ -7481,7 +7557,7 @@ impl Repository {checkpoint: GitRepositoryCheckpoint,) -> oneshot::Receiver<Result<()>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("restore_checkpoint", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.restore_checkpoint(checkpoint).await@@ -7603,7 +7679,7 @@ impl Repository {right: GitRepositoryCheckpoint,) -> oneshot::Receiver<Result<bool>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("compare_checkpoints", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.compare_checkpoints(left, right).await@@ -7629,7 +7705,7 @@ impl Repository {target_checkpoint: GitRepositoryCheckpoint,) -> oneshot::Receiver<Result<String>> {let id = self.id;- self.send_job(None, move |repo, _cx| async move {+ self.send_job("diff_checkpoints", None, move |repo, _cx| async move {match repo {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend@@ -7684,6 +7760,7 @@ impl Repository {) {let this = cx.weak_entity();let _ = self.send_keyed_job(+ "schedule_scan",Some(GitJobKey::ReloadGitState),None,|state, mut cx| async move {@@ -7715,7 +7792,7 @@ impl Repository {) -> mpsc::UnboundedSender<GitJob> {let (job_tx, mut job_rx) = mpsc::unbounded::<GitJob>();- cx.spawn(async move |_, cx| {+ cx.spawn(async move |this, cx| {let state = state.await.map_err(|err| anyhow::anyhow!(err))?;if let Some(git_hosting_provider_registry) =cx.update(|cx| GitHostingProviderRegistry::try_global(cx))@@ -7739,6 +7816,14 @@ impl Repository {.iter().any(|other_job| other_job.key.as_ref() == Some(current_key)){+ let skipped_job_id = job.id;+ this.update(cx, |repo, _| {+ repo.job_debug_queue.mark_complete(+ skipped_job_id,+ job_debug_queue::CompletedJobStatus::Skipped,+ );+ })+ .ok();continue;}(job.job)(state.clone(), cx).await;@@ -7761,7 +7846,7 @@ impl Repository {) -> mpsc::UnboundedSender<GitJob> {let (job_tx, mut job_rx) = mpsc::unbounded::<GitJob>();- cx.spawn(async move |_, cx| {+ cx.spawn(async move |this, cx| {let state = RepositoryState::Remote(state);let mut jobs = VecDeque::new();loop {@@ -7775,6 +7860,14 @@ impl Repository {.iter().any(|other_job| other_job.key.as_ref() == Some(current_key)){+ let skipped_job_id = job.id;+ this.update(cx, |repo, _| {+ repo.job_debug_queue.mark_complete(+ skipped_job_id,+ job_debug_queue::CompletedJobStatus::Skipped,+ );+ })+ .ok();continue;}(job.job)(state.clone(), cx).await;@@ -7797,7 +7890,7 @@ impl Repository {repo_path: RepoPath,cx: &App,) -> Task<Result<Option<String>>> {- let rx = self.send_job(None, move |state, _| async move {+ let rx = self.send_job("load_staged_text", None, move |state, _| async move {match state {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {anyhow::Ok(backend.load_index_text(repo_path).await)@@ -7822,7 +7915,7 @@ impl Repository {repo_path: RepoPath,cx: &App,) -> Task<Result<DiffBasesChange>> {- let rx = self.send_job(None, move |state, _| async move {+ let rx = self.send_job("load_committed_text", None, move |state, _| async move {match state {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {let committed_text = backend.load_committed_text(repo_path.clone()).await;@@ -7865,19 +7958,23 @@ impl Repository {pub fn load_commit_template_text(&mut self,) -> oneshot::Receiver<Result<Option<GitCommitTemplate>>> {- self.send_job(None, move |git_repo, _cx| async move {- match git_repo {- RepositoryState::Local(LocalRepositoryState { backend, .. }) => {- backend.load_commit_template().await+ self.send_job(+ "load_commit_template_text",+ None,+ move |git_repo, _cx| async move {+ match git_repo {+ RepositoryState::Local(LocalRepositoryState { backend, .. }) => {+ backend.load_commit_template().await+ }+ RepositoryState::Remote(_) => Ok(None),}- RepositoryState::Remote(_) => Ok(None),- }- })+ },+ )}fn load_blob_content(&mut self, oid: Oid, cx: &App) -> Task<Result<String>> {let repository_id = self.snapshot.id;- let rx = self.send_job(None, move |state, _| async move {+ let rx = self.send_job("load_blob_content", None, move |state, _| async move {match state {RepositoryState::Local(LocalRepositoryState { backend, .. }) => {backend.load_blob_content(oid).await@@ -7909,6 +8006,7 @@ impl Repository {let this = cx.weak_entity();let _ = self.send_keyed_job(+ "paths_changed",Some(GitJobKey::RefreshStatuses),None,|state, mut cx| async move {@@ -8015,8 +8113,12 @@ impl Repository {self.active_jobs.values().next().cloned()}+ pub fn job_debug_queue(&self) -> &job_debug_queue::GitJobDebugQueue {+ &self.job_debug_queue+ }+pub fn barrier(&mut self) -> oneshot::Receiver<()> {- self.send_job(None, |_, _| async {})+ self.send_job("barrier", None, |_, _| async {})}fn spawn_job_with_tracking<AsyncFn>(@@ -8086,7 +8188,7 @@ impl Repository {}pub fn access(&mut self, _cx: &App) -> oneshot::Receiver<GitAccess> {- self.send_job(None, move |git_repo, _cx| async move {+ self.send_job("access", None, move |git_repo, _cx| async move {match git_repo {// TODO: Correctly handle remote repositories, where the user// that's running the Zed remote may not own the `.git/`@@ -8108,6 +8210,24 @@ impl Repository {}}+fn format_job_key(key: &GitJobKey) -> SharedString {+ match key {+ GitJobKey::WriteIndex(paths) => {+ let paths_str: Vec<_> = paths+ .iter()+ .map(|p| {+ let rel: &RelPath = p;+ format!("{}", AsRef::<Path>::as_ref(rel).display())+ })+ .collect();+ format!("WriteIndex({})", paths_str.join(", ")).into()+ }+ GitJobKey::ReloadBufferDiffBases => "ReloadBufferDiffBases".into(),+ GitJobKey::RefreshStatuses => "RefreshStatuses".into(),+ GitJobKey::ReloadGitState => "ReloadGitState".into(),+ }+}+/// If `path` is a git linked worktree checkout, resolves it to the main/// repository's identity path. For regular linked worktrees this is the main/// repository's working directory; for linked worktrees backed by a bare repodiff --git a/crates/project/src/git_store/job_debug_queue.rs b/crates/project/src/git_store/job_debug_queue.rsnew file mode 100644index 00000000000..c204451d58b--- /dev/null+++ b/crates/project/src/git_store/job_debug_queue.rs@@ -0,0 +1,222 @@+use std::{collections::VecDeque, time::Instant};++use gpui::SharedString;++use super::JobId;++pub struct GitJobDebugQueue {+ pending: VecDeque<PendingJob>,+ running: VecDeque<RunningJob>,+ completed: VecDeque<CompletedJob>,+}++const MAX_COMPLETED_JOBS: usize = 500;++#[derive(Clone, Debug)]+pub struct PendingJob {+ pub id: JobId,+ pub description: SharedString,+ pub key: Option<SharedString>,+ pub enqueued_at: Instant,+}++#[derive(Clone, Debug)]+pub struct RunningJob {+ pub id: JobId,+ pub description: SharedString,+ pub key: Option<SharedString>,+ pub enqueued_at: Instant,+ pub started_at: Instant,+}++#[derive(Clone, Debug)]+pub struct CompletedJob {+ pub id: JobId,+ pub description: SharedString,+ pub key: Option<SharedString>,+ pub enqueued_at: Instant,+ pub started_at: Option<Instant>,+ pub completed_at: Instant,+ pub status: CompletedJobStatus,+}++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum CompletedJobStatus {+ Finished,+ Skipped,+}++impl GitJobDebugQueue {+ pub fn new() -> Self {+ Self {+ pending: VecDeque::new(),+ running: VecDeque::new(),+ completed: VecDeque::new(),+ }+ }++ pub fn add(&mut self, id: JobId, description: &'static str, key: Option<SharedString>) {+ self.pending.push_back(PendingJob {+ id,+ description: description.into(),+ key,+ enqueued_at: Instant::now(),+ });+ }++ pub fn mark_running(&mut self, id: JobId) {+ let Some(index) = self.pending.iter().position(|job| job.id == id) else {+ return;+ };+ // Safe to unwrap: `index` was just found by `position()`, so it's in bounds.+ let pending = self.pending.remove(index).unwrap();++ self.running.push_back(RunningJob {+ id: pending.id,+ description: pending.description,+ key: pending.key,+ enqueued_at: pending.enqueued_at,+ started_at: Instant::now(),+ });+ }++ pub fn mark_complete(&mut self, id: JobId, status: CompletedJobStatus) {+ let (enqueued_at, started_at, description, key) =+ if let Some(index) = self.running.iter().position(|job| job.id == id) {+ let running = self.running.remove(index).unwrap();+ (+ running.enqueued_at,+ Some(running.started_at),+ running.description,+ running.key,+ )+ } else if let Some(index) = self.pending.iter().position(|job| job.id == id) {+ let pending = self.pending.remove(index).unwrap();+ (pending.enqueued_at, None, pending.description, pending.key)+ } else {+ return;+ };++ self.completed.push_back(CompletedJob {+ id,+ description,+ key,+ enqueued_at,+ started_at,+ completed_at: Instant::now(),+ status,+ });++ while self.completed.len() > MAX_COMPLETED_JOBS {+ self.completed.pop_front();+ }+ }++ pub fn to_debug_string(&self) -> String {+ let mut entries = Vec::new();++ let mut pending_count = 0u64;+ let mut running_count = 0u64;+ let mut finished_count = 0u64;+ let mut skipped_count = 0u64;++ for job in &self.pending {+ pending_count += 1;+ entries.push((job.enqueued_at, self.format_pending(job)));+ }+ for job in &self.running {+ running_count += 1;+ entries.push((job.enqueued_at, self.format_running(job)));+ }+ for job in &self.completed {+ match job.status {+ CompletedJobStatus::Finished => finished_count += 1,+ CompletedJobStatus::Skipped => skipped_count += 1,+ }+ entries.push((job.enqueued_at, self.format_completed(job)));+ }++ entries.sort_by_key(|(enqueued_at, _)| *enqueued_at);++ let json_entries: Vec<serde_json::Value> =+ entries.into_iter().map(|(_, json)| json).collect();++ let json = serde_json::json!({+ "summary": {+ "pending": pending_count,+ "running": running_count,+ "finished": finished_count,+ "skipped": skipped_count,+ },+ "entries": json_entries,+ });++ serde_json::to_string_pretty(&json).unwrap_or_default()+ }++ fn format_pending(&self, job: &PendingJob) -> serde_json::Value {+ serde_json::json!({+ "id": job.id,+ "description": job.description.as_ref(),+ "key": job.key.as_ref().map(|k| k.as_ref()),+ "status": "Pending",+ "enqueued": format!("{} ago", format_duration(job.enqueued_at.elapsed())),+ })+ }++ fn format_running(&self, job: &RunningJob) -> serde_json::Value {+ serde_json::json!({+ "id": job.id,+ "description": job.description.as_ref(),+ "key": job.key.as_ref().map(|k| k.as_ref()),+ "status": "Running",+ "enqueued": format!("{} ago", format_duration(job.enqueued_at.elapsed())),+ "wait_time": format_duration(job.started_at.duration_since(job.enqueued_at)),+ "run_time": format!("{} (still running)", format_duration(job.started_at.elapsed())),+ })+ }++ fn format_completed(&self, job: &CompletedJob) -> serde_json::Value {+ let status = match job.status {+ CompletedJobStatus::Finished => "Finished",+ CompletedJobStatus::Skipped => "Skipped",+ };++ let (wait_time, run_time) = if let Some(started) = job.started_at {+ let wait = format_duration(started.duration_since(job.enqueued_at));+ let run = format_duration(job.completed_at.duration_since(started));+ (wait, Some(run))+ } else {+ let wait = format!(+ "{} (skipped)",+ format_duration(job.completed_at.duration_since(job.enqueued_at))+ );+ (wait, None)+ };++ serde_json::json!({+ "id": job.id,+ "description": job.description.as_ref(),+ "key": job.key.as_ref().map(|k| k.as_ref()),+ "status": status,+ "enqueued": format!("{} ago", format_duration(job.enqueued_at.elapsed())),+ "wait_time": wait_time,+ "run_time": run_time,+ })+ }+}++fn format_duration(duration: std::time::Duration) -> String {+ let secs = duration.as_secs_f64();+ if secs < 0.001 {+ format!("{:.0}us", secs * 1_000_000.0)+ } else if secs < 1.0 {+ format!("{:.0}ms", secs * 1000.0)+ } else if secs < 60.0 {+ format!("{:.0}s", secs)+ } else if secs < 3600.0 {+ format!("{:.0}m", secs / 60.0)+ } else {+ format!("{:.0}h", secs / 3600.0)+ }+}diff --git a/crates/project/src/telemetry_snapshot.rs b/crates/project/src/telemetry_snapshot.rsindex 6212b448835..1cd7bd75614 100644--- a/crates/project/src/telemetry_snapshot.rs+++ b/crates/project/src/telemetry_snapshot.rs@@ -77,7 +77,7 @@ impl TelemetryWorktreeSnapshot {repo.update(cx, |repo, _| {let current_branch =repo.branch.as_ref().map(|branch| branch.name().to_owned());- repo.send_job(None, |state, _| async move {+ repo.send_job("telemetry_snapshot", None, |state, _| async move {let RepositoryState::Local(LocalRepositoryState { backend, .. }) =stateelse {