new: Add toolchain usage telemetry. (#2045)

* Update url.

* Add method.

* Change to an instance.

* Switch to singleton.

* Remove checks.

* Change to post.

* switch to map.

* Add checks.

Author: milesj

CHANGELOG.md

@@ -15,6 +15,7 @@
 
 #### ⚙️ Internal
 
+- Added telemetry for toolchain usage.
 - Updated Rust to v1.88.0.
 
 ## 1.38.3

crates/action-pipeline/src/action_pipeline.rs

@@ -7,6 +7,7 @@ use crate::subscribers::console_subscriber::ConsoleSubscriber;
 use crate::subscribers::notifications_subscriber::NotificationsSubscriber;
 use crate::subscribers::remote_subscriber::RemoteSubscriber;
 use crate::subscribers::reports_subscriber::ReportsSubscriber;
+use crate::subscribers::telemetry_subscriber::TelemetrySubscriber;
 use crate::subscribers::webhooks_subscriber::WebhooksSubscriber;
 use miette::IntoDiagnostic;
 use moon_action::{Action, ActionNode, ActionPipelineStatus};
@@ -389,6 +390,8 @@ impl ActionPipeline {
                 .await;
         }
 
+        debug!("Subscribing remote services");
+
         self.emitter.subscribe(RemoteSubscriber).await;
 
         debug!("Subscribing run reports and estimates");
@@ -454,6 +457,16 @@ impl ActionPipeline {
                 ))
                 .await;
         }
+
+        if self.app_context.workspace_config.telemetry {
+            debug!("Subscribing telemetry");
+
+            self.emitter
+                .subscribe(TelemetrySubscriber::new(Arc::clone(
+                    &self.app_context.toolchain_config,
+                )))
+                .await;
+        }
     }
 }
 

crates/action-pipeline/src/subscribers/mod.rs

@@ -3,4 +3,5 @@ pub mod console_subscriber;
 pub mod notifications_subscriber;
 pub mod remote_subscriber;
 pub mod reports_subscriber;
+pub mod telemetry_subscriber;
 pub mod webhooks_subscriber;

crates/action-pipeline/src/subscribers/telemetry_subscriber.rs

@@ -0,0 +1,49 @@
+use crate::event_emitter::{Event, Subscriber};
+use async_trait::async_trait;
+use moon_api::Launchpad;
+use moon_common::is_ci;
+use moon_config::ToolchainConfig;
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+pub struct TelemetrySubscriber {
+    toolchain_config: Arc<ToolchainConfig>,
+}
+
+impl TelemetrySubscriber {
+    pub fn new(toolchain_config: Arc<ToolchainConfig>) -> Self {
+        Self { toolchain_config }
+    }
+}
+
+#[async_trait]
+impl Subscriber for TelemetrySubscriber {
+    async fn on_emit<'data>(&mut self, event: &Event<'data>) -> miette::Result<()> {
+        // Only capture toolchain usage in CI
+        if !is_ci() {
+            return Ok(());
+        }
+
+        if matches!(event, Event::PipelineStarted { .. }) {
+            let mut toolchains = BTreeMap::default();
+
+            for (id, plugin) in &self.toolchain_config.plugins {
+                if let Some(locator) = &plugin.plugin {
+                    toolchains.insert(id.to_string(), locator.to_string());
+                }
+            }
+
+            for platform in self.toolchain_config.get_enabled_platforms() {
+                toolchains.insert(platform.to_string().to_lowercase(), "legacy".to_owned());
+            }
+
+            if !toolchains.is_empty() {
+                let _ = Launchpad::instance()
+                    .track_toolchain_usage(toolchains)
+                    .await;
+            }
+        }
+
+        Ok(())
+    }
+}

crates/api/src/launchpad.rs

@@ -1,18 +1,22 @@
 use miette::IntoDiagnostic;
 use moon_cache::{CacheEngine, cache_item};
-use moon_common::{consts::CONFIG_DIRNAME, is_test_env};
+use moon_common::{consts::CONFIG_DIRNAME, is_ci, is_test_env};
 use moon_env::MoonEnvironment;
 use moon_env_var::GlobalEnvBag;
 use moon_time::now_millis;
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use starbase_utils::{fs, json};
-use std::env::{self, consts};
+use std::collections::BTreeMap;
+use std::env::consts;
 use std::path::Path;
+use std::sync::{Arc, OnceLock};
 use std::time::Duration;
 use tracing::{debug, instrument};
 use uuid::Uuid;
 
+static INSTANCE: OnceLock<Arc<Launchpad>> = OnceLock::new();
+
 const ALERT_PAUSE_DURATION: Duration = Duration::from_secs(43200); // 12 hours
 
 #[derive(Debug, Default, Deserialize, Serialize)]
@@ -30,6 +34,11 @@ cache_item!(
     }
 );
 
