Struct RecordingStreamBuilder

pub struct RecordingStreamBuilder { /* private fields */ }

Construct a RecordingStream.

let rec = RecordingStreamBuilder::new("rerun_example_app").save("my_recording.rrd")?;

Automatically sends a Chunk with the default RecordingProperties to the sink, unless an explicit recording_id is set via RecordingStreamBuilder::recording_id.

Implementations

impl RecordingStreamBuilder

pub fn new(application_id: impl Into<ApplicationId>) -> RecordingStreamBuilder

Create a new RecordingStreamBuilder with the given ApplicationId.

The ApplicationId is usually the name of your app.

let rec = RecordingStreamBuilder::new("rerun_example_app").save("my_recording.rrd")?;

pub fn default_enabled(self, default_enabled: bool) -> RecordingStreamBuilder

Set whether or not Rerun is enabled by default.

If the RERUN environment variable is set, it will override this.

Set also: Self::enabled.

pub fn enabled(self, enabled: bool) -> RecordingStreamBuilder

Set whether or not Rerun is enabled.

Setting this will ignore the RERUN environment variable.

Set also: Self::default_enabled.

pub fn recording_id( self, recording_id: impl Into<String>, ) -> RecordingStreamBuilder

Set the RecordingId for this context.

If you’re logging from multiple processes and want all the messages to end up in the same recording, you must make sure that they all set the same RecordingId using this function.

Note that many stores can share the same ApplicationId, but they all have unique RecordingIds.

The default is to use a random RecordingId.

When explicitly setting a RecordingId, the initial chunk that contains the recording properties will not be sent.

pub fn recording_name(self, name: impl Into<String>) -> RecordingStreamBuilder

Sets an optional name for the recording.

pub fn recording_started( self, started: impl Into<Timestamp>, ) -> RecordingStreamBuilder

Sets an optional name for the recording.

pub fn disable_properties(self) -> RecordingStreamBuilder

👎Deprecated since 0.22.0: use send_properties instead

Disables sending the RecordingProperties chunk.

pub fn send_properties(self, should_send: bool) -> RecordingStreamBuilder

Whether the RecordingProperties chunk should be sent.

pub fn store_id(self, store_id: StoreId) -> RecordingStreamBuilder

Set the StoreId for this context.

If you’re logging from multiple processes and want all the messages to end up as the same store, you must make sure they all set the same StoreId using this function.

Note that many stores can share the same ApplicationId, but they all have unique StoreIds.

The default is to use a random StoreId.

pub fn batcher_config( self, config: ChunkBatcherConfig, ) -> RecordingStreamBuilder

Specifies the configuration of the internal data batching mechanism.

See ChunkBatcher & ChunkBatcherConfig for more information.

pub fn buffered(self) -> Result<RecordingStream, RecordingStreamError>

Creates a new RecordingStream that starts in a buffering state (RAM).

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app").buffered()?;

pub fn memory( self, ) -> Result<(RecordingStream, MemorySinkStorage), RecordingStreamError>

Creates a new RecordingStream that is pre-configured to stream the data through to a crate::log_sink::MemorySink.

Example

let (rec, storage) = re_sdk::RecordingStreamBuilder::new("rerun_example_app").memory()?;

log_data(&rec);

let data = storage.take();

pub fn connect_grpc(self) -> Result<RecordingStream, RecordingStreamError>

Creates a new RecordingStream that is pre-configured to stream the data through to a remote Rerun instance.

See also Self::connect_grpc_opts if you wish to configure the connection.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app").connect_grpc()?;

pub fn connect_grpc_opts( self, url: impl Into<String>, flush_timeout: Option<Duration>, ) -> Result<RecordingStream, RecordingStreamError>

Creates a new RecordingStream that is pre-configured to stream the data through to a remote Rerun instance.

flush_timeout is the minimum time the GrpcSink will wait during a flush before potentially dropping data. Note: Passing None here can cause a call to flush to block indefinitely if a connection cannot be established.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app")
    .connect_grpc_opts("rerun+http://127.0.0.1:9876/proxy", re_sdk::default_flush_timeout())?;

pub fn serve_grpc(self) -> Result<RecordingStream, RecordingStreamError>

Creates a new RecordingStream that is pre-configured to stream the data through to a locally hosted gRPC server.

The server is hosted on the default IP and port, and may be connected to by any SDK or Viewer at rerun+http://127.0.0.1:9876/proxy or by just running rerun --connect.

To configure the gRPC server’s IP and port, use Self::serve_grpc_opts instead.

The gRPC server will buffer in memory so that late connecting viewers will still get all the data. You can limit the amount of data buffered by the gRPC server using Self::serve_grpc_opts, with the server_memory_limit argument. Once the memory limit is reached, the earliest logged data will be dropped. Static data is never dropped.

pub fn serve_grpc_opts( self, bind_ip: impl AsRef<str>, port: u16, server_memory_limit: MemoryLimit, ) -> Result<RecordingStream, RecordingStreamError>

Creates a new RecordingStream that is pre-configured to stream the data through to a locally hosted gRPC server.

The server is hosted on the given bind_ip and port, may be connected to by any SDK or Viewer at rerun+http://{bind_ip}:{port}/proxy.

