Struct segment::AutoBatcher

pub struct AutoBatcher { /* private fields */ }

A batcher can accept messages into an internal buffer, and report when messages must be flushed.

The recommended usage pattern looks something like this:

use segment::{AutoBatcher, Batcher, HttpClient};
use segment::message::{BatchMessage, Track, User};
use serde_json::json;

let client = HttpClient::default();
let batcher= Batcher::new(None);
let mut batcher = AutoBatcher::new(client, batcher, "your_write_key".to_string());

for i in 0..100 {
    let msg = Track {
        user: User::UserId { user_id: format!("user-{}", i) },
        event: "Example".to_owned(),
        properties: json!({ "foo": "bar" }),
        ..Default::default()
    };

    batcher.push(msg); // .await
}

Batcher will attempt to fit messages into maximally-sized batches, thus reducing the number of round trips required with Segment’s tracking API. However, if you produce messages infrequently, this may significantly delay the sending of messages to Segment.

If this delay is a concern, it is recommended that you periodically flush the batcher on your own by calling Self::flush.

Implementations

impl AutoBatcher

pub fn new(client: HttpClient, batcher: Batcher, key: String) -> Self

Construct a new, empty batcher.

use segment::{AutoBatcher, Batcher, HttpClient};

let client = HttpClient::default();
let batcher = Batcher::new(None);
let mut batcher = AutoBatcher::new(client, batcher, "your_write_key".to_string());

pub async fn push(&mut self, msg: impl Into<BatchMessage>) -> Result<()>

Push a message into the batcher. If the batcher is full, send it and create a new batcher with the message.

Returns an error if the message is too large to be sent to Segment’s API.

use serde_json::json;
use segment::{AutoBatcher, Batcher, HttpClient};
use segment::message::{BatchMessage, Track, User};

let client = HttpClient::default();
let batcher = Batcher::new(None);
let mut batcher = AutoBatcher::new(client, batcher, "your_write_key".to_string());

let msg = BatchMessage::Track(Track {
    user: User::UserId { user_id: String::from("user") },
    event: "Example".to_owned(),
    properties: json!({ "foo": "bar" }),
    ..Default::default()
});

batcher.push(msg); // .await

pub async fn flush(&mut self) -> Result<()>

Send all the message currently contained in the batcher, full or empty.

Returns an error if the message is too large to be sent to Segment’s API.

use serde_json::json;
use segment::{AutoBatcher, Batcher, HttpClient};
use segment::message::{BatchMessage, Track, User};

let client = HttpClient::default();
let batcher = Batcher::new(None);
let mut batcher = AutoBatcher::new(client, batcher, "your_write_key".to_string());

let msg = BatchMessage::Track(Track {
    user: User::UserId { user_id: String::from("user") },
    event: "Example".to_owned(),
    properties: json!({ "foo": "bar" }),
    ..Default::default()
});

batcher.push(msg); // .await
batcher.flush(); // .await

Trait Implementations

impl Clone for AutoBatcher

fn clone(&self) -> AutoBatcher

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AutoBatcher

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

Formats the value using the given formatter.