src/endpoints.rs

@@ -4,10 +4,12 @@ use axum::{
     http
 };
 use crate::structs::v3::PrometheusMetrics;
-use prometheus::{ Encoder, Gauge, Registry, TextEncoder};
+// use integr_structs::api::v3::PrometheusMetrics;
-use std::sync::{ Arc, MutexGuard };
+use prometheus::{Encoder, Registry, TextEncoder, Gauge};
+use std::sync::{Arc, MutexGuard};
 use crate::AppState;
-use tracing::{ error, debug, info, warn };
+// use log::{warn, info, error};
+use tracing::{info, error, warn};
 use crate::metrics::{MetricsProcesser, MetricsValueType};
 
 pub async fn update_metrics(
@@ -16,7 +18,7 @@ pub async fn update_metrics(
 ) -> impl IntoResponse {
     info!("post on /update");
 //     let resp = Response::new("body");
-    // debug!("{:?}", request);
+    // println!("{:?}", request);
     // debug!("{:?}", MetricsProcesser::get_type_of_value(&request));
     let service = &request.service_name;
     let endpoint = &request.endpoint_name;
@@ -41,8 +43,7 @@ pub async fn update_metrics(
                             error!("Cannot lock Metric Registry due to {} ", er)
                         },
                         Ok(registry) => {
-                            //  todo: error handler
+                            update_or_insert_metric(
-                            let _ = update_or_insert_metric(
                                 gauge, 
                                 registry,
                                 &metric_name
@@ -85,70 +86,16 @@ 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.clone())) {
+    match registry.register(Box::new(metric)) {
         Ok(_) => {
-            info!("Metric `{}` was registered!", metric_name);
+            info!("Metric `{}` was added!", metric_name);
         },
-        Err(er) => {
+        Err(_er) => {
-            // update or throw away
+            // update
-            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().)

src/main.rs

@@ -21,15 +21,8 @@ struct AppState {
 }
 
 #[tokio::main]
-async fn main() -> anyhow::Result<()> {
+async fn main() {
     // let _ = setup_logger().await;
-
-    tracing_subscriber::fmt()
-        .with_max_level(tracing::Level::DEBUG)
-        .init();
-
-    info!("Initializing local Prometehus metrics registry ...");
-
     let registry = Registry::new();
     // let counter_opts = Opts::new("example_counter", "Пример счётчика");
     // let histogram_opts = Opts::new("example_histogram", "Пример histogram");
@@ -59,8 +52,6 @@ async fn main() -> anyhow::Result<()> {
     // registry.register(Box::new(sunops.clone())).unwrap();
     
 
-    info!("Initializing shared state for Prometheus Exporter web-server ...");
-
     let state = Arc::new(AppState {
         registry: Mutex::new(registry),
         // counter: Mutex::new(counter),
@@ -69,15 +60,20 @@ async fn main() -> anyhow::Result<()> {
 
     // info!("Configurating Web-Server...");
 
-    info!("Configurating internals of Prometheus Exporter web-server...");
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::DEBUG)
+        .init();
+
+    info!("Configurating Web-Server...");
 
     let app = Router::new()
         .route("/metrics", get(metrics_handler))
+        // .route("/increment", get(increment_handler))
+        // .route("/sum", get(summary_handler))
         .route("/update", post(update_metrics))
         .with_state(state.clone());
 
     let listener = TcpListener::bind("0.0.0.0:9100").await.unwrap();
     info!("Serving on ...:9100");
-    axum::serve(listener, app).await?;
+    axum::serve(listener, app).await.unwrap();
-    Ok(())
 }

src/metrics.rs

@@ -2,8 +2,6 @@ use crate::structs::v3::MetricOutput;
 use serde_json::{Map, Value};
 use prometheus::Gauge;
 use tracing::error;
-use prometheus::Opts;
-use prometheus::GaugeVec;
 
 #[derive(Debug)]
 pub enum MetricsValueType { 
@@ -34,8 +32,6 @@ impl MetricsProcesser {
         }
         MetricsValueType::None
     }
-
-    // TODO: i64 and f63 support
     pub fn gauge_from_number(
         metric: &MetricOutput,
         metric_name: &str,
@@ -106,6 +102,9 @@ impl MetricsProcesser {
                             metric_value = value.as_f64().unwrap_or(0.0)
                         }
                     });
+                use prometheus::Opts;
+                use prometheus::GaugeVec;
+
                 let opts = Opts::new(&name, &help);
                 let gauge_vec = GaugeVec::new(opts, &[&label_name]);
                 match gauge_vec {
@@ -179,18 +178,3 @@ impl MetricsProcesser {
             .value.is_number()
     }
 }
-
-
-
-trait IsTaggedArray {
-    fn is_tagged_array(&self) -> bool;
-}
-
-impl IsTaggedArray for Value {
-    fn is_tagged_array(&self) -> bool {
-        if let Some(arr) = self.as_array() {
-            return arr[0].get("tag_name").is_some();
-        }
-        false
-    }
-}