Refactor: re_sdk no longer depends on re_viewer

.github/workflows/typos.yml

@@ -1,5 +1,6 @@
 # https://github.com/crate-ci/typos
 # Add exceptions to _typos.toml
+# install and run locally: cargo install typos-cli && typos
 
 name: Spell Check
 on: [pull_request]

crates/re_log_types/src/lib.rs

@@ -261,6 +261,7 @@ pub enum RecordingSource {
 
     /// The official Rerun Rust Logging SDK
     RustSdk {
+        /// `CARGO_PKG_RUST_VERSION` = the MSRV specified by out crate. TODO(#1509): remove or improve
         rust_version: String,
     },
 

crates/re_sdk/Cargo.toml

@@ -17,64 +17,51 @@ all-features = true
 
 
 [features]
-default = ["demo", "glam", "image", "native_viewer"]
-
-## Enable telemetry using our analytics SDK.
-analytics = ["re_web_viewer_server?/analytics", "re_viewer?/analytics"]
+default = ["demo", "glam", "image"]
 
 ## Enable the `demo` module (helpers for Rerun examples).
 demo = []
 
 ## Add support for some math operations using [`glam`](https://crates.io/crates/glam/).
 glam = ["re_log_types/glam"]
 
+## Add the `global_session` method.
+global = ["dep:once_cell", "dep:parking_lot"]
+
 ## Integration with the [`image`](https://crates.io/crates/image/) crate.
 image = ["re_log_types/image"]
 
-## Support for the native viewer.
-native_viewer = ["image", "dep:re_viewer"]
-
-## Support serving a web viewer over HTTP.
-##
-## Enabling this adds quite a bit to the compile time and binary size,
-## since it requires compiling and bundling the viewer as wasm.
-##
-## You also need to install some additional tools, which you can do by running
-## [`scripts/setup_web.sh`](https://github.com/rerun-io/rerun/blob/main/scripts/setup_web.sh).
-web_viewer = ["dep:re_ws_comms", "dep:re_web_viewer_server", "dep:webbrowser"]
+# Add a tokio runtime to the `Session` type.
+tokio_runtime = ["dep:tokio"]
 
 
 [dependencies]
 re_build_info.workspace = true
 re_error.workspace = true
-re_log.workspace = true
 re_log_types.workspace = true
+re_log.workspace = true
 re_memory.workspace = true
 re_sdk_comms = { workspace = true, features = ["client"] }
 re_smart_channel.workspace = true
-re_string_interner.workspace = true
 
 anyhow.workspace = true
 arrow2.workspace = true
 crossbeam = "0.8"
 document-features = "0.2"
 lazy_static.workspace = true
 nohash-hasher = "0.2"
-once_cell = "1.12"
-parking_lot = "0.12"
 thiserror.workspace = true
 
 # Optional dependencies:
-re_ws_comms = { workspace = true, optional = true, features = ["server"] }
-re_viewer = { workspace = true, default-features = false, optional = true }
-re_web_viewer_server = { workspace = true, optional = true }
-
-webbrowser = { version = "0.8", optional = true }
+once_cell = { version = "1.12", optional = true }
+parking_lot = { version = "0.12", optional = true }
 
 # Native dependencies:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-clap = { workspace = true, features = ["derive"] }
-tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+tokio = { workspace = true, optional = true, features = [
+  "macros",
+  "rt-multi-thread",
+] }
 
 
 [dev-dependencies]

crates/re_sdk/src/demo_util.rs

@@ -70,7 +70,7 @@ pub fn grid(from: glam::Vec3, to: glam::Vec3, n: usize) -> impl Iterator<Item =
 /// * `angular_step`: The factor applied between each step along the trigonometric circle.
 /// * `angular_offset`: Offsets the starting position on the trigonometric circle.
 /// * `z_step`: The factor applied between between each step along the Z axis.
-#[cfg(all(feature = "glam", feature = "native_viewer"))]
+#[cfg(feature = "glam")]
 pub fn color_spiral(
     num_points: usize,
     radius: f32,
@@ -91,10 +91,34 @@ pub fn color_spiral(
         .collect();
 
     let colors = (0..num_points)
-        .map(move |i| {
-            re_viewer::external::re_renderer::colormap_turbo_srgb(i as f32 / num_points as f32)
-        })
+        .map(move |i| colormap_turbo_srgb(i as f32 / num_points as f32))
         .collect();
 
     (points, colors)
 }
+
+/// Returns sRGB polynomial approximation from Turbo color map, assuming `t` is normalized.
+fn colormap_turbo_srgb(t: f32) -> [u8; 4] {
+    #![allow(clippy::excessive_precision)]
+    use glam::{Vec2, Vec4, Vec4Swizzles};
+
+    const R4: Vec4 = Vec4::new(0.13572138, 4.61539260, -42.66032258, 132.13108234);
+    const G4: Vec4 = Vec4::new(0.09140261, 2.19418839, 4.84296658, -14.18503333);
+    const B4: Vec4 = Vec4::new(0.10667330, 12.64194608, -60.58204836, 110.36276771);
+
+    const R2: Vec2 = Vec2::new(-152.94239396, 59.28637943);
+    const G2: Vec2 = Vec2::new(4.27729857, 2.82956604);
+    const B2: Vec2 = Vec2::new(-89.90310912, 27.34824973);
+
+    debug_assert!((0.0..=1.0).contains(&t));
+
+    let v4 = glam::vec4(1.0, t, t * t, t * t * t);
+    let v2 = v4.zw() * v4.z;
+
+    [
+        ((v4.dot(R4) + v2.dot(R2)) * 255.0) as u8,
+        ((v4.dot(G4) + v2.dot(G2)) * 255.0) as u8,
+        ((v4.dot(B4) + v2.dot(B2)) * 255.0) as u8,
+        255,
+    ]
+}

crates/re_sdk/src/file_writer.rs

@@ -2,6 +2,7 @@ use anyhow::Context as _;
 
 use re_log_types::LogMsg;
 
+/// Stream log messages to a file.
 pub struct FileWriter {
     // None = quit
     tx: std::sync::mpsc::Sender<Option<LogMsg>>,
@@ -50,8 +51,10 @@ impl FileWriter {
             join_handle: Some(join_handle),
         })
     }
+}
 
