quantrs2_device/cloud/monitoring/
resource.rs

1//! Resource monitoring and usage tracking configuration.
2
3use serde::{Deserialize, Serialize};
4use std::time::Duration;
5
6/// Resource monitoring configuration
7#[derive(Debug, Clone, Serialize, Deserialize)]
8pub struct CloudResourceMonitoringConfig {
9    /// Enable resource monitoring
10    pub enabled: bool,
11    /// Resource types to monitor
12    pub resource_types: Vec<ResourceType>,
13    /// Monitoring granularity
14    pub granularity: MonitoringGranularity,
15    /// Usage tracking
16    pub usage_tracking: UsageTrackingConfig,
17    /// Capacity planning
18    pub capacity_planning: CapacityPlanningConfig,
19    /// Resource optimization
20    pub optimization: ResourceOptimizationConfig,
21}
22
23/// Resource types
24#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
25pub enum ResourceType {
26    Compute,
27    Storage,
28    Network,
29    Quantum,
30    Database,
31    Memory,
32    GPU,
33    FPGA,
34    Custom(String),
35}
36
37/// Monitoring granularity
38#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
39pub enum MonitoringGranularity {
40    PerSecond,
41    PerMinute,
42    PerHour,
43    PerDay,
44    Custom(Duration),
45}
46
47/// Usage tracking configuration
48#[derive(Debug, Clone, Serialize, Deserialize)]
49pub struct UsageTrackingConfig {
50    /// Track resource utilization
51    pub track_utilization: bool,
52    /// Track resource allocation
53    pub track_allocation: bool,
54    /// Track resource efficiency
55    pub track_efficiency: bool,
56    /// Usage analytics
57    pub analytics: UsageAnalyticsConfig,
58    /// Resource tagging
59    pub tagging: ResourceTaggingConfig,
60}
61
62/// Usage analytics configuration
63#[derive(Debug, Clone, Serialize, Deserialize)]
64pub struct UsageAnalyticsConfig {
65    /// Enable analytics
66    pub enabled: bool,
67    /// Analytics methods
68    pub methods: Vec<UsageAnalyticsMethod>,
69    /// Analysis frequency
70    pub frequency: Duration,
71    /// Historical analysis
72    pub historical_analysis: HistoricalAnalysisConfig,
73    /// Predictive analytics
74    pub predictive_analytics: PredictiveAnalyticsConfig,
75}
76
77/// Usage analytics methods
78#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
79pub enum UsageAnalyticsMethod {
80    TrendAnalysis,
81    SeasonalAnalysis,
82    AnomalyDetection,
83    CapacityPlanning,
84    EfficiencyAnalysis,
85    CostAnalysis,
86    ResourceRightSizing,
87    Custom(String),
88}
89
90/// Historical analysis configuration
91#[derive(Debug, Clone, Serialize, Deserialize)]
92pub struct HistoricalAnalysisConfig {
93    /// Analysis window
94    pub window: Duration,
95    /// Comparison periods
96    pub comparison_periods: Vec<Duration>,
97    /// Statistical methods
98    pub statistical_methods: Vec<StatisticalMethod>,
99    /// Data retention
100    pub retention: Duration,
101}
102
103/// Statistical methods
104#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
105pub enum StatisticalMethod {
106    Mean,
107    Median,
108    StandardDeviation,
109    Percentiles,
110    Correlation,
111    Regression,
112    TimeSeries,
113    SeasonalDecomposition,
114    Custom(String),
115}
116
117/// Predictive analytics configuration
118#[derive(Debug, Clone, Serialize, Deserialize)]
119pub struct PredictiveAnalyticsConfig {
120    /// Enable predictive analytics
121    pub enabled: bool,
122    /// Prediction horizon
123    pub horizon: Duration,
124    /// Models to use
125    pub models: Vec<PredictiveModel>,
126    /// Model accuracy threshold
127    pub accuracy_threshold: f64,
128}
129
130/// Predictive models
131#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
132pub enum PredictiveModel {
133    LinearRegression,
134    TimeSeriesForecasting,
135    MachineLearning,
136    NeuralNetwork,
137    Custom(String),
138}
139
140/// Resource tagging configuration
141#[derive(Debug, Clone, Serialize, Deserialize)]
142pub struct ResourceTaggingConfig {
143    /// Enable automatic tagging
144    pub auto_tagging: bool,
145    /// Required tags
146    pub required_tags: Vec<String>,
147    /// Tag categories
148    pub categories: Vec<TagCategory>,
149    /// Tag validation rules
150    pub validation_rules: Vec<TagValidationRule>,
151}
152
153/// Tag categories
154#[derive(Debug, Clone, Serialize, Deserialize)]
155pub struct TagCategory {
156    /// Category name
157    pub name: String,
158    /// Category description
159    pub description: String,
160    /// Allowed values
161    pub allowed_values: Vec<String>,
162    /// Required category
163    pub required: bool,
164}
165
166/// Tag validation rules
167#[derive(Debug, Clone, Serialize, Deserialize)]
168pub struct TagValidationRule {
169    /// Rule name
170    pub name: String,
171    /// Tag key pattern
172    pub key_pattern: String,
173    /// Value validation
174    pub value_validation: ValueValidation,
175}
176
177/// Value validation types
178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
179pub enum ValueValidation {
180    Regex(String),
181    Enum(Vec<String>),
182    Range { min: f64, max: f64 },
183    Custom(String),
184}
185
186/// Capacity planning configuration
187#[derive(Debug, Clone, Serialize, Deserialize)]
188pub struct CapacityPlanningConfig {
189    /// Enable capacity planning
190    pub enabled: bool,
191    /// Planning horizon
192    pub horizon: Duration,
193    /// Growth models
194    pub growth_models: Vec<GrowthModel>,
195    /// Threshold-based planning
196    pub threshold_planning: ThresholdPlanningConfig,
197}
198
199/// Growth models
200#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
201pub enum GrowthModel {
202    Linear,
203    Exponential,
204    Seasonal,
205    MachineLearning,
206    Custom(String),
207}
208
209/// Threshold-based planning configuration
210#[derive(Debug, Clone, Serialize, Deserialize)]
211pub struct ThresholdPlanningConfig {
212    /// Utilization thresholds
213    pub utilization_thresholds: std::collections::HashMap<ResourceType, f64>,
214    /// Lead time for provisioning
215    pub provisioning_lead_time: Duration,
216    /// Buffer capacity percentage
217    pub buffer_capacity: f64,
218}
219
220/// Resource optimization configuration
221#[derive(Debug, Clone, Serialize, Deserialize)]
222pub struct ResourceOptimizationConfig {
223    /// Enable optimization recommendations
224    pub enabled: bool,
225    /// Optimization strategies
226    pub strategies: Vec<OptimizationStrategy>,
227    /// Automation level
228    pub automation_level: AutomationLevel,
229    /// Optimization frequency
230    pub frequency: Duration,
231}
232
233/// Optimization strategies
234#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
235pub enum OptimizationStrategy {
236    RightSizing,
237    Consolidation,
238    ScheduledScaling,
239    AutoScaling,
240    ResourcePooling,
241    Custom(String),
242}
243
244/// Automation levels
245#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
246pub enum AutomationLevel {
247    Manual,
248    SemiAutomatic,
249    Automatic,
250    FullyAutomated,
251}
252
253impl Default for CloudResourceMonitoringConfig {
254    fn default() -> Self {
255        Self {
256            enabled: true,
257            resource_types: vec![
258                ResourceType::Compute,
259                ResourceType::Storage,
260                ResourceType::Network,
261                ResourceType::Memory,
262            ],
263            granularity: MonitoringGranularity::PerMinute,
264            usage_tracking: UsageTrackingConfig::default(),
265            capacity_planning: CapacityPlanningConfig::default(),
266            optimization: ResourceOptimizationConfig::default(),
267        }
268    }
269}
270
271impl Default for UsageTrackingConfig {
272    fn default() -> Self {
273        Self {
274            track_utilization: true,
275            track_allocation: true,
276            track_efficiency: false,
277            analytics: UsageAnalyticsConfig::default(),
278            tagging: ResourceTaggingConfig::default(),
279        }
280    }
281}
282
283impl Default for UsageAnalyticsConfig {
284    fn default() -> Self {
285        Self {
286            enabled: true,
287            methods: vec![
288                UsageAnalyticsMethod::TrendAnalysis,
289                UsageAnalyticsMethod::AnomalyDetection,
290            ],
291            frequency: Duration::from_secs(3600), // hourly
292            historical_analysis: HistoricalAnalysisConfig::default(),
293            predictive_analytics: PredictiveAnalyticsConfig::default(),
294        }
295    }
296}
297
298impl Default for HistoricalAnalysisConfig {
299    fn default() -> Self {
300        Self {
301            window: Duration::from_secs(86400 * 30), // 30 days
302            comparison_periods: vec![
303                Duration::from_secs(86400),      // daily
304                Duration::from_secs(86400 * 7),  // weekly
305                Duration::from_secs(86400 * 30), // monthly
306            ],
307            statistical_methods: vec![StatisticalMethod::Mean, StatisticalMethod::Percentiles],
308            retention: Duration::from_secs(86400 * 365), // 1 year
309        }
310    }
311}
312
313impl Default for PredictiveAnalyticsConfig {
314    fn default() -> Self {
315        Self {
316            enabled: false,
317            horizon: Duration::from_secs(86400 * 30), // 30 days
318            models: vec![PredictiveModel::LinearRegression],
319            accuracy_threshold: 0.8,
320        }
321    }
322}
323
324impl Default for ResourceTaggingConfig {
325    fn default() -> Self {
326        Self {
327            auto_tagging: false,
328            required_tags: vec!["Environment".to_string(), "Project".to_string()],
329            categories: vec![],
330            validation_rules: vec![],
331        }
332    }
333}
334
335impl Default for CapacityPlanningConfig {
336    fn default() -> Self {
337        Self {
338            enabled: false,
339            horizon: Duration::from_secs(86400 * 90), // 90 days
340            growth_models: vec![GrowthModel::Linear],
341            threshold_planning: ThresholdPlanningConfig::default(),
342        }
343    }
344}
345
346impl Default for ThresholdPlanningConfig {
347    fn default() -> Self {
348        let mut thresholds = std::collections::HashMap::new();
349        thresholds.insert(ResourceType::Compute, 80.0);
350        thresholds.insert(ResourceType::Storage, 85.0);
351        thresholds.insert(ResourceType::Memory, 75.0);
352
353        Self {
354            utilization_thresholds: thresholds,
355            provisioning_lead_time: Duration::from_secs(86400), // 1 day
356            buffer_capacity: 20.0,
357        }
358    }
359}
360
361impl Default for ResourceOptimizationConfig {
362    fn default() -> Self {
363        Self {
364            enabled: false,
365            strategies: vec![OptimizationStrategy::RightSizing],
366            automation_level: AutomationLevel::Manual,
367            frequency: Duration::from_secs(86400 * 7), // weekly
368        }
369    }
370}
quantrs2_device/cloud/monitoring/resource.rs

quantrs2_device/cloud/monitoring/
resource.rs
