sentinel-core 0.1.3

The flow sentinel of your microservices.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! Initialization func initialize the Sentinel's runtime environment, including:
//! 1. override global config, from manually config or yaml file or env variable
//! 2. initialize global logger
//! 3. initiate core component async task, including: metric log, system statistic...

#[cfg(feature = "metric_log")]
use crate::log::metric;
use crate::{config, config::ConfigEntity, system_metric, utils, Result};

/// `init_default` initializes Sentinel using the configuration from system
/// environment and the default value.
#[inline]
pub fn init_default() -> Result<()> {
    init_sentinel(&mut String::new())
}

/// `init_with_config` initializes Sentinel using given config.
#[inline]
pub fn init_with_config(config_entity: ConfigEntity) -> Result<()> {
    config_entity.check()?;
    config::reset_global_config(config_entity);
    #[cfg(any(feature = "env_logger", feature = "log4rs"))]
    config::init_log()?;
    init_core_components()
}

/// Init loads Sentinel general configuration from the given YAML file
/// and initializes Sentinel.
#[inline]
pub fn init_with_config_file(config_path: String) -> Result<()> {
    let mut config_path = config_path;
    init_sentinel(&mut config_path)
}

#[inline]
fn init_sentinel(config_path: &mut String) -> Result<()> {
    // Initialize general config and logging module.
    config::init_config_with_yaml(config_path)?;
    init_core_components()
}

// `init_core_components` init core components with global config
#[inline]
fn init_core_components() -> Result<()> {
    if config::metric_log_flush_interval_sec() > 0 {
        #[cfg(feature = "metric_log")]
        metric::init_task();
    }

    let system_interval = config::system_stat_collect_interval_ms();
    let mut load_interval = system_interval;
    let mut cpu_interval = system_interval;
    let mut mem_interval = system_interval;

    if config::load_stat_collec_interval_ms() > 0 {
        load_interval = config::load_stat_collec_interval_ms();
    }
    if config::cpu_stat_collec_interval_ms() > 0 {
        cpu_interval = config::cpu_stat_collec_interval_ms();
    }
    if config::memory_stat_collec_interval_ms() > 0 {
        mem_interval = config::memory_stat_collec_interval_ms();
    }

    if load_interval > 0 {
        system_metric::init_load_collector(load_interval);
    }
    if cpu_interval > 0 {
        system_metric::init_cpu_collector(cpu_interval);
    }
    if mem_interval > 0 {
        system_metric::init_memory_collector(mem_interval);
    }

    if config::use_cache_time() {
        utils::start_time_ticker();
    }

    #[cfg(feature = "exporter")]
    crate::exporter::init();

    Ok(())
}