tracing and logging added

.env.example

@@ -1,3 +1,8 @@
 # port binding for prometheus-exporter
 # default value = 9100
 PROMETHEUS_EXPORTER_PORT = 9100
+
+# setting up max level of logging
+# default - INFO 
+# values : WARN, ERROR, INFO, DEBUG, TRACE
+PROMETHEUS_EXPORTER_LOG_LEVEL = "TRACE"

src/endpoints.rs

@@ -3,11 +3,12 @@ use axum::{
     response::IntoResponse,
     http
 };
+use tracing_subscriber::field::debug;
 use crate::structs::v3::PrometheusMetrics;
 use prometheus::{ Encoder, Gauge, Registry, TextEncoder};
 use std::sync::{ Arc, MutexGuard };
 use crate::AppState;
-use tracing::{ debug, error, info, warn };
+use tracing::{ debug, error, info, warn, trace };
 use crate::metrics::{MetricsProcesser, MetricsValueType};
 
 /// An `Update` endpoint
@@ -18,14 +19,14 @@ use crate::metrics::{MetricsProcesser, MetricsValueType};
 /// # Usage
 /// 
 /// ``` bash
-/// curl -X POST -d '"id" : ...' 'http::/localhost:9100/update'
+/// curl -X POST -d '...' 'http::/localhost:9100/update'
 /// ```
 /// 
 pub async fn update_metrics(
     State(state): State<Arc<AppState>>,
     Json(request) : Json<PrometheusMetrics<'_>>
 ) -> impl IntoResponse {
-    info!("post on /update");
+    trace!("post on /update");
     let service = &request.service_name;
     let endpoint = &request.endpoint_name;
 
@@ -35,9 +36,11 @@ pub async fn update_metrics(
         match MetricsProcesser::get_type_of_value(&i) {
             MetricsValueType::Array | 
             MetricsValueType::TaggedArray => {
-
+                trace!("processing an array of metrics");
+                //  ...
             },
             MetricsValueType::Number => {
+                trace!("processing a number type of metric");
                 let gauge = MetricsProcesser::gauge_from_number(
                     &i, 
                     &metric_name,
@@ -60,9 +63,11 @@ pub async fn update_metrics(
                 }
             },
             MetricsValueType::ArrayOfStrings => {
+                trace!("processing an array of strings");
                 warn!("String arrays are unsupported, ignoring ...");
             },
             _ => {
+                trace!("processing unrecognized type of metric");
                 warn!("Unrecognized metric type was supplied, ignoring ...");
             }
         }
@@ -83,13 +88,18 @@ pub async fn update_metrics(
 /// ```
 /// 
 pub async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
+    trace!("get on /metrics");
     let registry = state.registry.lock();
     
+    debug!("registry mutex lock is {}", registry.is_ok());
     return match registry {
         Ok(registry) => {
             let encoder = TextEncoder::new();
             let mut buffer = Vec::new();
             let metric_families = registry.gather();
+
+            debug!("vec of metric families - {:?}", &metric_families);
+            
             encoder.encode(&metric_families, &mut buffer).unwrap();
             String::from_utf8(buffer).unwrap()
         },
@@ -109,6 +119,7 @@ pub fn update_or_insert_metric<'a>(
     registry: MutexGuard<'a, Registry>,
     metric_name: &str
 ) -> anyhow::Result<()> {
+    trace!("fn update_or_insert_metric is running");
     use prometheus::Error;
     // let mut counter = 0;
     match registry.register(Box::new(metric.clone())) {
@@ -119,7 +130,7 @@ pub fn update_or_insert_metric<'a>(
             // update or throw away
             match er {
                 Error::AlreadyReg => {
-
+                    trace!("processing already regged metric");
                     match registry.unregister(Box::new(metric.clone())) {
                         Ok(_) => {
                             if let Err(er) = registry.register(Box::new(metric)) {

src/main.rs

@@ -11,7 +11,7 @@ use axum::{
     routing::{get, post}, 
     Router};
 use prometheus::Registry;
-use std::sync::{Arc, Mutex};
+use std::{str::FromStr, sync::{Arc, Mutex}};
 use endpoints::*;
 use tokio::net::TcpListener;
 use tracing::info;
@@ -27,8 +27,17 @@ struct AppState {
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
+    let log_level = std::env::var("PROMETHEUS_EXPORTER_LOG_LEVEL")
+    .unwrap_or_else(|_| "INFO".to_owned());
+
     tracing_subscriber::fmt()
-        .with_max_level(tracing::Level::DEBUG)
+        .with_max_level(tracing::Level::from_str(&log_level).unwrap_or_else(|_| tracing::Level::INFO))
+        .with_writer(std::io::stdout)
+        .with_span_events(tracing_subscriber::fmt::format::FmtSpan::NEW)
+        .with_line_number(false)
+        .with_target(false)
+        .with_file(false)
+        .compact()
         .init();
 
     info!("Loading env vars from .env if exists ...");
@@ -49,10 +58,12 @@ async fn main() -> anyhow::Result<()> {
         .route("/update", post(update_metrics))
         .with_state(state.clone());
 
-    let bind_address = format!("0.0.0.0:{}", std::env::var("PROMETHEUS_EXPORTER_PORT").unwrap_or_else(|_| "9100".to_owned()));
-    let listener = TcpListener::bind(bind_address).await.unwrap();
+    let port = std::env::var("PROMETHEUS_EXPORTER_PORT")
+    .unwrap_or_else(|_| "9100".to_owned());
+    let bind_address = format!("0.0.0.0:{}", &port);
+    let listener = TcpListener::bind(bind_address).await?;
     
-    info!("Serving on ...:9100");
+    info!("Serving on ...:{}", &port);
     axum::serve(listener, app).await?;
     Ok(())
 }

src/metrics.rs

@@ -1,9 +1,11 @@
 use crate::structs::v3::MetricOutput;
+use serde::de;
 use serde_json::{Map, Value};
 use prometheus::Gauge;
 use tracing::error;
 use prometheus::Opts;
 use prometheus::GaugeVec;
+use tracing::{debug, trace};
 
 #[derive(Debug)]
 pub enum MetricsValueType { 
@@ -20,18 +22,24 @@ pub struct MetricsProcesser;
 impl MetricsProcesser {
 
     pub fn get_type_of_value(metrics: &MetricOutput) -> MetricsValueType {
+        trace!("defining metric type");
         if Self::is_number(metrics) {
+            debug!("processing Number");
             return MetricsValueType::Number;
         }
         else if Self::is_array(metrics) {
             if Self::is_tagged_array(metrics) {
+                debug!("processing TaggedArray");
                 return MetricsValueType::TaggedArray;
             }
             if Self::is_array_of_string_values(metrics) {
+                debug!("processing ArrayOfStrings");
                 return MetricsValueType::ArrayOfStrings;
             }
+            debug!("processing Array");
             return MetricsValueType::Array;
         }
+        debug!("processing undefined type");
         MetricsValueType::None
     }
 
@@ -41,6 +49,7 @@ impl MetricsProcesser {
         metric_name: &str,
         metric_desc: &str
     ) -> Option<Gauge> {        
+        trace!("fn gauge_from_number is running");
         let gauge = Gauge::new(
             metric_name,
             metric_desc
@@ -64,6 +73,7 @@ impl MetricsProcesser {
                     },
                 };
                 gauge.set(val);
+                debug!("processed metric: {:?}", &gauge);
                 return Some(gauge);
             },
             Err(er) => error!("Cannot create Gauge metric {} due to {}", &metric_name, er),

src/structs.rs

@@ -17,6 +17,7 @@ pub mod v3 {
         pub value : Value,
         #[serde(rename = "description")]
         pub desc : Option<Cow<'a, String>>,
+        pub status: Option<isize>
     }
 
     #[derive(Serialize, Deserialize, Debug)]