port 4347 + influx query example + fmt

client/.env.development

@@ -1 +1 @@
-VUE_APP_API_URL="http://localhost:8000/api/"
+VUE_APP_API_URL="http://localhost:4347/api/"

server/config.example.toml

@@ -1,4 +1,4 @@
-port = 8000
+port = 4347
 
 [prometheus]
 url = "http://localhost:9090"
@@ -9,4 +9,10 @@ query = "rate(go_memstats_alloc_bytes_total[5m])"
 # url = "http://localhost:8086"
 # org_id = "5abe4759f7360f1c"
 # token = "sCAB2MVo8TJxhUH8UDJZIeCPwf-cykBtO0jhr207qCQSZ9d43JXObCYK_uAml2BL26JBYFauz95yIeC51kxQog=="
-# query = 'from(bucket: "main-backet") |> $range |> filter(fn: (r) => r["_measurement"] == "cpu") |> filter(fn: (r) => r["_field"] == "usage_system") |> filter(fn: (r) => r["cpu"] == "cpu-total") |> filter(fn: (r) => r["host"] == "roid") |> yield(name: "mean")'
+# query = """from(bucket: "main-backet")
+#   |> $range
+#   |> filter(fn: (r) => r["_measurement"] == "mem" or r["_measurement"] == "influxdb_telegrafs_total" or r["_measurement"] == "cpu")
+#   |> filter(fn: (r) => r["_field"] == "mapped")
+#   |> yield(name: "mean")
+# """
+

server/src/config.rs

@@ -1,13 +1,11 @@
-use std::collections::HashMap;
 use subbeat::types::{DatasourceConfig, InfluxConfig, PrometheusConfig};
 
 pub struct Config {
     pub port: u16,
-    pub datasource_config: DatasourceConfig
+    pub datasource_config: DatasourceConfig,
 }
 
 fn resolve_datasource(config: &mut config::Config) -> anyhow::Result<DatasourceConfig> {
-
     if config.get::<String>("prometheus.url").is_ok() {
         return Ok(DatasourceConfig::Prometheus(PrometheusConfig {
             url: config.get("prometheus.url")?,
@@ -25,16 +23,6 @@ fn resolve_datasource(config: &mut config::Config) -> anyhow::Result<DatasourceC
     }
 
     return Err(anyhow::format_err!("no datasource found"));
-
-
-    // if config.get::<String>("prometheus.url").is_err() {
-    //     config.set("url", "http://localhost:9090").unwrap();
-    // }
-    // if config.get::<String>("prometheus.query").is_err() {
-    //     config
-    //         .set("query", "rate(go_memstats_alloc_bytes_total[5m])")
-    //         .unwrap();
-    // }
 }
 
 // TODO: use actual config and env variables
@@ -52,11 +40,10 @@ impl Config {
         if config.get::<u16>("port").is_err() {
             config.set("port", "8000").unwrap();
         }
-        
 
         Ok(Config {
             port: config.get::<u16>("port").unwrap(),
-            datasource_config: resolve_datasource(&mut config)?
+            datasource_config: resolve_datasource(&mut config)?,
         })
     }
 }

server/src/services/analytic_service/analytic_service.rs

@@ -175,8 +175,6 @@ impl AnalyticService {
             Err(_e) => println!("Fail to send notification about learning start"),
         }
 
-        
-
         // TODO: logic for returning error
 
         // be careful if decide to store detections in db
@@ -248,7 +246,6 @@ impl AnalyticService {
         from: u64,
         to: u64,
     ) {
-
         let pt = pattern_detector::PatternDetector::new(lr);
         let mr = ms.query(from, to, DETECTION_STEP).await.unwrap();
 

server/src/services/metric_service.rs

@@ -1,34 +1,26 @@
-use subbeat::{datasources::prometheus::Prometheus, metric::{Metric, MetricResult}};
-
-// TODO: use resolve function as in subbeat itself
+use subbeat::{
+    metric::{Metric, MetricResult},
+};
 
 pub struct MetricService {
-    // url: String,
-    // query: String,
-
-    datasource: Box<dyn Metric + Sync + Send>
+    datasource: Box<dyn Metric + Sync + Send>,
 }
 
 impl Clone for MetricService {
     fn clone(&self) -> Self {
         return MetricService {
-            datasource: self.datasource.boxed_clone()
-        }
+            datasource: self.datasource.boxed_clone(),
+        };
     }
 }
 
 impl MetricService {
     pub fn new(ds_config: &subbeat::types::DatasourceConfig) -> MetricService {
         MetricService {
-            // url: url.to_string(),
-            // query: query.to_string(),
-            datasource: subbeat::datasources::resolve(ds_config)
+            datasource: subbeat::datasources::resolve(ds_config),
         }
     }
-
     pub async fn query(&self, from: u64, to: u64, step: u64) -> anyhow::Result<MetricResult> {
         return self.datasource.query(from, to, step).await;
     }
-
 }
-