arty_io_host 0.1.0

Unstable I/O driver hosting utilities for the Arty runtime.
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

use arty_io_core::{DriverError, DriverRole};
use data_privacy::classified;
use observed::event;

static SYSTEM_METADATA: data_privacy::DataClass = data_privacy::DataClass::new("arty", "SystemMetadata");
static IO_DRIVER_ERROR_MESSAGE: data_privacy::DataClass = data_privacy::DataClass::new("arty", "IoDriverErrorMessage");

#[classified(SYSTEM_METADATA)]
#[derive(Clone, Copy)]
pub(crate) struct IoContextName(pub(crate) &'static str);

#[classified(SYSTEM_METADATA)]
#[derive(Clone)]
pub(crate) struct IoDriverRoleLabel(pub(crate) String);

#[classified(IO_DRIVER_ERROR_MESSAGE)]
#[derive(Clone)]
pub(crate) struct IoDriverErrorMessage(pub(crate) String);

impl IoDriverErrorMessage {
    pub(crate) fn new(error: &DriverError) -> Self {
        Self(error.to_string())
    }
}

impl From<DriverRole> for IoDriverRoleLabel {
    fn from(role: DriverRole) -> Self {
        Self(role.to_string())
    }
}

#[event("arty.rt.io.driver.initialized")]
#[debug("I/O driver initialized")]
#[counter(name = "arty.rt.io.driver.initialized")]
pub(crate) struct IoDriverInitialized {
    #[dimension(log = "io.context")]
    pub(crate) context: IoContextName,
    #[dimension(log = "io.driver.role", metric = "io.driver.role")]
    pub(crate) role: IoDriverRoleLabel,
}

#[event("arty.rt.io.driver.initialization_failed")]
#[error("I/O driver initialization failed")]
#[counter(name = "arty.rt.io.driver.initialization_failed")]
pub(crate) struct IoDriverInitializationFailed {
    #[dimension(log = "io.context")]
    pub(crate) context: IoContextName,
    #[dimension(log = "io.driver.role", metric = "io.driver.role")]
    pub(crate) role: IoDriverRoleLabel,
    #[dimension(log = "error.message")]
    pub(crate) error: IoDriverErrorMessage,
}

#[event("arty.rt.io.driver.cycle_failed")]
#[error("I/O driver cycle failed")]
#[counter(name = "arty.rt.io.driver.cycle_failed")]
pub(crate) struct IoDriverCycleFailed {
    #[dimension(log = "io.context")]
    pub(crate) context: IoContextName,
    #[dimension(log = "io.driver.role", metric = "io.driver.role")]
    pub(crate) role: IoDriverRoleLabel,
    #[dimension(log = "error.message")]
    pub(crate) error: IoDriverErrorMessage,
}

#[event("arty.rt.io.driver.shutdown_failed")]
#[error("I/O driver shutdown failed")]
#[counter(name = "arty.rt.io.driver.shutdown_failed")]
pub(crate) struct IoDriverShutdownFailed {
    #[dimension(log = "io.context")]
    pub(crate) context: IoContextName,
    #[dimension(log = "io.driver.role", metric = "io.driver.role")]
    pub(crate) role: IoDriverRoleLabel,
    #[dimension(log = "error.message")]
    pub(crate) error: IoDriverErrorMessage,
}

#[cfg(test)]
#[cfg_attr(coverage_nightly, coverage(off))]
mod tests {
    use arty_io_core::{DriverError, DriverRole};

    use super::{IoDriverErrorMessage, IoDriverRoleLabel};

    #[test]
    fn telemetry_values_preserve_driver_details() {
        let error = DriverError::from_message("driver failed");

        let error_message = IoDriverErrorMessage::new(&error);
        let primary = IoDriverRoleLabel::from(DriverRole::Primary);
        let secondary = IoDriverRoleLabel::from(DriverRole::Secondary);

        assert_eq!(error_message.0, "driver failed");
        assert_eq!(primary.0, "primary");
        assert_eq!(secondary.0, "secondary");
    }
}