Skip to main content

alien_core/
heartbeat.rs

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    /// Alien resource id, such as the `alien.Container` or `alien.Storage`
14    /// resource id from the stack.
15    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    /// Writer/source for this inventory pass, such as `operator` or
29    /// `manager-observer`.
30    pub source_kind: String,
31    /// Stable scope for the provider list operation that produced this batch.
32    pub inventory_scope: String,
33    /// Platform whose observer produced this snapshot.
34    pub controller_platform: Platform,
35    /// Backend whose observer produced this snapshot.
36    pub backend: HeartbeatBackend,
37    /// Time the inventory scope was observed.
38    pub observed_at: DateTime<Utc>,
39    /// Whether this batch is a complete replacement for the scope. Complete
40    /// batches tombstone previously observed rows in the same scope when they
41    /// are absent from `resources`.
42    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    /// Provider-native stable identity: Kubernetes object identity, cloud ARN,
52    /// GCP full resource name, Azure resource id, etc.
53    pub raw_identity: String,
54    /// Provider-native kind, such as `apps/v1/Deployment`,
55    /// `AWS::S3::Bucket`, `storage.googleapis.com/Bucket`, or an Azure
56    /// resource type.
57    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    /// Release/version identity observed from the provider resource, when available.
68    #[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    /// Distinct container images the resource's running instances report, when
89    /// the provider exposes them.
90    #[serde(default, skip_serializing_if = "Vec::is_empty")]
91    pub images: Vec<ContainerImageIdentity>,
92}
93
94/// Image a running container reports.
95#[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    /// Container name.
100    pub name: String,
101    /// Image reference reported by the container runtime.
102    pub image: String,
103    /// Registry manifest digest in `sha256:<hex>` form, when the runtime
104    /// reports one.
105    #[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    /// Image this replica runs.
890    #[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    /// AWS Aurora Serverless v2 backend.
1582    Aurora(AuroraPostgresHeartbeatData),
1583    /// GCP Cloud SQL backend.
1584    CloudSql(GcpCloudSqlPostgresHeartbeatData),
1585    /// Azure Flexible Server backend.
1586    FlexibleServer(AzureFlexibleServerPostgresHeartbeatData),
1587    /// Local embedded Postgres backend.
1588    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/// Heartbeat data for a Redis resource. Everything comes from the cloud's
1617/// management and metrics APIs; the manager never opens a Redis connection.
1618#[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    /// AWS ElastiCache for Valkey.
1623    Elasticache(ElasticacheRedisHeartbeatData),
1624    /// GCP Memorystore for Valkey.
1625    Memorystore(MemorystoreRedisHeartbeatData),
1626    /// Azure Managed Redis.
1627    AzureManagedRedis(AzureManagedRedisHeartbeatData),
1628    /// Local Valkey container.
1629    Local(LocalRedisHeartbeatData),
1630}
1631
1632/// Same fields as every other resource heartbeat status.
1633#[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/// One sample of the numbers that matter for a Redis server. A field is `None`
1659/// when the cloud did not return that metric in the window.
1660#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1661#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1662#[serde(rename_all = "camelCase")]
1663pub struct RedisMetricsSample {
1664    /// Memory used as a percentage of the configured maximum (0-100).
1665    #[serde(skip_serializing_if = "Option::is_none")]
1666    pub memory_used_percent: Option<f64>,
1667    /// Keys evicted during the sampled window.
1668    #[serde(skip_serializing_if = "Option::is_none")]
1669    pub evictions: Option<f64>,
1670    /// Connected clients at the end of the window.
1671    #[serde(skip_serializing_if = "Option::is_none")]
1672    pub connected_clients: Option<f64>,
1673    /// Replication lag in seconds, when a replica exists.
1674    #[serde(skip_serializing_if = "Option::is_none")]
1675    pub replication_lag_seconds: Option<f64>,
1676}
1677
1678/// Configuration the controller reads back from the cloud, to compare with the
1679/// desired configuration.
1680#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
1681#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
1682#[serde(rename_all = "camelCase")]
1683pub struct RedisObservedConfig {
1684    /// Engine name and version as the cloud reports it.
1685    #[serde(skip_serializing_if = "Option::is_none")]
1686    pub engine_version: Option<String>,
1687    /// Node type or SKU name.
1688    #[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    /// Replicas behind the primary.
1699    #[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    /// Azure only: true when the server accepts connections from the public internet.
1706    #[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/// Content-free telemetry about what a sandbox resource is running.
1758///
1759/// Never anything from inside a sandbox. A controller reaches only the cloud's management APIs,
1760/// and the whole point of the resource is that the control plane cannot see what runs in it.
1761#[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/// AWS: the image a sandbox runs from, and the lifecycle state AWS reports for it.
1798#[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    /// Image the sandboxes belong to.
1804    pub image_identifier: String,
1805    /// The image's own lifecycle state, which is where AWS surfaces base-image deprecation.
1806    ///
1807    /// No sandbox count sits beside it: counting means `lambda:ListMicrovms`, which authorizes
1808    /// against no resource type and so cannot be granted without an account-wide reach the
1809    /// permission sets refuse. A field only an over-broad grant could fill is a field whose
1810    /// implementer ships AccessDenied into a customer's account.
1811    pub image_state: Option<String>,
1812}
1813
1814/// Azure: the sandbox group's ARM state. The data plane has no list operation, so a sandbox count
1815/// is not available here.
1816#[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/// GCP: the Agent Platform template sandboxes are cut from, and the engine it hangs under.
1826///
1827/// No sandbox count: that needs `aiplatform.sandboxEnvironments.list`, which only the management
1828/// permission set holds. No template state either — emission is gated on reading it `ACTIVE`,
1829/// which is what `status` already says.
1830#[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    /// Reasoning engine the template hangs under, without which the template id names nothing.
1836    pub engine: String,
1837    /// The template sandboxes are currently cut from.
1838    pub template_id: String,
1839}
1840
1841/// Kubernetes: pods carrying the sandbox label, in the deployment's namespace.
1842#[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    /// Claimed but unused pods waiting in the pool.
1850    pub idle_pods: u32,
1851}
1852
1853/// Local: containers Docker still holds for this sandbox.
1854#[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    /// Whether the loopback route is serving in this process. False after a manager restart until
1861    /// the next tick rebinds it.
1862    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        // A configured AI binding is not proof that its models are usable.
1890        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/// Provider control plane used to observe model availability without invoking
1902/// a model, spending customer quota, or accepting provider terms.
1903#[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    /// Applied quotas far below the cloud's default for this model. Empty when none were read
1959    /// or none are low.
1960    #[serde(default, skip_serializing_if = "Vec::is_empty")]
1961    pub quota_warnings: Vec<AiQuotaWarning>,
1962    /// Requests the cloud throttled for this model in the last hour, from the cloud's own
1963    /// metrics. `None` when not read; `Some(0)` is a real zero.
1964    #[serde(default, skip_serializing_if = "Option::is_none")]
1965    pub throttled_last_hour: Option<u64>,
1966}
1967
1968/// One quota the account has set well below the cloud's default (under 10%).
1969#[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    /// Conservative observation used until a provider control-plane read has
1991    /// completed. It never claims that a configured model is usable.
1992    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    /// Latest sampled `ServerlessDatabaseCapacity` (ACU).
2041    #[serde(skip_serializing_if = "Option::is_none")]
2042    pub serverless_capacity: Option<f64>,
2043    /// True when a `minCapacity: 0` instance has not reached 0 ACU over the observation
2044    /// window — it is silently paying always-on prices (auto-pause verification).
2045    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    /// The BYO-key provider serving this binding (e.g. "openai"). Used on the Local
2109    /// platform, where the app brings its own provider key instead of an ambient cloud.
2110    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    /// A variant that compiles can still be unreadable on the wire: the transport round-trips every
3079    /// heartbeat through the generated manager type, which matches on the tag string alone.
3080    #[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}