container meta lazy client to avoid block_on

Author: fredr

runtimes/core/src/metadata/mod.rs

@@ -2,9 +2,44 @@ use std::collections::HashMap;
 
 use crate::encore::runtime::v1::{environment::Cloud, Environment};
 use anyhow::Context;
+use tokio::sync::OnceCell;
 
 mod gce;
 
+#[derive(Debug)]
+pub struct ContainerMetaClient {
+    cell: OnceCell<ContainerMetadata>,
+    env: Environment,
+    http_client: reqwest::Client,
+    fallback: ContainerMetadata,
+}
+
+impl ContainerMetaClient {
+    pub fn new(env: Environment, http_client: reqwest::Client) -> Self {
+        Self {
+            cell: OnceCell::new(),
+            fallback: ContainerMetadata {
+                env_name: env.env_name.clone(),
+                ..Default::default()
+            },
+            env,
+            http_client,
+        }
+    }
+
+    pub async fn collect(&self) -> &ContainerMetadata {
+        self.cell
+            .get_or_try_init(|| async {
+                ContainerMetadata::collect(&self.env, &self.http_client).await
+            })
+            .await
+            .unwrap_or_else(|err| {
+                log::warn!("failed to fetch container metadata: {err}");
+                &self.fallback
+            })
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct ContainerMetadata {
     pub service_id: String,

runtimes/core/src/metrics/exporter/gcp.rs

@@ -1,4 +1,4 @@
-use crate::metadata::ContainerMetadata;
+use crate::metadata::ContainerMetaClient;
 use crate::metrics::exporter::Exporter;
 use crate::metrics::{CollectedMetric, MetricValue};
 use anyhow::Context;
@@ -17,7 +17,7 @@ pub struct Gcp {
     monitored_resource_type: String,
     monitored_resource_labels: HashMap<String, String>,
     metric_names: HashMap<String, String>,
-    container_meta: ContainerMetadata,
+    container_meta_client: Arc<ContainerMetaClient>,
 }
 
 #[derive(Debug)]
@@ -51,15 +51,15 @@ impl Gcp {
         monitored_resource_type: String,
         monitored_resource_labels: HashMap<String, String>,
         metric_names: HashMap<String, String>,
-        container_meta: ContainerMetadata,
+        container_meta_client: ContainerMetaClient,
     ) -> Self {
         Self {
             client: Arc::new(LazyMonitoringClient::new()),
             project_id,
             monitored_resource_type,
             monitored_resource_labels,
             metric_names,
-            container_meta,
+            container_meta_client: Arc::new(container_meta_client),
         }
     }
 
@@ -82,7 +82,7 @@ impl Gcp {
             self.project_id
         );
 
-        let time_series = self.get_metric_data(metrics);
+        let time_series = self.get_metric_data(metrics).await;
 
         // Send metrics in batches (Google Cloud allows up to 200 time series per request)
         for batch in time_series.chunks(200) {
@@ -94,12 +94,14 @@ impl Gcp {
         Ok(())
     }
 
-    fn get_metric_data(&self, collected: Vec<CollectedMetric>) -> Vec<TimeSeries> {
+    async fn get_metric_data(&self, collected: Vec<CollectedMetric>) -> Vec<TimeSeries> {
         let end_time = SystemTime::now();
         let ts_end_time: google_cloud_wkt::Timestamp = end_time.try_into().unwrap_or_default();
 
         let mut data: Vec<TimeSeries> = Vec::with_capacity(collected.len());
 
+        let container_meta = self.container_meta_client.collect().await;
+
         for metric in collected {
             let cloud_metric_name = match self.metric_names.get(metric.key.name()) {
                 Some(name) => name,
@@ -112,11 +114,11 @@ impl Gcp {
                 }
             };
 
-            let container_labels = self.container_meta.labels();
+            let container_labels = container_meta.labels();
             let container_labels_len = container_labels.len();
             let mut labels =
                 HashMap::with_capacity(container_labels_len + metric.key.labels().len());
-            labels.extend(container_labels);
+            labels.extend(container_labels.clone());
             labels.extend(
                 metric
                     .key
@@ -171,6 +173,18 @@ impl Gcp {
                 ),
             };
 
+            // Add container instance ID to node_id if present
+            let mut monitored_resource_labels = self.monitored_resource_labels.clone();
+            if let Some(node_id) = monitored_resource_labels.get("node_id") {
+                monitored_resource_labels.insert(
+                    "node_id".to_string(),
+                    format!("{}-{}", node_id, container_meta.instance_id),
+                );
+            }
+
+            let mut mr = MonitoredResource::new().set_type(&self.monitored_resource_type);
+            mr.labels = monitored_resource_labels;
+
             data.push(
                 TimeSeries::new()
                     .set_metric_kind(kind)
@@ -179,11 +193,7 @@ impl Gcp {
                             .set_type(format!("custom.googleapis.com/{}", cloud_metric_name))
                             .set_labels(labels),
                     )
-                    .set_resource(
-                        MonitoredResource::new()
-                            .set_type(&self.monitored_resource_type)
-                            .set_labels(&self.monitored_resource_labels),
-                    )
+                    .set_resource(mr)
                     .set_value_type(value_type)
                     .set_points(vec![Point::new()
                         .set_interval(interval)

runtimes/core/src/metrics/manager.rs

@@ -1,6 +1,6 @@
 use crate::{
     encore::runtime::v1::{self as pb, Environment},
-    metadata::{process_env_substitution, ContainerMetadata},
+    metadata::{process_env_substitution, ContainerMetaClient},
     metrics::{
         exporter::{self, Exporter},
         registry::Registry,
@@ -37,45 +37,30 @@ impl ProviderType {
         &self,
         env: &Environment,
         http_client: &reqwest::Client,
-        runtime_handle: tokio::runtime::Handle,
     ) -> Arc<dyn Exporter + Send + Sync> {
         match self {
             Self::Gcp(config) | Self::EncoreCloud(config) => {
-                runtime_handle.block_on(Self::create_gcp_exporter(config, env, http_client))
+                Self::create_gcp_exporter(config, env, http_client)
             }
         }
     }
 
-    async fn create_gcp_exporter(
+    fn create_gcp_exporter(
         provider_cfg: &pb::metrics_provider::GcpCloudMonitoring,
         env: &Environment,
         http_client: &reqwest::Client,
     ) -> Arc<dyn Exporter + Send + Sync> {
-        let container_meta = ContainerMetadata::collect(env, http_client)
-            .await
-            .unwrap_or_else(|_| ContainerMetadata {
-                env_name: env.env_name.clone(),
-                ..Default::default()
-            });
+        let container_meta_client = ContainerMetaClient::new(env.clone(), http_client.clone());
 
         let mut labels = provider_cfg.monitored_resource_labels.clone();
-
-        // Add container instance ID to node_id if present
-        if let Some(node_id) = labels.get("node_id").cloned() {
-            labels.insert(
-                "node_id".to_string(),
-                format!("{}-{}", node_id, container_meta.instance_id),
-            );
-        }
-
         process_env_substitution(&mut labels);
 
         Arc::new(exporter::Gcp::new(
             provider_cfg.project_id.clone(),
             provider_cfg.monitored_resource_type.clone(),
             labels,
             provider_cfg.metric_names.clone(),
-            container_meta,
+            container_meta_client,
         ))
     }
 }
@@ -110,11 +95,7 @@ impl Manager {
 
         for metrics_provider in &observability.metrics {
             if let Some(provider_type) = ProviderType::from_config(metrics_provider) {
-                manager.exporter = Some(provider_type.create_exporter(
-                    environment,
-                    http_client,
-                    runtime_handle.clone(),
-                ));
+                manager.exporter = Some(provider_type.create_exporter(environment, http_client));
                 break; // Take the first valid provider
             }
         }