Struct Config

pub struct Config {
    pub endpoints: Vec<String>,
    pub client_type: ClientType,
    pub recording_enabled: bool,
    pub recording_path: Option<String>,
    pub recording_flush_interval: Option<Duration>,
    pub default_resolution: TimestampResolution,
    pub element_kinds: Vec<ElementKindRegistration>,
    pub metric_definitions: Vec<MetricDefinition>,
    pub initialization_interval: Option<Duration>,
    pub cluster_monitor_interval: Option<Duration>,
    pub max_reg_elem_retries: usize,
}

Configuration settings for the Muse client.

The Config struct contains all necessary parameters to initialize the Muse client.

Fields

endpoints: Vec<String>

List of endpoint URLs for the Muse client.

client_type: ClientType

The type of client to use (Poet or Mock).

recording_enabled: bool

Enables event recording if set to true.

recording_path: Option<String>

File path for recording events (required if recording_enabled is true).

recording_flush_interval: Option<Duration>

Interval for flushing the recorder when recording is enabled.

default_resolution: TimestampResolution

Default timestamp resolution for metrics.

element_kinds: Vec<ElementKindRegistration>

List of element kinds to register upon initialization.

metric_definitions: Vec<MetricDefinition>

List of metric definitions available for reporting.

initialization_interval: Option<Duration>

Interval for initialization tasks (optional).

cluster_monitor_interval: Option<Duration>

Interval for cluster monitoring tasks (optional).

max_reg_elem_retries: usize

Maximum number of retries for element registration.

Implementations

impl Config

pub fn new( endpoints: Vec<String>, client_type: ClientType, recording_enabled: bool, recording_path: Option<String>, recording_flush_interval: Option<Duration>, default_resolution: TimestampResolution, element_kinds: Vec<ElementKindRegistration>, metric_definitions: Vec<MetricDefinition>, initialization_interval: Option<Duration>, cluster_monitor_interval: Option<Duration>, max_reg_elem_retries: usize, ) -> Result<Config, MuseError>

Creates a new Config instance with the provided settings.

Arguments

• endpoints: A vector of endpoint URLs.
• client_type: The client type to use.
• recording_enabled: Enables event recording.
• recording_path: File path for recording events.
• recording_flush_interval: Interval to flush recording events.
• default_resolution: Default timestamp resolution.
• element_kinds: Element kinds to register.
• metric_definitions: Metric definitions for reporting.
• initialization_interval: Interval for the initialization task.
• cluster_monitor_interval: Interval for cluster monitoring.
• max_reg_elem_retries: Max retries for element registration.

Errors

Returns a MuseError::Configuration if validation fails.

Examples

use ih_muse_core::prelude::*;
use ih_muse_proto::prelude::*;

let config = Config::new(
    vec!["http://localhost:8080".to_string()],
    ClientType::Poet,
    false,
    None,
    None,
    TimestampResolution::Milliseconds,
    vec![ElementKindRegistration::new("kind_code", Some("parent_code"), "kind_name", "description")],
    vec![MetricDefinition::new("metric_code", "metric_name", "description")],
    Some(std::time::Duration::from_secs(60)),
    Some(std::time::Duration::from_secs(60)),
    3,
).expect("Failed to create config");

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

Validates the configuration settings.

Ensures all required fields are properly set.

Errors

Returns a MuseError::Configuration if any validation check fails.

pub fn diff(&self, other: &Config) -> Vec<String>

Compares two configurations and returns a vector of strings describing the differences.

Arguments

• other - The configuration to compare with.

Returns

A vector of strings where each entry describes a difference between the two configurations.

pub fn pretty_diff(&self, other: &Config) -> String

Helper function to pretty-print the differences as a single string.

Arguments

• other - The configuration to compare with.

Returns

A single string containing all differences separated by newlines.

pub fn is_relevantly_equal(&self, other: &Config) -> bool

Checks if two Config instances are equivalent based on relevant fields, ignoring recording_enabled and recording_path.

Arguments

• other: The Config instance to compare with.

Returns

true if the relevant fields are equal, false otherwise.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Config

fn deserialize<__D>( __deserializer: __D, ) -> Result<Config, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Config

fn eq(&self, other: &Config) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Config

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Config