Dynamic Logs/Metrics (#1735)

* add config

* cli

* add

* add metric metadata to logs

* lint

* uncomment

* lint

* lint

* abstract

* dynamic-configure

* add

* add explanation

* add error handling

---------

Co-authored-by: Jonathan Widjaja <[email protected]>

Author: georgevanderson

apps/framework-cli/src/cli.rs

@@ -324,6 +324,7 @@ async fn top_command_handler(
             let (metrics, rx) = Metrics::new(TelemetryMetadata {
                 anonymous_telemetry_enabled: settings.telemetry.enabled,
                 machine_id: settings.telemetry.machine_id.clone(),
+                metric_labels: settings.metric.labels.clone(),
                 is_moose_developer: settings.telemetry.is_moose_developer,
                 is_production: project_arc.is_production,
                 project_name: project_arc.name().to_string(),
@@ -495,6 +496,7 @@ async fn top_command_handler(
             let (metrics, rx) = Metrics::new(TelemetryMetadata {
                 anonymous_telemetry_enabled: settings.telemetry.enabled,
                 machine_id: settings.telemetry.machine_id.clone(),
+                metric_labels: settings.metric.labels.clone(),
                 is_moose_developer: settings.telemetry.is_moose_developer,
                 is_production: project_arc.is_production,
                 project_name: project_arc.name().to_string(),

apps/framework-cli/src/cli/logger.rs

@@ -31,9 +31,8 @@
 //! ```
 //!
 
+use log::{error, warn};
 use log::{info, LevelFilter, Metadata, Record};
-use std::time::{Duration, SystemTime};
-
 use opentelemetry::logs::Logger;
 use opentelemetry::KeyValue;
 use opentelemetry_appender_log::OpenTelemetryLogBridge;
@@ -44,8 +43,13 @@ use opentelemetry_sdk::logs::LoggerProvider;
 use opentelemetry_sdk::Resource;
 use opentelemetry_semantic_conventions::resource::SERVICE_NAME;
 use serde::Deserialize;
+use serde_json::Value;
+use std::env;
+
+use std::time::{Duration, SystemTime};
 
 use crate::utilities::constants::{CONTEXT, CTX_SESSION_ID};
+use crate::utilities::decode_object;
 
 use super::settings::user_directory;
 
@@ -171,18 +175,18 @@ pub fn setup_logging(settings: &LoggerSettings, machine_id: &str) -> Result<(),
         })
     } else {
         fern::Dispatch::new().format(move |out, message, record| {
+            let log_json = serde_json::json!({
+                "timestamp": chrono::Utc::now().to_rfc3339(),
+                "severity": record.level().to_string(),
+                "session_id": &session_id,
+                "target": record.target(),
+                "message": message,
+            });
+
             out.finish(format_args!(
                 "{}",
-                serde_json::to_string(&serde_json::json!(
-                    {
-                        "timestamp": chrono::Utc::now().to_rfc3339(),
-                        "severity": record.level(),
-                        "session_id": &session_id,
-                        "target": record.target(),
-                        "message": message,
-                    }
-                ))
-                .expect("formatting `serde_json::Value` with string keys never fails")
+                serde_json::to_string(&log_json)
+                    .expect("formatting `serde_json::Value` with string keys never fails")
             ))
         })
     };
@@ -215,12 +219,30 @@ pub fn setup_logging(settings: &LoggerSettings, machine_id: &str) -> Result<(),
                 .build_log_exporter()
                 .unwrap();
 
+            let mut resource_attributes = vec![
+                KeyValue::new(SERVICE_NAME, "moose-cli"),
+                KeyValue::new("session_id", session_id.as_str()),
+                KeyValue::new("machine_id", String::from(machine_id)),
+            ];
+            let metric_labels = decode_object::decode_base64_to_json(
+                // We are reading from the environment variables because we metrics and logs are sharing
+                // the same fields to append to the JSON
+                env::var("MOOSE_METRIC__LABELS").unwrap().as_str(),
+            );
+            match metric_labels {
+                Ok(Value::Object(labels)) => {
+                    for (key, value) in labels {
+                        if let Some(value_str) = value.as_str() {
+                            resource_attributes.push(KeyValue::new(key, value_str.to_string()));
+                        }
+                    }
+                }
+                Err(e) => error!("Error decoding MOOSE_METRIC_LABELS: {}", e),
+                _ => warn!("Unexpected value for MOOSE_METRIC_LABELS"),
+            }
+
             let logger_provider = LoggerProvider::builder()
-                .with_config(Config::default().with_resource(Resource::new(vec![
-                    KeyValue::new(SERVICE_NAME, "moose-cli"),
-                    KeyValue::new("session_id", session_id.as_str()),
-                    KeyValue::new("machine_id", String::from(machine_id)),
-                ])))
+                .with_config(Config::default().with_resource(Resource::new(resource_attributes)))
                 .with_batch_exporter(otel_exporter, opentelemetry_sdk::runtime::Tokio)
                 .build();
 

apps/framework-cli/src/cli/settings.rs

@@ -8,9 +8,7 @@ use uuid::Uuid;
 
 use super::display::{Message, MessageType};
 use super::logger::LoggerSettings;
-use crate::utilities::constants::{
-    CLI_CONFIG_FILE, CLI_USER_DIRECTORY, ENVIRONMENT_VARIABLE_PREFIX,
-};
+use crate::utilities::constants::{CLI_CONFIG_FILE, CLI_USER_DIRECTORY};
 
 /// # Config
 /// Module to handle reading the config file from the user's home directory and configuring the CLI
@@ -21,11 +19,17 @@ use crate::utilities::constants::{
 /// - add a config file validation and error handling
 ///
 
+const ENVIRONMENT_VARIABLE_PREFIX: &str = "MOOSE";
+
+#[derive(Deserialize, Debug, Default)]
+pub struct MetricLabels {
+    pub labels: Option<String>,
+}
+
 #[derive(Deserialize, Debug)]
 pub struct Telemetry {
     pub machine_id: String,
     pub enabled: bool,
-
     #[serde(default)]
     pub is_moose_developer: bool,
 }
@@ -53,6 +57,9 @@ pub struct Settings {
     #[serde(default)]
     pub telemetry: Telemetry,
 
+    #[serde(default)]
+    pub metric: MetricLabels,
+
     #[serde(default)]
     pub features: Features,
 }

apps/framework-cli/src/metrics.rs

@@ -7,16 +7,23 @@ use prometheus_client::{
     registry::Registry,
 };
 use serde_json::json;
+use serde_json::Value;
+use std::env;
 use std::sync::Arc;
 use std::{path::PathBuf, time::Duration};
 use tokio::time;
 
 use chrono::Utc;
 
 use crate::utilities::constants::{self, CONTEXT, CTX_SESSION_ID};
-
-const ANONYMOUS_METRICS_URL: &str = "https://moosefood.514.dev/ingest/MooseSessionTelemetry/0.6";
-const ANONMOUS_METRICS_REPORTING_INTERVAL: Duration = Duration::from_secs(10);
+use crate::utilities::decode_object;
+const DEFAULT_ANONYMOUS_METRICS_URL: &str =
+    "https://moosefood.514.dev/ingest/MooseSessionTelemetry/0.6";
+lazy_static::lazy_static! {
+    static ref ANONYMOUS_METRICS_URL: String = env::var("MOOSE_METRICS_DEST")
+        .unwrap_or_else(|_| DEFAULT_ANONYMOUS_METRICS_URL.to_string());
+}
+const ANONYMOUS_METRICS_REPORTING_INTERVAL: Duration = Duration::from_secs(10);
 pub const TOTAL_LATENCY: &str = "moose_total_latency";
 pub const LATENCY: &str = "moose_latency";
 pub const INGESTED_BYTES: &str = "moose_ingested_bytes";
@@ -93,6 +100,7 @@ pub struct TelemetryMetadata {
     pub anonymous_telemetry_enabled: bool,
     pub machine_id: String,
     pub is_moose_developer: bool,
+    pub metric_labels: Option<String>,
     pub is_production: bool,
     pub project_name: String,
 }
@@ -438,6 +446,17 @@ impl Metrics {
 
         let cloned_metadata = self.telemetry_metadata.clone();
 
+        let metric_labels = match cloned_metadata.metric_labels {
+            Some(labels) => match decode_object::decode_base64_to_json(labels.as_str()) {
+                Ok(decoded) => decoded,
+                Err(e) => {
+                    log::warn!("Failed to decode metric labels: {:?}", e);
+                    serde_json::Value::Null
+                }
+            },
+            None => serde_json::Value::Null,
+        };
+
         if self.telemetry_metadata.anonymous_telemetry_enabled {
             tokio::spawn(async move {
                 let client = reqwest::Client::new();
@@ -458,7 +477,7 @@ impl Metrics {
                 };
 
                 loop {
-                    let _ = time::sleep(ANONMOUS_METRICS_REPORTING_INTERVAL).await;
+                    let _ = time::sleep(ANONYMOUS_METRICS_REPORTING_INTERVAL).await;
 
                     let session_duration_in_sec = Utc::now()
                         .signed_duration_since(session_start)
@@ -480,7 +499,7 @@ impl Metrics {
                             0
                         };
 
-                    let telemetry_payload = json!({
+                    let mut telemetry_payload = json!({
                         "timestamp": Utc::now(),
                         "machineId": cloned_metadata.machine_id.clone(),
                         "sequenceId": CONTEXT.get(CTX_SESSION_ID).unwrap(),
@@ -503,8 +522,15 @@ impl Metrics {
                         "ip": ip,
                     });
 
+                    // Merge metric_labels into telemetry_payload
+                    if let Some(payload_obj) = telemetry_payload.as_object_mut() {
+                        if let Value::Object(labels_obj) = metric_labels.clone() {
+                            payload_obj.extend(labels_obj);
+                        }
+                    }
+
                     let _ = client
-                        .post(ANONYMOUS_METRICS_URL)
+                        .post(ANONYMOUS_METRICS_URL.as_str())
                         .json(&telemetry_payload)
                         .send()
                         .await;

apps/framework-cli/src/utilities.rs

@@ -2,6 +2,7 @@ use std::path::Path;
 
 pub mod capture;
 pub mod constants;
+pub mod decode_object;
 pub mod docker;
 pub mod git;
 pub mod package_managers;

apps/framework-cli/src/utilities/decode_object.rs

@@ -0,0 +1,11 @@
+use base64::{engine::general_purpose, Engine as _};
+use serde_json::Value;
+
+pub fn decode_base64_to_json(encoded: &str) -> Result<Value, String> {
+    general_purpose::STANDARD
+        .decode(encoded)
+        .map_err(|e| format!("Invalid base64 encoding: {}", e))
+        .and_then(|json_str| {
+            serde_json::from_slice::<Value>(&json_str).map_err(|e| format!("Invalid JSON: {}", e))
+        })
+}