Web analytics

.vscode/settings.json

@@ -80,5 +80,6 @@
         "rerun_py/pyproject.toml"
     ],
     "cmake.buildDirectory": "${workspaceRoot}/build/",
-    "C_Cpp.autoAddFileAssociations": false
+    "C_Cpp.autoAddFileAssociations": false,
+    "rust-analyzer.showUnlinkedFileNotification": false
 }

crates/re_analytics/src/cli.rs

@@ -20,7 +20,7 @@ pub enum CliError {
 }
 
 pub fn clear() -> Result<(), CliError> {
-    let config = Config::load()?;
+    let config = Config::load_or_default()?;
 
     fn delete_dir(dir: &Path) -> Result<(), CliError> {
         eprint!("Are you sure you want to delete directory {dir:?}? [y/N]: ",);
@@ -50,13 +50,13 @@ pub fn clear() -> Result<(), CliError> {
 }
 
 pub fn set(props: impl IntoIterator<Item = (String, Property)>) -> Result<(), CliError> {
-    let mut config = Config::load()?;
+    let mut config = Config::load_or_default()?;
     config.opt_in_metadata.extend(props);
     config.save().map_err(Into::into)
 }
 
 pub fn opt(enabled: bool) -> Result<(), CliError> {
-    let mut config = Config::load()?;
+    let mut config = Config::load_or_default()?;
     config.analytics_enabled = enabled;
     config.save()?;
 

crates/re_analytics/src/event.rs

@@ -0,0 +1,88 @@
+use crate::{Event, Property};
+use std::collections::HashMap;
+
+use time::OffsetDateTime;
+
+/// The "public" API key can be obtained at <https://eu.posthog.com/project/settings#project-api-key>.
+/// Make sure you are logged in to the right organization and have the correct project open.
+/// Unfortunately that stuff is client-side routed, and there's no way to link directly to the right place.
+pub const PUBLIC_POSTHOG_PROJECT_KEY: &str = "phc_sgKidIE4WYYFSJHd8LEYY1UZqASpnfQKeMqlJfSXwqg";
+
+#[derive(Debug, serde::Serialize)]
+#[serde(untagged)]
+pub enum PostHogEvent<'a> {
+    Capture(PostHogCaptureEvent<'a>),
+    Identify(PostHogIdentifyEvent<'a>),
+}
+
+impl<'a> PostHogEvent<'a> {
+    pub fn from_event(analytics_id: &'a str, session_id: &'a str, event: &'a Event) -> Self {
+        let properties = event.props.iter().map(|(name, value)| {
+            (
+                name.as_ref(),
+                match value {
+                    &Property::Integer(v) => v.into(),
+                    &Property::Float(v) => v.into(),
+                    Property::String(v) => v.as_str().into(),
+                    &Property::Bool(v) => v.into(),
+                },
+            )
+        });
+
+        match event.kind {
+            crate::EventKind::Append => Self::Capture(PostHogCaptureEvent {
+                timestamp: event.time_utc,
+                event: event.name.as_ref(),
+                distinct_id: analytics_id,
+                properties: properties
+                    .chain([("session_id", session_id.into())])
+                    .collect(),
+            }),
+            crate::EventKind::Update => Self::Identify(PostHogIdentifyEvent {
+                timestamp: event.time_utc,
+                event: "$identify",
+                distinct_id: analytics_id,
+                properties: [("session_id", session_id.into())].into(),
+                set: properties.collect(),
+            }),
+        }
+    }
+}
+
+// See https://posthog.com/docs/api/post-only-endpoints#capture.
+#[derive(Debug, serde::Serialize)]
+pub struct PostHogCaptureEvent<'a> {
+    #[serde(with = "::time::serde::rfc3339")]
+    timestamp: OffsetDateTime,
+    event: &'a str,
+    distinct_id: &'a str,
+    properties: HashMap<&'a str, serde_json::Value>,
+}
+
+// See https://posthog.com/docs/api/post-only-endpoints#identify.
+#[derive(Debug, serde::Serialize)]
+pub struct PostHogIdentifyEvent<'a> {
+    #[serde(with = "::time::serde::rfc3339")]
+    timestamp: OffsetDateTime,
+    event: &'a str,
+    distinct_id: &'a str,
+    properties: HashMap<&'a str, serde_json::Value>,
+    #[serde(rename = "$set")]
+    set: HashMap<&'a str, serde_json::Value>,
+}
+
+// See https://posthog.com/docs/api/post-only-endpoints#batch-events.
+#[derive(Debug, serde::Serialize)]
+pub struct PostHogBatch<'a> {
+    api_key: &'static str,
+    batch: &'a [PostHogEvent<'a>],
+}
+
+impl<'a> PostHogBatch<'a> {
+    pub fn from_events(events: &'a [PostHogEvent<'a>]) -> Self {
+        Self {
+            api_key: PUBLIC_POSTHOG_PROJECT_KEY,
+            batch: events,
+        }
+    }
+}

