feat(telemetry): send repo_hash and commits_count in events (#178)

* feat(telemetry): add repo_hash and commits_count to event payload

* feat(telemetry): pass repo_hash and commits_count from all call sites

Author: BryanFRD

Cargo.lock

@@ -45,6 +45,8 @@ clap = { version = "4", features = ["derive", "env"], optional = true }
 colored = { version = "3", optional = true }
 git2 = { version = "0.20", features = ["vendored-libgit2", "vendored-openssl"], optional = true }
 ureq = { version = "3", features = ["json"], optional = true }
+sha2 = "0.11.0"
+hex = "0.4.3"
 
 [dev-dependencies]
 cargo-husky = { version = "1", default-features = false, features = ["user-hooks"] }

Cargo.toml

@@ -728,7 +728,7 @@ pub fn init(format: Option<ConfigFileFormat>) -> Result<()> {
     println!("Run: ferrflow check");
 
     if config.workspace.telemetry {
-        telemetry::send_event(telemetry::EventType::Init, None, None, None);
+        telemetry::send_event(telemetry::EventType::Init, None, None, None, None);
     }
 
     Ok(())

src/config.rs

@@ -28,7 +28,7 @@ pub fn check(config_path: Option<&Path>, verbose: bool) -> Result<()> {
     let result = run_release_logic(&root, &config, true, verbose);
 
     if config.workspace.telemetry {
-        telemetry::send_event(telemetry::EventType::Check, None, None, None);
+        telemetry::send_event(telemetry::EventType::Check, None, None, None, None);
     }
 
     result
@@ -79,8 +79,8 @@ fn run_release_logic(root: &Path, config: &Config, dry_run: bool, verbose: bool)
 
     let mut any_bumped = false;
     let mut files_to_commit: Vec<String> = Vec::new();
-    // (tag_name, tag_msg, body, pkg_name, version)
-    let mut tags_to_create: Vec<(String, String, String, String, String)> = Vec::new();
+    // (tag_name, tag_msg, body, pkg_name, version, commits_count)
+    let mut tags_to_create: Vec<(String, String, String, String, String, i32)> = Vec::new();
     let mut hook_contexts: Vec<(HookContext, usize)> = Vec::new(); // (ctx, pkg_index)
 
     for (pkg_idx, pkg) in config.packages.iter().enumerate() {
@@ -280,6 +280,7 @@ fn run_release_logic(root: &Path, config: &Config, dry_run: bool, verbose: bool)
                     Some(&pkg.name),
                     Some(&new_version),
                     None,
+                    Some(commits.len() as i32),
                 );
             }
 
@@ -290,6 +291,7 @@ fn run_release_logic(root: &Path, config: &Config, dry_run: bool, verbose: bool)
                 body,
                 pkg.name.clone(),
                 new_version.clone(),
+                commits.len() as i32,
             ));
         }
 
@@ -327,7 +329,7 @@ fn run_release_logic(root: &Path, config: &Config, dry_run: bool, verbose: bool)
         // Build the release commit message.
         let release_parts: Vec<String> = tags_to_create
             .iter()
-            .map(|(_, _, _, name, ver)| format!("{name} v{ver}"))
+            .map(|(_, _, _, name, ver, _)| format!("{name} v{ver}"))
             .collect();
         let skip_ci = if config.workspace.effective_skip_ci() {
             " [skip ci]"
@@ -362,7 +364,7 @@ fn run_release_logic(root: &Path, config: &Config, dry_run: bool, verbose: bool)
                             "Automated release commit.\n\n{}",
                             tags_to_create
                                 .iter()
-                                .map(|(tag, _, _, _, _)| format!("- `{tag}`"))
+                                .map(|(tag, _, _, _, _, _)| format!("- `{tag}`"))
                                 .collect::<Vec<_>>()
                                 .join("\n")
                         );
@@ -400,7 +402,7 @@ fn run_release_logic(root: &Path, config: &Config, dry_run: bool, verbose: bool)
             }
 
             // Tags are always created on the current HEAD.
