fix: track usage metrics (#1875)

Co-authored-by: Tushar Mathur <[email protected]>

Cargo.toml

@@ -142,14 +142,14 @@ dotenvy = "0.15.7"
 convert_case = "0.6.0"
 rand = "0.8.5"
 tailcall-macros = { path = "tailcall-macros" }
+tailcall-tracker = { path = "tailcall-tracker", optional = true }
 tonic-types = "0.11.0"
 datatest-stable = "0.2.9"
 tokio-test = "0.4.4"
 base64 = "0.22.1"
 
-
 [dev-dependencies]
-tailcall-prettier = {path = "tailcall-prettier"}
+tailcall-prettier = { path = "tailcall-prettier" }
 criterion = "0.5.1"
 httpmock = "0.7.0"
 pretty_assertions = "1.4.0"
@@ -185,6 +185,7 @@ cli = [
     "opentelemetry_sdk/rt-tokio",
     "dep:opentelemetry-otlp",
     "dep:opentelemetry-system-metrics",
+    "dep:tailcall-tracker"
 ]
 
 # Feature flag to enable all default features.
@@ -203,8 +204,8 @@ members = [
     "tailcall-prettier",
     "tailcall-query-plan",
     "tailcall-fixtures",
-    "tailcall-upstream-grpc"
-]
+    "tailcall-upstream-grpc",
+    "tailcall-tracker"]
 
 # Boost execution_spec snapshot diffing performance
 [profile.dev.package]

src/cli/command.rs

@@ -1,4 +1,5 @@
 use clap::{Parser, Subcommand};
+use strum_macros::Display;
 
 use crate::{config, generator};
 
@@ -20,7 +21,7 @@ pub struct Cli {
     pub command: Command,
 }
 
