alumet 0.8.0

Modular framework for hardware and software measurement (including energy consumption and more).
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

use tokio::runtime;

use crate::metrics::{
    def::{Metric, RawMetricId},
    online::MetricReader,
    registry::MetricRegistry,
};

use super::{AsyncOutputStream, BoxedAsyncOutput, Output};

/// An output builder, for any type of output.
///
/// Use this type in the pipeline builder.
pub enum OutputBuilder {
    Blocking(Box<dyn BlockingOutputBuilder>),
    Async(Box<dyn AsyncOutputBuilder>),
}

/// Like [`OutputBuilder`] but with a [`Send`] bound on the builder.
///
/// Use this type in the pipeline control loop.
pub enum SendOutputBuilder {
    Blocking(Box<dyn BlockingOutputBuilder + Send>),
    Async(Box<dyn AsyncOutputBuilder + Send>),
}

impl From<SendOutputBuilder> for OutputBuilder {
    fn from(value: SendOutputBuilder) -> Self {
        match value {
            SendOutputBuilder::Blocking(b) => OutputBuilder::Blocking(b),
            SendOutputBuilder::Async(b) => OutputBuilder::Async(b),
        }
    }
}

impl std::fmt::Debug for SendOutputBuilder {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Blocking(_) => f.debug_tuple("Blocking").field(&"Box<dyn _>").finish(),
            Self::Async(_) => f.debug_tuple("Async").field(&"Box<dyn _>").finish(),
        }
    }
}

/// Trait for builders of blocking outputs.
///
///  # Example
/// ```
/// use alumet::pipeline::elements::output::builder::{BlockingOutputBuilder, BlockingOutputBuildContext};
/// use alumet::pipeline::Output;
///
/// fn build_my_output() -> anyhow::Result<Box<dyn Output>> {
///     todo!("build a new output")
/// }
///
/// let builder: &dyn BlockingOutputBuilder = &|ctx: &mut dyn BlockingOutputBuildContext| {
///     let output = build_my_output()?;
///     Ok(output)
/// };
/// ```
pub trait BlockingOutputBuilder:
    FnOnce(&mut dyn BlockingOutputBuildContext) -> anyhow::Result<Box<dyn Output>>
{
}
impl<F> BlockingOutputBuilder for F where
    F: FnOnce(&mut dyn BlockingOutputBuildContext) -> anyhow::Result<Box<dyn Output>>
{
}

pub trait AsyncOutputBuilder:
    FnOnce(&mut dyn AsyncOutputBuildContext, AsyncOutputStream) -> anyhow::Result<BoxedAsyncOutput>
{
}
impl<F> AsyncOutputBuilder for F where
    F: FnOnce(&mut dyn AsyncOutputBuildContext, AsyncOutputStream) -> anyhow::Result<BoxedAsyncOutput>
{
}

/// Context provided when building new outputs.
pub(super) struct OutputBuildContext<'a> {
    pub(super) metrics_r: &'a MetricReader,
    pub(super) metrics: &'a MetricRegistry,
    pub(super) runtime: runtime::Handle,
}

pub trait BlockingOutputBuildContext {
    fn metric_by_name(&self, name: &str) -> Option<(RawMetricId, &Metric)>;
}

pub trait AsyncOutputBuildContext {
    fn async_runtime(&self) -> &tokio::runtime::Handle;

    /// Returns a `MetricReader`, which allows to access the metric registry.
    fn metrics_reader(&self) -> MetricReader;
}

impl BlockingOutputBuildContext for OutputBuildContext<'_> {
    fn metric_by_name(&self, name: &str) -> Option<(RawMetricId, &Metric)> {
        self.metrics.by_name(name)
    }
}

impl AsyncOutputBuildContext for OutputBuildContext<'_> {
    fn async_runtime(&self) -> &tokio::runtime::Handle {
        &self.runtime
    }

    fn metrics_reader(&self) -> MetricReader {
        self.metrics_r.clone()
    }
}