Documentation Index Fetch the complete documentation index at: https://mintlify.com/slunghq/slung/llms.txt
Use this file to discover all available pages before exploring further.
The Rust workflow SDK allows you to build WebAssembly-compiled workflows that react to live streams, query historical data, and write events back to Slung or external systems.
Installation Add the SDK to your Cargo.toml:
[ dependencies ] slung = "0.1"
Quick Start Create a reactive workflow that monitors a live stream:
use slung :: prelude ::* ; #[main] fn main () -> Result <()> { // Subscribe to live stream updates let handle = query_live ( "AVG:temp:[sensor=1]" ) ? ; poll_handle ( handle , on_event , 100.0 ) ? ; Ok (()) } fn on_event ( event : Event , alert_threshold : f64 ) -> Result <()> { if event . value > alert_threshold { println! ( "event timestamp={} value={}" , event . timestamp, event . value); for producer in event . producers { writeback_ws ( producer , "ALERT: threshold exceeded" ) ? ; } } Ok (()) }
Key Concepts Host Functions Workflows execute in a WebAssembly sandbox and communicate with Slung through host functions. These functions enable:
Querying live and historical data
Writing events
Sending writeback messages to WebSocket clients
Making HTTP requests
Event Model Events received from live queries contain:
pub struct Event { pub timestamp : i64 , // Unix microseconds pub value : f64 , // Numeric value pub tags : Vec < String >, // Event tags pub producers : Vec < u64 >, // Producer connection IDs }
Query Syntax Live and historical queries use the format:
AGGREGATE:series:[tag1,tag2,...]
Supported aggregates:
AVG - Running averageSUM - Cumulative sumMIN - Minimum valueMAX - Maximum value
Querying Data Live Queries Register a live query to receive streaming updates:
let handle = query_live ( "AVG:cpu:[host=server1]" ) ? ; poll_handle ( handle , | event , _ | { println! ( "CPU average: {}" , event . value); Ok (()) }, ()) ? ;
Historical Queries Query aggregated historical data:
let avg_temp = query_history ( "AVG:temp:[sensor=1]" ) ? ; let max_cpu = query_history ( "MAX:cpu:[host=server1]" ) ? ; println! ( "Average temperature: {}" , avg_temp ); println! ( "Max CPU usage: {}" , max_cpu );
Polling Aggregate State Poll once for the current aggregate state:
use slung :: PollState ; let handle = query_live ( "SUM:requests:[]" ) ? ; loop { if let Some ( state ) = poll_handle_state ( handle ) ? { match state { PollState :: Sum ( total ) => println! ( "Total requests: {}" , total ), PollState :: Avg ( avg ) => println! ( "Average: {}" , avg . sum / avg . count as f64 ), PollState :: Min ( min ) => println! ( "Minimum: {}" , min ), PollState :: Max ( max ) => println! ( "Maximum: {}" , max ), } } std :: thread :: sleep ( std :: time :: Duration :: from_millis ( 100 )); } free_handle ( handle ) ? ;
Writing Data Writing Events Write new events to Slung from your workflow:
let timestamp = unix_micros (); let value = 42.0 ; let tags = vec! [ "series=derived" . to_string (), "source=workflow" . to_string ()]; write_event ( timestamp , value , tags ) ? ;
The special tag series=<name> specifies the series name. All other tags are treated as regular tags.
Writeback to WebSocket Clients Send messages back to WebSocket producers:
fn on_event ( event : Event , _ : ()) -> Result <()> { for producer in event . producers { writeback_ws ( producer , "Processing complete" ) ? ; } Ok (()) }
HTTP Writeback Make HTTP requests to external services:
use slung :: WritebackMethod ; let response = writeback_http ( "https://api.example.com/webhook" , r#"{"alert": "threshold exceeded"}"# , WritebackMethod :: POST ) ? ; if let Some ( body ) = response { println! ( "Response: {:?}" , String :: from_utf8_lossy ( & body )); }
Prelude The slung::prelude module exports commonly used items:
This includes:
Event structAll query and write functions
The #[main] macro
Result type from std::io
Next Steps
Workflow API Reference Complete API reference for workflow functions
Host Functions Detailed host function reference