1use std::collections::BTreeMap;
2
3use crate::{ai_catalog::ClientApi, Platform, ResourceType};
4use chrono::{DateTime, Utc};
5use serde::{Deserialize, Serialize};
6use serde_json::Value as JsonValue;
7
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
10#[serde(rename_all = "camelCase")]
11pub struct ResourceHeartbeat {
12 pub deployment_id: Option<String>,
13 pub resource_id: String,
16 pub resource_type: ResourceType,
17 pub controller_platform: Platform,
18 pub backend: HeartbeatBackend,
19 pub observed_at: DateTime<Utc>,
20 pub data: ResourceHeartbeatData,
21 pub raw: Vec<RawHeartbeatSnippet>,
22}
23
24#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
25#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
26#[serde(rename_all = "camelCase")]
27pub struct ObservedInventoryBatch {
28 pub source_kind: String,
31 pub inventory_scope: String,
33 pub controller_platform: Platform,
35 pub backend: HeartbeatBackend,
37 pub observed_at: DateTime<Utc>,
39 pub complete: bool,
43 pub resources: Vec<ObservedResourceSample>,
44}
45
46#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
47#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
48#[serde(rename_all = "camelCase")]
49pub struct ObservedResourceSample {
50 pub deployment_id: Option<String>,
51 pub raw_identity: String,
54 pub provider_kind: String,
58 pub display_name: String,
59 #[serde(default, skip_serializing_if = "Option::is_none")]
60 pub namespace: Option<String>,
61 #[serde(default, skip_serializing_if = "Option::is_none")]
62 pub region: Option<String>,
63 #[serde(default, skip_serializing_if = "Option::is_none")]
64 pub scope: Option<String>,
65 #[serde(default, skip_serializing_if = "Option::is_none")]
66 pub resource_type_hint: Option<ResourceType>,
67 #[serde(default, skip_serializing_if = "Option::is_none")]
69 pub version: Option<String>,
70 #[serde(default, skip_serializing_if = "Option::is_none")]
71 pub alien_resource_id: Option<String>,
72 pub health: ObservedHealth,
73 pub lifecycle: ProviderLifecycleState,
74 #[serde(default, skip_serializing_if = "Option::is_none")]
75 pub message: Option<String>,
76 pub partial: bool,
77 pub provider_stale: bool,
78 #[serde(default, skip_serializing_if = "Option::is_none")]
79 pub counts: Option<ObservedCounts>,
80 #[serde(default, skip_serializing_if = "Vec::is_empty")]
81 pub collection_issues: Vec<HeartbeatCollectionIssue>,
82 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
83 pub labels: BTreeMap<String, String>,
84 #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
85 pub attributes: BTreeMap<String, JsonValue>,
86 #[serde(default, skip_serializing_if = "Vec::is_empty")]
87 pub raw: Vec<RawHeartbeatSnippet>,
88 #[serde(default, skip_serializing_if = "Vec::is_empty")]
91 pub images: Vec<ContainerImageIdentity>,
92}
93
94#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
96#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
97#[serde(rename_all = "camelCase")]
98pub struct ContainerImageIdentity {
99 pub name: String,
101 pub image: String,
103 #[serde(default, skip_serializing_if = "Option::is_none")]
106 pub digest: Option<String>,
107}
108
109#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
110#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
111#[serde(rename_all = "camelCase")]
112pub enum HeartbeatBackend {
113 Aws,
114 Gcp,
115 Azure,
116 Kubernetes,
117 Local,
118 Managed,
119 External,
120 Test,
121}
122
123#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
124#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
125#[serde(rename_all = "kebab-case")]
126pub enum HeartbeatCollectionIssueReason {
127 Forbidden,
128 NotInstalled,
129 ApiUnavailable,
130 CollectionFailed,
131 TimedOut,
132}
133
134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
135#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
136#[serde(tag = "resourceType", content = "data")]
137pub enum ResourceHeartbeatData {
138 #[serde(rename = "storage")]
139 Storage(StorageHeartbeatData),
140 #[serde(rename = "worker")]
141 Worker(WorkerHeartbeatData),
142 #[serde(rename = "container")]
143 Container(ContainerHeartbeatData),
144 #[serde(rename = "daemon")]
145 Daemon(DaemonHeartbeatData),
146 #[serde(rename = "compute-cluster")]
147 ComputeCluster(ComputeClusterHeartbeatData),
148 #[serde(rename = "kubernetes-cluster")]
149 KubernetesCluster(KubernetesClusterHeartbeatData),
150 #[serde(rename = "queue")]
151 Queue(QueueHeartbeatData),
152 #[serde(rename = "kv")]
153 Kv(KvHeartbeatData),
154 #[serde(rename = "postgres")]
155 Postgres(PostgresHeartbeatData),
156 #[serde(rename = "redis")]
157 Redis(RedisHeartbeatData),
158 #[serde(rename = "vault")]
159 Vault(VaultHeartbeatData),
160 #[serde(rename = "service-account")]
161 ServiceAccount(ServiceAccountHeartbeatData),
162 #[serde(rename = "network")]
163 Network(NetworkHeartbeatData),
164 #[serde(rename = "remote-stack-management")]
165 RemoteStackManagement(RemoteStackManagementHeartbeatData),
166 #[serde(rename = "artifact-registry")]
167 ArtifactRegistry(ArtifactRegistryHeartbeatData),
168 #[serde(rename = "build")]
169 Build(BuildHeartbeatData),
170 #[serde(rename = "service_activation")]
171 ServiceActivation(ServiceActivationHeartbeatData),
172 #[serde(rename = "azure_resource_group")]
173 AzureResourceGroup(AzureResourceGroupHeartbeatData),
174 #[serde(rename = "azure_storage_account")]
175 AzureStorageAccount(AzureStorageAccountHeartbeatData),
176 #[serde(rename = "azure_container_apps_environment")]
177 AzureContainerAppsEnvironment(AzureContainerAppsEnvironmentHeartbeatData),
178 #[serde(rename = "azure_service_bus_namespace")]
179 AzureServiceBusNamespace(AzureServiceBusNamespaceHeartbeatData),
180 #[serde(rename = "ai")]
181 Ai(AiHeartbeatData),
182 #[serde(rename = "key")]
183 Key(KeyHeartbeatData),
184 #[serde(rename = "sandbox")]
185 Sandbox(SandboxHeartbeatData),
186}
187
188#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
189#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
190#[serde(rename_all = "kebab-case")]
191pub enum ObservedHealth {
192 Unknown,
193 Healthy,
194 Degraded,
195 Unhealthy,
196}
197
198#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
199#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
200#[serde(rename_all = "kebab-case")]
201pub enum ProviderLifecycleState {
202 Unknown,
203 Creating,
204 Updating,
205 Running,
206 Scaling,
207 Stopping,
208 Stopped,
209 Deleting,
210 Deleted,
211 Failed,
212}
213
214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
215#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
216#[serde(rename_all = "camelCase")]
217pub struct KeyHeartbeatStatus {
218 pub health: ObservedHealth,
219 pub lifecycle: ProviderLifecycleState,
220 pub message: Option<String>,
221}
222
223#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
224#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
225#[serde(tag = "provider", content = "data", rename_all = "kebab-case")]
226pub enum KeyHeartbeatData {
227 AwsKms(AwsKmsKeyHeartbeatData),
228 GcpCloudKms(GcpCloudKmsKeyHeartbeatData),
229 AzureKeyVault(AzureKeyVaultKeyHeartbeatData),
230}
231
232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
233#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
234#[serde(rename_all = "camelCase")]
235pub struct AwsKmsKeyHeartbeatData {
236 pub status: KeyHeartbeatStatus,
237 pub key_arn: String,
238 pub key_state: String,
239 pub enabled: bool,
240 pub key_spec: String,
241 pub key_usage: String,
242}
243
244#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
245#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
246#[serde(rename_all = "camelCase")]
247pub struct GcpCloudKmsKeyHeartbeatData {
248 pub status: KeyHeartbeatStatus,
249 pub crypto_key_name: String,
250 pub purpose: String,
251 pub primary_version: Option<String>,
252 pub primary_state: Option<String>,
253 pub algorithm: Option<String>,
254}
255
256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
257#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
258#[serde(rename_all = "camelCase")]
259pub struct AzureKeyVaultKeyHeartbeatData {
260 pub status: KeyHeartbeatStatus,
261 pub key_id: String,
262 pub enabled: Option<bool>,
263 pub key_type: String,
264 pub key_operations: Vec<String>,
265 pub recovery_level: Option<String>,
266}
267
268#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
269#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
270#[serde(rename_all = "camelCase")]
271pub struct HeartbeatCollectionIssue {
272 pub source: String,
273 pub reason: HeartbeatCollectionIssueReason,
274 pub severity: HeartbeatIssueSeverity,
275 pub message: String,
276}
277
278#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
279#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
280#[serde(rename_all = "kebab-case")]
281pub enum HeartbeatIssueSeverity {
282 Info,
283 Warning,
284 Error,
285}
286
287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
288#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
289#[serde(rename_all = "camelCase")]
290pub struct KubernetesEventSnapshot {
291 pub reason: String,
292 #[serde(rename = "type")]
293 pub type_: Option<String>,
294 pub message: String,
295 pub count: Option<i32>,
296 pub first_timestamp: Option<DateTime<Utc>>,
297 pub last_timestamp: Option<DateTime<Utc>>,
298 pub event_time: Option<DateTime<Utc>>,
299 pub source: Option<KubernetesEventSource>,
300 pub involved_object: Option<KubernetesEventInvolvedObject>,
301 pub raw: Option<JsonValue>,
302}
303
304#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
305#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
306#[serde(rename_all = "camelCase")]
307pub struct KubernetesEventSource {
308 pub component: Option<String>,
309 pub host: Option<String>,
310}
311
312#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
313#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
314#[serde(rename_all = "camelCase")]
315pub struct KubernetesEventInvolvedObject {
316 pub kind: Option<String>,
317 pub namespace: Option<String>,
318 pub name: Option<String>,
319 pub uid: Option<String>,
320 pub api_version: Option<String>,
321 pub resource_version: Option<String>,
322 pub field_path: Option<String>,
323}
324
325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
326#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
327#[serde(rename_all = "camelCase")]
328pub struct ManagedRuntimeEventSnapshot {
329 pub event_id: Option<String>,
330 pub reason: String,
331 #[serde(rename = "type")]
332 pub type_: Option<String>,
333 pub message: String,
334 pub count: Option<i32>,
335 pub first_timestamp: Option<DateTime<Utc>>,
336 pub last_timestamp: Option<DateTime<Utc>>,
337 pub event_time: Option<DateTime<Utc>>,
338 pub source: Option<ManagedRuntimeEventSource>,
339 pub involved_object: Option<ManagedRuntimeEventInvolvedObject>,
340 pub details: Option<JsonValue>,
341 pub raw: Option<JsonValue>,
342}
343
344#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
345#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
346#[serde(rename_all = "camelCase")]
347pub struct ManagedRuntimeEventSource {
348 pub component: Option<String>,
349 pub host: Option<String>,
350}
351
352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
353#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
354#[serde(rename_all = "camelCase")]
355pub struct ManagedRuntimeEventInvolvedObject {
356 pub kind: Option<String>,
357 pub id: Option<String>,
358 pub name: Option<String>,
359 pub replica_id: Option<String>,
360 pub machine_id: Option<String>,
361 pub details: Option<JsonValue>,
362}
363
364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
365#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
366#[serde(rename_all = "camelCase")]
367pub struct LocalRuntimeEventSnapshot {
368 pub timestamp: DateTime<Utc>,
369 pub severity: HeartbeatIssueSeverity,
370 pub kind: String,
371 pub message: String,
372 pub subject: Option<LocalRuntimeEventSubject>,
373 pub raw: Option<JsonValue>,
374}
375
376#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
377#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
378#[serde(rename_all = "camelCase")]
379pub struct LocalRuntimeEventSubject {
380 pub kind: String,
381 pub id: Option<String>,
382 pub name: Option<String>,
383}
384
385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
386#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
387#[serde(rename_all = "camelCase")]
388pub struct RawHeartbeatSnippet {
389 pub source: String,
390 pub format: RawHeartbeatSnippetFormat,
391 pub collected_at: DateTime<Utc>,
392 pub body: String,
393 pub truncated: bool,
394}
395
396#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
397#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
398#[serde(rename_all = "kebab-case")]
399pub enum RawHeartbeatSnippetFormat {
400 Json,
401 Yaml,
402 Text,
403}
404
405#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
406#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
407#[serde(rename_all = "camelCase")]
408pub struct ObservedCounts {
409 pub desired: Option<u32>,
410 pub current: Option<u32>,
411 pub ready: Option<u32>,
412}
413
414#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
415#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
416#[serde(rename_all = "camelCase")]
417pub struct MetricSample {
418 pub value: f64,
419 pub unit: MetricUnit,
420}
421
422#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
423#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
424#[serde(rename_all = "kebab-case")]
425pub enum MetricUnit {
426 Count,
427 Percent,
428 Bytes,
429 Cores,
430 Milliseconds,
431 RequestsPerSecond,
432}
433
434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
435#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
436#[serde(tag = "backend", rename_all = "camelCase")]
437pub enum StorageHeartbeatData {
438 AwsS3(AwsS3StorageHeartbeatData),
439 GcpCloudStorage(GcpCloudStorageHeartbeatData),
440 AzureBlob(AzureBlobStorageHeartbeatData),
441 Local(LocalStorageHeartbeatData),
442}
443
444#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
445#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
446#[serde(rename_all = "camelCase")]
447pub struct StorageHeartbeatStatus {
448 pub health: ObservedHealth,
449 pub lifecycle: ProviderLifecycleState,
450 pub message: Option<String>,
451 pub stale: bool,
452 pub partial: bool,
453 pub collection_issues: Vec<HeartbeatCollectionIssue>,
454}
455
456#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
457#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
458#[serde(rename_all = "camelCase")]
459pub struct AwsS3StorageHeartbeatData {
460 pub status: StorageHeartbeatStatus,
461 pub name: String,
462 pub region: Option<String>,
463 pub bucket_location: Option<String>,
464 pub versioning_status: Option<String>,
465 pub versioning_enabled: Option<bool>,
466 pub lifecycle_present: bool,
467 pub lifecycle_rule_count: Option<u64>,
468 pub encryption_config_present: bool,
469 pub encryption_enabled: Option<bool>,
470 pub public_access_block_present: bool,
471 pub block_public_acls: Option<bool>,
472 pub ignore_public_acls: Option<bool>,
473 pub block_public_policy: Option<bool>,
474 pub restrict_public_buckets: Option<bool>,
475 pub bucket_policy_present: Option<bool>,
476 pub bucket_acl_present: Option<bool>,
477}
478
479#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
480#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
481#[serde(rename_all = "camelCase")]
482pub struct AzureBlobStorageHeartbeatData {
483 pub status: StorageHeartbeatStatus,
484 pub name: String,
485 pub storage_account_name: Option<String>,
486 pub resource_group: Option<String>,
487 pub location: Option<String>,
488 pub account_kind: Option<String>,
489 pub sku_name: Option<String>,
490 pub sku_tier: Option<String>,
491 pub access_tier: Option<String>,
492 pub provisioning_state: Option<String>,
493 pub primary_location: Option<String>,
494 pub secondary_location: Option<String>,
495 pub status_of_primary: Option<String>,
496 pub status_of_secondary: Option<String>,
497 pub public_network_access: Option<String>,
498 pub allow_blob_public_access: Option<bool>,
499 pub encryption_key_source: Option<String>,
500 pub blob_encryption_enabled: Option<bool>,
501 pub file_encryption_enabled: Option<bool>,
502 pub queue_encryption_enabled: Option<bool>,
503 pub table_encryption_enabled: Option<bool>,
504 pub blob_versioning_enabled: Option<bool>,
505 pub blob_delete_retention_enabled: Option<bool>,
506 pub blob_delete_retention_days: Option<u64>,
507 pub container_delete_retention_enabled: Option<bool>,
508 pub container_delete_retention_days: Option<u64>,
509 pub change_feed_enabled: Option<bool>,
510 pub change_feed_retention_days: Option<u64>,
511 pub container_public_access: Option<String>,
512}
513
514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
515#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
516#[serde(rename_all = "camelCase")]
517pub struct GcpCloudStorageHeartbeatData {
518 pub status: StorageHeartbeatStatus,
519 pub name: String,
520 pub bucket_id: Option<String>,
521 pub location: Option<String>,
522 pub location_type: Option<String>,
523 pub storage_class: Option<String>,
524 pub versioning_enabled: Option<bool>,
525 pub lifecycle_present: bool,
526 pub lifecycle_rule_count: Option<u64>,
527 pub retention_policy_effective_time: Option<String>,
528 pub retention_policy_is_locked: Option<bool>,
529 pub retention_period: Option<String>,
530 pub soft_delete_retention_duration_seconds: Option<String>,
531 pub soft_delete_effective_time: Option<String>,
532 pub uniform_bucket_level_access_enabled: Option<bool>,
533 pub uniform_bucket_level_access_locked_time: Option<String>,
534 pub public_access_prevention: Option<String>,
535 pub encryption_config_present: bool,
536 pub default_kms_key_name: Option<String>,
537}
538
539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
540#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
541#[serde(rename_all = "camelCase")]
542pub struct LocalStorageHeartbeatData {
543 pub status: StorageHeartbeatStatus,
544 pub path: String,
545 pub path_exists: bool,
546 pub is_directory: Option<bool>,
547 pub readonly: Option<bool>,
548 pub modified_at: Option<DateTime<Utc>>,
549}
550
551#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
552#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
553#[serde(tag = "backend", rename_all = "camelCase")]
554pub enum WorkerHeartbeatData {
555 AwsLambda(AwsLambdaWorkerHeartbeatData),
556 GcpCloudRun(GcpCloudRunWorkerHeartbeatData),
557 AzureContainerApps(AzureContainerAppsWorkerHeartbeatData),
558 Kubernetes(KubernetesWorkerHeartbeatData),
559 Local(LocalWorkerHeartbeatData),
560}
561
562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
563#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
564#[serde(tag = "backend", rename_all = "camelCase")]
565pub enum ContainerHeartbeatData {
566 HorizonPlatform(HorizonContainerHeartbeatData),
567 Kubernetes(KubernetesContainerHeartbeatData),
568 Local(LocalContainerHeartbeatData),
569}
570
571#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
572#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
573#[serde(tag = "backend", rename_all = "camelCase")]
574pub enum DaemonHeartbeatData {
575 Aws(AwsDaemonHeartbeatData),
576 Gcp(GcpDaemonHeartbeatData),
577 Azure(AzureDaemonHeartbeatData),
578 Machines(MachinesDaemonHeartbeatData),
579 Kubernetes(KubernetesDaemonHeartbeatData),
580 Local(LocalDaemonHeartbeatData),
581}
582
583#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
584#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
585#[serde(rename_all = "camelCase")]
586pub struct WorkloadHeartbeatStatus {
587 pub health: ObservedHealth,
588 pub lifecycle: ProviderLifecycleState,
589 pub message: Option<String>,
590 pub stale: bool,
591 pub partial: bool,
592 pub collection_issues: Vec<HeartbeatCollectionIssue>,
593}
594
595#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
596#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
597#[serde(rename_all = "camelCase")]
598pub struct WorkloadReplicaStatus {
599 pub desired: Option<u32>,
600 pub current: Option<u32>,
601 pub ready: Option<u32>,
602 pub available: Option<u32>,
603 pub updated: Option<u32>,
604 pub misscheduled: Option<u32>,
605}
606
607#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
608#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
609#[serde(rename_all = "camelCase")]
610pub struct AwsLambdaWorkerHeartbeatData {
611 pub status: WorkloadHeartbeatStatus,
612 pub function_name: String,
613 pub runtime: Option<String>,
614 pub package_type: Option<String>,
615 pub memory_size_mb: Option<i64>,
616 pub timeout_seconds: Option<i64>,
617 pub version: Option<String>,
618 pub revision_id: Option<String>,
619 pub last_modified: Option<String>,
620 pub state: Option<String>,
621 pub state_reason: Option<String>,
622 pub state_reason_code: Option<String>,
623 pub last_update_status: Option<String>,
624 pub last_update_status_reason: Option<String>,
625 pub last_update_status_reason_code: Option<String>,
626 pub code_sha256: Option<String>,
627 pub layer_count: u32,
628 pub function_url_auth_type: Option<String>,
629 pub function_url_cors_present: bool,
630 pub trigger_count: u32,
631}
632
633#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
634#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
635#[serde(rename_all = "camelCase")]
636pub struct GcpCloudRunWorkerHeartbeatData {
637 pub status: WorkloadHeartbeatStatus,
638 pub service: String,
639 pub region: Option<String>,
640 pub uri: Option<String>,
641 pub urls: Vec<String>,
642 pub latest_created_revision: Option<String>,
643 pub latest_ready_revision: Option<String>,
644 pub generation: Option<i64>,
645 pub observed_generation: Option<i64>,
646 pub traffic_count: u32,
647 pub min_instance_count: Option<i32>,
648 pub max_instance_count: Option<i32>,
649 pub container_image: Option<String>,
650 pub cpu_limit: Option<String>,
651 pub memory_limit: Option<String>,
652}
653
654#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
655#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
656#[serde(rename_all = "camelCase")]
657pub struct AzureContainerAppsWorkerHeartbeatData {
658 pub status: WorkloadHeartbeatStatus,
659 pub app_name: String,
660 pub revision: Option<String>,
661 pub environment_name: Option<String>,
662 pub provisioning_state: Option<String>,
663 pub running_status: Option<String>,
664 pub ingress_fqdn: Option<String>,
665 pub min_replicas: Option<i32>,
666 pub max_replicas: Option<i32>,
667 pub cpu: Option<f64>,
668 pub memory: Option<String>,
669}
670
671#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
672#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
673#[serde(rename_all = "camelCase")]
674pub struct KubernetesWorkerHeartbeatData {
675 pub status: WorkloadHeartbeatStatus,
676 pub namespace: String,
677 pub name: String,
678 pub workload_kind: KubernetesWorkloadKind,
679 pub replicas: WorkloadReplicaStatus,
680 pub restarts: Option<u32>,
681 pub cpu: Option<MetricSample>,
682 pub memory: Option<MetricSample>,
683 pub workload: Option<KubernetesWorkloadStatus>,
684 pub pods: Vec<KubernetesPodRuntimeUnitStatus>,
685 pub trigger_count: u32,
686 pub events: Vec<KubernetesEventSnapshot>,
687}
688
689#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
690#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
691#[serde(rename_all = "camelCase")]
692pub struct LocalWorkerHeartbeatData {
693 pub status: WorkloadHeartbeatStatus,
694 pub pid: Option<u32>,
695 pub command_supported: bool,
696 pub image_path_present: bool,
697 pub readiness_probe_ok: Option<bool>,
698 pub trigger_count: u32,
699 pub cpu: Option<MetricSample>,
700 pub memory: Option<MetricSample>,
701 pub process: Option<LocalRuntimeUnitStatus>,
702 pub events: Vec<LocalRuntimeEventSnapshot>,
703}
704
705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
706#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
707#[serde(rename_all = "camelCase")]
708pub struct HorizonContainerHeartbeatData {
709 pub status: WorkloadHeartbeatStatus,
710 pub container_id: String,
711 pub image: Option<String>,
712 #[serde(default)]
713 pub observed_image: Option<String>,
714 #[serde(default)]
715 pub latest_update_timestamp: Option<String>,
716 pub scheduling_mode: HorizonWorkloadSchedulingMode,
717 pub replicas: WorkloadReplicaStatus,
718 pub cpu: Option<MetricSample>,
719 pub memory: Option<MetricSample>,
720 pub attention_count: u32,
721 pub replica_units: Vec<ManagedRuntimeUnitStatus>,
722 pub events: Vec<ManagedRuntimeEventSnapshot>,
723}
724
725#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
726#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
727#[serde(rename_all = "camelCase")]
728pub enum HorizonWorkloadSchedulingMode {
729 Replicated,
730 Stateful,
731 Daemon,
732}
733
734#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
735#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
736#[serde(rename_all = "camelCase")]
737pub struct KubernetesContainerHeartbeatData {
738 pub status: WorkloadHeartbeatStatus,
739 pub namespace: String,
740 pub name: String,
741 pub workload_kind: KubernetesWorkloadKind,
742 pub replicas: WorkloadReplicaStatus,
743 pub restarts: Option<u32>,
744 pub cpu: Option<MetricSample>,
745 pub memory: Option<MetricSample>,
746 pub workload: Option<KubernetesWorkloadStatus>,
747 pub pods: Vec<KubernetesPodRuntimeUnitStatus>,
748 pub events: Vec<KubernetesEventSnapshot>,
749}
750
751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
752#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
753#[serde(rename_all = "camelCase")]
754pub struct LocalContainerHeartbeatData {
755 pub status: WorkloadHeartbeatStatus,
756 pub container_id: Option<String>,
757 pub name: Option<String>,
758 pub image: Option<String>,
759 pub runtime_status: Option<String>,
760 pub restart_count: Option<u32>,
761 pub port_count: u32,
762 pub bind_mount_count: u32,
763 pub local_url: Option<String>,
764 pub runtime_reachable: bool,
765 pub cpu: Option<MetricSample>,
766 pub memory: Option<MetricSample>,
767 pub container_unit: Option<LocalRuntimeUnitStatus>,
768 pub events: Vec<LocalRuntimeEventSnapshot>,
769}
770
771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
772#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
773#[serde(rename_all = "camelCase")]
774pub struct AwsDaemonHeartbeatData {
775 pub status: WorkloadHeartbeatStatus,
776 pub horizon_cluster_id: String,
777 #[serde(default)]
778 pub daemon_name: String,
779 pub horizon_status: String,
780 pub horizon_status_reason: Option<String>,
781 pub horizon_status_message: Option<String>,
782 pub capacity_group: String,
783 pub desired_machines: u32,
784 pub assigned_machines: u32,
785 pub healthy_instances: u32,
786 pub unavailable_instances: u32,
787 pub command_supported: bool,
788 #[serde(default)]
789 pub observed_image: Option<String>,
790 pub latest_update_timestamp: String,
791 pub daemon_instances: Vec<ManagedRuntimeUnitStatus>,
792 pub events: Vec<ManagedRuntimeEventSnapshot>,
793}
794
795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
796#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
797#[serde(rename_all = "camelCase")]
798pub struct GcpDaemonHeartbeatData {
799 pub status: WorkloadHeartbeatStatus,
800 pub horizon_cluster_id: String,
801 #[serde(default)]
802 pub daemon_name: String,
803 pub horizon_status: String,
804 pub horizon_status_reason: Option<String>,
805 pub horizon_status_message: Option<String>,
806 pub capacity_group: String,
807 pub desired_machines: u32,
808 pub assigned_machines: u32,
809 pub healthy_instances: u32,
810 pub unavailable_instances: u32,
811 pub command_supported: bool,
812 #[serde(default)]
813 pub observed_image: Option<String>,
814 pub latest_update_timestamp: String,
815 pub daemon_instances: Vec<ManagedRuntimeUnitStatus>,
816 pub events: Vec<ManagedRuntimeEventSnapshot>,
817}
818
819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
820#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
821#[serde(rename_all = "camelCase")]
822pub struct AzureDaemonHeartbeatData {
823 pub status: WorkloadHeartbeatStatus,
824 pub horizon_cluster_id: String,
825 #[serde(default)]
826 pub daemon_name: String,
827 pub horizon_status: String,
828 pub horizon_status_reason: Option<String>,
829 pub horizon_status_message: Option<String>,
830 pub capacity_group: String,
831 pub desired_machines: u32,
832 pub assigned_machines: u32,
833 pub healthy_instances: u32,
834 pub unavailable_instances: u32,
835 pub command_supported: bool,
836 #[serde(default)]
837 pub observed_image: Option<String>,
838 pub latest_update_timestamp: String,
839 pub daemon_instances: Vec<ManagedRuntimeUnitStatus>,
840 pub events: Vec<ManagedRuntimeEventSnapshot>,
841}
842
843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
844#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
845#[serde(rename_all = "camelCase")]
846pub struct MachinesDaemonHeartbeatData {
847 pub status: WorkloadHeartbeatStatus,
848 pub horizon_cluster_id: String,
849 #[serde(default)]
850 pub daemon_name: String,
851 pub horizon_status: String,
852 pub horizon_status_reason: Option<String>,
853 pub horizon_status_message: Option<String>,
854 pub capacity_group: String,
855 pub desired_machines: u32,
856 pub assigned_machines: u32,
857 pub healthy_instances: u32,
858 pub unavailable_instances: u32,
859 pub command_supported: bool,
860 #[serde(default)]
861 pub observed_image: Option<String>,
862 pub latest_update_timestamp: String,
863 pub daemon_instances: Vec<ManagedRuntimeUnitStatus>,
864 pub events: Vec<ManagedRuntimeEventSnapshot>,
865}
866
867#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
868#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
869#[serde(rename_all = "camelCase")]
870pub struct ManagedRuntimeUnitStatus {
871 pub replica_id: String,
872 pub name: String,
873 pub machine_id: Option<String>,
874 pub node_name: Option<String>,
875 pub ip: Option<String>,
876 pub ready: bool,
877 pub phase: Option<String>,
878 pub status: Option<String>,
879 pub reason: Option<String>,
880 pub message: Option<String>,
881 pub restart_count: Option<u32>,
882 pub waiting_reason: Option<String>,
883 pub terminated_reason: Option<String>,
884 pub metrics_healthy: Option<bool>,
885 pub metrics_status: Option<String>,
886 pub metrics_last_updated: Option<String>,
887 pub cpu: Option<MetricSample>,
888 pub memory: Option<MetricSample>,
889 #[serde(default)]
891 pub image: Option<String>,
892}
893
894#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
895#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
896#[serde(rename_all = "camelCase")]
897pub struct KubernetesDaemonHeartbeatData {
898 pub status: WorkloadHeartbeatStatus,
899 pub namespace: String,
900 pub name: String,
901 pub replicas: WorkloadReplicaStatus,
902 pub restarts: Option<u32>,
903 pub command_supported: bool,
904 pub cpu: Option<MetricSample>,
905 pub memory: Option<MetricSample>,
906 pub workload: Option<KubernetesWorkloadStatus>,
907 pub pods: Vec<KubernetesPodRuntimeUnitStatus>,
908 pub events: Vec<KubernetesEventSnapshot>,
909}
910
911#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
912#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
913#[serde(rename_all = "camelCase")]
914pub struct LocalDaemonHeartbeatData {
915 pub status: WorkloadHeartbeatStatus,
916 #[serde(default)]
917 pub daemon_name: String,
918 pub runtime_id: String,
919 pub pid: Option<u32>,
920 pub command_supported: bool,
921 pub image_path_present: bool,
922 pub restart_count: Option<u32>,
923 pub exit_reason: Option<String>,
924 pub daemon_instance: Option<LocalRuntimeUnitStatus>,
925 pub events: Vec<LocalRuntimeEventSnapshot>,
926}
927
928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
929#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
930#[serde(rename_all = "camelCase")]
931pub struct LocalRuntimeUnitStatus {
932 pub unit_id: String,
933 pub name: String,
934 pub kind: LocalRuntimeUnitKind,
935 pub ready: bool,
936 pub phase: Option<String>,
937 pub pid: Option<u32>,
938 pub restart_count: Option<u32>,
939 pub cpu: Option<MetricSample>,
940 pub memory: Option<MetricSample>,
941}
942
943#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
944#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
945#[serde(rename_all = "kebab-case")]
946pub enum LocalRuntimeUnitKind {
947 Container,
948 Process,
949 Daemon,
950}
951
952#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
953#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
954#[serde(rename_all = "camelCase")]
955pub enum KubernetesWorkloadKind {
956 Deployment,
957 StatefulSet,
958 DaemonSet,
959 ReplicaSet,
960 Pod,
961}
962
963#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
964#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
965#[serde(rename_all = "camelCase")]
966pub struct KubernetesWorkloadStatus {
967 pub desired_replicas: Option<u32>,
968 pub ready_replicas: Option<u32>,
969 pub available_replicas: Option<u32>,
970 pub updated_replicas: Option<u32>,
971 pub observed_generation: Option<i64>,
972 pub desired_generation: Option<i64>,
973 pub rollout_reason: Option<String>,
974 pub conditions: Vec<KubernetesWorkloadCondition>,
975}
976
977#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
978#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
979#[serde(rename_all = "camelCase")]
980pub struct KubernetesWorkloadCondition {
981 #[serde(rename = "type")]
982 pub condition_type: String,
983 pub status: String,
984 pub reason: Option<String>,
985 pub message: Option<String>,
986 pub last_transition_time: Option<DateTime<Utc>>,
987}
988
989#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
990#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
991#[serde(rename_all = "camelCase")]
992pub struct KubernetesPodRuntimeUnitStatus {
993 pub name: String,
994 pub uid: Option<String>,
995 pub phase: Option<String>,
996 pub ready: bool,
997 pub restart_count: u32,
998 pub waiting_reason: Option<String>,
999 pub terminated_reason: Option<String>,
1000 pub node_name: Option<String>,
1001 pub pod_ip: Option<String>,
1002 pub owner_references: Vec<KubernetesOwnerReference>,
1003 pub cpu: Option<MetricSample>,
1004 pub memory: Option<MetricSample>,
1005 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1006 pub containers: Vec<ContainerImageIdentity>,
1007}
1008
1009#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1010#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1011#[serde(rename_all = "camelCase")]
1012pub struct KubernetesOwnerReference {
1013 pub kind: String,
1014 pub name: String,
1015 pub uid: String,
1016 pub controller: bool,
1017}
1018
1019#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1020#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1021#[serde(tag = "backend", rename_all = "camelCase")]
1022pub enum ComputeClusterHeartbeatData {
1023 Aws(AwsComputeClusterHeartbeatData),
1024 Gcp(GcpComputeClusterHeartbeatData),
1025 Azure(AzureComputeClusterHeartbeatData),
1026 Machines(MachinesComputeClusterHeartbeatData),
1027 Local(LocalComputeClusterHeartbeatData),
1028}
1029
1030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1031#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1032#[serde(rename_all = "camelCase")]
1033pub struct ComputeClusterHeartbeatStatus {
1034 pub health: ObservedHealth,
1035 pub lifecycle: ProviderLifecycleState,
1036 pub message: Option<String>,
1037 pub stale: bool,
1038 pub partial: bool,
1039 pub collection_issues: Vec<HeartbeatCollectionIssue>,
1040}
1041
1042#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1043#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1044#[serde(rename_all = "camelCase")]
1045pub struct LocalComputeClusterHeartbeatData {
1046 pub status: ComputeClusterHeartbeatStatus,
1047 pub nodes: ObservedCounts,
1048 pub name: String,
1049 pub host_identifier: Option<String>,
1050 pub docker_available: bool,
1051 pub docker_version: Option<String>,
1052 pub docker_api_version: Option<String>,
1053 pub docker_os: Option<String>,
1054 pub docker_arch: Option<String>,
1055 pub network_name: Option<String>,
1056 pub network_available: bool,
1057 pub tracked_containers: Option<u32>,
1058 pub running_containers: Option<u32>,
1059}
1060
1061#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1062#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1063#[serde(rename_all = "camelCase")]
1064pub struct AwsComputeClusterHeartbeatData {
1065 pub status: ComputeClusterHeartbeatStatus,
1066 pub nodes: ObservedCounts,
1067 pub cpu: Option<MetricSample>,
1068 pub memory: Option<MetricSample>,
1069 pub name: String,
1070 pub region: Option<String>,
1071 pub backend_cluster_id: Option<String>,
1072 pub capacity_groups: Vec<ComputeCapacityGroupStatus>,
1073 pub provider_fleets: Vec<ProviderFleetStatus>,
1074}
1075
1076#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1077#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1078#[serde(rename_all = "camelCase")]
1079pub struct GcpComputeClusterHeartbeatData {
1080 pub status: ComputeClusterHeartbeatStatus,
1081 pub nodes: ObservedCounts,
1082 pub cpu: Option<MetricSample>,
1083 pub memory: Option<MetricSample>,
1084 pub name: String,
1085 pub region: Option<String>,
1086 pub backend_cluster_id: Option<String>,
1087 pub capacity_groups: Vec<ComputeCapacityGroupStatus>,
1088 pub provider_fleets: Vec<ProviderFleetStatus>,
1089}
1090
1091#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1092#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1093#[serde(rename_all = "camelCase")]
1094pub struct AzureComputeClusterHeartbeatData {
1095 pub status: ComputeClusterHeartbeatStatus,
1096 pub nodes: ObservedCounts,
1097 pub cpu: Option<MetricSample>,
1098 pub memory: Option<MetricSample>,
1099 pub name: String,
1100 pub region: Option<String>,
1101 pub backend_cluster_id: Option<String>,
1102 pub capacity_groups: Vec<ComputeCapacityGroupStatus>,
1103 pub provider_fleets: Vec<ProviderFleetStatus>,
1104}
1105
1106#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1107#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1108#[serde(rename_all = "camelCase")]
1109pub struct MachinesComputeClusterHeartbeatData {
1110 pub status: ComputeClusterHeartbeatStatus,
1111 pub nodes: ObservedCounts,
1112 pub cpu: Option<MetricSample>,
1113 pub memory: Option<MetricSample>,
1114 pub name: String,
1115 pub backend_cluster_id: Option<String>,
1116 pub capacity_groups: Vec<ComputeCapacityGroupStatus>,
1117 pub machines: Vec<MachinesComputeMachineStatus>,
1118}
1119
1120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1121#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1122#[serde(rename_all = "camelCase")]
1123pub struct MachinesComputeMachineStatus {
1124 pub machine_id: String,
1125 pub status: String,
1126 pub capacity_group: String,
1127 pub zone: String,
1128 pub public_ip: Option<String>,
1129 pub overlay_ip: Option<String>,
1130 pub last_heartbeat: String,
1131 pub horizond_version: Option<String>,
1132 pub replica_count: i64,
1133 pub cpu_cores: Option<f64>,
1134 pub memory_bytes: Option<i64>,
1135 pub drain_force: bool,
1136 pub drain_requested_at: Option<String>,
1137 pub drain_deadline_at: Option<String>,
1138 pub drained_at: Option<String>,
1139 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1140 pub drain_blockers: Vec<ComputeDrainBlocker>,
1141}
1142
1143#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1144#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1145#[serde(rename_all = "camelCase")]
1146pub struct ComputeCapacityGroupStatus {
1147 pub group_id: String,
1148 pub current_machines: u32,
1149 pub desired_machines: u32,
1150 pub min_machines: Option<u32>,
1151 pub max_machines: Option<u32>,
1152 pub instance_type: Option<String>,
1153 pub recommendation: Option<ComputeCapacityRecommendation>,
1154 pub capacity_blocker: Option<ComputeCapacityBlocker>,
1155 #[serde(default, skip_serializing_if = "Option::is_none")]
1156 pub drain_progress: Option<ComputeDrainProgress>,
1157}
1158
1159#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1160#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1161#[serde(rename_all = "camelCase")]
1162pub enum ComputeCapacityBlockerCategory {
1163 Quota,
1164 Capacity,
1165 Allocation,
1166 Other,
1167}
1168
1169#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1170#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1171#[serde(rename_all = "camelCase")]
1172pub struct ComputeCapacityBlocker {
1173 pub category: ComputeCapacityBlockerCategory,
1174 pub provider_code: Option<String>,
1175 pub message: String,
1176 pub provider_reference: Option<String>,
1177 pub observed_at: DateTime<Utc>,
1178}
1179
1180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1181#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1182#[serde(rename_all = "camelCase")]
1183pub struct ComputeCapacityRecommendation {
1184 pub desired_machines: u32,
1185 pub reason: Option<String>,
1186 pub utilization: Option<MetricSample>,
1187 pub unschedulable_replicas: Option<u32>,
1188}
1189
1190#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1191#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1192#[serde(rename_all = "camelCase")]
1193pub enum ComputeDrainProgressStatus {
1194 Draining,
1195 Drained,
1196 Terminating,
1197}
1198
1199#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1200#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1201#[serde(rename_all = "camelCase")]
1202pub struct ComputeDrainBlocker {
1203 pub workload_name: String,
1204 pub replica_id: String,
1205 pub scheduling_mode: String,
1206 pub state: String,
1207 pub reason: String,
1208}
1209
1210#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1211#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1212#[serde(rename_all = "camelCase")]
1213pub struct ComputeDrainProgress {
1214 pub machine_id: String,
1215 pub status: ComputeDrainProgressStatus,
1216 pub replica_count: i64,
1217 pub force: bool,
1218 pub stalled: bool,
1219 pub drain_requested_at: Option<String>,
1220 pub drain_deadline_at: Option<String>,
1221 pub drained_at: Option<String>,
1222 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1223 pub blockers: Vec<ComputeDrainBlocker>,
1224}
1225
1226#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1227#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1228#[serde(rename_all = "camelCase")]
1229pub struct ProviderFleetStatus {
1230 pub group_id: String,
1231 pub provider_id: String,
1232 pub location: Option<String>,
1233 pub current_machines: u32,
1234 pub desired_machines: u32,
1235}
1236
1237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1238#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1239#[serde(rename_all = "camelCase")]
1240pub struct KubernetesClusterHeartbeatData {
1241 pub status: WorkloadHeartbeatStatus,
1242 pub node_counts: ObservedCounts,
1243 pub pod_counts: ObservedCounts,
1244 pub cpu: Option<MetricSample>,
1245 pub memory: Option<MetricSample>,
1246 pub name: String,
1247 pub region: Option<String>,
1248 pub namespace: Option<String>,
1249 pub version: Option<String>,
1250 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1251 pub node_statuses: Vec<KubernetesClusterNodeStatus>,
1252 pub events: Vec<KubernetesEventSnapshot>,
1253}
1254
1255#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1256#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1257#[serde(rename_all = "camelCase")]
1258pub struct KubernetesClusterNodeStatus {
1259 pub name: String,
1260 pub uid: Option<String>,
1261 pub ready: bool,
1262 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1263 pub conditions: Vec<KubernetesNodeConditionStatus>,
1264 pub roles: Vec<String>,
1265 pub labels: BTreeMap<String, String>,
1266 pub allocatable: KubernetesNodeResources,
1267 pub capacity: KubernetesNodeResources,
1268 pub usage: Option<KubernetesNodeUsage>,
1269 pub kubelet_version: Option<String>,
1270 pub container_runtime_version: Option<String>,
1271}
1272
1273#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1274#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1275#[serde(rename_all = "camelCase")]
1276pub struct KubernetesNodeConditionStatus {
1277 pub type_: String,
1278 pub status: String,
1279 pub reason: Option<String>,
1280 pub message: Option<String>,
1281}
1282
1283#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1284#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1285#[serde(rename_all = "camelCase")]
1286pub struct KubernetesNodeResources {
1287 pub cpu: Option<MetricSample>,
1288 pub memory: Option<MetricSample>,
1289 pub pods: Option<u64>,
1290}
1291
1292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1293#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1294#[serde(rename_all = "camelCase")]
1295pub struct KubernetesNodeUsage {
1296 pub cpu: Option<MetricSample>,
1297 pub memory: Option<MetricSample>,
1298}
1299
1300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1301#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1302#[serde(tag = "backend", rename_all = "camelCase")]
1303pub enum QueueHeartbeatData {
1304 AwsSqs(AwsSqsQueueHeartbeatData),
1305 GcpPubSub(GcpPubSubQueueHeartbeatData),
1306 AzureServiceBus(AzureServiceBusQueueHeartbeatData),
1307 Local(LocalQueueHeartbeatData),
1308}
1309
1310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1311#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1312#[serde(rename_all = "camelCase")]
1313pub struct QueueHeartbeatStatus {
1314 pub health: ObservedHealth,
1315 pub lifecycle: ProviderLifecycleState,
1316 pub message: Option<String>,
1317 pub stale: bool,
1318 pub partial: bool,
1319 pub collection_issues: Vec<HeartbeatCollectionIssue>,
1320}
1321
1322impl Default for QueueHeartbeatStatus {
1323 fn default() -> Self {
1324 Self {
1325 health: ObservedHealth::Unknown,
1326 lifecycle: ProviderLifecycleState::Unknown,
1327 message: None,
1328 stale: false,
1329 partial: false,
1330 collection_issues: vec![],
1331 }
1332 }
1333}
1334
1335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1336#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1337#[serde(rename_all = "camelCase")]
1338pub struct LocalQueueHeartbeatData {
1339 pub status: QueueHeartbeatStatus,
1340 pub name: String,
1341 pub path: Option<String>,
1342 pub service_status: Option<String>,
1343}
1344
1345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
1346#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1347#[serde(rename_all = "camelCase")]
1348pub struct GcpPubSubQueueHeartbeatData {
1349 pub status: QueueHeartbeatStatus,
1350 pub topic_name: String,
1351 pub subscription_name: Option<String>,
1352 pub project_id: Option<String>,
1353 pub topic_full_name: Option<String>,
1354 pub subscription_full_name: Option<String>,
1355 pub endpoint: Option<String>,
1356 pub topic_labels: BTreeMap<String, String>,
1357 pub subscription_labels: BTreeMap<String, String>,
1358 pub message_storage_allowed_persistence_regions: Vec<String>,
1359 pub message_storage_enforce_in_transit: Option<bool>,
1360 pub kms_key_name: Option<String>,
1361 pub schema_name: Option<String>,
1362 pub schema_encoding: Option<String>,
1363 pub schema_first_revision_id: Option<String>,
1364 pub schema_last_revision_id: Option<String>,
1365 pub topic_message_retention_duration: Option<String>,
1366 pub topic_state: Option<String>,
1367 pub subscription_ack_deadline_seconds: Option<u32>,
1368 pub subscription_message_retention_duration: Option<String>,
1369 pub subscription_retain_acked_messages: Option<bool>,
1370 pub subscription_enable_message_ordering: Option<bool>,
1371 pub subscription_filter: Option<String>,
1372 pub subscription_detached: Option<bool>,
1373 pub subscription_state: Option<String>,
1374 pub subscription_push_config_present: Option<bool>,
1375 pub subscription_push_endpoint: Option<String>,
1376 pub subscription_push_attributes: BTreeMap<String, String>,
1377 pub subscription_push_oidc_service_account_email: Option<String>,
1378 pub subscription_push_oidc_audience: Option<String>,
1379 pub subscription_push_pubsub_wrapper_write_metadata: Option<bool>,
1380 pub subscription_push_no_wrapper_write_metadata: Option<bool>,
1381 pub subscription_dead_letter_topic: Option<String>,
1382 pub subscription_dead_letter_max_delivery_attempts: Option<u32>,
1383}
1384
1385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1386#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1387#[serde(rename_all = "camelCase")]
1388pub struct AzureServiceBusQueueHeartbeatData {
1389 pub status: QueueHeartbeatStatus,
1390 pub name: String,
1391 pub namespace_name: String,
1392 pub resource_group: Option<String>,
1393 pub resource_id: Option<String>,
1394 pub endpoint: Option<String>,
1395 pub queue_status: Option<String>,
1396 pub lock_duration: Option<String>,
1397 pub max_delivery_count: Option<u32>,
1398 pub requires_duplicate_detection: Option<bool>,
1399 pub duplicate_detection_history_time_window: Option<String>,
1400 pub requires_session: Option<bool>,
1401 pub dead_lettering_on_message_expiration: Option<bool>,
1402 pub forward_dead_lettered_messages_to: Option<String>,
1403 pub forward_to: Option<String>,
1404 pub default_message_time_to_live: Option<String>,
1405 pub auto_delete_on_idle: Option<String>,
1406 pub enable_batched_operations: Option<bool>,
1407 pub enable_express: Option<bool>,
1408 pub enable_partitioning: Option<bool>,
1409 pub max_message_size_in_kilobytes: Option<u64>,
1410 pub max_size_in_megabytes: Option<u32>,
1411 pub message_count: Option<u64>,
1412 pub active_message_count: Option<u64>,
1413 pub dead_letter_message_count: Option<u64>,
1414 pub scheduled_message_count: Option<u64>,
1415 pub transfer_message_count: Option<u64>,
1416 pub transfer_dead_letter_message_count: Option<u64>,
1417 pub size_in_bytes: Option<u64>,
1418 pub accessed_at: Option<String>,
1419 pub created_at: Option<String>,
1420 pub updated_at: Option<String>,
1421}
1422
1423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1424#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1425#[serde(rename_all = "camelCase")]
1426pub struct AwsSqsQueueHeartbeatData {
1427 pub status: QueueHeartbeatStatus,
1428 pub name: String,
1429 pub region: Option<String>,
1430 pub queue_url: Option<String>,
1431 pub queue_arn: Option<String>,
1432 pub visibility_timeout_seconds: Option<u32>,
1433 pub message_retention_period_seconds: Option<u32>,
1434 pub delay_seconds: Option<u32>,
1435 pub receive_message_wait_time_seconds: Option<u32>,
1436 pub maximum_message_size: Option<u32>,
1437 pub redrive_policy: Option<String>,
1438 pub redrive_allow_policy: Option<String>,
1439 pub fifo_queue: Option<bool>,
1440 pub content_based_deduplication: Option<bool>,
1441 pub deduplication_scope: Option<String>,
1442 pub fifo_throughput_limit: Option<String>,
1443 pub sse_enabled: Option<bool>,
1444 pub kms_master_key_id: Option<String>,
1445 pub kms_data_key_reuse_period_seconds: Option<u32>,
1446 pub sqs_managed_sse_enabled: Option<bool>,
1447 pub approximate_visible_messages: Option<u64>,
1448 pub approximate_in_flight_messages: Option<u64>,
1449 pub approximate_delayed_messages: Option<u64>,
1450 pub approximate_counts: bool,
1451}
1452
1453#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1454#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1455#[serde(tag = "backend", rename_all = "camelCase")]
1456pub enum KvHeartbeatData {
1457 AwsDynamoDb(AwsDynamoDbKvHeartbeatData),
1458 GcpFirestore(GcpFirestoreKvHeartbeatData),
1459 AzureTable(AzureTableKvHeartbeatData),
1460 Local(LocalKvHeartbeatData),
1461}
1462
1463#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1464#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1465#[serde(rename_all = "camelCase")]
1466pub struct KvHeartbeatStatus {
1467 pub health: ObservedHealth,
1468 pub lifecycle: ProviderLifecycleState,
1469 pub message: Option<String>,
1470 pub stale: bool,
1471 pub partial: bool,
1472 pub collection_issues: Vec<HeartbeatCollectionIssue>,
1473}
1474
1475impl Default for KvHeartbeatStatus {
1476 fn default() -> Self {
1477 Self {
1478 health: ObservedHealth::Unknown,
1479 lifecycle: ProviderLifecycleState::Unknown,
1480 message: None,
1481 stale: false,
1482 partial: false,
1483 collection_issues: vec![],
1484 }
1485 }
1486}
1487
1488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1489#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1490#[serde(rename_all = "camelCase")]
1491pub struct AwsDynamoDbKvHeartbeatData {
1492 pub status: KvHeartbeatStatus,
1493 pub name: String,
1494 pub region: Option<String>,
1495 pub table_arn: Option<String>,
1496 pub table_status: Option<String>,
1497 pub billing_mode: Option<String>,
1498 pub key_schema: Vec<AwsDynamoDbKeySchemaElement>,
1499 pub global_secondary_index_count: Option<u32>,
1500 pub local_secondary_index_count: Option<u32>,
1501 pub item_count: Option<u64>,
1502 pub table_size_bytes: Option<u64>,
1503 pub stream_enabled: Option<bool>,
1504 pub stream_view_type: Option<String>,
1505 pub ttl_status: Option<String>,
1506 pub ttl_attribute_name: Option<String>,
1507 pub deletion_protection_enabled: Option<bool>,
1508 pub sse_status: Option<String>,
1509 pub sse_type: Option<String>,
1510 pub table_class: Option<String>,
1511 pub replica_count: Option<u32>,
1512 pub restore_in_progress: Option<bool>,
1513}
1514
1515#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1516#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1517#[serde(rename_all = "camelCase")]
1518pub struct AwsDynamoDbKeySchemaElement {
1519 pub attribute_name: String,
1520 pub key_type: String,
1521}
1522
1523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1524#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1525#[serde(rename_all = "camelCase")]
1526pub struct GcpFirestoreKvHeartbeatData {
1527 pub status: KvHeartbeatStatus,
1528 pub database_name: String,
1529 pub project_id: Option<String>,
1530 pub endpoint: Option<String>,
1531 pub location_id: Option<String>,
1532 pub database_type: Option<String>,
1533 pub concurrency_mode: Option<String>,
1534 pub app_engine_integration_mode: Option<String>,
1535 pub delete_protection_state: Option<String>,
1536 pub point_in_time_recovery_enablement: Option<String>,
1537 pub version_retention_period: Option<String>,
1538 pub earliest_version_time: Option<String>,
1539 pub create_time: Option<String>,
1540 pub update_time: Option<String>,
1541 pub delete_time: Option<String>,
1542 pub database_edition: Option<String>,
1543 pub cmek_enabled: bool,
1544 pub source_info_present: bool,
1545}
1546
1547#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1548#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1549#[serde(rename_all = "camelCase")]
1550pub struct AzureTableKvHeartbeatData {
1551 pub status: KvHeartbeatStatus,
1552 pub table_name: String,
1553 pub storage_account_name: String,
1554 pub resource_group: Option<String>,
1555 pub endpoint: Option<String>,
1556 pub storage_account_resource_id: Option<String>,
1557 pub storage_account_location: Option<String>,
1558 pub storage_account_kind: Option<String>,
1559 pub storage_account_provisioning_state: Option<String>,
1560 pub storage_account_primary_status: Option<String>,
1561 pub table_exists: bool,
1562 pub signed_identifier_count: Option<u32>,
1563}
1564
1565#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1566#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1567#[serde(rename_all = "camelCase")]
1568pub struct LocalKvHeartbeatData {
1569 pub status: KvHeartbeatStatus,
1570 pub name: String,
1571 pub path: String,
1572 pub path_exists: bool,
1573 pub is_directory: Option<bool>,
1574 pub cloud_metadata_supported: bool,
1575}
1576
1577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1578#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1579#[serde(tag = "backend", rename_all = "camelCase")]
1580pub enum PostgresHeartbeatData {
1581 Aurora(AuroraPostgresHeartbeatData),
1583 CloudSql(GcpCloudSqlPostgresHeartbeatData),
1585 FlexibleServer(AzureFlexibleServerPostgresHeartbeatData),
1587 Local(LocalPostgresHeartbeatData),
1589}
1590
1591#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1592#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1593#[serde(rename_all = "camelCase")]
1594pub struct PostgresHeartbeatStatus {
1595 pub health: ObservedHealth,
1596 pub lifecycle: ProviderLifecycleState,
1597 pub message: Option<String>,
1598 pub stale: bool,
1599 pub partial: bool,
1600 pub collection_issues: Vec<HeartbeatCollectionIssue>,
1601}
1602
1603impl Default for PostgresHeartbeatStatus {
1604 fn default() -> Self {
1605 Self {
1606 health: ObservedHealth::Unknown,
1607 lifecycle: ProviderLifecycleState::Unknown,
1608 message: None,
1609 stale: false,
1610 partial: false,
1611 collection_issues: vec![],
1612 }
1613 }
1614}
1615
1616#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1619#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1620#[serde(tag = "backend", rename_all = "camelCase")]
1621pub enum RedisHeartbeatData {
1622 Elasticache(ElasticacheRedisHeartbeatData),
1624 Memorystore(MemorystoreRedisHeartbeatData),
1626 AzureManagedRedis(AzureManagedRedisHeartbeatData),
1628 Local(LocalRedisHeartbeatData),
1630}
1631
1632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1634#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1635#[serde(rename_all = "camelCase")]
1636pub struct RedisHeartbeatStatus {
1637 pub health: ObservedHealth,
1638 pub lifecycle: ProviderLifecycleState,
1639 pub message: Option<String>,
1640 pub stale: bool,
1641 pub partial: bool,
1642 pub collection_issues: Vec<HeartbeatCollectionIssue>,
1643}
1644
1645impl Default for RedisHeartbeatStatus {
1646 fn default() -> Self {
1647 Self {
1648 health: ObservedHealth::Unknown,
1649 lifecycle: ProviderLifecycleState::Unknown,
1650 message: None,
1651 stale: false,
1652 partial: false,
1653 collection_issues: vec![],
1654 }
1655 }
1656}
1657
1658#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1661#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1662#[serde(rename_all = "camelCase")]
1663pub struct RedisMetricsSample {
1664 #[serde(skip_serializing_if = "Option::is_none")]
1666 pub memory_used_percent: Option<f64>,
1667 #[serde(skip_serializing_if = "Option::is_none")]
1669 pub evictions: Option<f64>,
1670 #[serde(skip_serializing_if = "Option::is_none")]
1672 pub connected_clients: Option<f64>,
1673 #[serde(skip_serializing_if = "Option::is_none")]
1675 pub replication_lag_seconds: Option<f64>,
1676}
1677
1678#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1681#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1682#[serde(rename_all = "camelCase")]
1683pub struct RedisObservedConfig {
1684 #[serde(skip_serializing_if = "Option::is_none")]
1686 pub engine_version: Option<String>,
1687 #[serde(skip_serializing_if = "Option::is_none")]
1689 pub node_type: Option<String>,
1690 #[serde(skip_serializing_if = "Option::is_none")]
1691 pub endpoint: Option<String>,
1692 #[serde(skip_serializing_if = "Option::is_none")]
1693 pub port: Option<u16>,
1694 #[serde(skip_serializing_if = "Option::is_none")]
1695 pub eviction_policy: Option<String>,
1696 #[serde(skip_serializing_if = "Option::is_none")]
1697 pub persistence_enabled: Option<bool>,
1698 #[serde(skip_serializing_if = "Option::is_none")]
1700 pub replica_count: Option<u32>,
1701 #[serde(skip_serializing_if = "Option::is_none")]
1702 pub tls_enabled: Option<bool>,
1703 #[serde(skip_serializing_if = "Option::is_none")]
1704 pub auth_enabled: Option<bool>,
1705 #[serde(skip_serializing_if = "Option::is_none")]
1707 pub public_network_access: Option<bool>,
1708}
1709
1710#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1711#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1712#[serde(rename_all = "camelCase")]
1713pub struct ElasticacheRedisHeartbeatData {
1714 pub status: RedisHeartbeatStatus,
1715 pub replication_group_id: String,
1716 #[serde(skip_serializing_if = "Option::is_none")]
1717 pub state: Option<String>,
1718 pub config: RedisObservedConfig,
1719 pub metrics: RedisMetricsSample,
1720}
1721
1722#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1723#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1724#[serde(rename_all = "camelCase")]
1725pub struct MemorystoreRedisHeartbeatData {
1726 pub status: RedisHeartbeatStatus,
1727 pub instance_name: String,
1728 #[serde(skip_serializing_if = "Option::is_none")]
1729 pub state: Option<String>,
1730 pub config: RedisObservedConfig,
1731 pub metrics: RedisMetricsSample,
1732}
1733
1734#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1735#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1736#[serde(rename_all = "camelCase")]
1737pub struct AzureManagedRedisHeartbeatData {
1738 pub status: RedisHeartbeatStatus,
1739 pub cluster_name: String,
1740 #[serde(skip_serializing_if = "Option::is_none")]
1741 pub state: Option<String>,
1742 pub config: RedisObservedConfig,
1743 pub metrics: RedisMetricsSample,
1744}
1745
1746#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1747#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1748#[serde(rename_all = "camelCase")]
1749pub struct LocalRedisHeartbeatData {
1750 pub status: RedisHeartbeatStatus,
1751 pub name: String,
1752 pub port: Option<u16>,
1753 pub version: String,
1754 pub process_running: bool,
1755}
1756
1757#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1762#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1763#[serde(tag = "backend", rename_all = "camelCase")]
1764pub enum SandboxHeartbeatData {
1765 AwsMicrovm(AwsMicrovmSandboxHeartbeatData),
1766 AzureSandboxGroup(AzureSandboxGroupHeartbeatData),
1767 GcpAgentPlatform(GcpAgentPlatformSandboxHeartbeatData),
1768 KubernetesPods(KubernetesSandboxHeartbeatData),
1769 Local(LocalSandboxHeartbeatData),
1770}
1771
1772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1773#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1774#[serde(rename_all = "camelCase")]
1775pub struct SandboxHeartbeatStatus {
1776 pub health: ObservedHealth,
1777 pub lifecycle: ProviderLifecycleState,
1778 pub message: Option<String>,
1779 pub stale: bool,
1780 pub partial: bool,
1781 pub collection_issues: Vec<HeartbeatCollectionIssue>,
1782}
1783
1784impl Default for SandboxHeartbeatStatus {
1785 fn default() -> Self {
1786 Self {
1787 health: ObservedHealth::Healthy,
1788 lifecycle: ProviderLifecycleState::Running,
1789 message: None,
1790 stale: false,
1791 partial: false,
1792 collection_issues: Vec::new(),
1793 }
1794 }
1795}
1796
1797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1799#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1800#[serde(rename_all = "camelCase")]
1801pub struct AwsMicrovmSandboxHeartbeatData {
1802 pub status: SandboxHeartbeatStatus,
1803 pub image_identifier: String,
1805 pub image_state: Option<String>,
1812}
1813
1814#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1817#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1818#[serde(rename_all = "camelCase")]
1819pub struct AzureSandboxGroupHeartbeatData {
1820 pub status: SandboxHeartbeatStatus,
1821 pub sandbox_group: String,
1822 pub provisioning_state: Option<String>,
1823}
1824
1825#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1831#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1832#[serde(rename_all = "camelCase")]
1833pub struct GcpAgentPlatformSandboxHeartbeatData {
1834 pub status: SandboxHeartbeatStatus,
1835 pub engine: String,
1837 pub template_id: String,
1839}
1840
1841#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1843#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1844#[serde(rename_all = "camelCase")]
1845pub struct KubernetesSandboxHeartbeatData {
1846 pub status: SandboxHeartbeatStatus,
1847 pub namespace: String,
1848 pub active_sessions: u32,
1849 pub idle_pods: u32,
1851}
1852
1853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1855#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1856#[serde(rename_all = "camelCase")]
1857pub struct LocalSandboxHeartbeatData {
1858 pub status: SandboxHeartbeatStatus,
1859 pub active_sessions: u32,
1860 pub route_serving: bool,
1863}
1864
1865#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1866#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1867#[serde(tag = "backend", rename_all = "camelCase")]
1868pub enum AiHeartbeatData {
1869 AwsBedrock(AwsBedrockAiHeartbeatData),
1870 GcpVertex(GcpVertexAiHeartbeatData),
1871 AzureFoundry(AzureFoundryAiHeartbeatData),
1872 External(ExternalAiHeartbeatData),
1873}
1874
1875#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1876#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1877#[serde(rename_all = "camelCase")]
1878pub struct AiHeartbeatStatus {
1879 pub health: ObservedHealth,
1880 pub lifecycle: ProviderLifecycleState,
1881 pub message: Option<String>,
1882 pub stale: bool,
1883 pub partial: bool,
1884 pub collection_issues: Vec<HeartbeatCollectionIssue>,
1885}
1886
1887impl Default for AiHeartbeatStatus {
1888 fn default() -> Self {
1889 Self {
1891 health: ObservedHealth::Unknown,
1892 lifecycle: ProviderLifecycleState::Unknown,
1893 message: None,
1894 stale: false,
1895 partial: false,
1896 collection_issues: vec![],
1897 }
1898 }
1899}
1900
1901#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1904#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1905#[serde(rename_all = "kebab-case")]
1906pub enum AiAvailabilitySource {
1907 AwsBedrock,
1908 GcpVertex,
1909 AzureFoundry,
1910 Anthropic,
1911}
1912
1913#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1914#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1915#[serde(rename_all = "kebab-case")]
1916pub enum AiModelAvailability {
1917 Available,
1918 Blocked,
1919 Unknown,
1920}
1921
1922#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1923#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1924#[serde(rename_all = "kebab-case")]
1925pub enum AiAvailabilityBlocker {
1926 AgreementRequired,
1927 EntitlementRequired,
1928 ModelActivationRequired,
1929 DeploymentRequired,
1930 QuotaConfigurationRequired,
1931 RegionUnavailable,
1932 AccessDenied,
1933 ObservationFailed,
1934}
1935
1936#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
1937#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1938#[serde(rename_all = "kebab-case")]
1939pub enum AiAccessTest {
1940 Verified,
1941 Failed,
1942 NotChecked,
1943}
1944
1945#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1946#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1947#[serde(rename_all = "camelCase")]
1948pub struct AiModelAvailabilityObservation {
1949 pub public_model_id: String,
1950 pub client_apis: Vec<ClientApi>,
1951 pub availability: AiModelAvailability,
1952 pub blockers: Vec<AiAvailabilityBlocker>,
1953 pub access_test: AiAccessTest,
1954 #[serde(skip_serializing_if = "Option::is_none")]
1955 pub tested_at: Option<DateTime<Utc>>,
1956 #[serde(skip_serializing_if = "Option::is_none")]
1957 pub error_code: Option<String>,
1958 #[serde(default, skip_serializing_if = "Vec::is_empty")]
1961 pub quota_warnings: Vec<AiQuotaWarning>,
1962 #[serde(default, skip_serializing_if = "Option::is_none")]
1965 pub throttled_last_hour: Option<u64>,
1966}
1967
1968#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1970#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1971#[serde(rename_all = "camelCase")]
1972pub struct AiQuotaWarning {
1973 pub quota_name: String,
1974 pub applied: f64,
1975 pub default: f64,
1976}
1977
1978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1979#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1980#[serde(rename_all = "camelCase")]
1981pub struct AiAvailabilityObservation {
1982 pub source: AiAvailabilitySource,
1983 pub catalog_revision: String,
1984 #[serde(skip_serializing_if = "Option::is_none")]
1985 pub location: Option<String>,
1986 pub models: Vec<AiModelAvailabilityObservation>,
1987}
1988
1989impl AiAvailabilityObservation {
1990 pub fn unobserved(
1993 source: AiAvailabilitySource,
1994 platform: Platform,
1995 location: Option<String>,
1996 ) -> Self {
1997 Self {
1998 source,
1999 catalog_revision: crate::ai_catalog::AI_CATALOG_REVISION.to_string(),
2000 location,
2001 models: crate::ai_catalog::models_for(platform)
2002 .into_iter()
2003 .map(|model| AiModelAvailabilityObservation {
2004 public_model_id: model.public_id.to_string(),
2005 client_apis: ClientApi::ALL.to_vec(),
2006 availability: AiModelAvailability::Unknown,
2007 blockers: vec![AiAvailabilityBlocker::ObservationFailed],
2008 access_test: AiAccessTest::NotChecked,
2009 tested_at: None,
2010 error_code: None,
2011 quota_warnings: Vec::new(),
2012 throttled_last_hour: None,
2013 })
2014 .collect(),
2015 }
2016 }
2017}
2018
2019#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2020#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2021#[serde(rename_all = "camelCase")]
2022pub struct LocalPostgresHeartbeatData {
2023 pub status: PostgresHeartbeatStatus,
2024 pub name: String,
2025 pub port: Option<u16>,
2026 pub version: String,
2027 pub process_running: bool,
2028}
2029
2030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2031#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2032#[serde(rename_all = "camelCase")]
2033pub struct AuroraPostgresHeartbeatData {
2034 pub status: PostgresHeartbeatStatus,
2035 pub cluster_identifier: String,
2036 #[serde(skip_serializing_if = "Option::is_none")]
2037 pub engine_version: Option<String>,
2038 #[serde(skip_serializing_if = "Option::is_none")]
2039 pub endpoint: Option<String>,
2040 #[serde(skip_serializing_if = "Option::is_none")]
2042 pub serverless_capacity: Option<f64>,
2043 pub never_pauses: bool,
2046}
2047
2048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2049#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2050#[serde(rename_all = "camelCase")]
2051pub struct GcpCloudSqlPostgresHeartbeatData {
2052 pub status: PostgresHeartbeatStatus,
2053 pub instance_name: String,
2054 #[serde(skip_serializing_if = "Option::is_none")]
2055 pub state: Option<String>,
2056 #[serde(skip_serializing_if = "Option::is_none")]
2057 pub database_version: Option<String>,
2058}
2059
2060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2061#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2062#[serde(rename_all = "camelCase")]
2063pub struct AzureFlexibleServerPostgresHeartbeatData {
2064 pub status: PostgresHeartbeatStatus,
2065 pub server_name: String,
2066 #[serde(skip_serializing_if = "Option::is_none")]
2067 pub state: Option<String>,
2068 #[serde(skip_serializing_if = "Option::is_none")]
2069 pub version: Option<String>,
2070}
2071
2072#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2073#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2074#[serde(rename_all = "camelCase")]
2075pub struct AwsBedrockAiHeartbeatData {
2076 pub status: AiHeartbeatStatus,
2077 pub region: String,
2078 pub availability: AiAvailabilityObservation,
2079}
2080
2081#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2082#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2083#[serde(rename_all = "camelCase")]
2084pub struct GcpVertexAiHeartbeatData {
2085 pub status: AiHeartbeatStatus,
2086 pub project: String,
2087 pub location: String,
2088 pub availability: AiAvailabilityObservation,
2089}
2090
2091#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2092#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2093#[serde(rename_all = "camelCase")]
2094pub struct AzureFoundryAiHeartbeatData {
2095 pub status: AiHeartbeatStatus,
2096 pub account_name: String,
2097 pub endpoint: Option<String>,
2098 pub resource_group: Option<String>,
2099 pub location: Option<String>,
2100 pub availability: AiAvailabilityObservation,
2101}
2102
2103#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2104#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2105#[serde(rename_all = "camelCase")]
2106pub struct ExternalAiHeartbeatData {
2107 pub status: AiHeartbeatStatus,
2108 pub provider: String,
2111 #[serde(skip_serializing_if = "Option::is_none")]
2112 pub availability: Option<AiAvailabilityObservation>,
2113}
2114
2115#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2116#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2117#[serde(tag = "backend", rename_all = "camelCase")]
2118pub enum VaultHeartbeatData {
2119 AwsParameterStore(AwsParameterStoreVaultHeartbeatData),
2120 GcpSecretManager(GcpSecretManagerVaultHeartbeatData),
2121 AzureKeyVault(AzureKeyVaultHeartbeatData),
2122 KubernetesSecret(KubernetesSecretVaultHeartbeatData),
2123 Local(LocalVaultHeartbeatData),
2124}
2125
2126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2127#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2128#[serde(rename_all = "camelCase")]
2129pub struct VaultHeartbeatStatus {
2130 pub health: ObservedHealth,
2131 pub lifecycle: ProviderLifecycleState,
2132 pub message: Option<String>,
2133 pub stale: bool,
2134 pub partial: bool,
2135 pub collection_issues: Vec<HeartbeatCollectionIssue>,
2136}
2137
2138impl Default for VaultHeartbeatStatus {
2139 fn default() -> Self {
2140 Self {
2141 health: ObservedHealth::Healthy,
2142 lifecycle: ProviderLifecycleState::Running,
2143 message: None,
2144 stale: false,
2145 partial: false,
2146 collection_issues: vec![],
2147 }
2148 }
2149}
2150
2151#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2152#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2153#[serde(rename_all = "camelCase")]
2154pub struct AwsParameterStoreVaultHeartbeatData {
2155 pub status: VaultHeartbeatStatus,
2156 pub account_id: String,
2157 pub region: String,
2158 pub prefix: String,
2159 pub parameter_metadata_sampled: bool,
2160 pub sampled_parameter_count: Option<u32>,
2161 pub sampled_secure_string_count: Option<u32>,
2162 pub sampled_string_count: Option<u32>,
2163 pub sampled_string_list_count: Option<u32>,
2164 pub sampled_advanced_tier_count: Option<u32>,
2165 pub sampled_kms_key_metadata_present_count: Option<u32>,
2166 pub latest_modified_at: Option<DateTime<Utc>>,
2167 pub has_more_parameters: Option<bool>,
2168}
2169
2170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2171#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2172#[serde(rename_all = "camelCase")]
2173pub struct GcpSecretManagerVaultHeartbeatData {
2174 pub status: VaultHeartbeatStatus,
2175 pub project_id: String,
2176 pub location: String,
2177 pub prefix: String,
2178 pub secret_metadata_listed: bool,
2179}
2180
2181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2182#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2183#[serde(rename_all = "camelCase")]
2184pub struct AzureKeyVaultHeartbeatData {
2185 pub status: VaultHeartbeatStatus,
2186 pub name: String,
2187 pub resource_group: Option<String>,
2188 pub resource_id: Option<String>,
2189 pub location: Option<String>,
2190 pub vault_uri: Option<String>,
2191 pub provisioning_state: Option<String>,
2192 pub sku_family: Option<String>,
2193 pub sku_name: Option<String>,
2194 pub soft_delete_enabled: bool,
2195 pub soft_delete_retention_days: i32,
2196 pub purge_protection_enabled: Option<bool>,
2197 pub rbac_authorization_enabled: bool,
2198 pub public_network_access: String,
2199 pub access_policy_count: u32,
2200 pub private_endpoint_connection_count: u32,
2201 pub secret_metadata_listed: bool,
2202}
2203
2204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2205#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2206#[serde(rename_all = "camelCase")]
2207pub struct KubernetesSecretVaultHeartbeatData {
2208 pub status: VaultHeartbeatStatus,
2209 pub namespace: String,
2210 pub prefix: String,
2211 pub secret_metadata_listed: bool,
2212}
2213
2214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2215#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2216#[serde(rename_all = "camelCase")]
2217pub struct LocalVaultHeartbeatData {
2218 pub status: VaultHeartbeatStatus,
2219 pub path: String,
2220 pub path_exists: bool,
2221 pub is_directory: Option<bool>,
2222 pub readonly: Option<bool>,
2223 pub modified_at: Option<DateTime<Utc>>,
2224 pub secret_metadata_listed: bool,
2225}
2226
2227#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2228#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2229#[serde(tag = "backend", rename_all = "camelCase")]
2230pub enum ServiceAccountHeartbeatData {
2231 AwsIamRole(AwsIamRoleServiceAccountHeartbeatData),
2232 GcpServiceAccount(GcpServiceAccountHeartbeatData),
2233 AzureManagedIdentity(AzureManagedIdentityServiceAccountHeartbeatData),
2234 Local(LocalServiceAccountHeartbeatData),
2235}
2236
2237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2238#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2239#[serde(rename_all = "camelCase")]
2240pub struct ServiceAccountHeartbeatStatus {
2241 pub health: ObservedHealth,
2242 pub lifecycle: ProviderLifecycleState,
2243 pub message: Option<String>,
2244 pub stale: bool,
2245 pub partial: bool,
2246 pub collection_issues: Vec<HeartbeatCollectionIssue>,
2247}
2248
2249#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2250#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2251#[serde(rename_all = "camelCase")]
2252pub struct AwsIamRoleServiceAccountHeartbeatData {
2253 pub status: ServiceAccountHeartbeatStatus,
2254 pub role_name: String,
2255 pub role_arn: String,
2256 pub role_id: String,
2257 pub path: String,
2258 pub create_date: String,
2259 pub description: Option<String>,
2260 pub max_session_duration: Option<i32>,
2261 pub assume_role_policy_present: bool,
2262 pub permissions_boundary_type: Option<String>,
2263 pub permissions_boundary_arn: Option<String>,
2264 pub tag_count: u32,
2265 pub managed_tag_count: u32,
2266 pub attached_policy_count: u32,
2267 pub attached_policy_names: Vec<String>,
2268 pub inline_policy_count: u32,
2269 pub inline_policy_names: Vec<String>,
2270 pub stack_permissions_applied: bool,
2271 pub last_used_date: Option<String>,
2272 pub last_used_region: Option<String>,
2273}
2274
2275#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2276#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2277#[serde(rename_all = "camelCase")]
2278pub struct GcpServiceAccountHeartbeatData {
2279 pub status: ServiceAccountHeartbeatStatus,
2280 pub name: Option<String>,
2281 pub project_id: Option<String>,
2282 pub unique_id: Option<String>,
2283 pub email: String,
2284 pub display_name: Option<String>,
2285 pub description: Option<String>,
2286 pub oauth2_client_id: Option<String>,
2287 pub disabled: Option<bool>,
2288 pub etag: Option<String>,
2289 pub project_binding_count: u32,
2290 pub project_roles: Vec<String>,
2291 pub service_account_binding_count: u32,
2292 pub service_account_roles: Vec<String>,
2293}
2294
2295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2296#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2297#[serde(rename_all = "camelCase")]
2298pub struct AzureManagedIdentityServiceAccountHeartbeatData {
2299 pub status: ServiceAccountHeartbeatStatus,
2300 pub name: String,
2301 pub resource_id: String,
2302 pub resource_group: String,
2303 pub location: String,
2304 pub type_: Option<String>,
2305 pub client_id: Option<String>,
2306 pub principal_id: Option<String>,
2307 pub tenant_id: Option<String>,
2308 pub isolation_scope: Option<String>,
2309 pub managed_tag_count: u32,
2310 pub role_assignment_count: u32,
2311 pub role_assignment_ids: Vec<String>,
2312 pub custom_role_definition_count: u32,
2313 pub custom_role_definition_ids: Vec<String>,
2314 pub stack_permissions_applied: bool,
2315}
2316
2317#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2318#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2319#[serde(rename_all = "camelCase")]
2320pub struct LocalServiceAccountHeartbeatData {
2321 pub status: ServiceAccountHeartbeatStatus,
2322 pub identity: String,
2323 pub configured: bool,
2324}
2325
2326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2327#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2328#[serde(tag = "backend", rename_all = "camelCase")]
2329pub enum NetworkHeartbeatData {
2330 AwsVpc(AwsVpcNetworkHeartbeatData),
2331 GcpVpc(GcpVpcNetworkHeartbeatData),
2332 AzureVnet(AzureVnetNetworkHeartbeatData),
2333}
2334
2335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2336#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2337#[serde(rename_all = "camelCase")]
2338pub struct NetworkHeartbeatStatus {
2339 pub health: ObservedHealth,
2340 pub lifecycle: ProviderLifecycleState,
2341 pub message: Option<String>,
2342 pub stale: bool,
2343 pub partial: bool,
2344 pub collection_issues: Vec<HeartbeatCollectionIssue>,
2345}
2346
2347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2348#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2349#[serde(rename_all = "camelCase")]
2350pub struct AwsVpcNetworkHeartbeatData {
2351 pub status: NetworkHeartbeatStatus,
2352 pub vpc_id: Option<String>,
2353 pub vpc_state: Option<String>,
2354 pub cidr_block: Option<String>,
2355 pub public_subnet_ids: Vec<String>,
2356 pub private_subnet_ids: Vec<String>,
2357 pub availability_zones: Vec<String>,
2358 pub internet_gateway_id: Option<String>,
2359 pub nat_gateway_id: Option<String>,
2360 pub route_table_count: u32,
2361 pub security_group_id: Option<String>,
2362 pub is_byo_vpc: bool,
2363}
2364
2365#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2366#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2367#[serde(rename_all = "camelCase")]
2368pub struct GcpVpcNetworkHeartbeatData {
2369 pub status: NetworkHeartbeatStatus,
2370 pub network_name: Option<String>,
2371 pub network_self_link: Option<String>,
2372 pub subnetwork_name: Option<String>,
2373 pub subnetwork_self_link: Option<String>,
2374 pub region: Option<String>,
2375 pub cidr_block: Option<String>,
2376 pub router_name: Option<String>,
2377 pub cloud_nat_name: Option<String>,
2378 pub firewall_name: Option<String>,
2379 pub is_byo_vpc: bool,
2380}
2381
2382#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2383#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2384#[serde(rename_all = "camelCase")]
2385pub struct AzureVnetNetworkHeartbeatData {
2386 pub status: NetworkHeartbeatStatus,
2387 pub vnet_name: Option<String>,
2388 pub vnet_resource_id: Option<String>,
2389 pub resource_group: Option<String>,
2390 pub location: Option<String>,
2391 pub cidr_block: Option<String>,
2392 pub public_subnet_name: Option<String>,
2393 pub private_subnet_name: Option<String>,
2394 pub application_gateway_subnet_name: Option<String>,
2395 pub private_endpoint_subnet_name: Option<String>,
2396 pub nat_gateway_id: Option<String>,
2397 pub public_ip_id: Option<String>,
2398 pub nsg_id: Option<String>,
2399 pub is_byo_vnet: bool,
2400 pub last_byo_vnet_verification_error_code: Option<String>,
2401}
2402
2403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2404#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2405#[serde(tag = "backend", rename_all = "camelCase")]
2406pub enum RemoteStackManagementHeartbeatData {
2407 AwsIamRole(AwsRemoteStackManagementHeartbeatData),
2408 GcpServiceAccount(GcpRemoteStackManagementHeartbeatData),
2409 AzureManagedIdentity(AzureRemoteStackManagementHeartbeatData),
2410}
2411
2412#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2413#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2414#[serde(rename_all = "camelCase")]
2415pub struct RemoteStackManagementHeartbeatStatus {
2416 pub health: ObservedHealth,
2417 pub lifecycle: ProviderLifecycleState,
2418 pub message: Option<String>,
2419 pub stale: bool,
2420 pub partial: bool,
2421 pub collection_issues: Vec<HeartbeatCollectionIssue>,
2422}
2423
2424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2425#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2426#[serde(rename_all = "camelCase")]
2427pub struct AwsRemoteStackManagementHeartbeatData {
2428 pub status: RemoteStackManagementHeartbeatStatus,
2429 pub role_name: Option<String>,
2430 pub role_arn: Option<String>,
2431 pub management_permissions_applied: bool,
2432}
2433
2434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2435#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2436#[serde(rename_all = "camelCase")]
2437pub struct GcpRemoteStackManagementHeartbeatData {
2438 pub status: RemoteStackManagementHeartbeatStatus,
2439 pub service_account_email: Option<String>,
2440 pub service_account_unique_id: Option<String>,
2441 pub role_bound: bool,
2442 pub impersonation_granted: bool,
2443}
2444
2445#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2446#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2447#[serde(rename_all = "camelCase")]
2448pub struct AzureRemoteStackManagementHeartbeatData {
2449 pub status: RemoteStackManagementHeartbeatStatus,
2450 pub uami_resource_id: Option<String>,
2451 pub uami_client_id: Option<String>,
2452 pub uami_principal_id: Option<String>,
2453 pub tenant_id: Option<String>,
2454 pub fic_name: Option<String>,
2455 pub role_definition_id: Option<String>,
2456 pub role_assignment_ids: Vec<String>,
2457}
2458
2459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2460#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2461#[serde(tag = "backend", rename_all = "camelCase")]
2462pub enum ArtifactRegistryHeartbeatData {
2463 AwsEcr(AwsEcrArtifactRegistryHeartbeatData),
2464 GcpArtifactRegistry(GcpArtifactRegistryHeartbeatData),
2465 AzureContainerRegistry(AzureContainerRegistryHeartbeatData),
2466 Local(LocalArtifactRegistryHeartbeatData),
2467}
2468
2469#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2470#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2471#[serde(rename_all = "camelCase")]
2472pub struct ArtifactRegistryHeartbeatStatus {
2473 pub health: ObservedHealth,
2474 pub lifecycle: ProviderLifecycleState,
2475 pub message: Option<String>,
2476 pub stale: bool,
2477 pub partial: bool,
2478 pub collection_issues: Vec<HeartbeatCollectionIssue>,
2479}
2480
2481#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2482#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2483#[serde(rename_all = "camelCase")]
2484pub struct AwsEcrArtifactRegistryHeartbeatData {
2485 pub status: ArtifactRegistryHeartbeatStatus,
2486 pub registry_id: String,
2487 pub region: String,
2488 pub registry_uri: String,
2489 pub repository_prefix: String,
2490 pub pull_role_arn: Option<String>,
2491 pub push_role_arn: Option<String>,
2492 pub repository_count: u32,
2493 pub repositories_truncated: bool,
2494 pub repositories: Vec<AwsEcrRepositoryHeartbeatData>,
2495}
2496
2497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2498#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2499#[serde(rename_all = "camelCase")]
2500pub struct AwsEcrRepositoryHeartbeatData {
2501 pub repository_arn: String,
2502 pub registry_id: String,
2503 pub repository_name: String,
2504 pub repository_uri: String,
2505 pub created_at: f64,
2506 pub image_tag_mutability: Option<String>,
2507 pub scan_on_push: Option<bool>,
2508 pub encryption_type: Option<String>,
2509 pub kms_key_present: bool,
2510}
2511
2512#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2513#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2514#[serde(rename_all = "camelCase")]
2515pub struct GcpArtifactRegistryHeartbeatData {
2516 pub status: ArtifactRegistryHeartbeatStatus,
2517 pub project_id: String,
2518 pub location: String,
2519 pub repository_id: String,
2520 pub name: Option<String>,
2521 pub format: Option<String>,
2522 pub mode: Option<String>,
2523 pub description: Option<String>,
2524 pub label_count: u32,
2525 pub cleanup_policy_count: u32,
2526 pub cleanup_policy_dry_run: Option<bool>,
2527 pub kms_key_name_present: bool,
2528 pub size_bytes: Option<String>,
2529 pub satisfies_pzs: Option<bool>,
2530 pub create_time: Option<String>,
2531 pub update_time: Option<String>,
2532 pub iam_policy_etag_present: bool,
2533 pub iam_binding_count: u32,
2534 pub iam_roles: Vec<String>,
2535 pub pull_service_account_email: Option<String>,
2536 pub push_service_account_email: Option<String>,
2537}
2538
2539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2540#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2541#[serde(rename_all = "camelCase")]
2542pub struct AzureContainerRegistryHeartbeatData {
2543 pub status: ArtifactRegistryHeartbeatStatus,
2544 pub name: String,
2545 pub resource_id: Option<String>,
2546 pub resource_group: String,
2547 pub location: String,
2548 pub type_: Option<String>,
2549 pub login_server: Option<String>,
2550 pub sku_name: String,
2551 pub sku_tier: Option<String>,
2552 pub provisioning_state: Option<String>,
2553 pub admin_user_enabled: bool,
2554 pub anonymous_pull_enabled: bool,
2555 pub public_network_access: String,
2556 pub network_rule_bypass_options: String,
2557 pub network_rule_default_action: Option<String>,
2558 pub ip_rule_count: u32,
2559 pub encryption_status: Option<String>,
2560 pub encryption_key_vault_uri_present: bool,
2561 pub encryption_key_identifier_present: bool,
2562 pub policies_present: bool,
2563 pub policy_count: u32,
2564 pub private_endpoint_connection_count: u32,
2565 pub data_endpoint_enabled: Option<bool>,
2566 pub data_endpoint_host_names: Vec<String>,
2567 pub zone_redundancy: String,
2568 pub creation_date: Option<String>,
2569 pub managed_tag_count: u32,
2570}
2571
2572#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2573#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2574#[serde(rename_all = "camelCase")]
2575pub struct LocalArtifactRegistryHeartbeatData {
2576 pub status: ArtifactRegistryHeartbeatStatus,
2577 pub registry_url: String,
2578 pub reachable: bool,
2579}
2580
2581#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2582#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2583#[serde(tag = "backend", rename_all = "camelCase")]
2584pub enum BuildHeartbeatData {
2585 AwsCodeBuild(AwsCodeBuildHeartbeatData),
2586 GcpCloudBuild(GcpCloudBuildHeartbeatData),
2587 AzureContainerApps(AzureContainerAppsBuildHeartbeatData),
2588 KubernetesJob(KubernetesBuildHeartbeatData),
2589}
2590
2591#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2592#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2593#[serde(rename_all = "camelCase")]
2594pub struct BuildHeartbeatStatus {
2595 pub health: ObservedHealth,
2596 pub lifecycle: ProviderLifecycleState,
2597 pub message: Option<String>,
2598 pub stale: bool,
2599 pub partial: bool,
2600 pub collection_issues: Vec<HeartbeatCollectionIssue>,
2601}
2602
2603#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2604#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2605#[serde(rename_all = "camelCase")]
2606pub struct AwsCodeBuildHeartbeatData {
2607 pub status: BuildHeartbeatStatus,
2608 pub project_name: String,
2609 pub project_arn: Option<String>,
2610 pub description: Option<String>,
2611 pub source_type: Option<String>,
2612 pub artifacts_type: Option<String>,
2613 pub artifacts_encryption_disabled: Option<bool>,
2614 pub environment_type: Option<String>,
2615 pub environment_image: Option<String>,
2616 pub compute_type: Option<String>,
2617 pub image_pull_credentials_type: Option<String>,
2618 pub privileged_mode: Option<bool>,
2619 pub environment_variable_count: u32,
2620 pub service_role_present: bool,
2621 pub encryption_key_present: bool,
2622 pub cloud_watch_logs_status: Option<String>,
2623 pub s3_logs_status: Option<String>,
2624 pub timeout_in_minutes: Option<i32>,
2625 pub queued_timeout_in_minutes: Option<i32>,
2626 pub created: Option<f64>,
2627 pub last_modified: Option<f64>,
2628}
2629
2630#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2631#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2632#[serde(rename_all = "camelCase")]
2633pub struct GcpCloudBuildHeartbeatData {
2634 pub status: BuildHeartbeatStatus,
2635 pub project_id: String,
2636 pub location: String,
2637 pub build_config_id: String,
2638 pub service_account: Option<String>,
2639 pub environment_variable_count: u32,
2640}
2641
2642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2643#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2644#[serde(rename_all = "camelCase")]
2645pub struct AzureContainerAppsBuildHeartbeatData {
2646 pub status: BuildHeartbeatStatus,
2647 pub managed_environment_id: String,
2648 pub resource_group_name: String,
2649 pub managed_identity_id: Option<String>,
2650 pub resource_prefix: Option<String>,
2651 pub environment_variable_count: u32,
2652}
2653
2654#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2655#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2656#[serde(rename_all = "camelCase")]
2657pub struct KubernetesBuildHeartbeatData {
2658 pub status: BuildHeartbeatStatus,
2659 pub job_name: String,
2660 pub namespace: String,
2661 pub active: Option<i32>,
2662 pub succeeded: Option<i32>,
2663 pub failed: Option<i32>,
2664 pub start_time: Option<DateTime<Utc>>,
2665 pub completion_time: Option<DateTime<Utc>>,
2666 pub condition_count: u32,
2667 pub image_digest: Option<String>,
2668 pub events: Vec<KubernetesEventSnapshot>,
2669}
2670
2671#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2672#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2673#[serde(tag = "backend", rename_all = "camelCase")]
2674pub enum ServiceActivationHeartbeatData {
2675 GcpServiceUsage(GcpServiceUsageActivationHeartbeatData),
2676 AzureResourceProvider(AzureResourceProviderActivationHeartbeatData),
2677}
2678
2679#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2680#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2681#[serde(rename_all = "camelCase")]
2682pub struct ServiceActivationHeartbeatStatus {
2683 pub health: ObservedHealth,
2684 pub lifecycle: ProviderLifecycleState,
2685 pub message: Option<String>,
2686 pub stale: bool,
2687 pub partial: bool,
2688 pub collection_issues: Vec<HeartbeatCollectionIssue>,
2689}
2690
2691impl Default for ServiceActivationHeartbeatStatus {
2692 fn default() -> Self {
2693 Self {
2694 health: ObservedHealth::Healthy,
2695 lifecycle: ProviderLifecycleState::Running,
2696 message: None,
2697 stale: false,
2698 partial: false,
2699 collection_issues: vec![],
2700 }
2701 }
2702}
2703
2704#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2705#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2706#[serde(rename_all = "camelCase")]
2707pub struct GcpServiceUsageActivationHeartbeatData {
2708 pub status: ServiceActivationHeartbeatStatus,
2709 pub project_id: String,
2710 pub service_name: String,
2711 pub service_resource_name: Option<String>,
2712 pub title: Option<String>,
2713 pub state: Option<String>,
2714 pub enabled: bool,
2715 pub last_operation_name: Option<String>,
2716}
2717
2718#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2719#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2720#[serde(rename_all = "camelCase")]
2721pub struct AzureResourceProviderActivationHeartbeatData {
2722 pub status: ServiceActivationHeartbeatStatus,
2723 pub namespace: String,
2724 pub provider_id: Option<String>,
2725 pub registration_state: Option<String>,
2726 pub registration_policy: Option<String>,
2727 pub resource_type_count: u32,
2728 pub registered: bool,
2729}
2730
2731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2732#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2733#[serde(rename_all = "camelCase")]
2734pub struct AzureResourceGroupHeartbeatData {
2735 pub status: AzureResourceGroupHeartbeatStatus,
2736 pub name: String,
2737 pub resource_id: Option<String>,
2738 pub location: Option<String>,
2739 pub provisioning_state: Option<String>,
2740 pub managed_tags: BTreeMap<String, String>,
2741}
2742
2743#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2744#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2745#[serde(rename_all = "camelCase")]
2746pub struct AzureResourceGroupHeartbeatStatus {
2747 pub health: ObservedHealth,
2748 pub lifecycle: ProviderLifecycleState,
2749 pub message: Option<String>,
2750 pub stale: bool,
2751 pub partial: bool,
2752 pub collection_issues: Vec<HeartbeatCollectionIssue>,
2753}
2754
2755impl Default for AzureResourceGroupHeartbeatStatus {
2756 fn default() -> Self {
2757 Self {
2758 health: ObservedHealth::Healthy,
2759 lifecycle: ProviderLifecycleState::Running,
2760 message: None,
2761 stale: false,
2762 partial: false,
2763 collection_issues: vec![],
2764 }
2765 }
2766}
2767
2768#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2769#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2770#[serde(rename_all = "camelCase")]
2771pub struct AzureStorageAccountHeartbeatData {
2772 pub status: StorageHeartbeatStatus,
2773 pub name: String,
2774 pub resource_id: Option<String>,
2775 pub resource_group: Option<String>,
2776 pub location: Option<String>,
2777 pub kind: Option<String>,
2778 pub sku_name: Option<String>,
2779 pub sku_tier: Option<String>,
2780 pub provisioning_state: Option<String>,
2781 pub primary_endpoints: AzureStorageAccountEndpoints,
2782 pub secondary_endpoints: AzureStorageAccountEndpoints,
2783 pub public_network_access: Option<String>,
2784 pub allow_blob_public_access: Option<bool>,
2785 pub allow_shared_key_access: Option<bool>,
2786 pub minimum_tls_version: Option<String>,
2787 pub supports_https_traffic_only: Option<bool>,
2788 pub encryption_key_source: Option<String>,
2789 pub require_infrastructure_encryption: Option<bool>,
2790 pub network_default_action: Option<String>,
2791 pub network_bypass: Option<String>,
2792 pub network_ip_rule_count: Option<u32>,
2793 pub network_virtual_network_rule_count: Option<u32>,
2794 pub network_resource_access_rule_count: Option<u32>,
2795}
2796
2797#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
2798#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2799#[serde(rename_all = "camelCase")]
2800pub struct AzureStorageAccountEndpoints {
2801 pub blob: Option<String>,
2802 pub dfs: Option<String>,
2803 pub file: Option<String>,
2804 pub queue: Option<String>,
2805 pub table: Option<String>,
2806 pub web: Option<String>,
2807}
2808
2809#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2810#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2811#[serde(rename_all = "camelCase")]
2812pub struct AzureContainerAppsEnvironmentHeartbeatData {
2813 pub status: AzureContainerAppsEnvironmentHeartbeatStatus,
2814 pub name: String,
2815 pub resource_id: Option<String>,
2816 pub resource_group: Option<String>,
2817 pub location: Option<String>,
2818 pub kind: Option<String>,
2819 pub provisioning_state: Option<String>,
2820 pub default_domain: Option<String>,
2821 pub static_ip: Option<String>,
2822 pub custom_domain_verification_id: Option<String>,
2823 pub infrastructure_resource_group: Option<String>,
2824 pub event_stream_endpoint: Option<String>,
2825 pub zone_redundant: Option<bool>,
2826 pub workload_profile_count: u32,
2827 pub workload_profiles: Vec<AzureContainerAppsEnvironmentWorkloadProfile>,
2828}
2829
2830#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2831#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2832#[serde(rename_all = "camelCase")]
2833pub struct AzureContainerAppsEnvironmentHeartbeatStatus {
2834 pub health: ObservedHealth,
2835 pub lifecycle: ProviderLifecycleState,
2836 pub message: Option<String>,
2837 pub stale: bool,
2838 pub partial: bool,
2839 pub collection_issues: Vec<HeartbeatCollectionIssue>,
2840}
2841
2842#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
2843#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2844#[serde(rename_all = "camelCase")]
2845pub struct AzureContainerAppsEnvironmentWorkloadProfile {
2846 pub name: String,
2847 pub workload_profile_type: String,
2848 pub minimum_count: Option<i32>,
2849 pub maximum_count: Option<i32>,
2850}
2851
2852#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2853#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2854#[serde(rename_all = "camelCase")]
2855pub struct AzureServiceBusNamespaceHeartbeatData {
2856 pub status: QueueHeartbeatStatus,
2857 pub name: String,
2858 pub resource_id: Option<String>,
2859 pub resource_group: Option<String>,
2860 pub location: Option<String>,
2861 pub sku_name: Option<String>,
2862 pub sku_tier: Option<String>,
2863 pub sku_capacity: Option<i32>,
2864 pub namespace_status: Option<String>,
2865 pub provisioning_state: Option<String>,
2866 pub service_bus_endpoint: Option<String>,
2867 pub metric_id: Option<String>,
2868 pub public_network_access: Option<String>,
2869 pub disable_local_auth: Option<bool>,
2870 pub minimum_tls_version: Option<String>,
2871 pub premium_messaging_partitions: Option<i32>,
2872 pub private_endpoint_connection_count: u32,
2873 pub zone_redundant: Option<bool>,
2874 pub created_at: Option<String>,
2875 pub updated_at: Option<String>,
2876}
2877
2878#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
2879#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
2880#[serde(rename_all = "camelCase")]
2881pub struct NamedResourceDetail {
2882 pub name: String,
2883 pub region: Option<String>,
2884}
2885
2886#[cfg(test)]
2887mod tests {
2888 use super::*;
2889 use chrono::TimeZone as _;
2890 use serde_json::json;
2891
2892 fn observed_at() -> DateTime<Utc> {
2893 Utc.with_ymd_and_hms(2026, 5, 28, 10, 30, 0).unwrap()
2894 }
2895
2896 fn workload_status() -> WorkloadHeartbeatStatus {
2897 WorkloadHeartbeatStatus {
2898 health: ObservedHealth::Healthy,
2899 lifecycle: ProviderLifecycleState::Running,
2900 message: None,
2901 stale: false,
2902 partial: false,
2903 collection_issues: vec![],
2904 }
2905 }
2906
2907 fn workload_replicas() -> WorkloadReplicaStatus {
2908 WorkloadReplicaStatus {
2909 desired: Some(2),
2910 current: Some(2),
2911 ready: Some(1),
2912 available: Some(1),
2913 updated: Some(2),
2914 misscheduled: None,
2915 }
2916 }
2917
2918 fn heartbeat(data: ResourceHeartbeatData, resource_type: &str) -> ResourceHeartbeat {
2919 ResourceHeartbeat {
2920 deployment_id: Some("dep_123".to_string()),
2921 resource_id: "api".to_string(),
2922 resource_type: ResourceType::from(resource_type),
2923 controller_platform: Platform::Kubernetes,
2924 backend: HeartbeatBackend::Kubernetes,
2925 observed_at: observed_at(),
2926 data,
2927 raw: vec![RawHeartbeatSnippet {
2928 source: "kubernetes/apps/v1/deployments/api".to_string(),
2929 format: RawHeartbeatSnippetFormat::Json,
2930 collected_at: observed_at(),
2931 body: r#"{"readyReplicas":1}"#.to_string(),
2932 truncated: false,
2933 }],
2934 }
2935 }
2936
2937 #[test]
2938 fn resource_heartbeat_roundtrips_managed_resource_data() {
2939 let heartbeat_json = serde_json::to_value(heartbeat(
2940 ResourceHeartbeatData::Container(ContainerHeartbeatData::Kubernetes(
2941 KubernetesContainerHeartbeatData {
2942 status: workload_status(),
2943 namespace: "default".to_string(),
2944 name: "api".to_string(),
2945 workload_kind: KubernetesWorkloadKind::Deployment,
2946 replicas: workload_replicas(),
2947 restarts: None,
2948 cpu: None,
2949 memory: None,
2950 workload: None,
2951 pods: vec![],
2952 events: vec![],
2953 },
2954 )),
2955 "container",
2956 ))
2957 .unwrap();
2958
2959 let parsed: ResourceHeartbeat = serde_json::from_value(heartbeat_json).unwrap();
2960 assert_eq!(parsed.resource_id, "api");
2961 assert!(matches!(
2962 parsed.data,
2963 ResourceHeartbeatData::Container(ContainerHeartbeatData::Kubernetes(_))
2964 ));
2965 }
2966
2967 #[test]
2968 fn local_daemon_heartbeat_defaults_missing_daemon_name() {
2969 let mut value =
2970 serde_json::to_value(DaemonHeartbeatData::Local(LocalDaemonHeartbeatData {
2971 status: workload_status(),
2972 daemon_name: "agent".to_string(),
2973 runtime_id: "local-agent".to_string(),
2974 pid: None,
2975 command_supported: false,
2976 image_path_present: true,
2977 restart_count: None,
2978 exit_reason: None,
2979 daemon_instance: None,
2980 events: vec![],
2981 }))
2982 .unwrap();
2983
2984 value.as_object_mut().unwrap().remove("daemonName");
2985
2986 let parsed: DaemonHeartbeatData = serde_json::from_value(value).unwrap();
2987 match parsed {
2988 DaemonHeartbeatData::Local(data) => assert_eq!(data.daemon_name, ""),
2989 other => panic!("expected local daemon heartbeat, got {other:?}"),
2990 }
2991 }
2992
2993 #[test]
2994 fn container_heartbeat_serializes_resource_first_data() {
2995 let heartbeat = heartbeat(
2996 ResourceHeartbeatData::Container(ContainerHeartbeatData::Kubernetes(
2997 KubernetesContainerHeartbeatData {
2998 status: workload_status(),
2999 namespace: "default".to_string(),
3000 name: "api".to_string(),
3001 workload_kind: KubernetesWorkloadKind::Deployment,
3002 replicas: workload_replicas(),
3003 restarts: Some(1),
3004 cpu: Some(MetricSample {
3005 value: 0.5,
3006 unit: MetricUnit::Cores,
3007 }),
3008 memory: None,
3009 workload: None,
3010 pods: vec![],
3011 events: vec![],
3012 },
3013 )),
3014 "container",
3015 );
3016
3017 let value = serde_json::to_value(&heartbeat).unwrap();
3018
3019 assert_eq!(value["resourceType"], "container");
3020 assert_eq!(value["data"]["resourceType"], "container");
3021 assert_eq!(value["data"]["data"]["backend"], "kubernetes");
3022 assert_eq!(value["raw"][0]["body"], r#"{"readyReplicas":1}"#);
3023 assert!(value.get("collection").is_none());
3024 assert!(value["data"]["data"].get("summary").is_none());
3025 assert!(value["data"]["data"].get("detail").is_none());
3026 }
3027
3028 #[test]
3029 fn representative_workload_data_has_stable_tags() {
3030 let daemon = serde_json::to_value(ResourceHeartbeatData::Daemon(
3031 DaemonHeartbeatData::Kubernetes(KubernetesDaemonHeartbeatData {
3032 status: workload_status(),
3033 namespace: "default".to_string(),
3034 name: "agent".to_string(),
3035 replicas: workload_replicas(),
3036 restarts: Some(0),
3037 command_supported: true,
3038 cpu: None,
3039 memory: None,
3040 workload: None,
3041 pods: vec![],
3042 events: vec![],
3043 }),
3044 ))
3045 .unwrap();
3046 let worker = serde_json::to_value(ResourceHeartbeatData::Worker(
3047 WorkerHeartbeatData::AwsLambda(AwsLambdaWorkerHeartbeatData {
3048 status: workload_status(),
3049 function_name: "handler".to_string(),
3050 runtime: Some("nodejs22.x".to_string()),
3051 package_type: None,
3052 memory_size_mb: None,
3053 timeout_seconds: None,
3054 version: None,
3055 revision_id: None,
3056 last_modified: None,
3057 state: None,
3058 state_reason: None,
3059 state_reason_code: None,
3060 last_update_status: None,
3061 last_update_status_reason: None,
3062 last_update_status_reason_code: None,
3063 code_sha256: None,
3064 layer_count: 0,
3065 function_url_auth_type: None,
3066 function_url_cors_present: false,
3067 trigger_count: 0,
3068 }),
3069 ))
3070 .unwrap();
3071
3072 assert_eq!(daemon["resourceType"], "daemon");
3073 assert_eq!(daemon["data"]["backend"], "kubernetes");
3074 assert_eq!(worker["resourceType"], "worker");
3075 assert_eq!(worker["data"]["backend"], "awsLambda");
3076 }
3077
3078 #[test]
3081 fn gcp_sandbox_heartbeat_keeps_its_wire_tag_and_camel_case_names() {
3082 let data = ResourceHeartbeatData::Sandbox(SandboxHeartbeatData::GcpAgentPlatform(
3083 GcpAgentPlatformSandboxHeartbeatData {
3084 status: SandboxHeartbeatStatus::default(),
3085 engine: "eng".to_string(),
3086 template_id: "tpl1".to_string(),
3087 },
3088 ));
3089
3090 let value = serde_json::to_value(&data).unwrap();
3091 assert_eq!(
3092 value,
3093 json!({
3094 "resourceType": "sandbox",
3095 "data": {
3096 "backend": "gcpAgentPlatform",
3097 "status": {
3098 "health": "healthy",
3099 "lifecycle": "running",
3100 "message": null,
3101 "stale": false,
3102 "partial": false,
3103 "collectionIssues": []
3104 },
3105 "engine": "eng",
3106 "templateId": "tpl1"
3107 }
3108 })
3109 );
3110
3111 let parsed: ResourceHeartbeatData = serde_json::from_value(value).unwrap();
3112 assert_eq!(parsed, data);
3113 }
3114
3115 #[test]
3116 fn representative_cluster_and_data_variants_have_optional_counts() {
3117 let cluster = serde_json::to_value(ResourceHeartbeatData::KubernetesCluster(
3118 KubernetesClusterHeartbeatData {
3119 status: WorkloadHeartbeatStatus {
3120 health: ObservedHealth::Healthy,
3121 lifecycle: ProviderLifecycleState::Running,
3122 message: None,
3123 stale: false,
3124 partial: false,
3125 collection_issues: vec![],
3126 },
3127 node_counts: ObservedCounts {
3128 desired: Some(3),
3129 current: Some(3),
3130 ready: None,
3131 },
3132 pod_counts: ObservedCounts {
3133 desired: None,
3134 current: Some(12),
3135 ready: Some(11),
3136 },
3137 cpu: None,
3138 memory: None,
3139 name: "prod".to_string(),
3140 region: Some("us-east-1".to_string()),
3141 namespace: None,
3142 version: Some("1.33".to_string()),
3143 node_statuses: vec![],
3144 events: vec![],
3145 },
3146 ))
3147 .unwrap();
3148 let queue = serde_json::to_value(ResourceHeartbeatData::Queue(QueueHeartbeatData::AwsSqs(
3149 AwsSqsQueueHeartbeatData {
3150 status: QueueHeartbeatStatus {
3151 health: ObservedHealth::Healthy,
3152 lifecycle: ProviderLifecycleState::Running,
3153 message: None,
3154 stale: false,
3155 partial: false,
3156 collection_issues: vec![],
3157 },
3158 name: "jobs".to_string(),
3159 region: Some("us-east-1".to_string()),
3160 queue_url: Some("https://sqs.us-east-1.amazonaws.com/123/jobs".to_string()),
3161 queue_arn: Some("arn:aws:sqs:us-east-1:123:jobs".to_string()),
3162 visibility_timeout_seconds: Some(30),
3163 message_retention_period_seconds: Some(345600),
3164 delay_seconds: Some(0),
3165 receive_message_wait_time_seconds: Some(0),
3166 maximum_message_size: Some(262144),
3167 redrive_policy: None,
3168 redrive_allow_policy: None,
3169 fifo_queue: Some(false),
3170 content_based_deduplication: None,
3171 deduplication_scope: None,
3172 fifo_throughput_limit: None,
3173 sse_enabled: Some(false),
3174 kms_master_key_id: None,
3175 kms_data_key_reuse_period_seconds: None,
3176 sqs_managed_sse_enabled: Some(false),
3177 approximate_visible_messages: Some(42),
3178 approximate_in_flight_messages: Some(1),
3179 approximate_delayed_messages: Some(0),
3180 approximate_counts: true,
3181 },
3182 )))
3183 .unwrap();
3184 let storage = serde_json::to_value(ResourceHeartbeatData::Storage(
3185 StorageHeartbeatData::AwsS3(AwsS3StorageHeartbeatData {
3186 status: StorageHeartbeatStatus {
3187 health: ObservedHealth::Healthy,
3188 lifecycle: ProviderLifecycleState::Running,
3189 message: None,
3190 stale: false,
3191 partial: false,
3192 collection_issues: vec![],
3193 },
3194 name: "assets".to_string(),
3195 region: Some("us-east-1".to_string()),
3196 bucket_location: Some("us-east-1".to_string()),
3197 versioning_status: Some("Enabled".to_string()),
3198 versioning_enabled: Some(true),
3199 lifecycle_present: false,
3200 lifecycle_rule_count: Some(0),
3201 encryption_config_present: true,
3202 encryption_enabled: Some(true),
3203 public_access_block_present: true,
3204 block_public_acls: Some(true),
3205 ignore_public_acls: Some(true),
3206 block_public_policy: Some(true),
3207 restrict_public_buckets: Some(true),
3208 bucket_policy_present: Some(false),
3209 bucket_acl_present: Some(true),
3210 }),
3211 ))
3212 .unwrap();
3213 let gcp_storage = serde_json::to_value(ResourceHeartbeatData::Storage(
3214 StorageHeartbeatData::GcpCloudStorage(GcpCloudStorageHeartbeatData {
3215 status: StorageHeartbeatStatus {
3216 health: ObservedHealth::Healthy,
3217 lifecycle: ProviderLifecycleState::Running,
3218 message: None,
3219 stale: false,
3220 partial: false,
3221 collection_issues: vec![],
3222 },
3223 name: "assets".to_string(),
3224 bucket_id: Some("project/assets".to_string()),
3225 location: Some("US".to_string()),
3226 location_type: Some("multi-region".to_string()),
3227 storage_class: Some("STANDARD".to_string()),
3228 versioning_enabled: Some(true),
3229 lifecycle_present: false,
3230 lifecycle_rule_count: Some(0),
3231 retention_policy_effective_time: None,
3232 retention_policy_is_locked: None,
3233 retention_period: None,
3234 soft_delete_retention_duration_seconds: None,
3235 soft_delete_effective_time: None,
3236 uniform_bucket_level_access_enabled: Some(true),
3237 uniform_bucket_level_access_locked_time: None,
3238 public_access_prevention: Some("enforced".to_string()),
3239 encryption_config_present: true,
3240 default_kms_key_name: Some(
3241 "projects/p/locations/l/keyRings/r/cryptoKeys/k".to_string(),
3242 ),
3243 }),
3244 ))
3245 .unwrap();
3246 let kv = serde_json::to_value(ResourceHeartbeatData::Kv(KvHeartbeatData::AwsDynamoDb(
3247 AwsDynamoDbKvHeartbeatData {
3248 status: KvHeartbeatStatus {
3249 health: ObservedHealth::Healthy,
3250 lifecycle: ProviderLifecycleState::Running,
3251 message: None,
3252 stale: false,
3253 partial: false,
3254 collection_issues: vec![],
3255 },
3256 name: "state".to_string(),
3257 region: Some("us-east-1".to_string()),
3258 table_arn: None,
3259 table_status: Some("ACTIVE".to_string()),
3260 billing_mode: Some("PAY_PER_REQUEST".to_string()),
3261 key_schema: vec![AwsDynamoDbKeySchemaElement {
3262 attribute_name: "pk".to_string(),
3263 key_type: "HASH".to_string(),
3264 }],
3265 global_secondary_index_count: Some(0),
3266 local_secondary_index_count: Some(0),
3267 item_count: None,
3268 table_size_bytes: None,
3269 stream_enabled: Some(false),
3270 stream_view_type: None,
3271 ttl_status: Some("ENABLED".to_string()),
3272 ttl_attribute_name: Some("ttl".to_string()),
3273 deletion_protection_enabled: Some(false),
3274 sse_status: Some("ENABLED".to_string()),
3275 sse_type: Some("KMS".to_string()),
3276 table_class: None,
3277 replica_count: Some(0),
3278 restore_in_progress: None,
3279 },
3280 )))
3281 .unwrap();
3282
3283 assert_eq!(cluster["resourceType"], "kubernetes-cluster");
3284 assert!(cluster["data"].get("summary").is_none());
3285 assert!(cluster["data"].get("detail").is_none());
3286 assert_eq!(cluster["data"]["name"], "prod");
3287 assert_eq!(queue["data"]["backend"], "awsSqs");
3288 assert_eq!(queue["data"]["approximateVisibleMessages"], 42);
3289 assert!(queue["data"].get("summary").is_none());
3290 assert_eq!(storage["data"]["backend"], "awsS3");
3291 assert!(storage["data"].get("summary").is_none());
3292 assert_eq!(gcp_storage["data"]["backend"], "gcpCloudStorage");
3293 assert_eq!(gcp_storage["data"]["publicAccessPrevention"], "enforced");
3294 assert_eq!(kv["data"]["backend"], "awsDynamoDb");
3295 assert!(kv["data"].get("summary").is_none());
3296 assert_eq!(kv["data"]["itemCount"], json!(null));
3297 }
3298
3299 #[test]
3300 fn ai_heartbeat_serializes_stable_tags() {
3301 let aws = serde_json::to_value(ResourceHeartbeatData::Ai(AiHeartbeatData::AwsBedrock(
3302 AwsBedrockAiHeartbeatData {
3303 status: AiHeartbeatStatus::default(),
3304 region: "us-east-1".to_string(),
3305 availability: AiAvailabilityObservation::unobserved(
3306 AiAvailabilitySource::AwsBedrock,
3307 Platform::Aws,
3308 Some("us-east-1".to_string()),
3309 ),
3310 },
3311 )))
3312 .unwrap();
3313 let gcp = serde_json::to_value(ResourceHeartbeatData::Ai(AiHeartbeatData::GcpVertex(
3314 GcpVertexAiHeartbeatData {
3315 status: AiHeartbeatStatus::default(),
3316 project: "my-project".to_string(),
3317 location: "us-central1".to_string(),
3318 availability: AiAvailabilityObservation::unobserved(
3319 AiAvailabilitySource::GcpVertex,
3320 Platform::Gcp,
3321 Some("us-central1".to_string()),
3322 ),
3323 },
3324 )))
3325 .unwrap();
3326 let azure = serde_json::to_value(ResourceHeartbeatData::Ai(AiHeartbeatData::AzureFoundry(
3327 AzureFoundryAiHeartbeatData {
3328 status: AiHeartbeatStatus::default(),
3329 account_name: "my-ai-account".to_string(),
3330 endpoint: Some("https://my-ai-account.openai.azure.com/".to_string()),
3331 resource_group: Some("my-rg".to_string()),
3332 location: Some("eastus".to_string()),
3333 availability: AiAvailabilityObservation::unobserved(
3334 AiAvailabilitySource::AzureFoundry,
3335 Platform::Azure,
3336 Some("eastus".to_string()),
3337 ),
3338 },
3339 )))
3340 .unwrap();
3341
3342 assert_eq!(aws["resourceType"], "ai");
3343 assert_eq!(aws["data"]["backend"], "awsBedrock");
3344 assert_eq!(aws["data"]["region"], "us-east-1");
3345 assert!(aws["data"].get("summary").is_none());
3346
3347 assert_eq!(gcp["resourceType"], "ai");
3348 assert_eq!(gcp["data"]["backend"], "gcpVertex");
3349 assert_eq!(gcp["data"]["project"], "my-project");
3350 assert_eq!(gcp["data"]["location"], "us-central1");
3351
3352 assert_eq!(azure["resourceType"], "ai");
3353 assert_eq!(azure["data"]["backend"], "azureFoundry");
3354 assert_eq!(azure["data"]["accountName"], "my-ai-account");
3355 assert_eq!(
3356 azure["data"]["endpoint"],
3357 "https://my-ai-account.openai.azure.com/"
3358 );
3359 }
3360}