Web analytics

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

@@ -25,6 +25,9 @@ use web::{Pipeline, PipelineError};
 #[cfg(not(target_arch = "wasm32"))]
 pub mod cli;
 
+mod event;
+use event::{PostHogBatch, PostHogEvent};
+
 // ----------------------------------------------------------------------------
 
 use std::borrow::Cow;
@@ -189,6 +192,7 @@ impl From<&str> for Property {
 
 // ---
 
+#[cfg(not(target_arch = "wasm32"))]
 const DISCLAIMER: &str = "
     Welcome to Rerun!
 
@@ -235,36 +239,54 @@ pub struct Analytics {
     event_id: AtomicU64,
 }
 
-impl Analytics {
-    pub fn new(tick: Duration) -> Result<Self, AnalyticsError> {
-        let config = Config::load()?;
+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
+        }
+    };
 
-        #[cfg(target_arch = "wasm32")]
-        let config = if let Some(config) = config {
-            config
-        } else {
-            // the config doesnt exist in local storage yet, save it
-            let config = Config::default();
-            config.save()?;
-            config
-        };
+    if let Some(config) = config {
+        re_log::trace!(?config, "loaded analytics config");
 
-        #[cfg(not(target_arch = "wasm32"))]
-        let config = match config {
-            Some(config) => config,
-            None => Config::new()?,
-        };
+        Ok(config)
+    } else {
+        re_log::trace!(?config, "initialized analytics config");
 
-        re_log::trace!(?config, ?tick, "loaded 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,
@@ -309,84 +331,3 @@ impl Analytics {
         }
     }
 }
-
-const PUBLIC_POSTHOG_PROJECT_KEY: &str = "phc_sgKidIE4WYYFSJHd8LEYY1UZqASpnfQKeMqlJfSXwqg";
-
-#[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,
-        }
-    }
-}

crates/re_analytics/src/web/config.rs

@@ -25,14 +25,14 @@ pub enum ConfigError {
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Config {
     // NOTE: not a UUID on purpose, it is sometimes useful to use handcrafted IDs.
-    #[serde(rename = "i")]
+    #[serde(rename = "analytics_id")]
     pub analytics_id: String,
 
     /// A unique ID for this session.
     #[serde(skip, default = "::uuid::Uuid::new_v4")]
     pub session_id: Uuid,
 
-    #[serde(rename = "m", default)]
+    #[serde(rename = "metadata", default)]
     pub opt_in_metadata: HashMap<String, Property>,
 }
 
@@ -57,7 +57,7 @@ impl Config {
         let storage = get_local_storage()?;
         let value = storage
             .get_item(Self::STORAGE_KEY)
-            .map_err(|_| ConfigError::Storage(format!("failed to get `{}`", Self::STORAGE_KEY)))?;
+            .map_err(|_| ConfigError::Storage(format!("failed to get {:?}", Self::STORAGE_KEY)))?;
         match value {
             Some(value) => Ok(Some(serde_json::from_str(&value)?)),
             None => Ok(None),
@@ -77,7 +77,7 @@ impl Config {
         let string = serde_json::to_string(self)?;
         storage
             .set_item(Self::STORAGE_KEY, &string)
-            .map_err(|_| ConfigError::Storage(format!("failed to set `{}`", Self::STORAGE_KEY)))
+            .map_err(|_| ConfigError::Storage(format!("failed to set {:?}", Self::STORAGE_KEY)))
     }
 
     pub fn is_first_run(&self) -> bool {

crates/re_viewer/src/app.rs

@@ -45,7 +45,7 @@ pub struct StartupOptions {
 
     /// Set to identify the web page the viewer is running on.
     #[cfg(target_arch = "wasm32")]
-    pub analytics_url: Option<String>,
+    pub location: Option<eframe::Location>,
 
     /// Take a screenshot of the app and quit.
     /// We use this to generate screenshots of our exmples.
@@ -67,7 +67,7 @@ impl Default for StartupOptions {
             is_in_notebook: false,
 
             #[cfg(target_arch = "wasm32")]
-            analytics_url: None,
+            location: None,
 
             #[cfg(not(target_arch = "wasm32"))]
             screenshot_to_path_then_quit: None,
@@ -179,11 +179,7 @@ impl App {
             AppState::default()
         };
 
-        let mut analytics = ViewerAnalytics::new(
-            startup_options.is_in_notebook,
-            #[cfg(target_arch = "wasm32")]
-            startup_options.analytics_url.clone(),
-        );
+        let mut analytics = ViewerAnalytics::new(&startup_options);
         analytics.on_viewer_started(&build_info, app_env);
 
         let mut space_view_class_registry = SpaceViewClassRegistry::default();

crates/re_viewer/src/viewer_analytics.rs

@@ -13,6 +13,8 @@
 use re_analytics::{Analytics, Event, Property};
 use re_log_types::StoreSource;
 
+use crate::StartupOptions;
+
 pub struct ViewerAnalytics {
     // NOTE: Optional because it is possible to have the `analytics` feature flag enabled
     // while at the same time opting-out of analytics at run-time.
@@ -23,11 +25,8 @@ pub struct ViewerAnalytics {
 #[cfg(feature = "analytics")]
 impl ViewerAnalytics {
     #[allow(unused_mut, clippy::let_and_return)]
-    pub fn new(
-        disabled: bool,
-        #[cfg(target_arch = "wasm32")] analytics_url: Option<String>,
-    ) -> Self {
-        if disabled {
+    pub fn new(startup_options: &StartupOptions) -> Self {
+        if startup_options.is_in_notebook {
             return Self { analytics: None };
         }
 
@@ -42,8 +41,10 @@ impl ViewerAnalytics {
         let mut analytics = Self { analytics };
 
         #[cfg(target_arch = "wasm32")]
-        if let Some(url) = analytics_url {
-            analytics.register("url", url);
+        if let Some(location) = startup_options.location.as_ref() {
+            if location.hostname.contains("rerun.io") {
+                analytics.register("url", location.url.clone());
+            }
         }
 
         analytics
@@ -229,10 +230,7 @@ impl ViewerAnalytics {
 
 #[cfg(not(feature = "analytics"))]
 impl ViewerAnalytics {
-    pub fn new(
-        _disabled: bool,
-        #[cfg(target_arch = "wasm32")] _analytics_url: Option<String>,
-    ) -> Self {
+    pub fn new(_startup_options: &StartupOptions) -> Self {
         Self {}
     }
 
@@ -243,5 +241,5 @@ impl ViewerAnalytics {
     ) {
     }
 
-    pub fn on_open_recording(&mut self, store_db: &re_data_store::StoreDb) {}
+    pub fn on_open_recording(&mut self, _store_db: &re_data_store::StoreDb) {}
 }