remove querier metrics

Author: nikhilsinhaparseable

src/handlers/http/cluster/mod.rs

@@ -737,13 +737,11 @@ pub async fn get_node_info<T: Metadata + DeserializeOwned>(
         )
         .await?
         .iter()
-        .filter_map(|x| {
-            match serde_json::from_slice::<T>(x) {
-                Ok(val) => Some(val),
-                Err(e) => {
-                    error!("Failed to parse node metadata: {:?}", e);
-                    None
-                }
+        .filter_map(|x| match serde_json::from_slice::<T>(x) {
+            Ok(val) => Some(val),
+            Err(e) => {
+                error!("Failed to parse node metadata: {:?}", e);
+                None
             }
         })
         .collect();
@@ -992,7 +990,6 @@ async fn fetch_cluster_metrics() -> Result<Vec<Metrics>, PostError> {
         Err(err) => return Err(err),
     }
 
-    all_metrics.push(Metrics::querier_prometheus_metrics().await);
     Ok(all_metrics)
 }
 

src/handlers/http/modal/ingest_server.rs

@@ -30,8 +30,8 @@ use serde_json::Value;
 use tokio::sync::oneshot;
 use tokio::sync::OnceCell;
 
-use crate::metrics::init_system_metrics_scheduler;
 use crate::handlers::http::modal::NodeType;
+use crate::metrics::init_system_metrics_scheduler;
 use crate::{
     analytics,
     handlers::{

src/metrics/prom_utils.rs

@@ -16,15 +16,11 @@
  *
  */
 
-use std::collections::HashMap;
-use std::path::Path;
-
-use crate::about::current;
+use super::DiskMetrics;
+use super::MemoryMetrics;
 use crate::handlers::http::base_path_without_preceding_slash;
 use crate::handlers::http::ingest::PostError;
 use crate::handlers::http::modal::Metadata;
-use crate::option::Mode;
-use crate::parseable::PARSEABLE;
 use crate::HTTP_CLIENT;
 use actix_web::http::header;
 use chrono::NaiveDateTime;
@@ -34,15 +30,11 @@ use prometheus_parse::Value as PromValue;
 use serde::Serialize;
 use serde_json::Error as JsonError;
 use serde_json::Value as JsonValue;
+use std::collections::HashMap;
 use tracing::error;
 use tracing::warn;
 use url::Url;
 
-use super::get_system_metrics;
-use super::get_volume_disk_usage;
-use super::DiskMetrics;
-use super::MemoryMetrics;
-
 #[derive(Debug, Serialize, Clone)]
 pub struct Metrics {
     address: String,
@@ -200,57 +192,6 @@ impl Metrics {
         Ok(metrics)
     }
 
-    pub async fn querier_prometheus_metrics() -> Self {
-        let mut metrics = Metrics::new(
-            PARSEABLE.options.get_url(Mode::Query).to_string(),
-            "querier".to_string(),
-        );
-
-        let system_metrics = get_system_metrics().expect("Failed to get system metrics");
-
-        metrics.parseable_memory_usage.total = system_metrics.memory.total;
-        metrics.parseable_memory_usage.used = system_metrics.memory.used;
-        metrics.parseable_memory_usage.total_swap = system_metrics.memory.total_swap;
-        metrics.parseable_memory_usage.used_swap = system_metrics.memory.used_swap;
-        for cpu_usage in system_metrics.cpu {
-            metrics
-                .parseable_cpu_usage
-                .insert(cpu_usage.name.clone(), cpu_usage.usage);
-        }
-
-        let staging_disk_usage = get_volume_disk_usage(PARSEABLE.options.staging_dir())
-            .expect("Failed to get staging volume disk usage");
-
-        metrics.parseable_staging_disk_usage.total = staging_disk_usage.total;
-        metrics.parseable_staging_disk_usage.used = staging_disk_usage.used;
-        metrics.parseable_staging_disk_usage.available = staging_disk_usage.available;
-
-        if PARSEABLE.get_storage_mode_string() == "Local drive" {
-            let data_disk_usage =
-                get_volume_disk_usage(Path::new(&PARSEABLE.storage().get_endpoint()))
-                    .expect("Failed to get data volume disk usage");
-
-            metrics.parseable_data_disk_usage.total = data_disk_usage.total;
-            metrics.parseable_data_disk_usage.used = data_disk_usage.used;
-            metrics.parseable_data_disk_usage.available = data_disk_usage.available;
-        }
-
-        if PARSEABLE.options.hot_tier_storage_path.is_some() {
-            let hot_tier_disk_usage =
-                get_volume_disk_usage(PARSEABLE.hot_tier_dir().as_ref().unwrap())
-                    .expect("Failed to get hot tier volume disk usage");
-
-            metrics.parseable_hot_tier_disk_usage.total = hot_tier_disk_usage.total;
-            metrics.parseable_hot_tier_disk_usage.used = hot_tier_disk_usage.used;
-            metrics.parseable_hot_tier_disk_usage.available = hot_tier_disk_usage.available;
-        }
-
-        metrics.commit = current().commit_hash;
-        metrics.staging = PARSEABLE.options.staging_dir().display().to_string();
-
-        metrics
-    }
-
     fn build_metrics_from_samples(
         samples: Vec<PromSample>,
         metrics: &mut Metrics,
@@ -286,7 +227,7 @@ impl Metrics {
                 Self::process_simple_gauge(metrics, &metric_name, val)
             }
             MetricType::StorageSize(storage_type) => {
-                Self::process_storage_size(metrics, &storage_type, val)
+                Self::process_storage_size(metrics, &storage_type, val, metric_name)
             }
             MetricType::DiskUsage(volume_type) => {
                 Self::process_disk_usage(metrics, &volume_type, val, metric_name)
@@ -318,10 +259,24 @@ impl Metrics {
         }
     }
 
-    fn process_storage_size(metrics: &mut Metrics, storage_type: &str, val: f64) {
+    fn process_storage_size(
+        metrics: &mut Metrics,
+        storage_type: &str,
+        val: f64,
+        metric_name: &str,
+    ) {
+        let target = match metric_name {
+            "parseable_storage_size" => &mut metrics.parseable_storage_size,
+            "parseable_lifetime_events_storage_size" => {
+                &mut metrics.parseable_lifetime_storage_size
+            }
+            "parseable_deleted_events_storage_size" => &mut metrics.parseable_deleted_storage_size,
+            _ => return,
+        };
+
         match storage_type {
-            "staging" => metrics.parseable_storage_size.staging += val,
-            "data" => metrics.parseable_storage_size.data += val,
+            "staging" => target.staging += val,
+            "data" => target.data += val,
             _ => {}
         }
     }