-            for (tag_name, tag_msg, _, _, _) in &tags_to_create {
+            for (tag_name, tag_msg, _, _, _, _) in &tags_to_create {
                 create_tag(&repo, tag_name, tag_msg)?;
                 println!("  ✓ Created tag {}", tag_name.cyan());
             }
@@ -429,7 +431,7 @@ fn run_release_logic(root: &Path, config: &Config, dry_run: bool, verbose: bool)
             // Push tags (and branch for commit mode).
             let tag_refs: Vec<&str> = tags_to_create
                 .iter()
-                .map(|(t, _, _, _, _)| t.as_str())
+                .map(|(t, _, _, _, _, _)| t.as_str())
                 .collect();
             match mode {
                 ReleaseCommitMode::Commit => {
@@ -458,20 +460,21 @@ fn run_release_logic(root: &Path, config: &Config, dry_run: bool, verbose: bool)
             }
 
             if config.workspace.telemetry {
-                for (_, _, _, pkg_name, version) in &tags_to_create {
+                for (_, _, _, pkg_name, version, commit_count) in &tags_to_create {
                     telemetry::send_event(
                         telemetry::EventType::Release,
                         Some(pkg_name),
                         Some(version),
                         None,
+                        Some(*commit_count),
                     );
                 }
             }
 
             if let Ok(token) = std::env::var("GITHUB_TOKEN")
                 && let Some(slug) = get_repo_slug(&repo, &config.workspace.remote)
             {
-                for (tag_name, _, body, _, _) in &tags_to_create {
+                for (tag_name, _, body, _, _, _) in &tags_to_create {
                     match create_github_release(&token, &slug, tag_name, body) {
                         Ok(()) => println!("  ✓ GitHub Release {}", tag_name.cyan()),
                         Err(err) => eprintln!(
@@ -493,7 +496,7 @@ fn run_release_logic(root: &Path, config: &Config, dry_run: bool, verbose: bool)
                     .open(&summary_path)
                 {
                     let _ = writeln!(file, "## Released\n");
-                    for (tag_name, _, body, _, _) in &tags_to_create {
+                    for (tag_name, _, body, _, _, _) in &tags_to_create {
                         let _ = writeln!(file, "### {tag_name}\n");
                         let _ = writeln!(file, "{body}");
                     }

src/monorepo.rs

@@ -1,4 +1,5 @@
 use serde::Serialize;
+use sha2::Digest;
 
 const DEFAULT_API_URL: &str = "https://api.ferrflow.com";
 
@@ -22,6 +23,10 @@ struct EventPayload {
     package_version: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     metadata: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    repo_hash: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    commits_count: Option<i32>,
 }
 
 fn is_enabled() -> bool {
@@ -39,11 +44,28 @@ fn api_url() -> String {
     std::env::var("FERRFLOW_API_URL").unwrap_or_else(|_| DEFAULT_API_URL.to_string())
 }
 
+fn get_repo_hash() -> Option<String> {
+    let output = std::process::Command::new("git")
+        .args(["remote", "get-url", "origin"])
+        .output()
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let url = String::from_utf8(output.stdout).ok()?.trim().to_string();
+    if url.is_empty() {
+        return None;
+    }
+    let hash = sha2::Sha256::digest(url.as_bytes());
+    Some(hex::encode(hash))
+}
+
 pub fn send_event(
     event_type: EventType,
     package_name: Option<&str>,
     package_version: Option<&str>,
     metadata: Option<serde_json::Value>,
+    commits_count: Option<i32>,
 ) {
     if !is_enabled() {
         return;
@@ -54,6 +76,8 @@ pub fn send_event(
         package_name: package_name.map(String::from),
         package_version: package_version.map(String::from),
         metadata,
+        repo_hash: get_repo_hash(),
+        commits_count,
     };
 
     let url = format!("{}/events", api_url());
@@ -99,11 +123,15 @@ mod tests {
             package_name: None,
             package_version: None,
             metadata: None,
+            repo_hash: None,
+            commits_count: None,
         };
         let json = serde_json::to_value(&payload).unwrap();
         assert!(!json.as_object().unwrap().contains_key("package_name"));
         assert!(!json.as_object().unwrap().contains_key("package_version"));
         assert!(!json.as_object().unwrap().contains_key("metadata"));
+        assert!(!json.as_object().unwrap().contains_key("repo_hash"));
+        assert!(!json.as_object().unwrap().contains_key("commits_count"));
     }
 
     #[test]
@@ -113,11 +141,15 @@ mod tests {
             package_name: Some("my-pkg".into()),
             package_version: Some("1.0.0".into()),
             metadata: None,
+            repo_hash: Some("abc123".into()),
+            commits_count: Some(42),
         };
         let json = serde_json::to_value(&payload).unwrap();
         assert_eq!(json["event_type"], "release");
         assert_eq!(json["package_name"], "my-pkg");
         assert_eq!(json["package_version"], "1.0.0");
+        assert_eq!(json["repo_hash"], "abc123");
+        assert_eq!(json["commits_count"], 42);
     }
 
     #[test]