+#[derive(Serialize)]
+pub struct ToolchainUsage {
+    pub toolchains: BTreeMap<String, String>,
+}
+
 fn load_or_create_anonymous_uid(id_path: &Path) -> miette::Result<String> {
     if id_path.exists() {
         return Ok(fs::read_file(id_path)?);
@@ -60,13 +69,43 @@ pub struct VersionCheck {
     pub update_available: bool,
 }
 
-pub struct Launchpad;
+pub struct Launchpad {
+    #[allow(dead_code)]
+    moon_env: Arc<MoonEnvironment>,
+    moon_version: String,
+    user_id: String,
+    repo_id: Option<String>,
+}
 
 impl Launchpad {
+    pub fn register(moon_env: Arc<MoonEnvironment>) -> miette::Result<()> {
+        let user_id = load_or_create_anonymous_uid(&moon_env.id_file)?;
+
+        let repo_id = fs::find_upwards(CONFIG_DIRNAME, &moon_env.working_dir)
+            .map(|dir| create_anonymous_rid(dir.parent().unwrap()));
+
+        let moon_version = GlobalEnvBag::instance()
+            .get("MOON_VERSION")
+            .unwrap_or_default();
+
+        let _ = INSTANCE.set(Arc::new(Self {
+            moon_env,
+            moon_version,
+            user_id,
+            repo_id,
+        }));
+
+        Ok(())
+    }
+
+    pub fn instance() -> Arc<Launchpad> {
+        Arc::clone(INSTANCE.get().unwrap())
+    }
+
     #[instrument(skip_all)]
     pub async fn check_version(
+        &self,
         cache_engine: &CacheEngine,
-        moon_env: &MoonEnvironment,
         bypass_cache: bool,
         manifest_url: &str,
     ) -> miette::Result<Option<VersionCheck>> {
@@ -81,7 +120,7 @@ impl Launchpad {
             }
         }
 
-        if let Some(result) = Self::check_version_without_cache(moon_env, manifest_url).await? {
+        if let Some(result) = self.check_version_without_cache(manifest_url).await? {
             state.data.last_check_time = Some(now);
             state.data.local_version = Some(result.local_version.clone());
             state.data.remote_version = Some(result.remote_version.clone());
@@ -94,54 +133,33 @@ impl Launchpad {
     }
 
     pub async fn check_version_without_cache(
-        moon_env: &MoonEnvironment,
+        &self,
         manifest_url: &str,
     ) -> miette::Result<Option<VersionCheck>> {
         if is_test_env() || proto_core::is_offline() {
             return Ok(None);
         }
 
-        let version = GlobalEnvBag::instance()
-            .get("MOON_VERSION")
-            .unwrap_or_default();
+        let version = &self.moon_version;
 
         debug!(
             current_version = &version,
             manifest_url = manifest_url,
             "Checking for a new version of moon"
         );
 
-        let mut client = reqwest::Client::new()
-            .get(manifest_url)
-            .header("X-Moon-OS", consts::OS.to_owned())
-            .header("X-Moon-Arch", consts::ARCH.to_owned())
-            .header("X-Moon-Version", &version)
-            .header("X-Moon-CI", ci_env::is_ci().to_string())
+        let request = self
+            .create_request(manifest_url)?
             .header(
                 "X-Moon-CI-Provider",
                 format!("{:?}", ci_env::detect_provider()),
             )
-            .header("X-Moon-CD", cd_env::is_cd().to_string())
             .header(
                 "X-Moon-CD-Provider",
                 format!("{:?}", cd_env::detect_provider()),
-            )
-            .header(
-                "X-Moon-UID",
-                load_or_create_anonymous_uid(&moon_env.id_file)?,
-            );
-
-        if let Some(moon_dir) = fs::find_upwards(
-            CONFIG_DIRNAME,
-            env::current_dir().expect("Invalid working directory!"),
-        ) {
-            client = client.header(
-                "X-Moon-RID",
-                create_anonymous_rid(moon_dir.parent().unwrap()),
             );
-        }
 
-        let Ok(response) = client.send().await else {
+        let Ok(response) = request.send().await else {
             return Ok(None);
         };
 
@@ -150,7 +168,7 @@ impl Launchpad {
         };
 
         let data: CurrentVersion = json::parse(text)?;
-        let local_version = Version::parse(&version).into_diagnostic()?;
+        let local_version = Version::parse(version).into_diagnostic()?;
         let remote_version = Version::parse(&data.current_version).into_diagnostic()?;
         let update_available = remote_version > local_version;
 
@@ -168,4 +186,38 @@ impl Launchpad {
             update_available,
         }))
     }
+
+    pub async fn track_toolchain_usage(
+        &self,
+        toolchains: BTreeMap<String, String>,
+    ) -> miette::Result<()> {
+        if !is_ci() || is_test_env() || proto_core::is_offline() {
+            return Ok(());
+        }
+
+        let request = self
+            .create_request("https://launch.moonrepo.app/moon/toolchain_usage")?
+            .json(&ToolchainUsage { toolchains });
+
+        let _response = request.send().await.into_diagnostic()?;
+
+        Ok(())
+    }
+
+    fn create_request(&self, url: &str) -> miette::Result<reqwest::RequestBuilder> {
+        let mut client = reqwest::Client::new()
+            .post(url)
+            .header("X-Moon-OS", consts::OS.to_owned())
+            .header("X-Moon-Arch", consts::ARCH.to_owned())
+            .header("X-Moon-Version", self.moon_version.clone())
+            .header("X-Moon-CI", ci_env::is_ci().to_string())
+            .header("X-Moon-CD", cd_env::is_cd().to_string())
+            .header("X-Moon-UID", self.user_id.clone());
+
+        if let Some(repo_id) = &self.repo_id {
+            client = client.header("X-Moon-RID", repo_id.to_owned());
+        }
+
+        Ok(client)
+    }
 }

crates/app/src/commands/upgrade.rs

@@ -32,11 +32,9 @@ pub async fn upgrade(session: MoonSession) -> AppResult {
         return Err(AppError::UpgradeRequiresInternet.into());
     }
 
-    let remote_version = match Launchpad::check_version_without_cache(
-        &session.moon_env,
-        &session.toolchain_config.moon.manifest_url,
-    )
-    .await
+    let remote_version = match Launchpad::instance()
+        .check_version_without_cache(&session.toolchain_config.moon.manifest_url)
+        .await
     {
         Ok(Some(result)) if result.update_available => result.remote_version,
         Ok(_) => {

crates/app/src/session.rs

@@ -4,6 +4,7 @@ use crate::components::*;
 use crate::systems::*;
 use async_trait::async_trait;
 use moon_action_graph::{ActionGraphBuilder, ActionGraphBuilderOptions};
+use moon_api::Launchpad;
 use moon_app_context::AppContext;
 use moon_cache::CacheEngine;
 use moon_common::is_formatted_output;
@@ -317,10 +318,11 @@ impl AppSession for MoonSession {
             self.tasks_config = tasks_config;
         }
 
-        // Load components
+        // Load singleton components
 
         startup::register_feature_flags(&self.workspace_config)?;
 
+        Launchpad::register(self.moon_env.clone())?;
         ProcessRegistry::register(self.workspace_config.pipeline.kill_process_threshold);
 
         Ok(None)
@@ -376,7 +378,6 @@ impl AppSession for MoonSession {
 
             execute::check_for_new_version(
                 &self.console,
-                &self.moon_env,
                 &cache_engine,
                 &self.toolchain_config.moon.manifest_url,
             )

crates/app/src/systems/execute.rs

@@ -2,22 +2,23 @@ use moon_api::Launchpad;
 use moon_cache::CacheEngine;
 use moon_common::{color, is_formatted_output, is_test_env};
 use moon_console::{Checkpoint, Console};
-use moon_env::MoonEnvironment;
 use starbase::AppResult;
 use tracing::{debug, instrument};
 
 #[instrument(skip_all)]
 pub async fn check_for_new_version(
     console: &Console,
-    moon_env: &MoonEnvironment,
     cache_engine: &CacheEngine,
     manifest_url: &str,
 ) -> AppResult {
     if is_test_env() || is_formatted_output() {
         return Ok(None);
     }
 
-    match Launchpad::check_version(cache_engine, moon_env, false, manifest_url).await {
+    match Launchpad::instance()
+        .check_version(cache_engine, false, manifest_url)
+        .await
+    {
         Ok(Some(result)) => {
             if !result.update_available {
                 return Ok(None);

crates/config/src/toolchain/moon_config.rs

@@ -6,7 +6,7 @@ config_struct!(
     #[derive(Config)]
     pub struct MoonConfig {
         /// A secure URL to lookup the latest version.
-        #[setting(validate = validate::url_secure, default = "https://launch.moonrepo.app/versions/cli/current")]
+        #[setting(validate = validate::url_secure, default = "https://launch.moonrepo.app/moon/check_version")]
         pub manifest_url: String,
 
         /// A secure URL for downloading the moon binary.

packages/types/src/toolchain-config.ts

@@ -111,7 +111,7 @@ export interface MoonConfig {
 	/**
 	 * A secure URL to lookup the latest version.
 	 *
-	 * @default 'https://launch.moonrepo.app/versions/cli/current'
+	 * @default 'https://launch.moonrepo.app/moon/check_version'
 	 */
 	manifestUrl?: string;
 }
@@ -481,7 +481,7 @@ export interface PartialMoonConfig {
 	/**
 	 * A secure URL to lookup the latest version.
 	 *
-	 * @default 'https://launch.moonrepo.app/versions/cli/current'
+	 * @default 'https://launch.moonrepo.app/moon/check_version'
 	 */
 	manifestUrl?: string | null;
 }