-#[derive(Subcommand)]
+#[derive(Subcommand, Display)]
 pub enum Command {
     /// Starts the GraphQL server on the configured port
     Start {

src/cli/tc.rs

@@ -3,8 +3,10 @@ use std::path::Path;
 
 use anyhow::Result;
 use clap::Parser;
+use convert_case::{Case, Casing};
 use dotenvy::dotenv;
 use inquire::Confirm;
+use lazy_static::lazy_static;
 use stripmargin::StripMargin;
 
 use super::command::{Cli, Command};
@@ -23,6 +25,9 @@ const FILE_NAME: &str = ".tailcallrc.graphql";
 const YML_FILE_NAME: &str = ".graphqlrc.yml";
 const JSON_FILE_NAME: &str = ".tailcallrc.schema.json";
 
+lazy_static! {
+    static ref TRACKER: tailcall_tracker::Tracker = tailcall_tracker::Tracker::default();
+}
 pub async fn run() -> Result<()> {
     if let Ok(path) = dotenv() {
         tracing::info!("Env file: {:?} loaded", path);
@@ -31,6 +36,16 @@ pub async fn run() -> Result<()> {
     update_checker::check_for_update().await;
     let runtime = cli::runtime::init(&Blueprint::default());
     let config_reader = ConfigReader::init(runtime.clone());
+
+    // Initialize ping event every 60 seconds
+    let _ = TRACKER
+        .init_ping(tokio::time::Duration::from_secs(60))
+        .await;
+
+    // Dispatch the command as an event
+    let _ = TRACKER
+        .dispatch(cli.command.to_string().to_case(Case::Snake).as_str())
+        .await;
     match cli.command {
         Command::Start { file_paths } => {
             let config_module = config_reader.read_all(&file_paths).await?;

tailcall-tracker/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "tailcall-tracker"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+reqwest = { version = "0.11", features = ["json", "rustls-tls"] }
+anyhow = "1.0.82"
+lazy_static = "1.4.0"
+serde = { version = "1.0.200", features = ["derive"] }
+serde_json = { version = "1.0.82", features = ["preserve_order"] }
+machineid-rs = "1.2.4"
+tokio = { version = "1.0.1", features = ["rt", "time"] }
+tracing = "0.1.40"
+sysinfo = "0.30.12"

tailcall-tracker/src/check_tracking.rs

@@ -0,0 +1,52 @@
+use std::env;
+
+const LONG_ENV_FILTER_VAR_NAME: &str = "TAILCALL_TRACKER";
+const SHORT_ENV_FILTER_VAR_NAME: &str = "TC_TRACKER";
+const VERSION: &str = match option_env!("APP_VERSION") {
+    Some(version) => version,
+    _ => "0.1.0-dev",
+};
+
+/// Checks if tracking is enabled
+pub fn check_tracking() -> bool {
+    let is_prod = !VERSION.contains("dev");
+    let usage_enabled = env::var(LONG_ENV_FILTER_VAR_NAME)
+        .or(env::var(SHORT_ENV_FILTER_VAR_NAME))
+        .map(|v| !v.eq_ignore_ascii_case("false"))
+        .ok();
+    check_tracking_inner(is_prod, usage_enabled)
+}
+
+fn check_tracking_inner(is_prod_build: bool, tracking_enabled: Option<bool>) -> bool {
+    if let Some(usage_enabled) = tracking_enabled {
+        usage_enabled
+    } else {
+        is_prod_build
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn usage_enabled_true() {
+        assert!(check_tracking_inner(true, Some(true)));
+        assert!(check_tracking_inner(false, Some(true)));
+    }
+
+    #[test]
+    fn usage_enabled_false() {
+        assert!(!check_tracking_inner(true, Some(false)));
+        assert!(!check_tracking_inner(false, Some(false)));
+    }
+
+    #[test]
+    fn usage_enabled_none_is_prod_true() {
+        assert!(check_tracking_inner(true, None));
+    }
+
+    #[test]
+    fn usage_enabled_none_is_prod_false() {
+        assert!(!check_tracking_inner(false, None));
+    }
+}

tailcall-tracker/src/event.rs

@@ -0,0 +1,52 @@
+use machineid_rs::{Encryption, HWIDComponent, IdBuilder};
+use serde::{Deserialize, Serialize};
+use sysinfo::System;
+
+const PARAPHRASE: &str = "tc_key";
+const DEFAULT_CLIENT_ID: &str = "<anonymous>";
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Params {
+    cpu_cores: String,
+    os_name: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct EventValue {
+    name: String,
+    params: Params,
+}
+
+impl EventValue {
+    fn new(name: &str) -> EventValue {
+        let sys = System::new_all();
+        let cores = sys.physical_core_count().unwrap_or(2).to_string();
+        let os_name = System::long_os_version().unwrap_or("Unknown".to_string());
+        EventValue {
+            name: name.to_string(),
+            params: Params { cpu_cores: cores, os_name },
+        }
+    }
+}
+
+/// Event structure to be sent to GA
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Event {
+    client_id: String,
+    events: Vec<EventValue>,
+}
+
+impl Event {
+    pub fn new(name: &str) -> Self {
+        let mut builder = IdBuilder::new(Encryption::SHA256);
+        builder
+            .add_component(HWIDComponent::SystemID)
+            .add_component(HWIDComponent::CPUCores);
+
+        let id = builder
+            .build(PARAPHRASE)
+            .unwrap_or(DEFAULT_CLIENT_ID.to_string());
+
+        Self { client_id: id, events: vec![EventValue::new(name)] }
+    }
+}

tailcall-tracker/src/lib.rs

@@ -0,0 +1,4 @@
+mod check_tracking;
+mod event;
+mod tracker;
+pub use tracker::Tracker;

tailcall-tracker/src/tracker.rs

@@ -0,0 +1,76 @@
+use reqwest::header::{HeaderName, HeaderValue};
+
+use crate::check_tracking::check_tracking;
+use crate::event::Event;
+
+const API_SECRET: &str = "GVaEzXFeRkCI9YBIylbEjQ";
+const MEASUREMENT_ID: &str = "G-JEP3QDWT0G";
+const BASE_URL: &str = "https://www.google-analytics.com";
+
+///
+/// Base structure to track usage of the CLI application
+#[derive(Debug, Clone)]
+pub struct Tracker {
+    base_url: String,
+    api_secret: String,
+    measurement_id: String,
+    is_tracking: bool,
+}
+
+impl Default for Tracker {
+    fn default() -> Self {
+        Self {
+            base_url: BASE_URL.to_string(),
+            api_secret: API_SECRET.to_string(),
+            measurement_id: MEASUREMENT_ID.to_string(),
+            is_tracking: check_tracking(),
+        }
+    }
+}
+
+impl Tracker {
+    /// Initializes the ping event to be sent after the provided duration
+    pub async fn init_ping(&'static self, duration: tokio::time::Duration) {
+        if self.is_tracking {
+            let mut interval = tokio::time::interval(duration);
+            tokio::task::spawn(async move {
+                loop {
+                    interval.tick().await;
+                    let _ = self.dispatch("ping").await;
+                }
+            });
+        }
+    }
+
+    fn create_request(&self, event_name: &str) -> anyhow::Result<reqwest::Request> {
+        let event = Event::new(event_name);
+        tracing::debug!("Sending event: {:?}", event);
+        let mut url = reqwest::Url::parse(self.base_url.as_str())?;
+        url.set_path("/mp/collect");
+        url.query_pairs_mut()
+            .append_pair("api_secret", self.api_secret.as_str())
+            .append_pair("measurement_id", self.measurement_id.as_str());
+        let mut request = reqwest::Request::new(reqwest::Method::POST, url);
+        let header_name = HeaderName::from_static("content-type");
+        let header_value = HeaderValue::from_str("application/json")?;
+        request.headers_mut().insert(header_name, header_value);
+
+        let _ = request
+            .body_mut()
+            .insert(reqwest::Body::from(serde_json::to_string(&event)?));
+        Ok(request)
+    }
+
+    pub async fn dispatch(&'static self, name: &str) -> anyhow::Result<()> {
+        if self.is_tracking {
+            let request = self.create_request(name)?;
+            let client = reqwest::Client::new();
+            let response = client.execute(request).await?;
+            let status = response.status();
+            let text = response.text().await?;
+            tracing::debug!("Tracker: {}, message: {:?}", status.as_str(), text);
+        }
+
+        Ok(())
+    }
+}