An event now means the thing happened (#827)

Author: fiskus

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

@@ -53,10 +53,6 @@ pub async fn package_commit(
     workflow: WorkflowIntent,
     uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackageCommitted(PackageEvent::for_uri(
-        uri.as_ref(),
-    )));
-
     let msg_init = format!("Committing package {namespace}");
     let msg_ok = format!("Successfully committed {namespace}");
     let msg_err = |err: &Error| format!("Failed to commit: {err}");
@@ -65,7 +61,12 @@ pub async fn package_commit(
     if let Ok(ns) = &result {
         watcher.clear_paused(ns).await;
     }
-    Notify::new(msg_init).map(result.map(|_| ()), msg_ok, msg_err)
+    Notify::new(msg_init)
+        .on_success(
+            &tracing,
+            MixpanelEvent::PackageCommitted(PackageEvent::for_uri(uri.as_ref())),
+        )
+        .map(result.map(|_| ()), msg_ok, msg_err)
 }
 
 async fn certify_latest_command(m: &model::Model, namespace: &str) -> Result<(), Error> {
@@ -81,19 +82,20 @@ pub async fn certify_latest(
     namespace: String,
     uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::LatestCertified(RemotePackageEvent::for_uri(
-        uri.as_ref(),
-    )));
-
     let msg_init = format!("Certifying latest for {namespace}");
     let msg_ok = format!("Successfully certified latest for {namespace}");
     let msg_err = |err: &Error| format!("Failed to certify latest: {err}");
 
-    Notify::new(msg_init).map(
-        certify_latest_command(&m, &namespace).await,
-        msg_ok,
-        msg_err,
-    )
+    Notify::new(msg_init)
+        .on_success(
+            &tracing,
+            MixpanelEvent::LatestCertified(RemotePackageEvent::for_uri(uri.as_ref())),
+        )
+        .map(
+            certify_latest_command(&m, &namespace).await,
+            msg_ok,
+            msg_err,
+        )
 }
 
 async fn reset_local_command(
@@ -113,10 +115,6 @@ pub async fn reset_local(
     namespace: String,
     uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::LocalReset(RemotePackageEvent::for_uri(
-        uri.as_ref(),
-    )));
-
     let msg_init = format!("Resetting local for {namespace}");
     let msg_ok = format!("Successfully reset local for {namespace}");
     let msg_err = |err: &Error| format!("Failed to reset local: {err}");
@@ -125,7 +123,12 @@ pub async fn reset_local(
     if let Ok(ns) = &result {
         watcher.clear_paused(ns).await;
     }
-    Notify::new(msg_init).map(result.map(|_| ()), msg_ok, msg_err)
+    Notify::new(msg_init)
+        .on_success(
+            &tracing,
+            MixpanelEvent::LocalReset(RemotePackageEvent::for_uri(uri.as_ref())),
+        )
+        .map(result.map(|_| ()), msg_ok, msg_err)
 }
 
 /// The user-visible text for a failed write, given the action that failed
@@ -163,10 +166,6 @@ pub async fn package_push(
     namespace: String,
     uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackagePushed(RemotePackageEvent::for_uri(
-        uri.as_ref(),
-    )));
-
     let msg_init = format!("Pushing package {namespace}");
 
     let result = package_push_command(&m, &namespace).await;
@@ -187,7 +186,12 @@ pub async fn package_push(
     };
     let msg_err = |err: &Error| write_failure_message("push package", err);
 
-    Notify::new(msg_init).map(result.map(|_| ()), msg_ok, msg_err)
+    Notify::new(msg_init)
+        .on_success(
+            &tracing,
+            MixpanelEvent::PackagePushed(RemotePackageEvent::for_uri(uri.as_ref())),
+        )
+        .map(result.map(|_| ()), msg_ok, msg_err)
 }
 
 async fn package_publish_command(
@@ -352,10 +356,6 @@ pub async fn package_pull(
     namespace: String,
     uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackagePulled(RemotePackageEvent::for_uri(
-        uri.as_ref(),
-    )));
-
     let msg_init = format!("Pulling package {namespace}");
     let msg_ok = format!("Successfully pulled package {namespace}");
     let msg_err = |err: &Error| format!("Failed to pull package: {err}");
@@ -364,7 +364,12 @@ pub async fn package_pull(
     if let Ok(ns) = &result {
         watcher.clear_paused(ns).await;
     }
-    Notify::new(msg_init).map(result.map(|_| ()), msg_ok, msg_err)
+    Notify::new(msg_init)
+        .on_success(
+            &tracing,
+            MixpanelEvent::PackagePulled(RemotePackageEvent::for_uri(uri.as_ref())),
+        )
+        .map(result.map(|_| ()), msg_ok, msg_err)
 }
 
 async fn package_pull_outcome_command(
@@ -407,19 +412,20 @@ pub async fn package_uninstall(
     namespace: String,
     uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::PackageUninstalled(PackageEvent::for_uri(
-        uri.as_ref(),
-    )));
-
     let msg_init = format!("Uninstalling package {namespace}");
     let msg_ok = format!("Successfully uninstalled package {namespace}");
     let msg_err = |err: &Error| format!("Failed to uninstall package: {err}");
 
-    Notify::new(msg_init).map(
-        package_uninstall_command(&m, &namespace).await,
-        msg_ok,
-        msg_err,
-    )
+    Notify::new(msg_init)
+        .on_success(
+            &tracing,
+            MixpanelEvent::PackageUninstalled(PackageEvent::for_uri(uri.as_ref())),
+        )
+        .map(
+            package_uninstall_command(&m, &namespace).await,
+            msg_ok,
+            msg_err,
+        )
 }
 
 /// Typed response for the `set_remote` command. `resolution_warning` is
@@ -459,15 +465,17 @@ pub async fn set_remote(
 ) -> Result<SetRemoteResponse, String> {
     // The origin is this command's own argument: the remote being set.
     let origin_host = Host::from_str(&origin).ok();
-    tracing.track(MixpanelEvent::RemoteSet(RemotePackageEvent::for_host(
-        origin_host,
-    )));
-
     // `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.
     Notify::new(format!("Setting remote for {namespace}"));
     match set_remote_command(&m, &namespace, &origin, &bucket, workflow).await {
         Ok((ns, resolution_warning)) => {
+            // Reported here rather than through `Notify::on_success`, because this
+            // command returns a typed payload and so does not route its outcome
+            // through `map`. Same rule, hand-applied: the success arm only.
+            tracing.track(MixpanelEvent::RemoteSet(RemotePackageEvent::for_host(
+                origin_host,
+            )));
             watcher.clear_paused(&ns).await;
             let message = format!("Successfully set remote for {namespace}");
             ::tracing::debug!("{message}");
@@ -505,17 +513,20 @@ pub async fn package_create(
     message: Option<String>,
 ) -> Result<String, String> {
     // A package created here has no remote yet, so it belongs to no deployment.
-    tracing.track(MixpanelEvent::PackageCreated(PackageEvent::hostless()));
-
     let msg_init = format!("Creating package {namespace}");
     let msg_ok = format!("Successfully created package {namespace}");
     let msg_err = |err: &Error| format!("Failed to create package: {err}");
 
-    Notify::new(msg_init).map(
-        package_create_command(&m, &namespace, source, message).await,
-        msg_ok,
-        msg_err,
-    )
+    Notify::new(msg_init)
+        .on_success(
+            &tracing,
+            MixpanelEvent::PackageCreated(PackageEvent::hostless()),
+        )
+        .map(
+            package_create_command(&m, &namespace, source, message).await,
+            msg_ok,
+            msg_err,
+        )
 }
 
 async fn package_install_paths_command(
@@ -538,19 +549,20 @@ pub async fn package_install_paths(
 ) -> Result<String, String> {
     // 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(
-        RemotePackageEvent::for_uri(target.as_ref()),
-    ));
-
     let msg_init = format!("Installing paths from {uri}");
     let msg_ok = format!("Successfully installed {} paths", paths.len());
     let msg_err = |err: &Error| format!("Failed to install paths: {err}");
 
-    Notify::new(msg_init).map(
-        package_install_paths_command(&m, &uri, &paths).await,
-        msg_ok,
-        msg_err,
-    )
+    Notify::new(msg_init)
+        .on_success(
+            &tracing,
+            MixpanelEvent::PackageInstalled(RemotePackageEvent::for_uri(target.as_ref())),
+        )
+        .map(
+            package_install_paths_command(&m, &uri, &paths).await,
+            msg_ok,
+            msg_err,
+        )
 }
 
 async fn add_to_quiltignore_command(
@@ -591,19 +603,20 @@ pub async fn add_to_quiltignore(
     pattern: String,
     uri: Option<S3PackageUri>,
 ) -> Result<String, String> {
-    tracing.track(MixpanelEvent::QuiltignorePatternAdded(
-        PackageEvent::for_uri(uri.as_ref()),
-    ));
-
     let msg_init = format!("Adding {pattern} to .quiltignore");
     let msg_ok = format!("Added {pattern} to .quiltignore");
     let msg_err = |err: &Error| format!("Failed to update .quiltignore: {err}");
 
-    Notify::new(msg_init).map(
-        add_to_quiltignore_command(&m, &namespace, &pattern).await,
-        msg_ok,
-        msg_err,
-    )
+    Notify::new(msg_init)
+        .on_success(
+            &tracing,
+            MixpanelEvent::QuiltignorePatternAdded(PackageEvent::for_uri(uri.as_ref())),
+        )
+        .map(
+            add_to_quiltignore_command(&m, &namespace, &pattern).await,
+            msg_ok,
+            msg_err,
+        )
 }
 
 #[tauri::command]