zksync_protobuf_config 0.1.0

Protobuf deserialization for ZKsync configs
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

use anyhow::Context as _;
use zksync_config::configs::{self};
use zksync_protobuf::{required, ProtoRepr};

use crate::proto::observability as proto;

impl ProtoRepr for proto::Observability {
    type Type = configs::ObservabilityConfig;
    fn read(&self) -> anyhow::Result<Self::Type> {
        let (sentry_url, sentry_environment) = if let Some(sentry) = &self.sentry {
            let sentry_url = required(&sentry.url).context("sentry_url")?.clone();
            let sentry_url = if sentry_url.to_lowercase() == *"unset" {
                None
            } else {
                Some(sentry_url)
            };

            (
                sentry_url,
                Some(
                    required(&sentry.environment)
                        .context("sentry.environment")?
                        .clone(),
                ),
            )
        } else {
            (None, None)
        };
        Ok(Self::Type {
            sentry_url,
            sentry_environment,
            log_format: required(&self.log_format).context("log_format")?.clone(),
            opentelemetry: self
                .opentelemetry
                .as_ref()
                .map(|cfg| cfg.read().context("opentelemetry"))
                .transpose()?,
            log_directives: self.log_directives.clone(),
        })
    }

    fn build(this: &Self::Type) -> Self {
        let sentry = if this.sentry_url.is_none() || this.sentry_environment.is_none() {
            None
        } else {
            Some(proto::Sentry {
                url: this.sentry_url.clone(),
                environment: this.sentry_environment.clone(),
                panic_interval: None,
                error_interval: None,
            })
        };
        Self {
            sentry,
            log_format: Some(this.log_format.clone()),
            opentelemetry: this.opentelemetry.as_ref().map(ProtoRepr::build),
            log_directives: this.log_directives.clone(),
        }
    }
}

impl ProtoRepr for proto::Opentelemetry {
    type Type = configs::OpentelemetryConfig;

    fn read(&self) -> anyhow::Result<Self::Type> {
        Ok(Self::Type {
            level: required(&self.level).context("level")?.clone(),
            endpoint: required(&self.endpoint).context("endpoint")?.clone(),
        })
    }

    fn build(this: &Self::Type) -> Self {
        Self {
            level: Some(this.level.clone()),
            endpoint: Some(this.endpoint.clone()),
        }
    }
}