Module window 

Windowing module for stream processing

This module provides comprehensive windowing functionality for time-based aggregations and event processing. It supports three main types of windows:

Window Types

Tumbling Windows

Fixed-size, non-overlapping windows. Each event belongs to exactly one window.

Time:     0----5----10---15---20---25---30
Windows:  [----][----][----][----][----]

Use cases:

• Periodic aggregations (e.g., metrics every 5 minutes)
• Non-overlapping batch processing
• Fixed-interval reporting

Sliding Windows

Fixed-size, overlapping windows. Events can belong to multiple windows.

Time:     0----5----10---15---20---25---30
Windows:  [----------]
               [----------]
                    [----------]

Use cases:

• Moving averages
• Smoothed metrics
• Trend detection
• Rate calculations over time

Session Windows

Variable-size windows based on inactivity gaps. Events are grouped into sessions separated by periods of inactivity.

Time:     0-2--5----------12-14----20
Sessions: [----]           [---]   [-]
Gap:           ^^^^^^^^^^^^     ^^^^

Use cases:

• User session analysis
• Burst detection
• Activity clustering
• Pattern recognition in irregular events

Window Assignment

Windows are assigned using the WindowAssigner trait, which determines which window(s) an event belongs to based on its timestamp.

Window Triggers

Triggers determine when a window should be evaluated and emit results. Multiple trigger types are supported:

• OnWatermarkTrigger: Fires when watermark passes window end (event-time)
• ProcessingTimeTrigger: Fires based on processing time
• CountTrigger: Fires after N elements
• CompositeTrigger: Combines multiple triggers with AND/OR logic
• ImmediateTrigger: Fires on every element
• NeverTrigger: Never fires automatically

Example Usage

use processor::window::{
    assigner::{TumblingWindowAssigner, SlidingWindowAssigner, SessionWindowAssigner},
    trigger::{OnWatermarkTrigger, ProcessingTimeTrigger, CountTrigger},
};
use chrono::Duration;

// Tumbling window: 5-minute non-overlapping windows
let tumbling = TumblingWindowAssigner::new(Duration::minutes(5));

// Sliding window: 10-minute windows, sliding every 1 minute
let sliding = SlidingWindowAssigner::new(
    Duration::minutes(10),
    Duration::minutes(1),
);

// Session window: 30-second inactivity gap
let session = SessionWindowAssigner::new(Duration::seconds(30));

// Triggers
let watermark_trigger = OnWatermarkTrigger::new();
let processing_trigger = ProcessingTimeTrigger::with_delay(Duration::seconds(5));
let count_trigger = CountTrigger::new(100); // Fire after 100 elements

Window Merging

Session windows support merging when events arrive within the session gap. The window module handles this automatically:

Initial state:    Window A [0, 5)    Window B [10, 15)
Event at t=7:     Window A [0, 12)   (merged, extends to cover gap)
Event at t=12:    Window A [0, 17)   (merged with B)

Re-exports

pub use types::Window;

pub use types::WindowBounds;

pub use types::WindowType;

pub use assigner::WindowAssigner;

pub use assigner::TumblingWindowAssigner;

pub use assigner::SlidingWindowAssigner;

pub use assigner::SessionWindowAssigner;

pub use trigger::WindowTrigger;

pub use trigger::TriggerResult;

pub use trigger::TriggerContext;

pub use trigger::OnWatermarkTrigger;

pub use trigger::ProcessingTimeTrigger;

pub use trigger::CountTrigger;

pub use trigger::CompositeTrigger;

pub use trigger::CompositeMode;

pub use trigger::ImmediateTrigger;

pub use trigger::NeverTrigger;

pub use manager::WindowManager;

pub use manager::WindowMetadata;

pub use manager::WindowStats;

Modules

assigner

Window assigners

manager

Window lifecycle management

trigger

Window triggers

types

Window types and bounds

Structs

WindowMerger

Window merger for session windows