feat(telemetry): add run and repo events (#6876)

### Description

Adds events for repo and run.

Author: tknickman

Cargo.lock

@@ -83,8 +83,7 @@ impl Vendor {
         None
     }
 
-    #[allow(dead_code)]
-    fn get_name() -> Option<&'static str> {
+    pub fn get_name() -> Option<&'static str> {
         Self::infer().map(|v| v.name)
     }
 

crates/turborepo-ci/src/lib.rs

@@ -21,6 +21,15 @@ pub enum ResolvedEnvMode {
     Strict,
 }
 
+impl std::fmt::Display for ResolvedEnvMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ResolvedEnvMode::Loose => write!(f, "loose"),
+            ResolvedEnvMode::Strict => write!(f, "strict"),
+        }
+    }
+}
+
 #[derive(Clone, Debug, Error)]
 pub enum Error {
     #[error("Failed to parse regex: {0}")]

crates/turborepo-env/src/lib.rs

@@ -250,7 +250,7 @@ pub extern "C" fn get_package_file_hashes(buffer: Buffer) -> Buffer {
     };
     let inputs = req.inputs.as_slice();
     let hasher = turborepo_scm::SCM::new(&turbo_root);
-    let response = match hasher.get_package_file_hashes(&turbo_root, &package_path, inputs) {
+    let response = match hasher.get_package_file_hashes(&turbo_root, &package_path, inputs, None) {
         Ok(hashes) => {
             let mut to_return = HashMap::new();
             for (filename, hash) in hashes {

crates/turborepo-ffi/src/lib.rs

@@ -22,7 +22,7 @@ use itertools::Itertools;
 use rayon::iter::ParallelBridge;
 use tracing::debug;
 use turborepo_analytics::{start_analytics, AnalyticsHandle, AnalyticsSender};
-use turborepo_api_client::{APIAuth, APIClient};
+use turborepo_api_client::{APIAuth, APIClient, Client};
 use turborepo_cache::{AsyncCache, RemoteCacheOpts};
 use turborepo_ci::Vendor;
 use turborepo_env::EnvironmentVariableMap;
@@ -32,6 +32,10 @@ use turborepo_repository::{
     package_json::PackageJson,
 };
 use turborepo_scm::SCM;
+use turborepo_telemetry::events::{
+    generic::{DaemonInitStatus, GenericEventBuilder},
+    repo::{RepoEventBuilder, RepoType},
+};
 use turborepo_ui::{cprint, cprintln, ColorSelector, BOLD_GREY, GREY};
 
 use self::task_id::TaskName;
@@ -170,6 +174,8 @@ impl<'a> Run<'a> {
         let package_json_path = self.base.repo_root.join_component("package.json");
         let root_package_json = PackageJson::load(&package_json_path)?;
         let mut opts = self.opts()?;
+        let run_telemetry = GenericEventBuilder::new();
+        let repo_telemetry = RepoEventBuilder::new(&self.base.repo_root.to_string());
 
         let config = self.base.config()?;
 
@@ -184,16 +190,28 @@ impl<'a> Run<'a> {
             // value
             opts.cache_opts.skip_remote = !enabled;
         }
-
+        run_telemetry.track_is_linked(is_linked);
+        // we only track the remote cache if we're linked because this defaults to
+        // Vercel
+        if is_linked {
+            run_telemetry.track_remote_cache(api_client.base_url());
+        }
         let _is_structured_output = opts.run_opts.graph.is_some()
             || matches!(opts.run_opts.dry_run, Some(DryRunMode::Json));
 
         let is_single_package = opts.run_opts.single_package;
+        repo_telemetry.track_type(if is_single_package {
+            RepoType::SinglePackage
+        } else {
+            RepoType::Monorepo
+        });
 
         let is_ci_or_not_tty = turborepo_ci::is_ci() || !std::io::stdout().is_terminal();
+        run_telemetry.track_ci(turborepo_ci::Vendor::get_name());
 
         let daemon = match (is_ci_or_not_tty, opts.run_opts.daemon) {
             (true, None) => {
+                run_telemetry.track_daemon_init(DaemonInitStatus::Skipped);
                 debug!("skipping turbod since we appear to be in a non-interactive context");
                 None
             }
@@ -207,16 +225,19 @@ impl<'a> Run<'a> {
 
                 match connector.connect().await {
                     Ok(client) => {
+                        run_telemetry.track_daemon_init(DaemonInitStatus::Started);
                         debug!("running in daemon mode");
                         Some(client)
                     }
                     Err(e) => {
+                        run_telemetry.track_daemon_init(DaemonInitStatus::Failed);
                         debug!("failed to connect to daemon {e}");
                         None
                     }
                 }
             }
             (_, Some(false)) => {
+                run_telemetry.track_daemon_init(DaemonInitStatus::Disabled);
                 debug!("skipping turbod since --no-daemon was passed");
                 None
             }
@@ -236,6 +257,10 @@ impl<'a> Run<'a> {
                 .build()
                 .await?;
 
+        repo_telemetry.track_package_manager(pkg_dep_graph.package_manager().to_string());
+        repo_telemetry.track_size(pkg_dep_graph.len());
+        run_telemetry.track_run_type(opts.run_opts.dry_run.is_some());
+
         let root_turbo_json =
             TurboJson::load(&self.base.repo_root, &root_package_json, is_single_package)?;
 
@@ -366,6 +391,7 @@ impl<'a> Run<'a> {
             workspaces,
             engine.task_definitions(),
             &self.base.repo_root,
+            &run_telemetry,
         )?;
 
         if opts.run_opts.parallel {

crates/turborepo-lib/src/run/mod.rs

@@ -190,6 +190,7 @@ impl<'a> Visitor<'a> {
                 EnvMode::Strict => ResolvedEnvMode::Strict,
                 EnvMode::Loose => ResolvedEnvMode::Loose,
             };
+            package_task_event.track_env_mode(&task_env_mode.to_string());
 
             let dependency_set = engine.dependencies(&info).ok_or(Error::MissingDefinition)?;
 

crates/turborepo-lib/src/task_graph/visitor.rs

@@ -12,7 +12,9 @@ use turborepo_cache::CacheHitMetadata;
 use turborepo_env::{BySource, DetailedMap, EnvironmentVariableMap, ResolvedEnvMode};
 use turborepo_repository::package_graph::{WorkspaceInfo, WorkspaceName};
 use turborepo_scm::SCM;
-use turborepo_telemetry::events::task::PackageTaskEventBuilder;
+use turborepo_telemetry::events::{
+    generic::GenericEventBuilder, task::PackageTaskEventBuilder, EventBuilder,
+};
 
 use crate::{
     engine::TaskNode,
@@ -71,6 +73,7 @@ impl PackageInputsHashes {
         workspaces: HashMap<&WorkspaceName, &WorkspaceInfo>,
         task_definitions: &HashMap<TaskId<'static>, TaskDefinition>,
         repo_root: &AbsoluteSystemPath,
+        telemetry: &GenericEventBuilder,
     ) -> Result<PackageInputsHashes, Error> {
         tracing::trace!(scm_manual=%scm.is_manual(), "scm running in {} mode", if scm.is_manual() { "manual" } else { "git" });
 
@@ -91,7 +94,11 @@ impl PackageInputsHashes {
                     Ok(def) => def,
                     Err(err) => return Some(Err(err)),
                 };
+                let package_task_event =
+                    PackageTaskEventBuilder::new(task_id.package(), task_id.task())
+                        .with_parent(telemetry);
 
+                package_task_event.track_scm_mode(if scm.is_manual() { "manual" } else { "git" });
                 let workspace_name = task_id.to_workspace_name();
 
                 let pkg = match workspaces
@@ -107,10 +114,12 @@ impl PackageInputsHashes {
                     .parent()
                     .unwrap_or_else(|| AnchoredSystemPath::new("").unwrap());
 
+                let scm_telemetry = package_task_event.child();
                 let mut hash_object = match scm.get_package_file_hashes(
                     repo_root,
                     package_path,
                     &task_definition.inputs,
+                    Some(scm_telemetry),
                 ) {
                     Ok(hash_object) => hash_object,
                     Err(err) => return Some(Err(err.into())),

crates/turborepo-lib/src/task_hash.rs

@@ -21,6 +21,7 @@ sha1 = "0.10.5"
 thiserror = { workspace = true }
 tracing = { workspace = true }
 turbopath = { workspace = true }
+turborepo-telemetry = { path = "../turborepo-telemetry" }
 wax = { workspace = true }
 which = { workspace = true }
 

crates/turborepo-scm/Cargo.toml

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use itertools::{Either, Itertools};
 use tracing::debug;
 use turbopath::{AbsoluteSystemPath, AnchoredSystemPath, PathError, RelativeUnixPathBuf};
+use turborepo_telemetry::events::task::{FileHashMethod, PackageTaskEventBuilder};
 
 use crate::{hash_object::hash_objects, Error, Git, SCM};
 
@@ -28,26 +29,44 @@ impl SCM {
         turbo_root: &AbsoluteSystemPath,
         package_path: &AnchoredSystemPath,
         inputs: &[S],
+        telemetry: Option<PackageTaskEventBuilder>,
     ) -> Result<GitHashes, Error> {
         match self {
-            SCM::Manual => crate::manual::get_package_file_hashes_from_processing_gitignore(
-                turbo_root,
-                package_path,
-                inputs,
-            ),
-            SCM::Git(git) => git
-                .get_package_file_hashes(turbo_root, package_path, inputs)
-                .or_else(|e| {
-                    debug!(
-                        "failed to use git to hash files: {}. Falling back to manual",
-                        e
-                    );
-                    crate::manual::get_package_file_hashes_from_processing_gitignore(
-                        turbo_root,
-                        package_path,
-                        inputs,
-                    )
-                }),
+            SCM::Manual => {
+                if let Some(telemetry) = telemetry {
+                    telemetry.track_file_hash_method(FileHashMethod::Manual);
+                }
+                crate::manual::get_package_file_hashes_from_processing_gitignore(
+                    turbo_root,
+                    package_path,
+                    inputs,
+                )
+            }
+            SCM::Git(git) => {
+                let result = git.get_package_file_hashes(turbo_root, package_path, inputs);
+                match result {
+                    Ok(hashes) => {
+                        if let Some(telemetry) = telemetry {
+                            telemetry.track_file_hash_method(FileHashMethod::Git);
+                        }
+                        Ok(hashes)
+                    }
+                    Err(err) => {
+                        debug!(
+                            "failed to use git to hash files: {}. Falling back to manual",
+                            err
+                        );
+                        if let Some(telemetry) = telemetry {
+                            telemetry.track_file_hash_method(FileHashMethod::Manual);
+                        }
+                        crate::manual::get_package_file_hashes_from_processing_gitignore(
+                            turbo_root,
+                            package_path,
+                            inputs,
+                        )
+                    }
+                }
+            }
         }
     }
 
@@ -272,7 +291,12 @@ mod tests {
         repo_root.join_component(".git").remove_dir_all().unwrap();
         let pkg_path = repo_root.anchor(&my_pkg_dir).unwrap();
         let hashes = git
-            .get_package_file_hashes::<&str>(&repo_root, &pkg_path, &[])
+            .get_package_file_hashes::<&str>(
+                &repo_root,
+                &pkg_path,
+                &[],
+                Some(PackageTaskEventBuilder::new("my-pkg", "test")),
+            )
             .unwrap();
         let mut expected = GitHashes::new();
         expected.insert(

crates/turborepo-scm/src/package_deps.rs

@@ -5,6 +5,17 @@ use uuid::Uuid;
 use super::{Event, EventBuilder, EventType, Identifiable};
 use crate::{config::TelemetryConfig, telem};
 
+pub enum DaemonInitStatus {
+    // skipped due to context (running in CI etc)
+    Skipped,
+    /// daemon was started
+    Started,
+    /// daemon failed to start
+    Failed,
+    /// daemon was manually disabled by user
+    Disabled,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GenericEventBuilder {
     id: String,
@@ -119,4 +130,58 @@ impl GenericEventBuilder {
         });
         self
     }
+
+    // run data
+
+    pub fn track_is_linked(&self, is_linked: bool) -> &Self {
+        self.track(Event {
+            key: "is_linked".to_string(),
+            value: if is_linked { "true" } else { "false" }.to_string(),
+            is_sensitive: EventType::NonSensitive,
+        });
+        self
+    }
+
+    pub fn track_remote_cache(&self, cache_url: &str) -> &Self {
+        self.track(Event {
+            key: "remote_cache_url".to_string(),
+            value: cache_url.to_string(),
+            is_sensitive: EventType::NonSensitive,
+        });
+        self
+    }
+
+    pub fn track_ci(&self, ci: Option<&'static str>) -> &Self {
+        if let Some(ci) = ci {
+            self.track(Event {
+                key: "ci".to_string(),
+                value: ci.to_string(),
+                is_sensitive: EventType::NonSensitive,
+            });
+        }
+        self
+    }
+
+    pub fn track_run_type(&self, is_dry: bool) -> &Self {
+        self.track(Event {
+            key: "run_type".to_string(),
+            value: if is_dry { "dry" } else { "full" }.to_string(),
+            is_sensitive: EventType::NonSensitive,
+        });
+        self
+    }
+
+    pub fn track_daemon_init(&self, status: DaemonInitStatus) -> &Self {
+        self.track(Event {
+            key: "daemon_status".to_string(),
+            value: match status {
+                DaemonInitStatus::Skipped => "skipped".to_string(),
+                DaemonInitStatus::Started => "started".to_string(),
+                DaemonInitStatus::Failed => "failed".to_string(),
+                DaemonInitStatus::Disabled => "disabled".to_string(),
+            },
+            is_sensitive: EventType::NonSensitive,
+        });
+        self
+    }
 }