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.

Add telemetry for context compaction (#58928)

Richard Feldmanfa4ae33e2079
diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs
index 11c78737e85..0cf5fc84d84 100644
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -1140,6 +1140,7 @@ pub struct Thread {
/// `cumulative_token_usage` for the in-flight completion request. Reset at
/// the start of each request.
current_request_token_usage: TokenUsage,
+ pending_compaction_telemetry: Option<CompactionTelemetry>,
#[allow(unused)]
initial_project_snapshot: Shared<Task<Option<Arc<ProjectSnapshot>>>>,
pub(crate) context_server_registry: Entity<ContextServerRegistry>,
@@ -1273,6 +1274,7 @@ impl Thread {
request_token_usage: HashMap::default(),
cumulative_token_usage: TokenUsage::default(),
current_request_token_usage: TokenUsage::default(),
+ pending_compaction_telemetry: None,
initial_project_snapshot: {
let project_snapshot = Self::project_snapshot(project.clone(), cx);
cx.foreground_executor()
@@ -1651,6 +1653,7 @@ impl Thread {
request_token_usage: db_thread.request_token_usage.clone(),
cumulative_token_usage: db_thread.cumulative_token_usage,
current_request_token_usage: TokenUsage::default(),
+ pending_compaction_telemetry: None,
initial_project_snapshot: Task::ready(db_thread.initial_project_snapshot).shared(),
context_server_registry,
profile_id,
@@ -2244,6 +2247,10 @@ impl Thread {
(model, request)
});
+ if compaction.is_some() {
+ self.pending_compaction_telemetry = self.build_compaction_telemetry("manual", cx);
+ }
+
self.clear_summary();
cx.notify();
@@ -2271,13 +2278,27 @@ impl Thread {
// If we were cancelled, `cancel()` already took `running_turn`
// (possibly for a new turn), so leave it alone.
if *cancellation_rx.borrow() {
+ this.update(cx, |this, _| {
+ this.emit_compaction_telemetry_outcome("canceled", None)
+ })
+ .log_err();
return;
}
match result {
+ // On success, the telemetry event is deferred until the next
+ // completion reports usage (see `handle_completion_event`),
+ // so we leave `pending_compaction_telemetry` in place here.
Ok(_) => event_stream.send_stop(acp::StopReason::EndTurn),
Err(error) => {
log::error!("Manual compaction failed: {:?}", error);
+ this.update(cx, |this, _| {
+ this.emit_compaction_telemetry_outcome(
+ "failed",
+ Some(error.to_string()),
+ )
+ })
+ .log_err();
event_stream.send_error(error);
}
}
@@ -2416,12 +2437,23 @@ impl Thread {
)
.await
{
+ // On success the telemetry event is deferred until the
+ // completion below reports usage, so we can record an
+ // accurate post-compaction context size (see
+ // `handle_completion_event`).
Ok(ControlFlow::Continue(())) => {}
- Ok(ControlFlow::Break(())) => return Ok(()),
+ Ok(ControlFlow::Break(())) => {
+ this.update(cx, |this, _| {
+ this.emit_compaction_telemetry_outcome("canceled", None)
+ })?;
+ return Ok(());
+ }
Err(error) => {
log::error!("Compaction failed: {}", error);
+ let error_message = error.to_string();
match error.downcast::<LanguageModelCompletionError>() {
Ok(error) => {
+ attempt += 1;
match Self::retry_completion_error(
this,
event_stream,
@@ -2430,13 +2462,44 @@ impl Thread {
attempt,
cx,
)
- .await?
+ .await
{
- ControlFlow::Break(()) => return Ok(()),
- ControlFlow::Continue(()) => continue,
+ Ok(ControlFlow::Break(())) => {
+ this.update(cx, |this, _| {
+ this.emit_compaction_telemetry_outcome("canceled", None)
+ })?;
+ return Ok(());
+ }
+ Ok(ControlFlow::Continue(())) => {
+ this.update(cx, |this, _| {
+ if let Some(telemetry) =
+ this.pending_compaction_telemetry.as_mut()
+ {
+ telemetry.retries += 1;
+ }
+ })?;
+ continue;
+ }
+ Err(retry_error) => {
+ this.update(cx, |this, _| {
+ this.emit_compaction_telemetry_outcome(
+ "failed",
+ Some(error_message),
+ )
+ })?;
+ return Err(retry_error);
+ }
}
}
- Err(error) => return Err(error),
+ Err(error) => {
+ this.update(cx, |this, _| {
+ this.emit_compaction_telemetry_outcome(
+ "failed",
+ Some(error_message),
+ )
+ })?;
+ return Err(error);
+ }
}
}
}
@@ -2746,6 +2809,11 @@ impl Thread {
let model = this.model.clone()?;
let request = this.build_compaction_request(insertion_ix, &model, cx);
this.current_request_token_usage = TokenUsage::default();
+ // Preserve telemetry across retries so the retry count keeps
+ // accumulating rather than resetting on each attempt.
+ if this.pending_compaction_telemetry.is_none() {
+ this.pending_compaction_telemetry = this.build_compaction_telemetry("auto", cx);
+ }
Some((model, request, insertion_ix))
})?
else {
@@ -3017,6 +3085,12 @@ impl Thread {
cache_creation_input_tokens = usage.cache_creation_input_tokens,
cache_read_input_tokens = usage.cache_read_input_tokens,
);
+ // A successful compaction defers its telemetry until the first
+ // completion that follows it, so `tokens_after` reflects the
+ // real post-compaction context size.
+ if let Some(telemetry) = self.pending_compaction_telemetry.take() {
+ telemetry.emit("succeeded", None, Some(total_input_tokens(usage)));
+ }
self.update_token_usage(usage, cx);
}
Stop(StopReason::Refusal) => return Err(CompletionError::Refusal.into()),
@@ -3857,6 +3931,48 @@ impl Thread {
.rposition(|message| matches!(&**message, Message::Compaction(_)))
}
+ /// Captures the data for an `"Agent Compaction Completed"` telemetry event
+ /// at the moment a compaction starts. Returns `None` if there's no model.
+ fn build_compaction_telemetry(
+ &self,
+ trigger: &'static str,
+ cx: &App,
+ ) -> Option<CompactionTelemetry> {
+ let model = self.model.as_ref()?;
+ let auto_compact = AgentSettings::get_global(cx).auto_compact;
+ let max_tokens = model.max_token_count();
+ let tokens_before = self
+ .latest_request_token_usage()
+ .map(|usage| total_input_tokens(usage).saturating_add(usage.output_tokens));
+ Some(CompactionTelemetry {
+ trigger,
+ thread_id: self.id.to_string(),
+ parent_thread_id: self.parent_thread_id().map(|id| id.to_string()),
+ prompt_id: self.prompt_id.to_string(),
+ model: model.telemetry_id(),
+ model_provider: model.provider_id().to_string(),
+ thinking_effort: self.thinking_effort.clone(),
+ max_tokens,
+ tokens_before,
+ auto_compact_enabled: auto_compact.enabled,
+ auto_compact_threshold: auto_compact.threshold.to_string(),
+ auto_compact_threshold_tokens: auto_compact_threshold_token_count(
+ auto_compact.threshold,
+ max_tokens,
+ ),
+ retries: 0,
+ })
+ }
+
+ /// Emits a pending compaction telemetry event for a non-success outcome
+ /// (`"failed"` or `"canceled"`), with no post-compaction token count. A
+ /// no-op if no compaction telemetry is pending.
+ fn emit_compaction_telemetry_outcome(&mut self, status: &'static str, error: Option<String>) {
+ if let Some(telemetry) = self.pending_compaction_telemetry.take() {
+ telemetry.emit(status, error, None);
+ }
+ }
+
fn compaction_message_target_ix(&self, cx: &App) -> Option<usize> {
let auto_compact = AgentSettings::get_global(cx).auto_compact;
if !auto_compact.enabled {
@@ -4131,6 +4247,52 @@ fn auto_compact_threshold_token_count(
}
}
+/// Snapshot of the data needed to report an `"Agent Compaction Completed"`
+/// telemetry event, captured when a compaction starts.
+struct CompactionTelemetry {
+ /// `"auto"` for threshold-triggered compaction, `"manual"` for `/compact`.
+ trigger: &'static str,
+ thread_id: String,
+ parent_thread_id: Option<String>,
+ prompt_id: String,
+ model: String,
+ model_provider: String,
+ thinking_effort: Option<String>,
+ max_tokens: u64,
+ /// Tokens in the context window immediately before compaction.
+ tokens_before: Option<u64>,
+ auto_compact_enabled: bool,
+ auto_compact_threshold: String,
+ auto_compact_threshold_tokens: u64,
+ /// Number of times the compaction request was retried before the final
+ /// outcome.
+ retries: u32,
+}
+
+impl CompactionTelemetry {
+ fn emit(self, status: &'static str, error: Option<String>, tokens_after: Option<u64>) {
+ telemetry::event!(
+ "Agent Compaction Completed",
+ trigger = self.trigger,
+ status = status,
+ error = error,
+ thread_id = self.thread_id,
+ parent_thread_id = self.parent_thread_id,
+ prompt_id = self.prompt_id,
+ model = self.model,
+ model_provider = self.model_provider,
+ thinking_effort = self.thinking_effort,
+ max_tokens = self.max_tokens,
+ tokens_before = self.tokens_before,
+ tokens_after = tokens_after,
+ auto_compact_enabled = self.auto_compact_enabled,
+ auto_compact_threshold = self.auto_compact_threshold,
+ auto_compact_threshold_tokens = self.auto_compact_threshold_tokens,
+ retries = self.retries,
+ );
+ }
+}
+
fn user_message_byte_len(message: &LanguageModelRequestMessage) -> usize {
message
.content
diff --git a/crates/agent_settings/src/agent_settings.rs b/crates/agent_settings/src/agent_settings.rs
index 7ba386236b1..bcd5d85afa9 100644
--- a/crates/agent_settings/src/agent_settings.rs
+++ b/crates/agent_settings/src/agent_settings.rs
@@ -2,6 +2,7 @@ mod agent_profile;
mod user_agents_md;
use std::cmp::Ordering::{Equal, Greater, Less};
+use std::fmt;
use std::path::{Component, Path, PathBuf};
use std::sync::{Arc, LazyLock};
@@ -155,6 +156,16 @@ impl AutoCompactThreshold {
pub const DEFAULT: Self = Self::Percentage(0.9);
}
+impl fmt::Display for AutoCompactThreshold {
+ fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::Percentage(percent) => write!(formatter, "{}%", percent * 100.0),
+ Self::TokensUsed(tokens) => write!(formatter, "{tokens}"),
+ Self::TokensRemaining(tokens) => write!(formatter, "-{tokens}"),
+ }
+ }
+}
+
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct AutoCompactSettings {
pub enabled: bool,
@@ -921,6 +932,11 @@ mod tests {
TokensRemaining(20_000)
);
+ assert_eq!(Percentage(0.9).to_string(), "90%");
+ assert_eq!(Percentage(0.925).to_string(), "92.5%");
+ assert_eq!(TokensUsed(100_000).to_string(), "100000");
+ assert_eq!(TokensRemaining(20_000).to_string(), "-20000");
+
// 0 is invalid in every form.
assert!(parse_auto_compact_threshold("0").is_err());
assert!(parse_auto_compact_threshold("0%").is_err());