Add posthog for but cli operations

Author: krlvi

Cargo.lock

@@ -27,6 +27,8 @@ bstr.workspace = true
 anyhow.workspace = true
 # rmcp = { git = "https://github.com/modelcontextprotocol/rust-sdk", branch = "main" }
 rmcp = "0.1.5"
+command-group = { version = "5.0.1", features = ["with-tokio"] }
+sysinfo = "0.36.0"
 gitbutler-project.workspace = true
 gix.workspace = true
 but-core.workspace = true

crates/but/Cargo.toml

@@ -54,12 +54,14 @@ For examples `but rub --help`.")]
     #[clap(hide = true)]
     Metrics {
         #[clap(long, value_enum)]
-        command_name: MetricsCommandName,
+        command_name: CommandName,
+        #[clap(long)]
+        props: String,
     },
 }
 
 #[derive(Debug, Clone, Copy, clap::ValueEnum, Default)]
-pub enum MetricsCommandName {
+pub enum CommandName {
     #[clap(alias = "log")]
     Log,
     #[clap(alias = "status")]

crates/but/src/args.rs

@@ -1,9 +1,9 @@
-use anyhow::{Context, Ok, Result};
+use anyhow::{Context, Result};
 
 mod args;
-use args::{Args, Subcommands, actions, claude};
+use args::{Args, CommandName, Subcommands, actions, claude};
 use but_settings::AppSettings;
-use metrics::{Event, Metrics};
+use metrics::{Event, Metrics, Props, metrics_if_configured};
 mod command;
 mod id;
 mod log;
@@ -20,6 +20,7 @@ async fn main() -> Result<()> {
 
     let namespace = option_env!("IDENTIFIER").unwrap_or("com.gitbutler.app");
     gitbutler_secret::secret::set_application_namespace(namespace);
+    let start = std::time::Instant::now();
 
     match &args.cmd {
         Subcommands::Mcp { internal } => {
@@ -39,37 +40,70 @@ async fn main() -> Result<()> {
             }
             None => command::list_actions(&args.current_dir, args.json, 0, 10),
         },
-        Subcommands::Metrics { command_name } => {
+        Subcommands::Metrics {
+            command_name,
+            props,
+        } => {
             let event = &mut Event::new((*command_name).into());
+            if let Ok(props) = Props::from_json_string(props) {
+                props.update_event(event);
+            }
             Metrics::capture_blocking(&app_settings, event.clone()).await;
             Ok(())
         }
         Subcommands::Claude(claude::Platform { cmd }) => match cmd {
             claude::Subcommands::PreTool => {
-                let out = command::claude::handle_pre_tool_call()?;
-                println!("{}", serde_json::to_string(&out)?);
+                let result = command::claude::handle_pre_tool_call();
+                let p = props(start, &result);
+                println!("{}", serde_json::to_string(&result?)?);
+                metrics_if_configured(app_settings, CommandName::ClaudePreTool, p).ok();
                 Ok(())
             }
             claude::Subcommands::PostTool => {
-                let out = command::claude::handle_post_tool_call()?;
-                println!("{}", serde_json::to_string(&out)?);
+                let result = command::claude::handle_post_tool_call();
+                let p = props(start, &result);
+                println!("{}", serde_json::to_string(&result?)?);
+                metrics_if_configured(app_settings, CommandName::ClaudePostTool, p).ok();
                 Ok(())
             }
             claude::Subcommands::Stop => {
-                let out = command::claude::handle_stop().await?;
-                println!("{}", serde_json::to_string(&out)?);
+                let result = command::claude::handle_stop().await;
+                let p = props(start, &result);
+                println!("{}", serde_json::to_string(&result?)?);
+                metrics_if_configured(app_settings, CommandName::ClaudeStop, p).ok();
                 Ok(())
             }
         },
-        Subcommands::Log => log::commit_graph(&args.current_dir, args.json),
-        Subcommands::Status => status::worktree(&args.current_dir, args.json),
+        Subcommands::Log => {
+            let result = log::commit_graph(&args.current_dir, args.json);
+            metrics_if_configured(app_settings, CommandName::Log, props(start, &result)).ok();
+            Ok(())
+        }
+        Subcommands::Status => {
+            let result = status::worktree(&args.current_dir, args.json);
+            metrics_if_configured(app_settings, CommandName::Status, props(start, &result)).ok();
+            Ok(())
+        }
         Subcommands::Rub { source, target } => {
             let result = rub::handle(&args.current_dir, args.json, source, target)
                 .context("Rubbed the wrong way.");
             if let Err(e) = &result {
                 eprintln!("{} {}", e, e.root_cause());
             }
+            metrics_if_configured(app_settings, CommandName::Rub, props(start, &result)).ok();
             Ok(())
         }
     }
 }
+
+fn props<E, T, R>(start: std::time::Instant, result: R) -> Props
+where
+    R: std::ops::Deref<Target = Result<T, E>>,
+    E: std::fmt::Display,
+{
+    let error = result.as_ref().err().map(|e| e.to_string());
+    let mut props = Props::new();
+    props.insert("durationMs", start.elapsed().as_millis());
+    props.insert("error", error);
+    props
+}

crates/but/src/main.rs

@@ -1,10 +1,12 @@
 use std::{collections::HashMap, env};
 
 use but_settings::AppSettings;
+use clap::ValueEnum;
+use command_group::AsyncCommandGroup;
 use posthog_rs::Client;
 use serde::{Deserialize, Serialize};
 
-use crate::args::MetricsCommandName;
+use crate::args::CommandName;
 
 #[derive(Debug, Clone)]
 pub struct Metrics {
@@ -25,20 +27,53 @@ pub enum EventKind {
     Unknown,
 }
 
-impl From<MetricsCommandName> for EventKind {
-    fn from(command_name: MetricsCommandName) -> Self {
+impl From<CommandName> for EventKind {
+    fn from(command_name: CommandName) -> Self {
         match command_name {
-            MetricsCommandName::Log => EventKind::CliLog,
-            MetricsCommandName::Status => EventKind::CliStatus,
-            MetricsCommandName::Rub => EventKind::CliRub,
-            MetricsCommandName::ClaudePreTool => EventKind::ClaudePreTool,
-            MetricsCommandName::ClaudePostTool => EventKind::ClaudePostTool,
-            MetricsCommandName::ClaudeStop => EventKind::ClaudeStop,
+            CommandName::Log => EventKind::CliLog,
+            CommandName::Status => EventKind::CliStatus,
+            CommandName::Rub => EventKind::CliRub,
+            CommandName::ClaudePreTool => EventKind::ClaudePreTool,
+            CommandName::ClaudePostTool => EventKind::ClaudePostTool,
+            CommandName::ClaudeStop => EventKind::ClaudeStop,
             _ => EventKind::Unknown,
         }
     }
 }
 
+pub struct Props {
+    values: HashMap<String, serde_json::Value>,
+}
+
+impl Props {
+    pub fn new() -> Self {
+        Props {
+            values: HashMap::new(),
+        }
+    }
+
+    pub fn insert<K: Into<String>, V: Serialize>(&mut self, key: K, value: V) {
+        if let Ok(value) = serde_json::to_value(value) {
+            self.values.insert(key.into(), value);
+        }
+    }
+
+    pub fn as_json_string(&self) -> String {
+        serde_json::to_string(&self.values).unwrap_or_default()
+    }
+
+    pub fn from_json_string(json: &str) -> Result<Self, serde_json::Error> {
+        let values: HashMap<String, serde_json::Value> = serde_json::from_str(json)?;
+        Ok(Props { values })
+    }
+
+    pub fn update_event(&self, event: &mut Event) {
+        for (key, value) in &self.values {
+            event.insert_prop(key, value);
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct Event {
     event_name: EventKind,
@@ -149,3 +184,30 @@ fn posthog_client(app_settings: AppSettings) -> Option<impl Future<Output = post
         None
     }
 }
+
+/// If metrics are configured, this function spawns a process to handle metrics logging so that this CLI process can exit as soon as possible.
+pub(crate) fn metrics_if_configured(
+    app_settings: AppSettings,
+    cmd: CommandName,
+    props: Props,
+) -> anyhow::Result<()> {
+    if !app_settings.telemetry.app_metrics_enabled {
+        return Ok(());
+    }
+    if let Some(v) = cmd.to_possible_value() {
+        let binary_path = std::env::current_exe().unwrap_or_default();
+        let mut group = tokio::process::Command::new(binary_path)
+            .arg("metrics")
+            .arg("--command-name")
+            .arg(v.get_name())
+            .arg("--props")
+            .arg(props.as_json_string())
+            .stderr(std::process::Stdio::null())
+            .stdout(std::process::Stdio::null())
+            .group()
+            .kill_on_drop(false)
+            .spawn()?;
+        group.inner().id().map(|id| sysinfo::Pid::from(id as usize));
+    }
+    Ok(())
+}