ckb-bin 1.1.0

CKB executable
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use ckb_app_config::ExitCode;
use ckb_async_runtime::Handle;
use ckb_build_info::Version;
use ckb_logger_service::{self, LoggerInitGuard};
use ckb_metrics_service::{self, Guard as MetricsInitGuard};

use crate::setup::Setup;

pub const CKB_LOG_ENV: &str = "CKB_LOG";

pub struct SetupGuard {
    _logger_guard: Option<LoggerInitGuard>,
    #[cfg(feature = "with_sentry")]
    _sentry_guard: Option<sentry::ClientInitGuard>,
    _metrics_guard: MetricsInitGuard,
}

impl SetupGuard {
    #[cfg(feature = "with_sentry")]
    pub(crate) fn from_setup(
        setup: &Setup,
        version: &Version,
        async_handle: Handle,
        silent_logging: bool,
        enable_logging: bool,
    ) -> Result<(Self, ckb_logger_config::Config), ExitCode> {
        // Initialization of logger must do before sentry, since `logger::init()` and
        // `sentry_config::init()` both registers custom panic hooks, but `logger::init()`
        // replaces all hooks previously registered.
        let logger_guard = if enable_logging {
            Some(if silent_logging {
                ckb_logger_service::init_silent()?
            } else {
                let mut logger_config = setup.config.logger().to_owned();
                if logger_config.emit_sentry_breadcrumbs.is_none() {
                    logger_config.emit_sentry_breadcrumbs = Some(setup.is_sentry_enabled);
                }
                ckb_logger_service::init(Some(CKB_LOG_ENV), logger_config, None)?
            })
        } else {
            None
        };

        let sentry_guard = if setup.is_sentry_enabled {
            let sentry_config = setup.config.sentry();

            ckb_logger::info_target!(
                crate::LOG_TARGET_SENTRY,
                "**Notice**: \
                 The ckb process will send stack trace to sentry on Rust panics. \
                 This is enabled by default before mainnet, which can be opted out by setting \
                 the option `dsn` to empty in the config file. The DSN is now {}",
                sentry_config.dsn
            );

            let guard = sentry_config.init(version);

            sentry::configure_scope(|scope| {
                scope.set_tag("subcommand", &setup.subcommand_name);
            });

            Some(guard)
        } else {
            ckb_logger::info_target!(crate::LOG_TARGET_SENTRY, "sentry is disabled");
            None
        };

        let metrics_config = setup.config.metrics().to_owned();
        let metrics_guard =
            ckb_metrics_service::init(metrics_config, async_handle).map_err(|err| {
                eprintln!("Config Error: {err:?}");
                ExitCode::Config
            })?;

        Ok((
            Self {
                _logger_guard: logger_guard,
                _sentry_guard: sentry_guard,
                _metrics_guard: metrics_guard,
            },
            setup.config.logger().to_owned(),
        ))
    }

    #[cfg(not(feature = "with_sentry"))]
    pub(crate) fn from_setup(
        setup: &Setup,
        _version: &Version,
        async_handle: Handle,
        silent_logging: bool,
        // For ckb run, logging can be disabled here, since it requires `Shared` to create a logger that will be used for `ckb run`
        enable_logging: bool,
    ) -> Result<(Self, ckb_logger_config::Config), ExitCode> {
        let logger_guard = if enable_logging {
            Some(if silent_logging {
                ckb_logger_service::init_silent()?
            } else {
                let logger_config = setup.config.logger().to_owned();
                ckb_logger_service::init(Some(CKB_LOG_ENV), logger_config, None)?
            })
        } else {
            None
        };

        let metrics_config = setup.config.metrics().to_owned();
        let metrics_guard =
            ckb_metrics_service::init(metrics_config, async_handle).map_err(|err| {
                eprintln!("Config Error: {err:?}");
                ExitCode::Config
            })?;

        Ok((
            Self {
                _logger_guard: logger_guard,
                _metrics_guard: metrics_guard,
            },
            setup.config.logger().to_owned(),
        ))
    }
}