Struct NormalizationConfig 

pub struct NormalizationConfig {
    pub enabled: bool,
    pub interval: Duration,
    pub fill_strategy: FillStrategy,
    pub alignment: AlignmentStrategy,
    pub buffer_size: usize,
    pub interpolation_max_gap: Duration,
    pub drop_outliers: bool,
    pub outlier_threshold: f64,
    pub emit_metrics: bool,
}

Time-series normalization configuration

Provides configuration for normalizing time-series data by aligning events to fixed intervals, filling gaps, and handling out-of-order events.

Normalization is applied before windowing to ensure consistent event time alignment and reduce skew in aggregations.

Example

use processor::config::{NormalizationConfig, FillStrategy, AlignmentStrategy};
use std::time::Duration;

let config = NormalizationConfig::new()
    .enabled()
    .with_interval(Duration::from_secs(5))
    .with_fill_strategy(FillStrategy::LinearInterpolation)
    .with_alignment(AlignmentStrategy::Start)
    .with_buffer_size(1000);

Fields

enabled: bool

Enable time-series normalization

interval: Duration

Fixed interval for time alignment (e.g., 1s, 5s, 1min)

fill_strategy: FillStrategy

Strategy for filling missing data points

alignment: AlignmentStrategy

Alignment strategy for timestamps (start, end, or center of interval)

buffer_size: usize

Buffer size for handling out-of-order events

interpolation_max_gap: Duration

Maximum gap to interpolate (larger gaps use fill strategy)

drop_outliers: bool

Enable outlier detection and removal

outlier_threshold: f64

Outlier threshold in standard deviations (z-score)

emit_metrics: bool

Enable metrics emission for normalization operations

Implementations

impl NormalizationConfig

pub fn new() -> Self

Create a new normalization configuration with defaults

pub fn enabled(self) -> Self

Enable normalization

pub fn with_interval(self, interval: Duration) -> Self

Set the normalization interval

Example

use processor::config::NormalizationConfig;
use std::time::Duration;

let config = NormalizationConfig::new()
    .with_interval(Duration::from_secs(5)); // Normalize to 5-second intervals

pub fn with_fill_strategy(self, strategy: FillStrategy) -> Self

Set the fill strategy

pub fn with_alignment(self, alignment: AlignmentStrategy) -> Self

Set the alignment strategy

pub fn with_buffer_size(self, size: usize) -> Self

Set the buffer size for out-of-order events

pub fn with_interpolation_max_gap(self, gap: Duration) -> Self

Set the maximum gap for interpolation

pub fn with_outlier_detection(self, threshold: f64) -> Self

Enable outlier detection and removal

pub fn with_metrics(self, enabled: bool) -> Self

Enable or disable metrics emission

pub fn validate(&self) -> Result<()>

Validate normalization configuration

pub fn interval_ms(&self) -> u64

Get interval in milliseconds

pub fn interpolation_max_gap_ms(&self) -> u64

Get interpolation max gap in milliseconds

Trait Implementations

impl Clone for NormalizationConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NormalizationConfig

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

Formats the value using the given formatter.

impl Default for NormalizationConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NormalizationConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for NormalizationConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.