mirror of
https://github.com/rustfs/rustfs.git
synced 2026-07-28 17:18:58 +00:00
Zhengchao An
27b8592879
docs: add documentation to storage-api public types Add doc comments to public structs, enums, and traits in storage-api crate to improve documentation coverage. Refs #741
126 lines
4.8 KiB
Rust
126 lines
4.8 KiB
Rust
// Copyright 2024 RustFS Team
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
use std::fmt::Debug;
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::{CapabilitySnapshotError, CapabilityStatus};
|
|
|
|
/// Snapshot of observability capabilities and state.
|
|
#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct ObservabilitySnapshot {
|
|
/// Runtime telemetry capabilities.
|
|
pub runtime_telemetry: CapabilityStatus,
|
|
/// Userspace profiling capabilities.
|
|
pub userspace_profiling: UserspaceProfilingCapability,
|
|
/// Memory sampling state.
|
|
pub memory_sampling: MemorySamplingState,
|
|
/// Platform support information.
|
|
pub platform: PlatformSupport,
|
|
}
|
|
|
|
/// Capabilities for userspace profiling.
|
|
#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct UserspaceProfilingCapability {
|
|
/// CPU profiling capability.
|
|
pub cpu: CapabilityStatus,
|
|
/// Memory profiling capability.
|
|
pub memory: CapabilityStatus,
|
|
/// Continuous CPU profiling capability.
|
|
pub continuous_cpu: CapabilityStatus,
|
|
/// Periodic CPU profiling capability.
|
|
pub periodic_cpu: CapabilityStatus,
|
|
}
|
|
|
|
/// State of memory sampling capabilities.
|
|
#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct MemorySamplingState {
|
|
/// Process-level memory sampling.
|
|
pub process: CapabilityStatus,
|
|
/// System-level memory sampling.
|
|
pub system: CapabilityStatus,
|
|
/// Cgroup-level memory sampling.
|
|
pub cgroup: CapabilityStatus,
|
|
}
|
|
|
|
/// Platform support information.
|
|
#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct PlatformSupport {
|
|
/// Target triple (e.g., x86_64-unknown-linux-gnu).
|
|
pub target_triple: Option<String>,
|
|
/// Operating system.
|
|
pub os: Option<String>,
|
|
/// Architecture.
|
|
pub arch: Option<String>,
|
|
/// Memory allocator capability.
|
|
pub allocator: CapabilityStatus,
|
|
/// eBPF support.
|
|
pub ebpf: CapabilityStatus,
|
|
/// NUMA support.
|
|
pub numa: CapabilityStatus,
|
|
}
|
|
|
|
/// Provider for observability snapshots.
|
|
#[async_trait::async_trait]
|
|
pub trait ObservabilitySnapshotProvider: Send + Sync + Debug {
|
|
/// Get a snapshot of observability capabilities and state.
|
|
async fn observability_snapshot(&self) -> Result<ObservabilitySnapshot, CapabilitySnapshotError>;
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::CapabilityState;
|
|
|
|
#[test]
|
|
fn observability_snapshot_preserves_unknown_and_unsupported_states() {
|
|
let snapshot = ObservabilitySnapshot {
|
|
runtime_telemetry: CapabilityStatus::unknown(),
|
|
userspace_profiling: UserspaceProfilingCapability {
|
|
cpu: CapabilityStatus::unsupported().with_reason("unsupported target"),
|
|
memory: CapabilityStatus::disabled(),
|
|
continuous_cpu: CapabilityStatus::unknown(),
|
|
periodic_cpu: CapabilityStatus::supported(),
|
|
},
|
|
memory_sampling: MemorySamplingState {
|
|
process: CapabilityStatus::supported(),
|
|
system: CapabilityStatus::supported(),
|
|
cgroup: CapabilityStatus::unknown(),
|
|
},
|
|
platform: PlatformSupport {
|
|
target_triple: Some("x86_64-unknown-linux-gnu".to_owned()),
|
|
os: Some("linux".to_owned()),
|
|
arch: Some("x86_64".to_owned()),
|
|
allocator: CapabilityStatus::supported(),
|
|
ebpf: CapabilityStatus::unknown(),
|
|
numa: CapabilityStatus::unsupported(),
|
|
},
|
|
};
|
|
|
|
let encoded = serde_json::to_string(&snapshot).expect("serialize observability snapshot");
|
|
let decoded: ObservabilitySnapshot = serde_json::from_str(&encoded).expect("deserialize observability snapshot");
|
|
|
|
assert_eq!(decoded.runtime_telemetry.state, CapabilityState::Unknown);
|
|
assert_eq!(decoded.userspace_profiling.cpu.state, CapabilityState::Unsupported);
|
|
assert_eq!(decoded.userspace_profiling.memory.state, CapabilityState::Disabled);
|
|
assert_eq!(decoded.platform.numa.state, CapabilityState::Unsupported);
|
|
assert_eq!(decoded.platform.ebpf.state, CapabilityState::Unknown);
|
|
}
|
|
}
|