Attribute every telemetry event to the deployment it concerns

Only three of the emitted analytics events said which Quilt deployment
they happened against, so no per-stack question could be answered from
the data. The host was already handed to the telemetry layer by the
list/detail read paths and went nowhere useful: into a set nothing read,
and into a Sentry scope tag written on the calling thread.

Tracking now takes an EventContext beside the event, so each of the 33
emission sites names the deployment it concerns or explicitly declares
that it concerns none. The context is a struct so later dimensions are
added in one place rather than onto individual event variants. The three
events that declared their own `host` field lose it — one spelling of the
property for every event — with the wire form unchanged, so existing
reports keep working. The never-emitted ErrorOccurred variant goes too.

Package operations receive the package URI the acting surface already
renders from and read its catalog, rather than telemetry re-deriving the
host from local lineage: attribution then names the deployment the user
acted on, costs no I/O, cannot fail, and needs no ordering constraint
against an uninstall destroying the lineage a lookup would read.

Crash reports get the host through the Sentry client's event hook instead
of the scope. Hubs are thread-local and a worker's hub is a snapshot of
the process scope taken when that thread first touched Sentry, so the old
tag reached crashes on one worker and nowhere else. The hook stamps every
outgoing event on any thread, and latest-host-wins replaces the
first-sighting guard.

Deliberately hostless: app launch, first-run setup, package creation (no
remote yet), the local debug/diagnostics actions, and opening a URL in the
browser — one command serves catalog links, docs, local paths and mailto:,
so its URL's host is not necessarily a deployment.

Author: fiskus

Cargo.lock

@@ -9,6 +9,12 @@
 <!-- markdownlint-disable MD013 -->
 # Changelog
 
+## [v0.20.0-alpha4] - 2026-07-30
+
+### Changed
+
+- Usage analytics and crash reports now record which Quilt deployment an action concerned, so activity can be read per stack; actions that concern no deployment (app launch, first-run setup, the local debug and diagnostics actions) record none rather than an inherited one
+
 ## [v0.20.0-alpha3] - 2026-07-29
 
 ### Changed

quilt-sync/CHANGELOG.md

@@ -1,6 +1,6 @@
 [package]
 name = "quilt-sync"
-version = "0.20.0-alpha3"
+version = "0.20.0-alpha4"
 authors = ["Quilt Data, Inc."]
 description = "Cross-platform desktop application for editing Quilt data packages"
 documentation = "https://docs.quiltdata.com"

quilt-sync/src-tauri/Cargo.toml

@@ -1,6 +1,17 @@
 //! Tauri IPC commands, grouped by domain. Everything is re-exported at
 //! `commands::*` so `main.rs`'s `generate_handler!` list and other callers
 //! keep the flat `commands::<name>` paths.
+//!
+//! # The `uri` argument some commands take but never use
+//!
+//! A package operation is addressed by its `namespace`; several also accept the
+//! package `uri` the calling surface rendered from, and do nothing with it but
+//! read its catalog for [telemetry attribution](crate::telemetry::Telemetry::track).
+//! It is passed rather than resolved from local lineage on purpose: the catalog
+//! the user acted on is what the analytics question asks about, and deriving it
+//! here would add I/O and a failure path to every tracked action — including one
+//! that would have to run *before* an uninstall destroys the lineage it reads.
+//! See [`crate::telemetry::EventContext::for_uri`].
 
 mod auth;
 mod commit_data;

quilt-sync/src-tauri/src/commands.rs

@@ -20,7 +20,7 @@ use crate::notify::Notify;
 use crate::oauth::OAuthState;
 use crate::quilt;
 use crate::routes;
-use crate::telemetry::{MixpanelEvent, Telemetry, mixpanel::LoginFlow, prelude::*};
+use crate::telemetry::{EventContext, MixpanelEvent, Telemetry, mixpanel::LoginFlow, prelude::*};
 
 // ── Login data for Leptos UI ──
 
@@ -97,7 +97,15 @@ pub async fn erase_auth(
     tracing: tauri::State<'_, Telemetry>,
     host: String,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::AuthErased).await;
+    // The host is the command's own argument; an unparseable one still logs
+    // out, it just cannot be attributed.
+    let host_parsed = Host::from_str(&host).ok();
+    tracing
+        .track(
+            MixpanelEvent::AuthErased,
+            EventContext::for_host(host_parsed.as_ref()),
+        )
+        .await;
 
     let app_handle = app_handle.lock().await;
 