-    pub fn write(&self, msg: LogMsg) {
+impl crate::LogSink for FileWriter {
+    fn send(&mut self, msg: LogMsg) {
         self.tx.send(Some(msg)).ok();
     }
 }

crates/re_sdk/src/lib.rs

@@ -9,18 +9,20 @@
 // Send data to a rerun session
 #[cfg(not(target_arch = "wasm32"))]
 mod file_writer;
+
+#[cfg(feature = "global")]
 mod global;
+
+mod log_sink;
 mod msg_sender;
-#[cfg(feature = "web_viewer")]
-mod remote_viewer_server;
 mod session;
 
+#[cfg(feature = "global")]
 pub use self::global::{global_session, global_session_with_default_enabled};
+
 pub use self::msg_sender::{MsgSender, MsgSenderError};
 pub use self::session::Session;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub mod clap;
+pub use log_sink::{BufferedSink, LogSink, TcpSink};
 
 #[cfg(feature = "demo")]
 pub mod demo_util;
@@ -67,9 +69,6 @@ pub mod external {
     pub use re_memory;
     pub use re_sdk_comms;
 
-    #[cfg(feature = "native_viewer")]
-    pub use re_viewer;
-
     #[cfg(feature = "glam")]
     pub use re_log_types::external::glam;
 
@@ -106,22 +105,24 @@ fn get_rerun_env() -> Option<bool> {
 ///
 /// Also adds some helpful logging.
 fn decide_logging_enabled(default_enabled: bool) -> bool {
+    // We use `info_once` so that we can call this function
+    // multiple times without spamming the log.
     match get_rerun_env() {
         Some(true) => {
-            re_log::info!(
+            re_log::info_once!(
                 "Rerun Logging is enabled by the '{RERUN_ENV_VAR}' environment variable."
             );
             true
         }
         Some(false) => {
-            re_log::info!(
+            re_log::info_once!(
                 "Rerun Logging is disabled by the '{RERUN_ENV_VAR}' environment variable."
             );
             false
         }
         None => {
             if !default_enabled {
-                re_log::info!(
+                re_log::info_once!(
                     "Rerun Logging has been disabled. Turn it on with the '{RERUN_ENV_VAR}' environment variable."
                 );
             }

crates/re_sdk/src/log_sink.rs

@@ -0,0 +1,83 @@
+use re_log_types::LogMsg;
+
+/// Where the SDK sends its log messages.
+pub trait LogSink: Send {
+    /// Send this log message.
+    fn send(&mut self, msg: LogMsg);
+
+    /// Send all these log messages.
+    fn send_all(&mut self, messages: Vec<LogMsg>) {
+        for msg in messages {
+            self.send(msg);
+        }
+    }
+
+    /// Drain all buffered [`LogMsg`]es and return them.
+    fn drain_backlog(&mut self) -> Vec<LogMsg> {
+        vec![]
+    }
+
+    /// Wait until all logged data have been sent to the remove server (if any).
+    fn flush(&self) {}
+
+    /// If the TCP session is disconnected, allow it to quit early and drop unsent messages.
+    fn drop_msgs_if_disconnected(&self) {}
+}
+
+// ----------------------------------------------------------------------------
+
+/// Store log messages in memory until you call [`LogSink::drain_backlog`].
+#[derive(Default)]
+pub struct BufferedSink(Vec<LogMsg>);
+
+impl BufferedSink {
+    /// An empty buffer.
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+impl LogSink for BufferedSink {
+    fn send(&mut self, msg: LogMsg) {
+        self.0.push(msg);
+    }
+
+    fn send_all(&mut self, mut messages: Vec<LogMsg>) {
+        self.0.append(&mut messages);
+    }
+
+    fn drain_backlog(&mut self) -> Vec<LogMsg> {
+        std::mem::take(&mut self.0)
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+/// Stream log messages to a Rerun TCP server.
+pub struct TcpSink {
+    client: re_sdk_comms::Client,
+}
+
+impl TcpSink {
+    /// Connect to the given address in a background thread.
+    /// Retries until successful.
+    pub fn new(addr: std::net::SocketAddr) -> Self {
+        Self {
+            client: re_sdk_comms::Client::new(addr),
+        }
+    }
+}
+
+impl LogSink for TcpSink {
+    fn send(&mut self, msg: LogMsg) {
+        self.client.send(msg);
+    }
+
+    fn flush(&self) {
+        self.client.flush();
+    }
+
+    fn drop_msgs_if_disconnected(&self) {
+        self.client.drop_if_disconnected();
+    }
+}