crazy but stable metric update logic (temp)

src/endpoints.rs

@@ -4,12 +4,10 @@ use axum::{
     http
 };
 use crate::structs::v3::PrometheusMetrics;
-// use integr_structs::api::v3::PrometheusMetrics;
-use prometheus::{Encoder, Registry, TextEncoder, Gauge};
+use prometheus::{ Encoder, Gauge, Registry, TextEncoder};
 use std::sync::{ Arc, MutexGuard };
 use crate::AppState;
-// use log::{warn, info, error};
-use tracing::{info, error, warn};
+use tracing::{ error, debug, info, warn };
 use crate::metrics::{MetricsProcesser, MetricsValueType};
 
 pub async fn update_metrics(
@@ -18,7 +16,7 @@ pub async fn update_metrics(
 ) -> impl IntoResponse {
     info!("post on /update");
 //     let resp = Response::new("body");
-    // println!("{:?}", request);
+    debug!("{:?}", request);
     // debug!("{:?}", MetricsProcesser::get_type_of_value(&request));
     let service = &request.service_name;
     let endpoint = &request.endpoint_name;
@@ -43,7 +41,8 @@ pub async fn update_metrics(
                             error!("Cannot lock Metric Registry due to {} ", er)
                         },
                         Ok(registry) => {
-                            update_or_insert_metric(
+                            //  todo: error handler
+                            let _ = update_or_insert_metric(
                                 gauge, 
                                 registry,
                                 &metric_name
@@ -86,16 +85,70 @@ pub fn update_or_insert_metric<'a>(
     metric: Gauge, 
     registry: MutexGuard<'a, Registry>,
     metric_name: &str
-) {
+) -> anyhow::Result<()> {
+    use prometheus::Error;
     // let mut counter = 0;
-    match registry.register(Box::new(metric)) {
+    match registry.register(Box::new(metric.clone())) {
         Ok(_) => {
-            info!("Metric `{}` was added!", metric_name);
+            info!("Metric `{}` was registered!", metric_name);
         },
-        Err(_er) => {
-            // update
+        Err(er) => {
+            // update or throw away
+            match er {
+                Error::AlreadyReg => {
+
+                    match registry.unregister(Box::new(metric.clone())) {
+                        Ok(_) => {
+                            if let Err(er) = registry.register(Box::new(metric)) {
+                                warn!("Cannot update metric `{}`", metric_name);
+                                return Err(anyhow::Error::msg(
+                                    format!("Cannot update metric `{}` due to {}", metric_name, er)
+                                ))
+                            } else {
+                                info!("OK on metric `{}` update", metric_name);
+                            }
+                        },
+                        Err(er) => {
+                            error!("Cannot unregister metric `{}` due to {}", metric_name, er);
+                            return Err(anyhow::Error::msg(
+                                format!("Cannot unregister metric `{}` due to {}", metric_name, er)
+                            ))
                         },
                     }
+                    // use prometheus::opts;
+                    // use prometheus::GaugeVec;
+
+                    // let vec = GaugeVec::new(opts!("test", "test_help"), &["label"]).unwrap();
+                    // // vec.with_label_values(&["default"]).set(42.0);
+                    // if registry.unregister(Box::new(vec)).is_err() {
+                    //     debug!("unregister failed");
+                    // };
+                    
+                    // let vec = GaugeVec::new(opts!("test1", "test_help1"), &["label"]).unwrap();
+                    // vec.with_label_values(&["goood!"]).set(412.0);
+                    // let _ = registry.register(Box::new(vec));
+                    // registry
+                    //     .gather()
+                    //     .iter_mut()
+                    //     .filter(|target| target.get_name() == metric_name.trim())
+                    //     .for_each(|family| {
+                    //         // let prev: &mut GaugeVec = family.mut_metric()[0].mut_gauge();
+
+                    //         // GaugeVec::
+
+                    //         // info!("Metric `{}` was updated, new value - {}", metric_name, new);
+                    //     });
+                },
+                _ => {
+                    error!("Cannot register new metric `{}` due to {}", metric_name, er);
+                    return Err(anyhow::Error::msg(
+                        format!("Cannot register new metric `{}` due to {}", metric_name, er)
+                    ))
+                }
+            }
+        },
+    }
+    Ok(())
     // registry.gather()
     //     .iter()
     //     .filter(|fam| fam.get_name().)