@@ -329,15 +337,17 @@ pub(super) async fn switch_role_command(
 ) -> Result<RolesData, Error> {
     let host = Host::from_str(host)?;
     let info = m.switch_role(&host, role).await?;
-    let host_name = host.to_string();
     // Three caches, not two: the stored credentials (expired by the switch),
     // the S3 clients holding their own copy, and the role name the roster
     // quotes back at the user. The last two are `adopt_role`'s job.
     adopt_role(m, roles, &host, info.clone()).await;
     watcher.clear_role_denied_pauses().await;
 
     tracing
-        .track(MixpanelEvent::RoleSwitched { host: host_name })
+        .track(
+            MixpanelEvent::RoleSwitched,
+            EventContext::for_host(Some(&host)),
+        )
         .await;
 
     Ok(RolesData::from(info))
@@ -384,10 +394,12 @@ async fn login_command(
     model::login(m, &host, code).await?;
 
     tracing
-        .track(MixpanelEvent::UserLoggedIn {
-            host: host.to_string(),
-            flow: LoginFlow::Legacy,
-        })
+        .track(
+            MixpanelEvent::UserLoggedIn {
+                flow: LoginFlow::Legacy,
+            },
+            EventContext::for_host(Some(&host)),
+        )
         .await;
 
     Ok(())
@@ -435,7 +447,10 @@ pub async fn login_oauth(
     model::open_in_web_browser(&request.authorize_url).map_err(|e| e.to_string())?;
 
     tracing
-        .track(MixpanelEvent::OAuthLoginInitiated { host: host.clone() })
+        .track(
+            MixpanelEvent::OAuthLoginInitiated,
+            EventContext::for_host(Some(&host_parsed)),
+        )
         .await;
 
     Ok(format!("Opening browser for OAuth login to {host}"))

quilt-sync/src-tauri/src/commands/auth.rs

@@ -9,7 +9,7 @@ use serde::Serialize;
 
 use quilt_rs::io::remote::WorkflowIntent;
 
-use quilt_uri::Host;
+use quilt_uri::{Host, S3PackageUri};
 
 use crate::Error;
 use crate::autopull::Watcher;
@@ -19,7 +19,7 @@ use crate::notify::Notify;
 use crate::publish_settings::SharedPublishSettings;
 use crate::quilt;
 use crate::quilt::flow::PullOutcome;
-use crate::telemetry::MixpanelEvent;
+use crate::telemetry::{EventContext, MixpanelEvent};
 
 async fn package_commit_command(
     m: &model::Model,
@@ -38,6 +38,10 @@ async fn package_commit_command(
 }
 
 #[tauri::command]
+#[allow(
+    clippy::too_many_arguments,
+    reason = "three of these are Tauri state injections a caller never passes; the rest are the revision's own fields plus the telemetry context"
+)]
 pub async fn package_commit(
     m: tauri::State<'_, model::Model>,
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
@@ -46,8 +50,14 @@ pub async fn package_commit(
     message: String,
     metadata: String,
     workflow: WorkflowIntent,
+    uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackageCommitted).await;
+    tracing
+        .track(
+            MixpanelEvent::PackageCommitted,
+            EventContext::for_uri(uri.as_ref()),
+        )
+        .await;
 
     let msg_init = format!("Committing package {namespace}");
     let msg_ok = format!("Successfully committed {namespace}");
@@ -71,8 +81,14 @@ pub async fn certify_latest(
     m: tauri::State<'_, model::Model>,
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
     namespace: String,
+    uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::LatestCertified).await;
+    tracing
+        .track(
+            MixpanelEvent::LatestCertified,
+            EventContext::for_uri(uri.as_ref()),
+        )
+        .await;
 
     let msg_init = format!("Certifying latest for {namespace}");
     let msg_ok = format!("Successfully certified latest for {namespace}");
@@ -100,8 +116,14 @@ pub async fn reset_local(
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
     watcher: tauri::State<'_, Watcher>,
     namespace: String,
+    uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::LocalReset).await;
+    tracing
+        .track(
+            MixpanelEvent::LocalReset,
+            EventContext::for_uri(uri.as_ref()),
+        )
+        .await;
 
     let msg_init = format!("Resetting local for {namespace}");
     let msg_ok = format!("Successfully reset local for {namespace}");
@@ -147,8 +169,14 @@ pub async fn package_push(
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
     watcher: tauri::State<'_, Watcher>,
     namespace: String,
+    uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackagePushed).await;
+    tracing
+        .track(
+            MixpanelEvent::PackagePushed,
+            EventContext::for_uri(uri.as_ref()),
+        )
+        .await;
 
     let msg_init = format!("Pushing package {namespace}");
 
@@ -202,6 +230,7 @@ pub async fn package_publish(
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
     watcher: tauri::State<'_, Watcher>,
     namespace: String,
+    uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
     let msg_init = format!("Publishing package {namespace}");
     let result = package_publish_command(&m, &settings, &namespace).await;
@@ -210,11 +239,26 @@ pub async fn package_publish(
     }
 
     if let Ok((_, outcome)) = &result {
-        tracing.track(MixpanelEvent::PackagePublished).await;
+        tracing
+            .track(
+                MixpanelEvent::PackagePublished,
+                EventContext::for_uri(uri.as_ref()),
+            )
+            .await;
         if matches!(outcome, quilt::PublishOutcome::CommittedAndPushed(_)) {
-            tracing.track(MixpanelEvent::PackageCommitted).await;
+            tracing
+                .track(
+                    MixpanelEvent::PackageCommitted,
+                    EventContext::for_uri(uri.as_ref()),
+                )
+                .await;
         }
-        tracing.track(MixpanelEvent::PackagePushed).await;
+        tracing
+            .track(
+                MixpanelEvent::PackagePushed,
+                EventContext::for_uri(uri.as_ref()),
+            )
+            .await;
     }
 
     let msg_ok = match &result {
@@ -262,6 +306,10 @@ async fn package_commit_and_push_command(
 }
 
 #[tauri::command]
+#[allow(
+    clippy::too_many_arguments,
+    reason = "three of these are Tauri state injections a caller never passes; the rest are the revision's own fields plus the telemetry context"
+)]
 pub async fn package_commit_and_push(
     m: tauri::State<'_, model::Model>,
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
@@ -270,6 +318,7 @@ pub async fn package_commit_and_push(
     message: String,
     metadata: String,
     workflow: WorkflowIntent,
+    uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
     let msg_init = format!("Publishing package {namespace}");
     let result =
@@ -279,11 +328,26 @@ pub async fn package_commit_and_push(
     }
 
     if let Ok((_, outcome)) = &result {
-        tracing.track(MixpanelEvent::PackagePublished).await;
+        tracing
+            .track(
+                MixpanelEvent::PackagePublished,
+                EventContext::for_uri(uri.as_ref()),
+            )
+            .await;
         if matches!(outcome, quilt::PublishOutcome::CommittedAndPushed(_)) {
-            tracing.track(MixpanelEvent::PackageCommitted).await;
+            tracing
+                .track(
+                    MixpanelEvent::PackageCommitted,
+                    EventContext::for_uri(uri.as_ref()),
+                )
+                .await;
         }
-        tracing.track(MixpanelEvent::PackagePushed).await;
+        tracing
+            .track(
+                MixpanelEvent::PackagePushed,
+                EventContext::for_uri(uri.as_ref()),
+            )
+            .await;
     }
 
     let msg_ok = match &result {
@@ -315,8 +379,14 @@ pub async fn package_pull(
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
     watcher: tauri::State<'_, Watcher>,
     namespace: String,
+    uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackagePulled).await;
+    tracing
+        .track(
+            MixpanelEvent::PackagePulled,
+            EventContext::for_uri(uri.as_ref()),
+        )
+        .await;
 
     let msg_init = format!("Pulling package {namespace}");
     let msg_ok = format!("Successfully pulled package {namespace}");
@@ -367,8 +437,14 @@ pub async fn package_uninstall(
     m: tauri::State<'_, model::Model>,
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
     namespace: String,
+    uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackageUninstalled).await;
+    tracing
+        .track(
+            MixpanelEvent::PackageUninstalled,
+            EventContext::for_uri(uri.as_ref()),
+        )
+        .await;
 
     let msg_init = format!("Uninstalling package {namespace}");
     let msg_ok = format!("Successfully uninstalled package {namespace}");
@@ -416,7 +492,14 @@ pub async fn set_remote(
     bucket: String,
     workflow: WorkflowIntent,
 ) -> Result<SetRemoteResponse, String> {
-    tracing.track(MixpanelEvent::RemoteSet).await;
+    // The origin is this command's own argument: the remote being set.
+    let origin_host = Host::from_str(&origin).ok();
+    tracing
+        .track(
+            MixpanelEvent::RemoteSet,
+            EventContext::for_host(origin_host.as_ref()),
+        )
+        .await;
 
     // `Notify::new` logs the init line; on success/failure we log explicitly so
     // the success payload can be the typed struct rather than a bare string.
@@ -459,7 +542,10 @@ pub async fn package_create(
     source: Option<String>,
     message: Option<String>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackageCreated).await;
+    // A package created here has no remote yet, so it belongs to no deployment.
+    tracing
+        .track(MixpanelEvent::PackageCreated, EventContext::default())
+        .await;
 
     let msg_init = format!("Creating package {namespace}");
     let msg_ok = format!("Successfully created package {namespace}");
@@ -490,7 +576,14 @@ pub async fn package_install_paths(
     uri: String,
     paths: Vec<String>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackageInstalled).await;
+    // Installing names its package by URI, so the catalog is already in hand.
+    let target = S3PackageUri::try_from(uri.as_str()).ok();
+    tracing
+        .track(
+            MixpanelEvent::PackageInstalled,
+            EventContext::for_uri(target.as_ref()),
+        )
+        .await;
 
     let msg_init = format!("Installing paths from {uri}");
     let msg_ok = format!("Successfully installed {} paths", paths.len());
@@ -539,8 +632,14 @@ pub async fn add_to_quiltignore(
     tracing: tauri::State<'_, crate::telemetry::Telemetry>,
     namespace: String,
     pattern: String,
+    uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::QuiltignorePatternAdded).await;
+    tracing
+        .track(
+            MixpanelEvent::QuiltignorePatternAdded,
+            EventContext::for_uri(uri.as_ref()),
+        )
+        .await;
 
     let msg_init = format!("Adding {pattern} to .quiltignore");
     let msg_ok = format!("Added {pattern} to .quiltignore");