rustfs_storage_api/
observability.rs1use std::fmt::Debug;
16
17use serde::{Deserialize, Serialize};
18
19use crate::{CapabilitySnapshotError, CapabilityStatus};
20
21#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
23#[serde(deny_unknown_fields)]
24pub struct ObservabilitySnapshot {
25 pub runtime_telemetry: CapabilityStatus,
27 pub userspace_profiling: UserspaceProfilingCapability,
29 pub memory_sampling: MemorySamplingState,
31 pub platform: PlatformSupport,
33}
34
35#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
37#[serde(deny_unknown_fields)]
38pub struct UserspaceProfilingCapability {
39 pub cpu: CapabilityStatus,
41 pub memory: CapabilityStatus,
43 pub continuous_cpu: CapabilityStatus,
45 pub periodic_cpu: CapabilityStatus,
47}
48
49#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
51#[serde(deny_unknown_fields)]
52pub struct MemorySamplingState {
53 pub process: CapabilityStatus,
55 pub system: CapabilityStatus,
57 pub cgroup: CapabilityStatus,
59}
60
61#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
63#[serde(deny_unknown_fields)]
64pub struct PlatformSupport {
65 pub target_triple: Option<String>,
67 pub os: Option<String>,
69 pub arch: Option<String>,
71 pub allocator: CapabilityStatus,
73 pub ebpf: CapabilityStatus,
75 pub numa: CapabilityStatus,
77}
78
79#[async_trait::async_trait]
81pub trait ObservabilitySnapshotProvider: Send + Sync + Debug {
82 async fn observability_snapshot(&self) -> Result<ObservabilitySnapshot, CapabilitySnapshotError>;
84}
85
86#[cfg(test)]
87mod tests {
88 use super::*;
89 use crate::CapabilityState;
90
91 #[test]
92 fn observability_snapshot_preserves_unknown_and_unsupported_states() {
93 let snapshot = ObservabilitySnapshot {
94 runtime_telemetry: CapabilityStatus::unknown(),
95 userspace_profiling: UserspaceProfilingCapability {
96 cpu: CapabilityStatus::unsupported().with_reason("unsupported target"),
97 memory: CapabilityStatus::disabled(),
98 continuous_cpu: CapabilityStatus::unknown(),
99 periodic_cpu: CapabilityStatus::supported(),
100 },
101 memory_sampling: MemorySamplingState {
102 process: CapabilityStatus::supported(),
103 system: CapabilityStatus::supported(),
104 cgroup: CapabilityStatus::unknown(),
105 },
106 platform: PlatformSupport {
107 target_triple: Some("x86_64-unknown-linux-gnu".to_owned()),
108 os: Some("linux".to_owned()),
109 arch: Some("x86_64".to_owned()),
110 allocator: CapabilityStatus::supported(),
111 ebpf: CapabilityStatus::unknown(),
112 numa: CapabilityStatus::unsupported(),
113 },
114 };
115
116 let encoded = serde_json::to_string(&snapshot).expect("serialize observability snapshot");
117 let decoded: ObservabilitySnapshot = serde_json::from_str(&encoded).expect("deserialize observability snapshot");
118
119 assert_eq!(decoded.runtime_telemetry.state, CapabilityState::Unknown);
120 assert_eq!(decoded.userspace_profiling.cpu.state, CapabilityState::Unsupported);
121 assert_eq!(decoded.userspace_profiling.memory.state, CapabilityState::Disabled);
122 assert_eq!(decoded.platform.numa.state, CapabilityState::Unsupported);
123 assert_eq!(decoded.platform.ebpf.state, CapabilityState::Unknown);
124 }
125}