0.0.0.0 is a good default for bind_ip.

The gRPC server will buffer all log data in memory so that late connecting viewers will get all the data. You can limit the amount of data buffered by the gRPC server with the server_memory_limit argument. Once reached, the earliest logged data will be dropped. Static data is never dropped.

pub fn save( self, path: impl Into<PathBuf>, ) -> Result<RecordingStream, RecordingStreamError>

Creates a new RecordingStream that is pre-configured to stream the data through to an RRD file on disk.

The Rerun Viewer is able to read continuously from the resulting rrd file while it is being written. However, depending on your OS and configuration, changes may not be immediately visible due to file caching. This is a common issue on Windows and (to a lesser extent) on MacOS.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app").save("my_recording.rrd")?;

pub fn stdout(self) -> Result<RecordingStream, RecordingStreamError>

Creates a new RecordingStream that is pre-configured to stream the data through to stdout.

If there isn’t any listener at the other end of the pipe, the RecordingStream will default back to buffered mode, in order not to break the user’s terminal.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app").stdout()?;

pub fn spawn(self) -> Result<RecordingStream, RecordingStreamError>

Spawns a new Rerun Viewer process from an executable available in PATH, then creates a new RecordingStream that is pre-configured to stream the data through to that viewer over gRPC.

If a Rerun Viewer is already listening on this port, the stream will be redirected to that viewer instead of starting a new one.

See also Self::spawn_opts if you wish to configure the behavior of thew Rerun process as well as the underlying connection.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app").spawn()?;

pub fn spawn_opts( self, opts: &SpawnOptions, flush_timeout: Option<Duration>, ) -> Result<RecordingStream, RecordingStreamError>

Spawns a new Rerun Viewer process from an executable available in PATH, then creates a new RecordingStream that is pre-configured to stream the data through to that viewer over gRPC.

If a Rerun Viewer is already listening on this port, the stream will be redirected to that viewer instead of starting a new one.

The behavior of the spawned Viewer can be configured via opts. If you’re fine with the default behavior, refer to the simpler Self::spawn.

flush_timeout is the minimum time the GrpcSink will wait during a flush before potentially dropping data. Note: Passing None here can cause a call to flush to block indefinitely if a connection cannot be established.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app")
    .spawn_opts(&re_sdk::SpawnOptions::default(), re_sdk::default_flush_timeout())?;

pub fn serve( self, bind_ip: &str, web_port: WebViewerServerPort, grpc_port: u16, server_memory_limit: MemoryLimit, open_browser: bool, ) -> Result<RecordingStream, RecordingStreamError>

👎Deprecated since 0.20.0: use rec.serve_grpc() with rerun::serve_web_viewer() instead

Creates a new RecordingStream that is pre-configured to stream the data through to a web-based Rerun viewer via gRPC.

If the open_browser argument is true, your default browser will be opened with a connected web-viewer.

If not, you can connect to this server using the rerun binary (cargo install rerun-cli --locked).

Details

This method will spawn two servers: one HTTPS server serving the Rerun Web Viewer .html and .wasm files, and then one gRPC server that streams the log data to the web viewer (or to a native viewer, or to multiple viewers).

The gRPC server will buffer all log data in memory so that late connecting viewers will get all the data. You can limit the amount of data buffered by the gRPC server with the server_memory_limit argument. Once reached, the earliest logged data will be dropped. Static data is never dropped.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app")
    .serve("0.0.0.0",
           Default::default(),
           Default::default(),
           re_sdk::MemoryLimit::from_fraction_of_total(0.25),
           true)?;

pub fn serve_web( self, bind_ip: &str, web_port: WebViewerServerPort, grpc_port: u16, server_memory_limit: MemoryLimit, open_browser: bool, ) -> Result<RecordingStream, RecordingStreamError>

Creates a new RecordingStream that is pre-configured to stream the data through to a web-based Rerun viewer via gRPC.

If the open_browser argument is true, your default browser will be opened with a connected web-viewer.

If not, you can connect to this server using the rerun binary (cargo install rerun-cli --locked).

Details

This method will spawn two servers: one HTTPS server serving the Rerun Web Viewer .html and .wasm files, and then one gRPC server that streams the log data to the web viewer (or to a native viewer, or to multiple viewers).

The gRPC server will buffer all log data in memory so that late connecting viewers will get all the data. You can limit the amount of data buffered by the gRPC server with the server_memory_limit argument. Once reached, the earliest logged data will be dropped. Static data is never dropped.

Calling serve_web is equivalent to calling Self::serve_grpc followed by crate::serve_web_viewer.

Example

let rec = re_sdk::RecordingStreamBuilder::new("rerun_example_app")
    .serve_web("0.0.0.0",
               Default::default(),
               Default::default(),
               re_sdk::MemoryLimit::from_fraction_of_total(0.25),
               true)?;

pub fn into_args( self, ) -> (bool, StoreInfo, Option<RecordingProperties>, ChunkBatcherConfig)

Returns whether or not logging is enabled, a StoreInfo and the associated batcher configuration.

This can be used to then construct a RecordingStream manually using RecordingStream::new.

Trait Implementations

impl Debug for RecordingStreamBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.