crates/re_analytics/src/lib.rs

@@ -11,16 +11,23 @@
 #[cfg(not(target_arch = "wasm32"))]
 mod native;
 #[cfg(not(target_arch = "wasm32"))]
-use native::{Config, ConfigError, Pipeline, PipelineError};
+pub use native::{Config, ConfigError};
+#[cfg(not(target_arch = "wasm32"))]
+use native::{Pipeline, PipelineError};
 
 #[cfg(target_arch = "wasm32")]
 mod web;
 #[cfg(target_arch = "wasm32")]
-use web::{Config, ConfigError, Pipeline, PipelineError};
+pub use web::{Config, ConfigError};
+#[cfg(target_arch = "wasm32")]
+use web::{Pipeline, PipelineError};
 
 #[cfg(not(target_arch = "wasm32"))]
 pub mod cli;
 
+mod event;
+use event::{PostHogBatch, PostHogEvent};
+
 // ----------------------------------------------------------------------------
 
 use std::borrow::Cow;
@@ -185,6 +192,7 @@ impl From<&str> for Property {
 
 // ---
 
+#[cfg(not(target_arch = "wasm32"))]
 const DISCLAIMER: &str = "
     Welcome to Rerun!
 
@@ -231,19 +239,54 @@ pub struct Analytics {
     event_id: AtomicU64,
 }
 
-impl Analytics {
-    pub fn new(tick: Duration) -> Result<Self, AnalyticsError> {
-        let config = Config::load()?;
-        re_log::trace!(?config, ?tick, "loaded analytics config");
+fn load_config() -> Result<Config, ConfigError> {
+    let config = match Config::load() {
+        Ok(config) => config,
+        #[allow(unused_variables)]
+        Err(err) => {
+            // NOTE: This will cause the first run disclaimer to show up again on native,
+            //       and analytics will be disabled for the rest of the session.
+            #[cfg(not(target_arch = "wasm32"))]
+            re_log::warn!("failed to load analytics config file: {err}");
+            None
+        }
+    };
+
+    if let Some(config) = config {
+        re_log::trace!(?config, "loaded analytics config");
+
+        Ok(config)
+    } else {
+        re_log::trace!(?config, "initialized analytics config");
 
+        // NOTE: If this fails, we give up, because we can't produce
+        //       a config on native any other way.
+        let config = Config::new()?;
+
+        #[cfg(not(target_arch = "wasm32"))]
         if config.is_first_run() {
             eprintln!("{DISCLAIMER}");
 
             config.save()?;
-            re_log::trace!(?config, ?tick, "saved analytics config");
+            re_log::trace!(?config, "saved analytics config");
         }
 
+        #[cfg(target_arch = "wasm32")]
+        {
+            // always save the config on web, without printing a disclaimer.
+            config.save()?;
+            re_log::trace!(?config, "saved analytics config");
+        }
+
+        Ok(config)
+    }
+}
+
+impl Analytics {
+    pub fn new(tick: Duration) -> Result<Self, AnalyticsError> {
+        let config = load_config()?;
         let pipeline = Pipeline::new(&config, tick)?;
+        re_log::trace!("initialized analytics pipeline");
 
         Ok(Self {
             config,

crates/re_analytics/src/native/config.rs

@@ -10,8 +10,6 @@ use uuid::Uuid;
 
 use crate::Property;
 
-// ---
-
 #[derive(thiserror::Error, Debug)]
 pub enum ConfigError {
     #[error("Couldn't compute config location")]
@@ -61,28 +59,40 @@ pub struct Config {
 }
 
 impl Config {
-    pub fn load() -> Result<Config, ConfigError> {
+    pub fn new() -> Result<Self, ConfigError> {
         let dirs = Self::project_dirs()?;
         let config_path = dirs.config_dir().join("analytics.json");
         let data_path = dirs.data_local_dir().join("analytics");
-        let config = match File::open(&config_path) {
+        Ok(Self {
+            analytics_id: Uuid::new_v4().to_string(),
+            analytics_enabled: true,
+            opt_in_metadata: Default::default(),
+            session_id: Uuid::new_v4(),
+            is_first_run: true,
+            config_file_path: config_path,
+            data_dir_path: data_path,
+        })
+    }
+
+    pub fn load_or_default() -> Result<Config, ConfigError> {
+        match Self::load()? {
+            Some(config) => Ok(config),
+            None => Config::new(),
+        }
+    }
+
+    pub fn load() -> Result<Option<Config>, ConfigError> {
+        let dirs = Self::project_dirs()?;
+        let config_path = dirs.config_dir().join("analytics.json");
+        match File::open(config_path) {
             Ok(file) => {
                 let reader = BufReader::new(file);
-                serde_json::from_reader(reader)?
+                let config = serde_json::from_reader(reader)?;
+                Ok(Some(config))
             }
-            Err(err) if err.kind() == std::io::ErrorKind::NotFound => Config {
-                analytics_id: Uuid::new_v4().to_string(),
-                analytics_enabled: true,
-                opt_in_metadata: Default::default(),
-                session_id: Uuid::new_v4(),
-                is_first_run: true,
-                config_file_path: config_path,
-                data_dir_path: data_path,
-            },
-            Err(err) => return Err(ConfigError::Io(err)),
-        };
-
-        Ok(config)
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(None),
+            Err(err) => Err(ConfigError::Io(err)),
+        }
     }
 
     pub fn save(&self) -> Result<(), ConfigError> {

crates/re_analytics/src/native/pipeline.rs

@@ -14,11 +14,6 @@ use super::sink::PostHogSink;
 use super::AbortSignal;
 use crate::{Config, Event};
 
-// TODO(cmc): abstract away the concept of a `Pipeline` behind an actual trait when comes the time
-// to support more than just PostHog.
-
-// ---
-
 #[derive(thiserror::Error, Debug)]
 pub enum PipelineError {
     #[error(transparent)]

crates/re_analytics/src/native/sink.rs

@@ -1,17 +1,7 @@
-use std::collections::HashMap;
 use std::sync::Arc;
 
-use time::OffsetDateTime;
-
 use super::AbortSignal;
-use crate::{Event, Property};
-
-// TODO(cmc): abstract away the concept of a `Sink` behind an actual trait when comes the time to
-// support more than just PostHog.
-
-const PUBLIC_POSTHOG_PROJECT_KEY: &str = "phc_sgKidIE4WYYFSJHd8LEYY1UZqASpnfQKeMqlJfSXwqg";
-
-// ---
+use crate::{Event, PostHogBatch, PostHogEvent};
 
 #[derive(Debug, Clone)]
 struct Url(String);
@@ -78,86 +68,3 @@ impl PostHogSink {
         ehttp::fetch(ehttp::Request::post(Self::URL, json.into_bytes()), on_done);
     }
 }
-
-// ---
-
-// TODO(cmc): support PostHog's view event
-
-#[derive(Debug, serde::Serialize)]
-#[serde(untagged)]
-enum PostHogEvent<'a> {
-    Capture(PostHogCaptureEvent<'a>),
-    Identify(PostHogIdentifyEvent<'a>),
-}
-
-impl<'a> PostHogEvent<'a> {
-    fn from_event(analytics_id: &'a str, session_id: &'a str, event: &'a Event) -> Self {
-        let properties = event.props.iter().map(|(name, value)| {
-            (
-                name.as_ref(),
-                match value {
-                    &Property::Integer(v) => v.into(),
-                    &Property::Float(v) => v.into(),
-                    Property::String(v) => v.as_str().into(),
-                    &Property::Bool(v) => v.into(),
-                },
-            )
-        });
-
-        match event.kind {
-            crate::EventKind::Append => Self::Capture(PostHogCaptureEvent {
-                timestamp: event.time_utc,
-                event: event.name.as_ref(),
-                distinct_id: analytics_id,
-                properties: properties
-                    .chain([("session_id", session_id.into())])
-                    .collect(),
-            }),
-            crate::EventKind::Update => Self::Identify(PostHogIdentifyEvent {
-                timestamp: event.time_utc,
-                event: "$identify",
-                distinct_id: analytics_id,
-                properties: [("session_id", session_id.into())].into(),
-                set: properties.collect(),
-            }),
-        }
-    }
-}
-
-// See https://posthog.com/docs/api/post-only-endpoints#capture.
-#[derive(Debug, serde::Serialize)]
-struct PostHogCaptureEvent<'a> {
-    #[serde(with = "::time::serde::rfc3339")]
-    timestamp: OffsetDateTime,
-    event: &'a str,
-    distinct_id: &'a str,
-    properties: HashMap<&'a str, serde_json::Value>,
-}
-
-// See https://posthog.com/docs/api/post-only-endpoints#identify.
-#[derive(Debug, serde::Serialize)]
-struct PostHogIdentifyEvent<'a> {
-    #[serde(with = "::time::serde::rfc3339")]
-    timestamp: OffsetDateTime,
-    event: &'a str,
-    distinct_id: &'a str,
-    properties: HashMap<&'a str, serde_json::Value>,
-    #[serde(rename = "$set")]
-    set: HashMap<&'a str, serde_json::Value>,
-}
-
-// See https://posthog.com/docs/api/post-only-endpoints#batch-events.
-#[derive(Debug, serde::Serialize)]
-struct PostHogBatch<'a> {
-    api_key: &'static str,
-    batch: &'a [PostHogEvent<'a>],
-}
-
-impl<'a> PostHogBatch<'a> {
-    fn from_events(events: &'a [PostHogEvent<'a>]) -> Self {
-        Self {
-            api_key: PUBLIC_POSTHOG_PROJECT_KEY,
-            batch: events,
-        }
-    }
-}