From d94b0f809b011bb84859d7be60b23e229bc6737d Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 21 Jan 2025 09:40:31 +0300
Subject: [PATCH 01/54] rc created

---
 crates/config-delivery/src/main.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/crates/config-delivery/src/main.rs b/crates/config-delivery/src/main.rs
index 2be1247..99eded1 100644
--- a/crates/config-delivery/src/main.rs
+++ b/crates/config-delivery/src/main.rs
@@ -18,7 +18,8 @@ async fn main() -> Result<()> {
     let _ = setup_logger().await?;
     dotenv().ok();
     info!("Pulling env vars from .env file if exists ...");
-    println!("Hello, world!");
+
+    // 
 
     Ok(())
 }
-- 
2.40.1


From c607bdc0d6c5520073f5cda336b9e433310a952b Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 21 Jan 2025 09:44:14 +0300
Subject: [PATCH 02/54] feat created

---
 crates/config-delivery/src/integration.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/config-delivery/src/integration.rs b/crates/config-delivery/src/integration.rs
index e69de29..bdbe7b3 100644
--- a/crates/config-delivery/src/integration.rs
+++ b/crates/config-delivery/src/integration.rs
@@ -0,0 +1 @@
+// mock 
\ No newline at end of file
-- 
2.40.1


From 1e65db7ca510eef2d607f037219868cbc4a1fab9 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 21 Jan 2025 09:53:06 +0300
Subject: [PATCH 03/54] config: integration mock added

---
 crates/config-delivery/src/integration.rs | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/crates/config-delivery/src/integration.rs b/crates/config-delivery/src/integration.rs
index bdbe7b3..9d9e6f3 100644
--- a/crates/config-delivery/src/integration.rs
+++ b/crates/config-delivery/src/integration.rs
@@ -1 +1,16 @@
-// mock 
\ No newline at end of file
+use tokio::sync::mpsc::Sender;
+use integr_structs::api::ApiConfig;
+use anyhow::Result;
+use tokio::time::{sleep, Duration};
+// mock 
+
+#[allow(dead_code, unused_variables)]
+pub async fn init_integration_mech(tx: &Sender<ApiConfig>) -> Result<()> {
+    loop {
+        sleep(Duration::from_secs(10)).await;
+        let conf = ApiConfig::default();
+        tx.send(conf).await?;
+    }
+    // Ok(())
+}
+
-- 
2.40.1


From a225ec690ee146cb2509c6c58bc149b7810c72c0 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 21 Jan 2025 10:43:05 +0300
Subject: [PATCH 04/54] delivery tiny logic

---
 crates/config-delivery/src/delivery.rs    | 30 ++++++++++++++++++++++-
 crates/config-delivery/src/integration.rs |  8 ++++--
 crates/config-delivery/src/main.rs        | 30 ++++++++++++++++++++---
 3 files changed, 61 insertions(+), 7 deletions(-)

diff --git a/crates/config-delivery/src/delivery.rs b/crates/config-delivery/src/delivery.rs
index 38afe4b..287b567 100644
--- a/crates/config-delivery/src/delivery.rs
+++ b/crates/config-delivery/src/delivery.rs
@@ -6,13 +6,41 @@ use integr_structs::api::ApiConfig;
 use tokio::time::{sleep, Instant};
 use tokio::net::UnixStream;
 use std::env;
+use tokio::sync::mpsc::Receiver;
+use log::{info, error};
+use serde_json::to_string_pretty;
 
+#[derive(Debug)]
 enum UnixSocketConsumer {
     ApiGrubber,
     Preproc,
 }
 // to create us-client
 struct UnixSocketClient;  
+// to catch new configs from integr submod
+type ConfigGateway = Receiver<ApiConfig>;
+
+pub async fn init_delivery_mech(rx: ConfigGateway) -> Result<()> {
+    let mut rx = rx; 
+    loop {
+        while rx.is_empty() {
+            continue;
+        };
+        info!("New config was pulled. Redirecting it ...");
+        let config = rx.recv().await.unwrap();
+        match UnixSocketConsumer::ApiGrubber.get_stream_object().await {
+            Ok(socket) => {
+                socket.try_write(to_string_pretty(&config)?.as_bytes())?;
+            },
+            Err(er) => {
+                error!("Cannot coonect to ApiGrubber Unix-Socket due to {er}");
+            }
+        }
+    }
+    // let api_sock = UnixSocketConsumer::ApiGrubber.get_stream_object().await?;
+    // let preproc_sock = UnixSocketConsumer::Preproc.get_stream_object().await?;
+    Ok(())
+}
 
 impl UnixSocketConsumer {
     pub async fn get_stream_object(&self) -> Result<UnixStream> {
@@ -20,7 +48,7 @@ impl UnixSocketConsumer {
             UnixSocketConsumer::ApiGrubber => env::var("API_GRUBBER_SOCKET")?,
             UnixSocketConsumer::Preproc => env::var("PREPROC_SOCKET")?,
         };
-        UnixStream::connect(socket_file).await.or_else(|_| Err(Error::msg("Cannot create Unix-Socket client")))
+        UnixStream::connect(socket_file).await.or_else(|_| Err(Error::msg(format!("Cannot create {:?} Unix-Socket client", self))))
     } 
 }
 
diff --git a/crates/config-delivery/src/integration.rs b/crates/config-delivery/src/integration.rs
index 9d9e6f3..b2b9f55 100644
--- a/crates/config-delivery/src/integration.rs
+++ b/crates/config-delivery/src/integration.rs
@@ -1,13 +1,17 @@
+use std::sync::Arc;
+
 use tokio::sync::mpsc::Sender;
 use integr_structs::api::ApiConfig;
 use anyhow::Result;
 use tokio::time::{sleep, Duration};
 // mock 
 
+type Worker = Arc<Sender<ApiConfig>>;
+
 #[allow(dead_code, unused_variables)]
-pub async fn init_integration_mech(tx: &Sender<ApiConfig>) -> Result<()> {
+pub async fn init_integration_mech(tx: Worker) -> Result<()> {
     loop {
-        sleep(Duration::from_secs(10)).await;
+        sleep(Duration::from_secs(5)).await;
         let conf = ApiConfig::default();
         tx.send(conf).await?;
     }
diff --git a/crates/config-delivery/src/main.rs b/crates/config-delivery/src/main.rs
index 99eded1..4e20dc5 100644
--- a/crates/config-delivery/src/main.rs
+++ b/crates/config-delivery/src/main.rs
@@ -2,11 +2,16 @@ mod delivery;
 mod integration;
 mod logger;
 
+use integr_structs::api::ApiConfig;
 use logger::setup_logger;
 use dotenv::dotenv;
 use anyhow::Result;
 use tokio::sync::mpsc;
-use log::info;  
+use log::{info, error};  
+use integration::init_integration_mech;
+use delivery::init_delivery_mech;
+use tokio::task::JoinHandle;
+use std::sync::Arc;
 
 // Arch :
 // 1) 2 Unix-Socket client (for api grub and preproc)                          :: i think its a continious process for events when services are unavailable
@@ -16,10 +21,27 @@ use log::info;
 #[tokio::main(flavor = "multi_thread")]
 async fn main() -> Result<()> {
     let _ = setup_logger().await?;
-    dotenv().ok();
     info!("Pulling env vars from .env file if exists ...");
+    dotenv().ok();
 
-    // 
-
+    let (tx, rx) = mpsc::channel::<ApiConfig>(1);
+    let tx = Arc::new(tx);
+    let integr_jh = tokio::spawn(
+        async move {
+            if let Err(er) = init_integration_mech(tx).await {
+                error!("Error in integration submodule during to: {}", er);
+            }
+        }
+    );
+    let deliv_future = tokio::spawn(async move {
+        if let Err(er) = init_delivery_mech(rx).await {
+            error!("Error in delivery submodule during to: {}", er);
+        }
+    });
+    // for deliv adding
+    // let action_vec: Vec<JoinHandle<()>> = vec![integr_jh, deliv_future];
+    for event in vec![integr_jh, deliv_future] {
+        let _ = event.await;
+    }
     Ok(())
 }
-- 
2.40.1


From 1f5656f7b8eccb8707ab41f5d02d0c6ac0cdc7b8 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 21 Jan 2025 16:02:40 +0300
Subject: [PATCH 05/54] config template added to the repo

---
 template_global_config.json | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 template_global_config.json

diff --git a/template_global_config.json b/template_global_config.json
new file mode 100644
index 0000000..699cae2
--- /dev/null
+++ b/template_global_config.json
@@ -0,0 +1,21 @@
+{ 
+	"id" : 1 ,
+	"template" : 	
+		[{
+			"id" :"conference", 
+			"name" : "Conference",
+			"url" : "https://$ip_address/api/v1/conferences",
+			"measure" : 
+				[
+					"total", "number", "description", 
+					"shutdown", "startTime", "stopTime",
+					"participants_total", "participants_online"
+				]
+		}],
+	"ip_address" : 	"127.0.0.1:8081",
+	"login" : "",
+	"pass" : "" ,
+	"api_key" : 	"908c709827bd40n98r7209837x98273",
+	"period" : 		"10",
+	"timeout" : "2"
+}
-- 
2.40.1


From ab75252e6b9a7846ded0a42f186f5eacddd196fb Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 21 Jan 2025 16:03:16 +0300
Subject: [PATCH 06/54] refactor#1

---
 crates/api-grub/src/main.rs            |  1 +
 crates/config-delivery/src/delivery.rs | 14 ++++++++------
 crates/config-delivery/src/main.rs     |  1 -
 3 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/crates/api-grub/src/main.rs b/crates/api-grub/src/main.rs
index 208d646..bbd48ba 100644
--- a/crates/api-grub/src/main.rs
+++ b/crates/api-grub/src/main.rs
@@ -21,6 +21,7 @@ async fn main() -> Result<()>{
     // config update channel
     let (tx, mut rx) = mpsc::channel::<ApiConfig>(1);
     // futures
+    // todo : rewrite with spawn
     let config_fut = init_config_grub_mechanism(&tx);
     let grub_fut = init_api_grub_mechanism(config, &mut rx);
 
diff --git a/crates/config-delivery/src/delivery.rs b/crates/config-delivery/src/delivery.rs
index 287b567..c75bbf9 100644
--- a/crates/config-delivery/src/delivery.rs
+++ b/crates/config-delivery/src/delivery.rs
@@ -3,7 +3,7 @@
 
 use anyhow::{Error, Result};
 use integr_structs::api::ApiConfig;
-use tokio::time::{sleep, Instant};
+use tokio::time::{sleep, Duration};
 use tokio::net::UnixStream;
 use std::env;
 use tokio::sync::mpsc::Receiver;
@@ -31,15 +31,16 @@ pub async fn init_delivery_mech(rx: ConfigGateway) -> Result<()> {
         match UnixSocketConsumer::ApiGrubber.get_stream_object().await {
             Ok(socket) => {
                 socket.try_write(to_string_pretty(&config)?.as_bytes())?;
+                info!("New api config was pulled");
             },
             Err(er) => {
                 error!("Cannot coonect to ApiGrubber Unix-Socket due to {er}");
             }
         }
+        sleep(Duration::from_secs(3)).await;
     }
     // let api_sock = UnixSocketConsumer::ApiGrubber.get_stream_object().await?;
     // let preproc_sock = UnixSocketConsumer::Preproc.get_stream_object().await?;
-    Ok(())
 }
 
 impl UnixSocketConsumer {
@@ -52,12 +53,13 @@ impl UnixSocketConsumer {
     } 
 }
 
-async fn check_unix_socket_file(path: &str) -> bool {
-    std::path::Path::new(path).exists()
-}
+// async fn check_unix_socket_file(path: &str) -> bool {
+//     std::path::Path::new(path).exists()
+// }
 
-#[cfg(tests)]
+#[cfg(test)]
 mod delivery_unittests {
+    #[allow(unused_imports)]
     use super::*;
     use tokio::test;
 
diff --git a/crates/config-delivery/src/main.rs b/crates/config-delivery/src/main.rs
index 4e20dc5..7f8803b 100644
--- a/crates/config-delivery/src/main.rs
+++ b/crates/config-delivery/src/main.rs
@@ -10,7 +10,6 @@ use tokio::sync::mpsc;
 use log::{info, error};  
 use integration::init_integration_mech;
 use delivery::init_delivery_mech;
-use tokio::task::JoinHandle;
 use std::sync::Arc;
 
 // Arch :
-- 
2.40.1


From d3fcfae15b8017f9038408b72cbf63c74931e782 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 21 Jan 2025 16:31:10 +0300
Subject: [PATCH 07/54] new valid structs for sharing between services

---
 crates/integr-structs/src/api.rs | 35 ++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 70f07a4..82e8f5d 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -1,4 +1,7 @@
+use std::collections::{HashMap, HashSet};
+
 use serde::{Serialize, Deserialize};
+use serde_json::Value;
 
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -21,4 +24,36 @@ impl Default for ApiConfig {
             delay : 0,
         }
     }
+}
+
+// v2
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ApiConfigV2 {
+    id : u64,
+    #[serde(default)]
+    template : Vec<Template>,
+    ip_address : String,
+    login : Option<String>,
+    pass : Option<String>,
+    api_key : Option<String>,
+    period : u32,               // if "0" -> inf
+    timeout :  u32,             // if "0" -> no-delay
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Template {
+    id : String,
+    name : String,
+    url : String,
+    #[serde(default)]
+    measure : Vec<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ProcessedEndpoint { 
+    id : String,
+    name : String,
+    url : String,
+    #[serde(default)]
+    metrics : HashMap<String, Value>
 }
\ No newline at end of file
-- 
2.40.1


From dd2973924a307068ed8be6c04cdd3a705015d0cd Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 21 Jan 2025 17:24:33 +0300
Subject: [PATCH 08/54] v2 structs

---
 crates/integr-structs/src/api.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 82e8f5d..b061f71 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 use serde::{Serialize, Deserialize};
 use serde_json::Value;
-- 
2.40.1


From efb00dcf5e9dfb043af7e37f22b2bb45b82ed48e Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 21 Jan 2025 17:25:42 +0300
Subject: [PATCH 09/54] preproc setting up

---
 README.md                       |  4 +--
 crates/preproc/Cargo.toml       |  8 ++++++
 crates/preproc/src/config.rs    | 21 ++++++++++++++
 crates/preproc/src/logger.rs    | 50 +++++++++++++++++++++++++++++++++
 crates/preproc/src/main.rs      | 19 +++++++++++--
 crates/preproc/src/transform.rs |  1 +
 6 files changed, 99 insertions(+), 4 deletions(-)
 create mode 100644 crates/preproc/src/config.rs
 create mode 100644 crates/preproc/src/logger.rs
 create mode 100644 crates/preproc/src/transform.rs

diff --git a/README.md b/README.md
index c8897c7..4bfcad2 100644
--- a/README.md
+++ b/README.md
@@ -10,6 +10,6 @@
 | Crate (submodule)   |  Progress  |
 |---|---|
 |`api-grub`   | ✅✅✅✅✅✅✅🔲🔲🔲  |
-|`config-delivery`   | ✅✅✅✅🔲🔲🔲🔲🔲🔲  |
+|`config-delivery`   | ✅✅✅✅✅✅🔲🔲🔲🔲  |
 |`integrs-structs`   | ✅✅✅✅✅✅🔲🔲🔲🔲  |
-|`preproc`   | 🔲🔲🔲🔲🔲🔲🔲🔲🔲🔲  |
+|`preproc`   | ✅✅✅🔲🔲🔲🔲🔲🔲🔲  |
diff --git a/crates/preproc/Cargo.toml b/crates/preproc/Cargo.toml
index 1b55bd2..9ef8c92 100644
--- a/crates/preproc/Cargo.toml
+++ b/crates/preproc/Cargo.toml
@@ -4,3 +4,11 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+anyhow = "1.0.95"
+chrono = "0.4.39"
+dotenv = "0.15.0"
+env_logger = "0.11.6"
+log = "0.4.25"
+serde = { version = "1.0.217", features = ["derive"] }
+serde_json = "1.0.137"
+tokio = { version = "1.43.0", features = ["full"] }
diff --git a/crates/preproc/src/config.rs b/crates/preproc/src/config.rs
new file mode 100644
index 0000000..e22c5e0
--- /dev/null
+++ b/crates/preproc/src/config.rs
@@ -0,0 +1,21 @@
+// mod for prpeproc config pulling and updating 
+
+
+
+
+
+
+
+#[cfg(test)]
+mod config_unittests {
+    use tokio::test;
+
+    #[test]
+    async fn create_unix_socket_server() { assert!(true) }
+
+    #[test]
+    async fn verify_on_valid_config() { assert!(true) }
+
+    #[test]
+    async fn verify_on_invalid_config() { assert!(true) }
+}
\ No newline at end of file
diff --git a/crates/preproc/src/logger.rs b/crates/preproc/src/logger.rs
new file mode 100644
index 0000000..6578b44
--- /dev/null
+++ b/crates/preproc/src/logger.rs
@@ -0,0 +1,50 @@
+use chrono::Local;
+use env_logger::Builder;
+use log::LevelFilter;
+use std::io::Write;
+use anyhow::Result;
+use log::info;
+
+pub async fn setup_logger() -> Result<()> {
+    Builder::new()
+        .format(move |buf, record| {
+            writeln!(
+                buf,
+                "|{}| {} [{}] - {}",
+                "config-delivery",
+                Local::now().format("%d-%m-%Y %H:%M:%S"),
+                record.level(),
+                record.args(),
+            )
+        })
+        .filter(None, LevelFilter::Info)
+        .target(env_logger::Target::Stdout)
+        .init();
+
+    info!("Logger configured");
+    Ok(())
+}
+
+
+#[cfg(test)]
+mod logger_unittests {
+    use tokio::test;
+    use super::*;
+    #[test]
+    async fn check_logger_builder() {
+        Builder::new()
+        .format(move |buf, record| {
+            writeln!(
+                buf,
+                "|{}| {} [{}] - {}",
+                "config-delivery",
+                Local::now().format("%d-%m-%Y %H:%M:%S"),
+                record.level(),
+                record.args(),
+            )
+        })
+        .filter(None, LevelFilter::Info)
+        .target(env_logger::Target::Stdout)
+        .init();
+    }
+}
\ No newline at end of file
diff --git a/crates/preproc/src/main.rs b/crates/preproc/src/main.rs
index e7a11a9..3d9c8e1 100644
--- a/crates/preproc/src/main.rs
+++ b/crates/preproc/src/main.rs
@@ -1,3 +1,18 @@
-fn main() {
-    println!("Hello, world!");
+mod config;
+mod transform;
+mod logger;
+
+use logger::setup_logger;
+use dotenv::dotenv;
+use anyhow::Result;
+use log::info;
+
+#[tokio::main(flavor = "multi_thread")]
+async fn main() -> Result<()>{
+    let _ = setup_logger().await?;
+    
+    info!("Pulling env vars from .env file if exists ...");
+    dotenv().ok();
+
+    Ok(())
 }
diff --git a/crates/preproc/src/transform.rs b/crates/preproc/src/transform.rs
new file mode 100644
index 0000000..43337c5
--- /dev/null
+++ b/crates/preproc/src/transform.rs
@@ -0,0 +1 @@
+// mod for preproccessing and transfering to the CM metrics data   
\ No newline at end of file
-- 
2.40.1


From 59ab93a46ed02f2b7993fea82485eae0ba637eff Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 23 Jan 2025 16:47:59 +0300
Subject: [PATCH 10/54] v2 changes init

---
 config_api.json                           | 44 ++++++++----
 crates/api-grub/src/config.rs             | 14 ++--
 crates/api-grub/src/main.rs               |  8 +--
 crates/api-grub/src/net.rs                | 42 +++++------
 crates/config-delivery/src/delivery.rs    |  4 +-
 crates/config-delivery/src/integration.rs |  6 +-
 crates/config-delivery/src/main.rs        |  4 +-
 crates/integr-structs/src/api.rs          | 87 +++++++++++++++++++----
 template_global_config.json               | 28 +++++---
 9 files changed, 162 insertions(+), 75 deletions(-)

diff --git a/config_api.json b/config_api.json
index 9136b29..fe911ce 100644
--- a/config_api.json
+++ b/config_api.json
@@ -1,13 +1,31 @@
-{
-    "endpoints" : [
-        {
-            "url" : "http://127.0.0.1:8081/ping",
-            "method" : "GET"
-        },
-        {
-            "url" : "http://127.0.0.1:8081/",
-            "method" : "GET"
-        }
-    ],
-    "delay" : 5
-}
\ No newline at end of file
+{ 
+	"id" : 1 ,
+	"template" : 	
+		[{
+			"id" :"mock_api_1", 
+			"name" : "Mock / ",
+			"url" : "http://127.0.0.1:8081/",
+			"method" : "GET",
+			"measure" : 
+				[
+					"operation", "response", "empty_field"
+				]
+		},
+		{
+			"id" :"mock_api_2", 
+			"name" : "Mock /ping ",
+			"url" : "http://127.0.0.1:8081/ping",
+			"method" : "GET",
+			"measure" : 
+				[
+					"operation", "response", "empty_field"
+				]
+		}
+		],
+	"ip_address" : 	"127.0.0.1:8081",
+	"login" : "",
+	"pass" : "" ,
+	"api_key" : 	"908c709827bd40n98r7209837x98273",
+	"period" : 		10,
+	"timeout" : 2
+}
diff --git a/crates/api-grub/src/config.rs b/crates/api-grub/src/config.rs
index 9a30354..f68e77e 100644
--- a/crates/api-grub/src/config.rs
+++ b/crates/api-grub/src/config.rs
@@ -1,7 +1,7 @@
 //  mod to communicate with api-grub config file
 //  1) check changes in unix-socket  
 //  2) save changes in local config file
-use integr_structs::api::ApiConfig;
+use integr_structs::api::{ApiConfig, ApiConfigV2};
 use anyhow::{Error, Ok, Result};
 use log::{info, warn, error}; 
 use std::{fs, path::Path};
@@ -15,7 +15,7 @@ const CONFIG_PATH: &str = "config_api.json";
 const SOCKET_PATH: &str = "api-grub.sock";
 
 // todo! rewrite to use current_exe
-pub async fn pull_local_config() -> Result<ApiConfig> {
+pub async fn pull_local_config() -> Result<ApiConfigV2> {
     // let conf_path = std::env::current_exe()?;
     let path = Path::new(CONFIG_PATH);
     // return match conf_path.parent() {
@@ -28,7 +28,7 @@ pub async fn pull_local_config() -> Result<ApiConfig> {
     //     None => Err(Error::msg("No local conf was found")) 
     // }
     if path.exists() && path.is_file() {
-        let config: ApiConfig = from_str(
+        let config: ApiConfigV2 = from_str(
             &fs::read_to_string(CONFIG_PATH)?
         )?;
         Ok(config)
@@ -39,7 +39,7 @@ pub async fn pull_local_config() -> Result<ApiConfig> {
 
 // for config pulling
 // ++++ reader to channel 
-pub async fn init_config_grub_mechanism(tx: &Sender<ApiConfig>) -> Result<()> {
+pub async fn init_config_grub_mechanism(tx: &Sender<ApiConfigV2>) -> Result<()> {
     info!("Initializing Unix-Socket listening for pulling new configs...");
     let server = init_unix_listener().await?;
     // 
@@ -51,7 +51,7 @@ pub async fn init_config_grub_mechanism(tx: &Sender<ApiConfig>) -> Result<()> {
             if let Err(er) =  stream.read_to_string(&mut buffer).await {
                 warn!("Cannot read config from stream due to {}", er);
             } else {
-                let config: Result<ApiConfig, serde_json::Error> = from_str(&buffer);
+                let config: Result<ApiConfigV2, serde_json::Error> = from_str(&buffer);
                 if let stdOk(conf) = config {
                     info!("New config was pulled from Unix-Stream. Saving it locally and sharing with API-grub module...");
                     if let Err(er) = save_new_config(&buffer).await {
@@ -97,13 +97,13 @@ mod config_unittests {
     #[test]
     async fn check_save_new_config() {
         use std::fs;
-        use integr_structs::api::ApiConfig;
+        use integr_structs::api::ApiConfigV2;
         use serde_json::to_string;
         
         let test_config_path  = "test_config_api.json";
 
         // config gen  
-        let config = to_string::<ApiConfig>(&ApiConfig::default());
+        let config = to_string::<ApiConfigV2>(&ApiConfigV2::default());
         assert!(config.is_ok());
         let config = config.unwrap();
 
diff --git a/crates/api-grub/src/main.rs b/crates/api-grub/src/main.rs
index bbd48ba..2fe4a95 100644
--- a/crates/api-grub/src/main.rs
+++ b/crates/api-grub/src/main.rs
@@ -3,7 +3,7 @@ mod net;
 mod logger;
 
 use anyhow::Result;
-use integr_structs::api::ApiConfig;
+use integr_structs::api::ApiConfigV2;
 use logger::setup_logger;
 use log::{info, warn};
 use config::{pull_local_config, init_config_grub_mechanism};
@@ -19,7 +19,7 @@ async fn main() -> Result<()>{
     setup_logger().await?;
     let config = get_config().await;
     // config update channel
-    let (tx, mut rx) = mpsc::channel::<ApiConfig>(1);
+    let (tx, mut rx) = mpsc::channel::<ApiConfigV2>(1);
     // futures
     // todo : rewrite with spawn
     let config_fut = init_config_grub_mechanism(&tx);
@@ -30,7 +30,7 @@ async fn main() -> Result<()>{
     Ok(())
 }
 
-async fn get_config() -> ApiConfig {
+async fn get_config() -> ApiConfigV2 {
     return match pull_local_config().await {
         Ok(conf) => {
             info!("Local config was loaded");
@@ -38,7 +38,7 @@ async fn get_config() -> ApiConfig {
         },
         Err(er) => {
             warn!("Cannot get local config due to {}", er);
-            ApiConfig::default()
+            ApiConfigV2::default()
         }
     }
 }
\ No newline at end of file
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index 62ddb5c..0c6f3bd 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -1,6 +1,6 @@
 // module to handle unix-socket connection + pulling info from api 
 use anyhow::{Error, Result};
-use integr_structs::api::ApiConfig;
+use integr_structs::api::{ApiConfig, ApiConfigV2, Template};
 use log::{error, info};
 use tokio::sync::mpsc::Receiver;
 use tokio::time::{sleep, Duration};
@@ -15,33 +15,37 @@ impl RestMethod {
             "patch" => Method::PATCH,
             "put" => Method::PUT,
             "delete" => Method::DELETE,
+            "head" => Method::HEAD,
+            "trace" => Method::TRACE,
+            "options" => Method::OPTIONS,
+            "connect" => Method::CONNECT,
             "get" | _ => Method::GET
         }
     } 
 }
 struct ApiPoll<'a> {
-    config : &'a mut ApiConfig,
+    config : &'a mut ApiConfigV2,
     client : Client,
 }
 
 impl<'a> ApiPoll<'a> {
-    pub async fn new(poll_cfg : &'a mut ApiConfig) -> Self {
+    pub async fn new(poll_cfg : &'a mut ApiConfigV2) -> Self {
         Self {
             config : poll_cfg,
             client : Client::new(),
         }
     }
     // can be weak and with bug test needed
-    pub async fn change_config(&mut self, conf: ApiConfig) {
+    pub async fn change_config(&mut self, conf: ApiConfigV2) {
         *self.config = conf;
     }
     pub async fn is_default(&self) -> bool {
-        self.config.endpoints.len() == 0
+        self.config.template.len() == 0
     }
     pub async fn process_polling(&self) -> Result<Vec<String>> {
         let mut buffer: Vec<String> = vec![];
         // TODO: rewrite nextly to async 
-        for point in &self.config.endpoints {
+        for point in &self.config.template {
             // let a = self.client.get(&point.url).send().await.unwrap();
             // a.text().await.unwrap();
             match self.client.request(RestMethod::from_str(&point.method).await, &point.url).send().await {
@@ -51,14 +55,13 @@ impl<'a> ApiPoll<'a> {
                         continue;
                     }
                     if let Ok(text) = resp.text().await {
-                        info!("{}: {} - Successfull grubbing info", &point.method.to_uppercase(), &point.url);
                         buffer.push(text);
                     } else {
                         error!("{}: {} - Error with extracting text field from Response", &point.method.to_uppercase(), &point.url);
                     }
                 },
                 Err(er) => {
-                    error!("{}: {} - Query crushed due to {}", &point.method.to_uppercase(), &point.url, er);
+                    error!("{}: {} endpoint is unreachable", &point.method.to_uppercase(), &point.url);
                 },
             }
         }
@@ -68,12 +71,12 @@ impl<'a> ApiPoll<'a> {
         }
     }
     pub async fn get_delay(&self) -> u32 {
-        self.config.delay
+        self.config.timeout
     }
 }
 
 // for api info pulling 
-pub async fn init_api_grub_mechanism(config: ApiConfig, rx: &mut Receiver<ApiConfig>) -> Result<()> {
+pub async fn init_api_grub_mechanism(config: ApiConfigV2, rx: &mut Receiver<ApiConfigV2>) -> Result<()> {
     info!("Initializing API-info grubbing mechanism...");
     let mut config = config;
     let mut poller = ApiPoll::new(&mut config).await;
@@ -111,16 +114,16 @@ mod net_unittests {
     } 
     #[test]
     async fn check_api_poll_change_config() {
-        let mut conf1 = ApiConfig::default();
-        let conf2 = ApiConfig { endpoints : vec![], delay : 10, };
+        let mut conf1 = ApiConfigV2::default();
+        let conf2 = ApiConfigV2::pattern();
         let mut poll = ApiPoll::new(&mut conf1).await;
         poll.change_config(conf2).await;
-        assert_eq!(poll.config.delay, 10)
+        assert_eq!(poll.config.timeout, 1)
     }
 
     #[test]
     async fn check_api_poll_is_default() {
-        let mut conf1 = ApiConfig::default();
+        let mut conf1 = ApiConfigV2::default();
         let poll = ApiPoll::new(&mut conf1).await;
         assert!(poll.is_default().await)
     }
@@ -130,15 +133,8 @@ mod net_unittests {
         use log::{set_max_level, LevelFilter};
 
         set_max_level(LevelFilter::Off);
-        let mut conf1 = ApiConfig { 
-            endpoints : vec![ 
-                ApiEndpoint { 
-                    url : String::from("https://dummy-json.mock.beeceptor.com/countries"), 
-                    method: String::from("get"),
-            }], 
-            delay : 10, 
-        };
-        let conf2 = ApiConfig::default(); 
+        let mut conf1 = ApiConfigV2::pattern();
+        let conf2 = ApiConfigV2::default(); 
 
         let mut poll = ApiPoll::new(&mut conf1).await;
         assert!(poll.process_polling().await.is_ok());
diff --git a/crates/config-delivery/src/delivery.rs b/crates/config-delivery/src/delivery.rs
index c75bbf9..6226764 100644
--- a/crates/config-delivery/src/delivery.rs
+++ b/crates/config-delivery/src/delivery.rs
@@ -2,7 +2,7 @@
 // using Unix-Socket Client
 
 use anyhow::{Error, Result};
-use integr_structs::api::ApiConfig;
+use integr_structs::api::ApiConfigV2;
 use tokio::time::{sleep, Duration};
 use tokio::net::UnixStream;
 use std::env;
@@ -18,7 +18,7 @@ enum UnixSocketConsumer {
 // to create us-client
 struct UnixSocketClient;  
 // to catch new configs from integr submod
-type ConfigGateway = Receiver<ApiConfig>;
+type ConfigGateway = Receiver<ApiConfigV2>;
 
 pub async fn init_delivery_mech(rx: ConfigGateway) -> Result<()> {
     let mut rx = rx; 
diff --git a/crates/config-delivery/src/integration.rs b/crates/config-delivery/src/integration.rs
index b2b9f55..bf883a7 100644
--- a/crates/config-delivery/src/integration.rs
+++ b/crates/config-delivery/src/integration.rs
@@ -1,18 +1,18 @@
 use std::sync::Arc;
 
 use tokio::sync::mpsc::Sender;
-use integr_structs::api::ApiConfig;
+use integr_structs::api::ApiConfigV2;
 use anyhow::Result;
 use tokio::time::{sleep, Duration};
 // mock 
 
-type Worker = Arc<Sender<ApiConfig>>;
+type Worker = Arc<Sender<ApiConfigV2>>;
 
 #[allow(dead_code, unused_variables)]
 pub async fn init_integration_mech(tx: Worker) -> Result<()> {
     loop {
         sleep(Duration::from_secs(5)).await;
-        let conf = ApiConfig::default();
+        let conf = ApiConfigV2::default();
         tx.send(conf).await?;
     }
     // Ok(())
diff --git a/crates/config-delivery/src/main.rs b/crates/config-delivery/src/main.rs
index 7f8803b..e5955b7 100644
--- a/crates/config-delivery/src/main.rs
+++ b/crates/config-delivery/src/main.rs
@@ -2,7 +2,7 @@ mod delivery;
 mod integration;
 mod logger;
 
-use integr_structs::api::ApiConfig;
+use integr_structs::api::ApiConfigV2;
 use logger::setup_logger;
 use dotenv::dotenv;
 use anyhow::Result;
@@ -23,7 +23,7 @@ async fn main() -> Result<()> {
     info!("Pulling env vars from .env file if exists ...");
     dotenv().ok();
 
-    let (tx, rx) = mpsc::channel::<ApiConfig>(1);
+    let (tx, rx) = mpsc::channel::<ApiConfigV2>(1);
     let tx = Arc::new(tx);
     let integr_jh = tokio::spawn(
         async move {
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index b061f71..4365f3f 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -29,24 +29,87 @@ impl Default for ApiConfig {
 // v2
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ApiConfigV2 {
-    id : u64,
+    pub id : u64,
     #[serde(default)]
-    template : Vec<Template>,
-    ip_address : String,
-    login : Option<String>,
-    pass : Option<String>,
-    api_key : Option<String>,
-    period : u32,               // if "0" -> inf
-    timeout :  u32,             // if "0" -> no-delay
+    pub template : Vec<Template>,
+    pub ip_address : String,
+    pub login : Option<String>,
+    pub pass : Option<String>,
+    pub api_key : Option<String>,
+    pub period : u32,               // if "0" -> inf
+    pub timeout :  u32,             // if "0" -> no-delay
 }
 
+impl Default for ApiConfigV2 {
+    fn default() -> Self {
+        ApiConfigV2 {
+            id : 0,
+            template : Vec::new(),
+            ip_address : String::from("no_ip"),
+            login : None,
+            pass : None,
+            api_key : None,
+            period : 0,               
+            timeout :  0,  
+        }
+    }
+}
+impl ApiConfigV2 {
+    pub fn template() -> Self {
+        ApiConfigV2 {
+            id : 1111,
+            template : Vec::new(),
+            ip_address : String::from("ip"),
+            login : None,
+            pass : None,
+            api_key : None,
+            period : 1111,               
+            timeout :  1111,  
+        }
+    }
+    pub fn pattern() -> Self {
+        ApiConfigV2 {
+            id : 1111,
+            template : vec![
+                Template {
+                    id : String::from("no id"),
+                    name : String::from("open api"),
+                    url : String::from("https://dummy-json.mock.beeceptor.com/countries"),
+                    method : String::from("GET"),
+                    measure : Vec::new(),
+                }
+            ],
+            ip_address : String::from("ip"),
+            login : None,
+            pass : None,
+            api_key : None,
+            period : 1,               
+            timeout :  1,  
+        }
+    }
+}
+
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Template {
-    id : String,
-    name : String,
-    url : String,
+    pub id : String,
+    pub name : String,
+    pub url : String,
+    pub method : String,
     #[serde(default)]
-    measure : Vec<String>,
+    pub measure : Vec<String>,
+}
+
+impl Default for Template {
+    fn default() -> Self {
+        Template {
+            id : String::from("no-id"),
+            name : String::from("no-name"),
+            url : String::from("no-url"),
+            method : String::from("no-method"),
+            measure : Vec::new(),
+        }
+    }
 }
 
 #[derive(Serialize, Deserialize, Debug)]
diff --git a/template_global_config.json b/template_global_config.json
index 699cae2..fe911ce 100644
--- a/template_global_config.json
+++ b/template_global_config.json
@@ -2,20 +2,30 @@
 	"id" : 1 ,
 	"template" : 	
 		[{
-			"id" :"conference", 
-			"name" : "Conference",
-			"url" : "https://$ip_address/api/v1/conferences",
+			"id" :"mock_api_1", 
+			"name" : "Mock / ",
+			"url" : "http://127.0.0.1:8081/",
+			"method" : "GET",
 			"measure" : 
 				[
-					"total", "number", "description", 
-					"shutdown", "startTime", "stopTime",
-					"participants_total", "participants_online"
+					"operation", "response", "empty_field"
 				]
-		}],
+		},
+		{
+			"id" :"mock_api_2", 
+			"name" : "Mock /ping ",
+			"url" : "http://127.0.0.1:8081/ping",
+			"method" : "GET",
+			"measure" : 
+				[
+					"operation", "response", "empty_field"
+				]
+		}
+		],
 	"ip_address" : 	"127.0.0.1:8081",
 	"login" : "",
 	"pass" : "" ,
 	"api_key" : 	"908c709827bd40n98r7209837x98273",
-	"period" : 		"10",
-	"timeout" : "2"
+	"period" : 		10,
+	"timeout" : 2
 }
-- 
2.40.1


From 498bedf1f453c18cbf381937c253332f4a4dd99d Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 23 Jan 2025 18:22:04 +0300
Subject: [PATCH 11/54] new config template

---
 config_api.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/config_api.json b/config_api.json
index fe911ce..24e96c4 100644
--- a/config_api.json
+++ b/config_api.json
@@ -8,7 +8,7 @@
 			"method" : "GET",
 			"measure" : 
 				[
-					"operation", "response", "empty_field"
+					"operation", "response"
 				]
 		},
 		{
@@ -27,5 +27,5 @@
 	"pass" : "" ,
 	"api_key" : 	"908c709827bd40n98r7209837x98273",
 	"period" : 		10,
-	"timeout" : 2
+	"timeout" : 10
 }
-- 
2.40.1


From 70b7d41f87da1855a9951a508f869252755e538f Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 23 Jan 2025 18:22:35 +0300
Subject: [PATCH 12/54] + async endpoint polling

---
 crates/api-grub/src/net.rs | 71 ++++++++++++++++++++++++++------------
 1 file changed, 48 insertions(+), 23 deletions(-)

diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index 0c6f3bd..e6a59d6 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -1,11 +1,15 @@
 // module to handle unix-socket connection + pulling info from api 
 use anyhow::{Error, Result};
-use integr_structs::api::{ApiConfig, ApiConfigV2, Template};
+use integr_structs::api::ApiConfigV2;
 use log::{error, info};
 use tokio::sync::mpsc::Receiver;
 use tokio::time::{sleep, Duration};
 use reqwest::{Client, Method};
+use std::sync::Arc;
+use tokio::task::JoinHandle;
+use tokio::sync::Mutex;
 
+type BufferType = Arc<Mutex<Vec<String>>>;
 struct RestMethod;
 
 impl RestMethod {
@@ -42,33 +46,54 @@ impl<'a> ApiPoll<'a> {
     pub async fn is_default(&self) -> bool {
         self.config.template.len() == 0
     }
-    pub async fn process_polling(&self) -> Result<Vec<String>> {
-        let mut buffer: Vec<String> = vec![];
+    pub async fn process_polling(&self) -> Result<()> {
+        let buffer: BufferType = Arc::new(Mutex::new(vec![]));
+        let mut join_handles: Vec<JoinHandle<()>> = vec![];
+        let client = Arc::new(self.client.clone());
+        let template = Arc::new(self.config.template.clone());
+
         // TODO: rewrite nextly to async 
-        for point in &self.config.template {
+        for point in template.iter() {
+            let point = Arc::new(point.clone());
+            let buffer = buffer.clone();
+            let client = client.clone();
             // let a = self.client.get(&point.url).send().await.unwrap();
             // a.text().await.unwrap();
-            match self.client.request(RestMethod::from_str(&point.method).await, &point.url).send().await {
-                Ok(resp) => {
-                    if !resp.status().is_success() {
-                        error!("ErrorCode in Response from API. Check configuration");
-                        continue;
-                    }
-                    if let Ok(text) = resp.text().await {
-                        buffer.push(text);
-                    } else {
-                        error!("{}: {} - Error with extracting text field from Response", &point.method.to_uppercase(), &point.url);
-                    }
-                },
-                Err(er) => {
-                    error!("{}: {} endpoint is unreachable", &point.method.to_uppercase(), &point.url);
-                },
-            }
+            let endpoint_processer = tokio::spawn(async move {
+                let point = point.clone();
+                match client.request(RestMethod::from_str(&point.method).await, &point.url).send().await {
+                    Ok(resp) => {
+                        if !resp.status().is_success() {
+                            error!("ErrorCode in Response from API. Check configuration");
+                            return;
+                        }
+                        if let Ok(text) = resp.text().await {
+                            let mut buffer = buffer.lock().await;
+                            buffer.push(text);
+                        } else {
+                            error!("{}: {} - Error with extracting text field from Response", &point.method.to_uppercase(), &point.url);
+                        }
+                    },
+                    Err(_) => {
+                        error!("{}: {} endpoint is unreachable", &point.method.to_uppercase(), &point.url);
+                    },
+                }
+            });
+            join_handles.push(endpoint_processer);
         }
+
+        for i in join_handles {
+            let _ = i.await;
+        }
+
+        let buffer = buffer.lock().await;
         match &buffer.len() {
             0 => Err(Error::msg("Error due to API grubbing. Check config" )),
-            _ => Ok(buffer),
+            _ => {
+                Ok(())
+            },
         }
+        // Ok(())
     }
     pub async fn get_delay(&self) -> u32 {
         self.config.timeout
@@ -80,6 +105,7 @@ pub async fn init_api_grub_mechanism(config: ApiConfigV2, rx: &mut Receiver<ApiC
     info!("Initializing API-info grubbing mechanism...");
     let mut config = config;
     let mut poller = ApiPoll::new(&mut config).await;
+    // let arc_poller = Arc::new(poller);
     loop {
         if poller.is_default().await {
             sleep(Duration::from_secs(5)).await;
@@ -101,7 +127,6 @@ pub async fn init_api_grub_mechanism(config: ApiConfigV2, rx: &mut Receiver<ApiC
 mod net_unittests {
     use super::*;
     use tokio::test;
-    use integr_structs::api::{ApiConfig, ApiEndpoint};
     
     #[test]
     async fn check_str_to_rest_method() {
@@ -124,7 +149,7 @@ mod net_unittests {
     #[test]
     async fn check_api_poll_is_default() {
         let mut conf1 = ApiConfigV2::default();
-        let poll = ApiPoll::new(&mut conf1).await;
+        let mut poll = ApiPoll::new(&mut conf1).await;
         assert!(poll.is_default().await)
     }
 
-- 
2.40.1


From 72c59dbce9aab10d54eb5b99e35115dc0e859c5d Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 23 Jan 2025 19:40:38 +0300
Subject: [PATCH 13/54] v2 completed, getting + preproc

---
 crates/api-grub/src/net.rs       | 10 +++++++---
 crates/integr-structs/Cargo.toml |  1 +
 crates/integr-structs/src/api.rs | 33 ++++++++++++++++++++++++++++----
 3 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index e6a59d6..ba587cb 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -1,6 +1,6 @@
 // module to handle unix-socket connection + pulling info from api 
 use anyhow::{Error, Result};
-use integr_structs::api::ApiConfigV2;
+use integr_structs::api::{ApiConfigV2, ProcessedEndpoint};
 use log::{error, info};
 use tokio::sync::mpsc::Receiver;
 use tokio::time::{sleep, Duration};
@@ -9,7 +9,7 @@ use std::sync::Arc;
 use tokio::task::JoinHandle;
 use tokio::sync::Mutex;
 
-type BufferType = Arc<Mutex<Vec<String>>>;
+type BufferType = Arc<Mutex<Vec<String>>>; 
 struct RestMethod;
 
 impl RestMethod {
@@ -68,6 +68,10 @@ impl<'a> ApiPoll<'a> {
                             return;
                         }
                         if let Ok(text) = resp.text().await {
+                            // 
+                            let a = ProcessedEndpoint::from_target_response(&text, &point);
+                            println!("{}", a.unwrap());
+                            // 
                             let mut buffer = buffer.lock().await;
                             buffer.push(text);
                         } else {
@@ -149,7 +153,7 @@ mod net_unittests {
     #[test]
     async fn check_api_poll_is_default() {
         let mut conf1 = ApiConfigV2::default();
-        let mut poll = ApiPoll::new(&mut conf1).await;
+        let poll = ApiPoll::new(&mut conf1).await;
         assert!(poll.is_default().await)
     }
 
diff --git a/crates/integr-structs/Cargo.toml b/crates/integr-structs/Cargo.toml
index fdf9743..9183deb 100644
--- a/crates/integr-structs/Cargo.toml
+++ b/crates/integr-structs/Cargo.toml
@@ -4,5 +4,6 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+anyhow = "1.0.95"
 serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.135"
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 4365f3f..de77a5e 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
-
 use serde::{Serialize, Deserialize};
-use serde_json::Value;
+use serde_json::{ to_string_pretty, Value };
+use anyhow::Result;
 
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -90,7 +90,7 @@ impl ApiConfigV2 {
 }
 
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Template {
     pub id : String,
     pub name : String,
@@ -117,6 +117,31 @@ pub struct ProcessedEndpoint {
     id : String,
     name : String,
     url : String,
+    method : String,
     #[serde(default)]
-    metrics : HashMap<String, Value>
+    metrics : HashMap<String, Value>,
+}
+
+impl ProcessedEndpoint {
+    pub fn new(id: &str, name: &str, url: &str, method: &str, metrics: HashMap<String, Value>) -> Self {
+        ProcessedEndpoint {
+            id : id.to_owned(),
+            name : name.to_owned(),
+            url : url.to_owned(),
+            method : method.to_owned(), 
+            metrics : metrics,
+        }
+    }
+    pub fn from_target_response(response: &str, keys: &Template) -> Result<String> {
+        let mut hm: HashMap<String, Value> = HashMap::new();
+        let mut response: Value = serde_json::from_str(response)?;
+
+        let _ = keys.measure.iter()
+            .map(|key| (key, response[key].take()))
+            .for_each(|(key, value)| {
+                hm.insert(key.clone(), value);
+            });
+        let val = ProcessedEndpoint::new(&keys.id, &keys.name, &keys.url, &keys.method,hm);
+        Ok(to_string_pretty(&val)?)
+    }
 }
\ No newline at end of file
-- 
2.40.1


From 0bd9b55f87d181511e71c6aa00428c3c5ebe518e Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 23 Jan 2025 21:04:54 +0300
Subject: [PATCH 14/54] valid (nearly) db export and so on

---
 .env                       |   7 ++-
 crates/api-grub/Cargo.toml |   5 +-
 crates/api-grub/src/net.rs | 122 +++++++++++++++++++++++++++++--------
 3 files changed, 107 insertions(+), 27 deletions(-)

diff --git a/.env b/.env
index 2cbea56..b406691 100644
--- a/.env
+++ b/.env
@@ -1,3 +1,8 @@
 CONFIG_SERVER_CREDS = "ws://127.0.0.1:8080"
 API_GRUBBER_SOCKET = "api-grub.sock"
-PREPROC_SOCKET = "preproc.sock"
\ No newline at end of file
+PREPROC_SOCKET = "preproc.sock"
+
+DB_HOST = "192.168.2.37"
+DB_USER = "vlad"
+DB_PASSWORD = "vlad"
+DB_DBNAME = "vks"
\ No newline at end of file
diff --git a/crates/api-grub/Cargo.toml b/crates/api-grub/Cargo.toml
index 8c51835..b5e4a92 100644
--- a/crates/api-grub/Cargo.toml
+++ b/crates/api-grub/Cargo.toml
@@ -12,4 +12,7 @@ env_logger = "0.11.6"
 log = "0.4.25"
 anyhow = "1.0.95"
 chrono = "0.4.39"
-reqwest = { version = "0.12.12", features = ["rustls-tls", "json"] }
\ No newline at end of file
+reqwest = { version = "0.12.12", features = ["rustls-tls", "json"] }
+deadpool-postgres = "0.14.1"
+tokio-postgres = "0.7.12"
+dotenv = "0.15.0"
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index ba587cb..ee13e5f 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -2,14 +2,70 @@
 use anyhow::{Error, Result};
 use integr_structs::api::{ApiConfigV2, ProcessedEndpoint};
 use log::{error, info};
+use serde_json::Value;
 use tokio::sync::mpsc::Receiver;
 use tokio::time::{sleep, Duration};
 use reqwest::{Client, Method};
 use std::sync::Arc;
 use tokio::task::JoinHandle;
-use tokio::sync::Mutex;
+// use tokio::sync::Mutex;
+use tokio_postgres::types::ToSql;
+use deadpool_postgres::{Config, Pool, Runtime, Client as PgClient};
+use tokio_postgres::NoTls;
+use dotenv::dotenv;
+use std::env;
+
+// type BufferType = Arc<Mutex<Vec<String>>>; 
+
+struct Exporter {
+    pool : Option<Pool>,
+}
+
+impl Exporter {
+    fn config_construct() -> Result<Config> {
+        let mut cfg = Config::new();
+        cfg.host = Some(env::var("DB_HOST")?);
+        cfg.dbname = Some(env::var("DB_DBNAME")?);
+        cfg.user = Some(env::var("DB_USER")?);
+        cfg.password = Some(env::var("DB_PASSWORD")?);
+        Ok(cfg)
+    }
+    fn pool_construct() -> Option<Pool> {
+        return match Self::config_construct() {
+            Ok(config) => {
+                if let Ok(pool) = config.create_pool(Some(Runtime::Tokio1), NoTls) {
+                    info!("Connected to PostgreSQL");
+                    return Some(pool);
+                }
+                None
+            },
+            Err(_) => {
+                error!("Bad DB credentials or it's unreachable");
+                None
+            },
+        } 
+    } 
+    pub fn is_no_connection(&self) -> bool { self.pool.is_none() }
+    pub fn init() -> Self {
+        Self {
+            pool : Self::pool_construct()
+        }
+    }
+    pub async fn get_connection_from_pool(&self) -> Option<PgClient> {
+        if let Some(pool) = &self.pool {
+            return Some(pool.get().await.ok()?);
+        }
+        None
+    } 
+    pub async fn export_data(client: PgClient, metrics: &str) -> Result<()> {
+        // client.
+        let query = "INSERT INTO metrics (body) VALUES ($1);"; 
+        let _ = client.execute(query, &[&query]).await?;
+        Ok(())
+    }
+
+}
 
-type BufferType = Arc<Mutex<Vec<String>>>; 
 struct RestMethod;
 
 impl RestMethod {
@@ -46,34 +102,43 @@ impl<'a> ApiPoll<'a> {
     pub async fn is_default(&self) -> bool {
         self.config.template.len() == 0
     }
-    pub async fn process_polling(&self) -> Result<()> {
-        let buffer: BufferType = Arc::new(Mutex::new(vec![]));
-        let mut join_handles: Vec<JoinHandle<()>> = vec![];
+    pub async fn process_polling(&self, exporter: Arc<Exporter>) -> Result<()> {
+        // let buffer: BufferType = Arc::new(Mutex::new(vec![]));
+        let mut join_handles: Vec<JoinHandle<Result<()>>> = vec![];
         let client = Arc::new(self.client.clone());
         let template = Arc::new(self.config.template.clone());
 
         // TODO: rewrite nextly to async 
         for point in template.iter() {
             let point = Arc::new(point.clone());
-            let buffer = buffer.clone();
+            // let buffer = buffer.clone();
             let client = client.clone();
-            // let a = self.client.get(&point.url).send().await.unwrap();
-            // a.text().await.unwrap();
+            let exporter = exporter.clone();
             let endpoint_processer = tokio::spawn(async move {
                 let point = point.clone();
                 match client.request(RestMethod::from_str(&point.method).await, &point.url).send().await {
                     Ok(resp) => {
                         if !resp.status().is_success() {
                             error!("ErrorCode in Response from API. Check configuration");
-                            return;
+                            return Err(Error::msg("Error during sending request"));
                         }
                         if let Ok(text) = resp.text().await {
                             // 
-                            let a = ProcessedEndpoint::from_target_response(&text, &point);
-                            println!("{}", a.unwrap());
+                            let metrics = ProcessedEndpoint::from_target_response(&text, &point)?;
                             // 
-                            let mut buffer = buffer.lock().await;
-                            buffer.push(text);
+                            if let Some(conn) = exporter.get_connection_from_pool().await {
+                                if let Err(er) =  Exporter::export_data(conn, &metrics).await {
+                                    error!("Cannot export data to DB during to: {}", er);
+                                    return Err(Error::msg("Error during exporting data to DB"));
+                                }
+                            } else {
+                                if !exporter.is_no_connection() {
+                                    return Err(Error::msg("Error during getting connection from pool"));
+                                }
+                            }
+
+                            // let mut buffer = buffer.lock().await;
+                            // buffer.push(text);
                         } else {
                             error!("{}: {} - Error with extracting text field from Response", &point.method.to_uppercase(), &point.url);
                         }
@@ -82,6 +147,7 @@ impl<'a> ApiPoll<'a> {
                         error!("{}: {} endpoint is unreachable", &point.method.to_uppercase(), &point.url);
                     },
                 }
+                Ok(())
             });
             join_handles.push(endpoint_processer);
         }
@@ -90,14 +156,14 @@ impl<'a> ApiPoll<'a> {
             let _ = i.await;
         }
 
-        let buffer = buffer.lock().await;
-        match &buffer.len() {
-            0 => Err(Error::msg("Error due to API grubbing. Check config" )),
-            _ => {
-                Ok(())
-            },
-        }
-        // Ok(())
+        // let buffer = buffer.lock().await;
+        // match &buffer.len() {
+        //     0 => Err(Error::msg("Error due to API grubbing. Check config" )),
+        //     _ => {
+        //         Ok(())
+        //     },
+        // }
+        Ok(())
     }
     pub async fn get_delay(&self) -> u32 {
         self.config.timeout
@@ -107,10 +173,15 @@ impl<'a> ApiPoll<'a> {
 // for api info pulling 
 pub async fn init_api_grub_mechanism(config: ApiConfigV2, rx: &mut Receiver<ApiConfigV2>) -> Result<()> {
     info!("Initializing API-info grubbing mechanism...");
+    info!("Loading vars from .env file if exists...");
+    let _ = dotenv().ok();
+
     let mut config = config;
     let mut poller = ApiPoll::new(&mut config).await;
-    // let arc_poller = Arc::new(poller);
+    let client = Exporter::init(); 
+    let shared_pool = Arc::new(client);
     loop {
+        let shared_pool = shared_pool.clone();
         if poller.is_default().await {
             sleep(Duration::from_secs(5)).await;
         } else {
@@ -120,7 +191,7 @@ pub async fn init_api_grub_mechanism(config: ApiConfigV2, rx: &mut Receiver<ApiC
                     info!("Config changed");
                 }
             }
-            info!("Data from API: {:?}", poller.process_polling().await);
+            info!("Data from API: {:?}", poller.process_polling(shared_pool).await);
             sleep(Duration::from_secs(poller.get_delay().await as u64)).await;
         }
     }
@@ -164,11 +235,12 @@ mod net_unittests {
         set_max_level(LevelFilter::Off);
         let mut conf1 = ApiConfigV2::pattern();
         let conf2 = ApiConfigV2::default(); 
+        let exporter = Arc::new(Exporter::init());
 
         let mut poll = ApiPoll::new(&mut conf1).await;
-        assert!(poll.process_polling().await.is_ok());
+        assert!(poll.process_polling(exporter.clone()).await.is_ok());
 
         poll.change_config(conf2).await;
-        assert!(poll.process_polling().await.is_err());
+        assert!(poll.process_polling(exporter.clone()).await.is_err());
     }
 }
\ No newline at end of file
-- 
2.40.1


From 5e22a5e6b2ef57f8014f105622495f4bcbce73fd Mon Sep 17 00:00:00 2001
From: Vladislav Drozdov <ya2@ya.ru>
Date: Thu, 23 Jan 2025 21:30:13 +0300
Subject: [PATCH 15/54] progress update

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 4bfcad2..072cfc6 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@
 
 | Crate (submodule)   |  Progress  |
 |---|---|
-|`api-grub`   | ✅✅✅✅✅✅✅🔲🔲🔲  |
-|`config-delivery`   | ✅✅✅✅✅✅🔲🔲🔲🔲  |
-|`integrs-structs`   | ✅✅✅✅✅✅🔲🔲🔲🔲  |
-|`preproc`   | ✅✅✅🔲🔲🔲🔲🔲🔲🔲  |
+|`api-grub`   | ✅✅✅✅✅✅✅✅✅🔲  |
+|`config-delivery`   | ✅✅✅✅✅✅✅🔲🔲🔲  |
+|`integrs-structs`   | ✅✅✅✅✅✅✅✅🔲🔲  |
+|`preproc`   | ✅✅✅❌❌❌❌❌❌❌  | (разработка временно остановлена)
-- 
2.40.1


From 21b1f3035447b56c2966aabc3cb8ace77eef5cac Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Mon, 27 Jan 2025 14:00:55 +0300
Subject: [PATCH 16/54] + exporter communication example

---
 .gitignore                 |  3 ++-
 config_api.json            |  7 +++++--
 crates/api-grub/Cargo.toml |  2 +-
 crates/api-grub/src/net.rs | 24 +++++++++++++++++++-----
 4 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/.gitignore b/.gitignore
index 5195f75..2a25479 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 /target
 Cargo.lock
-*.sock
\ No newline at end of file
+*.sock
+.env
\ No newline at end of file
diff --git a/config_api.json b/config_api.json
index 24e96c4..d5be22f 100644
--- a/config_api.json
+++ b/config_api.json
@@ -8,7 +8,8 @@
 			"method" : "GET",
 			"measure" : 
 				[
-					"operation", "response"
+					"response", "test_metric_1", "test_metric_2",
+					"test_metric_3", "test_metric_4", "test_metric_5"
 				]
 		},
 		{
@@ -18,7 +19,9 @@
 			"method" : "GET",
 			"measure" : 
 				[
-					"operation", "response", "empty_field"
+					"response", "test_metric_1", "test_metric_2",
+					"test_metric_3", "test_metric_4", "test_metric_5",
+					"empty_field"
 				]
 		}
 		],
diff --git a/crates/api-grub/Cargo.toml b/crates/api-grub/Cargo.toml
index b5e4a92..cf61de9 100644
--- a/crates/api-grub/Cargo.toml
+++ b/crates/api-grub/Cargo.toml
@@ -13,6 +13,6 @@ log = "0.4.25"
 anyhow = "1.0.95"
 chrono = "0.4.39"
 reqwest = { version = "0.12.12", features = ["rustls-tls", "json"] }
-deadpool-postgres = "0.14.1"
+deadpool-postgres = { version = "0.14.1", features = ["serde"] }
 tokio-postgres = "0.7.12"
 dotenv = "0.15.0"
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index ee13e5f..e2580b2 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -2,18 +2,17 @@
 use anyhow::{Error, Result};
 use integr_structs::api::{ApiConfigV2, ProcessedEndpoint};
 use log::{error, info};
-use serde_json::Value;
 use tokio::sync::mpsc::Receiver;
 use tokio::time::{sleep, Duration};
 use reqwest::{Client, Method};
 use std::sync::Arc;
 use tokio::task::JoinHandle;
 // use tokio::sync::Mutex;
-use tokio_postgres::types::ToSql;
 use deadpool_postgres::{Config, Pool, Runtime, Client as PgClient};
 use tokio_postgres::NoTls;
 use dotenv::dotenv;
 use std::env;
+use serde::{Deserialize, Serialize};
 
 // type BufferType = Arc<Mutex<Vec<String>>>; 
 
@@ -59,8 +58,8 @@ impl Exporter {
     } 
     pub async fn export_data(client: PgClient, metrics: &str) -> Result<()> {
         // client.
-        let query = "INSERT INTO metrics (body) VALUES ($1);"; 
-        let _ = client.execute(query, &[&query]).await?;
+        let query = client.prepare_cached("INSERT INTO metrics (body) VALUES ($1);").await?; 
+        let _ = client.query(&query, &[&metrics]).await?;
         Ok(())
     }
 
@@ -125,9 +124,24 @@ impl<'a> ApiPoll<'a> {
                         if let Ok(text) = resp.text().await {
                             // 
                             let metrics = ProcessedEndpoint::from_target_response(&text, &point)?;
+                            // dbg!(&metrics);
+                            println!("{}", &metrics);
                             // 
                             if let Some(conn) = exporter.get_connection_from_pool().await {
-                                if let Err(er) =  Exporter::export_data(conn, &metrics).await {
+                                
+                                // TEST: to exporter 
+                                let res = client.request(
+                                    RestMethod::from_str("post").await,
+                                    "http://192.168.2.34:9101/update")
+                                .json(&metrics)
+                                .send().await;
+                                if let Err(er) = res {
+                                    error!("Cannot send data to exporter due to: {}", er);
+                                } else {
+                                    println!("{:?}", res.unwrap().text().await);
+                                }
+
+                                if let Err(er) = Exporter::export_data(conn, &metrics).await {
                                     error!("Cannot export data to DB during to: {}", er);
                                     return Err(Error::msg("Error during exporting data to DB"));
                                 }
-- 
2.40.1


From d7f4cedc00fd7b93386e02d33f8465a2170063ce Mon Sep 17 00:00:00 2001
From: Vladislav Drozdov <ya2@ya.ru>
Date: Mon, 27 Jan 2025 14:03:27 +0300
Subject: [PATCH 17/54] refactor

---
 .env | 8 --------
 1 file changed, 8 deletions(-)
 delete mode 100644 .env

diff --git a/.env b/.env
deleted file mode 100644
index b406691..0000000
--- a/.env
+++ /dev/null
@@ -1,8 +0,0 @@
-CONFIG_SERVER_CREDS = "ws://127.0.0.1:8080"
-API_GRUBBER_SOCKET = "api-grub.sock"
-PREPROC_SOCKET = "preproc.sock"
-
-DB_HOST = "192.168.2.37"
-DB_USER = "vlad"
-DB_PASSWORD = "vlad"
-DB_DBNAME = "vks"
\ No newline at end of file
-- 
2.40.1


From 268f042d4f78a01b22e512261232b51a356cbf4b Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Mon, 27 Jan 2025 14:06:19 +0300
Subject: [PATCH 18/54] refactor#2

---
 .env.example | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 .env.example

diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..44f53d8
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,8 @@
+CONFIG_SERVER_CREDS = "ws://ip.ip.ip.ip:port"
+API_GRUBBER_SOCKET = "api-grubber.sock"
+PREPROC_SOCKET = "preproc.sock"
+
+DB_HOST = "ip.addr.postgresql.server"
+DB_USER = "db_user"
+DB_PASSWORD = "db_user_password"
+DB_DBNAME = "db_name"
\ No newline at end of file
-- 
2.40.1


From eda3a61acc61ba6e088dab72f2b7223e8b7c6916 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Mon, 27 Jan 2025 14:06:58 +0300
Subject: [PATCH 19/54] env fle input

---
 .env.example | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.env.example b/.env.example
index 44f53d8..a8a5abb 100644
--- a/.env.example
+++ b/.env.example
@@ -5,4 +5,4 @@ PREPROC_SOCKET = "preproc.sock"
 DB_HOST = "ip.addr.postgresql.server"
 DB_USER = "db_user"
 DB_PASSWORD = "db_user_password"
-DB_DBNAME = "db_name"
\ No newline at end of file
+DB_DBNAME = "db_name"1
\ No newline at end of file
-- 
2.40.1


From 90588b27d582634a117e9c0553be6ffa372e9aa6 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Mon, 10 Feb 2025 13:21:42 +0300
Subject: [PATCH 20/54] prerefactor changes

---
 crates/api-grub/src/config.rs    | 2 +-
 crates/api-grub/src/net.rs       | 7 ++++++-
 crates/integr-structs/src/api.rs | 6 +++---
 3 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/crates/api-grub/src/config.rs b/crates/api-grub/src/config.rs
index f68e77e..11fe491 100644
--- a/crates/api-grub/src/config.rs
+++ b/crates/api-grub/src/config.rs
@@ -1,7 +1,7 @@
 //  mod to communicate with api-grub config file
 //  1) check changes in unix-socket  
 //  2) save changes in local config file
-use integr_structs::api::{ApiConfig, ApiConfigV2};
+use integr_structs::api::ApiConfigV2;
 use anyhow::{Error, Ok, Result};
 use log::{info, warn, error}; 
 use std::{fs, path::Path};
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index e2580b2..b7b48bd 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -12,7 +12,6 @@ use deadpool_postgres::{Config, Pool, Runtime, Client as PgClient};
 use tokio_postgres::NoTls;
 use dotenv::dotenv;
 use std::env;
-use serde::{Deserialize, Serialize};
 
 // type BufferType = Arc<Mutex<Vec<String>>>; 
 
@@ -107,6 +106,8 @@ impl<'a> ApiPoll<'a> {
         let client = Arc::new(self.client.clone());
         let template = Arc::new(self.config.template.clone());
 
+        if self.is_default().await { return Err(Error::msg("Default config with no endpoints")) }
+
         // TODO: rewrite nextly to async 
         for point in template.iter() {
             let point = Arc::new(point.clone());
@@ -155,10 +156,12 @@ impl<'a> ApiPoll<'a> {
                             // buffer.push(text);
                         } else {
                             error!("{}: {} - Error with extracting text field from Response", &point.method.to_uppercase(), &point.url);
+                            return Err(Error::msg("Error with extracting text field from Response"));
                         }
                     },
                     Err(_) => {
                         error!("{}: {} endpoint is unreachable", &point.method.to_uppercase(), &point.url);
+                        return Err(Error::msg("Endpoint is unreachable"));
                     },
                 }
                 Ok(())
@@ -254,7 +257,9 @@ mod net_unittests {
         let mut poll = ApiPoll::new(&mut conf1).await;
         assert!(poll.process_polling(exporter.clone()).await.is_ok());
 
+        dbg!(&poll.config);
         poll.change_config(conf2).await;
+        dbg!(&poll.config);
         assert!(poll.process_polling(exporter.clone()).await.is_err());
     }
 }
\ No newline at end of file
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index de77a5e..c062da7 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -27,7 +27,7 @@ impl Default for ApiConfig {
 }
 
 // v2
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct ApiConfigV2 {
     pub id : u64,
     #[serde(default)]
@@ -90,7 +90,7 @@ impl ApiConfigV2 {
 }
 
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 pub struct Template {
     pub id : String,
     pub name : String,
@@ -106,7 +106,7 @@ impl Default for Template {
             id : String::from("no-id"),
             name : String::from("no-name"),
             url : String::from("no-url"),
-            method : String::from("no-method"),
+            method : String::from("post"),
             measure : Vec::new(),
         }
     }
-- 
2.40.1


From 3039a66a11c2af847a32e30f0809cb3319ce5132 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 11 Feb 2025 18:35:03 +0300
Subject: [PATCH 21/54] mock exporter added

---
 Cargo.toml                  |  2 +-
 crates/exporter/Cargo.toml  | 10 ++++++++
 crates/exporter/src/main.rs | 46 +++++++++++++++++++++++++++++++++++++
 3 files changed, 57 insertions(+), 1 deletion(-)
 create mode 100644 crates/exporter/Cargo.toml
 create mode 100644 crates/exporter/src/main.rs

diff --git a/Cargo.toml b/Cargo.toml
index bbeed62..6b81d58 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [workspace]
 resolver = "2"
 members = [
-    "crates/api-grub", "crates/config-delivery", "crates/integr-structs", "crates/preproc", 
+    "crates/api-grub", "crates/config-delivery", "crates/exporter", "crates/integr-structs", "crates/preproc", 
 ]
 
 [profile.dev]
diff --git a/crates/exporter/Cargo.toml b/crates/exporter/Cargo.toml
new file mode 100644
index 0000000..a3f0402
--- /dev/null
+++ b/crates/exporter/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "exporter"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+axum = "0.8.1"
+prometheus = "0.13.4"
+tokio = { version = "1.43.0", features = ["full"] }
+
diff --git a/crates/exporter/src/main.rs b/crates/exporter/src/main.rs
new file mode 100644
index 0000000..9bee6e7
--- /dev/null
+++ b/crates/exporter/src/main.rs
@@ -0,0 +1,46 @@
+use axum::{extract::State, routing::get, Router};
+use prometheus::{Encoder, TextEncoder, Counter, Opts, Registry};
+use std::sync::{Arc, Mutex};
+use tokio::net::TcpListener;
+
+struct AppState {
+    registry: Registry,
+    counter: Mutex<Counter>,
+}
+
+async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
+    let encoder = TextEncoder::new();
+    let mut buffer = Vec::new();
+    let metric_families = state.registry.gather();
+    encoder.encode(&metric_families, &mut buffer).unwrap();
+    String::from_utf8(buffer).unwrap()
+}
+
+async fn increment_handler(State(state): State<Arc<AppState>>) -> &'static str {
+    let mut counter = state.counter.lock().unwrap();
+    counter.inc();
+    "Counter incremented"
+}
+
+#[tokio::main]
+async fn main() {
+    let registry = Registry::new();
+    let counter_opts = Opts::new("example_counter", "Пример счётчика");
+    let counter = Counter::with_opts(counter_opts).unwrap();
+    registry.register(Box::new(counter.clone())).unwrap();
+
+    let state = Arc::new(AppState {
+        registry,
+        counter: Mutex::new(counter),
+    });
+
+    let app = Router::new()
+        .route("/metrics", get(metrics_handler))
+        .route("/increment", get(increment_handler))
+        .with_state(state.clone());
+
+    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
+    // axum::Server::from_tcp(listener).unwrap().serve(app.into_make_service()).await.unwrap();
+    // let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+}
\ No newline at end of file
-- 
2.40.1


From 0dde8e76047ee1b22dad3f26a38771f25e2ca92e Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 11 Feb 2025 20:43:41 +0300
Subject: [PATCH 22/54] dockerfile added (glibc6 error on running)

---
 crates/exporter/Dockerfile | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 crates/exporter/Dockerfile

diff --git a/crates/exporter/Dockerfile b/crates/exporter/Dockerfile
new file mode 100644
index 0000000..8d003bd
--- /dev/null
+++ b/crates/exporter/Dockerfile
@@ -0,0 +1,17 @@
+FROM rust:1.75 AS builder
+
+WORKDIR /app
+
+COPY . .
+
+RUN cargo build --release
+
+FROM debian:bullseye-slim
+
+WORKDIR /app
+# RUN sudo apt update
+# RUN sudo apt install libc6
+COPY --from=builder /app/target/release/exporter /app/server
+EXPOSE 9100
+
+CMD ["/app/server"]
-- 
2.40.1


From 784a6f751709f564a25332a0177cac6dec1ef6c0 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 11 Feb 2025 20:43:56 +0300
Subject: [PATCH 23/54] exporter summary test

---
 crates/exporter/src/main.rs | 65 ++++++++++++++++++++++++++++++++++---
 1 file changed, 60 insertions(+), 5 deletions(-)

diff --git a/crates/exporter/src/main.rs b/crates/exporter/src/main.rs
index 9bee6e7..93bcb8b 100644
--- a/crates/exporter/src/main.rs
+++ b/crates/exporter/src/main.rs
@@ -1,17 +1,31 @@
 use axum::{extract::State, routing::get, Router};
-use prometheus::{Encoder, TextEncoder, Counter, Opts, Registry};
+use prometheus::{proto::{Histogram, Quantile, Summary}, Counter, Encoder, Opts, Registry, TextEncoder};
 use std::sync::{Arc, Mutex};
 use tokio::net::TcpListener;
 
 struct AppState {
     registry: Registry,
     counter: Mutex<Counter>,
+    sum : Mutex<Summary>,
 }
 
 async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
     let encoder = TextEncoder::new();
     let mut buffer = Vec::new();
-    let metric_families = state.registry.gather();
+    // 
+    let mut fm = prometheus::proto::MetricFamily::new();
+    // prometheus::Registry::
+    let mut met = prometheus::proto::Metric::new(); 
+    let mutex_guard = state.sum.lock().unwrap();
+    met.set_summary(mutex_guard.clone());
+    // let metric = met.take_label();
+    fm.set_metric(vec![met].into());
+    fm.set_help("example summary".to_string());
+    fm.set_name("example_summary".to_string());
+    fm.set_field_type(prometheus::proto::MetricType::SUMMARY);
+    
+    let mut metric_families = state.registry.gather();
+    metric_families.push(fm);
     encoder.encode(&metric_families, &mut buffer).unwrap();
     String::from_utf8(buffer).unwrap()
 }
@@ -22,25 +36,66 @@ async fn increment_handler(State(state): State<Arc<AppState>>) -> &'static str {
     "Counter incremented"
 }
 
+async fn summary_handler(State(state): State<Arc<AppState>>) -> &'static str {
+    let mut sum = state.sum.lock().unwrap();
+    let qs = sum.get_quantile();
+    let new_qs: Vec<Quantile> = qs
+        .into_iter()
+        .enumerate()
+        .map(|(idx, q)| {
+            let mut q = q.to_owned();
+            q.set_value(q.get_value() + idx as f64);
+            // q.set_quantile(q.get_quantile() * 2.0);
+            q
+        })
+        .collect();
+    sum.set_quantile(new_qs.into());
+    "Summary changed"
+}
+
+
 #[tokio::main]
 async fn main() {
     let registry = Registry::new();
     let counter_opts = Opts::new("example_counter", "Пример счётчика");
+    // let histogram_opts = Opts::new("example_histogram", "Пример histogram");
+
+    use prometheus::proto::{Summary, Quantile};
+    // use prometheus::proto::
+
+    // let guage = prometheus::ProtobufEncoder::new();
+
+
+
+    let mut sunops = Summary::new();
+    let mut q1 = Quantile::new();
+    let mut q2 = Quantile::new();
+
+    q1.set_quantile(25.0);
+    q2.set_quantile(75.0);
+    // prometheus::proto::Metric::
+
+    let vq = vec![q1, q2];
+    sunops.set_quantile(vq.into());
+
     let counter = Counter::with_opts(counter_opts).unwrap();
     registry.register(Box::new(counter.clone())).unwrap();
+    // registry.register(Box::new(prometheus::proto::MetricFamily::));
+    // registry.register(Box::new(sunops.clone())).unwrap();
+    
 
     let state = Arc::new(AppState {
         registry,
         counter: Mutex::new(counter),
+        sum : Mutex::new(sunops)
     });
 
     let app = Router::new()
         .route("/metrics", get(metrics_handler))
         .route("/increment", get(increment_handler))
+        .route("/sum", get(summary_handler))
         .with_state(state.clone());
 
-    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
-    // axum::Server::from_tcp(listener).unwrap().serve(app.into_make_service()).await.unwrap();
-    // let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    let listener = TcpListener::bind("0.0.0.0:9100").await.unwrap();
     axum::serve(listener, app).await.unwrap();
 }
\ No newline at end of file
-- 
2.40.1


From 5dae0fe2a5789a3f00af8a80dba82b8ef8c4dfc5 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 10:23:38 +0300
Subject: [PATCH 24/54] json mod added

---
 crates/api-grub/src/json.rs      | 176 +++++++++++++++++++++++++++++++
 crates/api-grub/src/main.rs      |   1 +
 crates/integr-structs/src/api.rs |  25 +++++
 3 files changed, 202 insertions(+)
 create mode 100644 crates/api-grub/src/json.rs

diff --git a/crates/api-grub/src/json.rs b/crates/api-grub/src/json.rs
new file mode 100644
index 0000000..f0f64d6
--- /dev/null
+++ b/crates/api-grub/src/json.rs
@@ -0,0 +1,176 @@
+// use serde::{de::value, Serialize};
+use serde_json::{json, Value};
+use integr_structs::api::v3::{TestMetric, TestMetricOutput};
+
+pub struct JsonParser;
+
+impl JsonParser {
+    pub fn parse(targets: &Vec<TestMetric>, json: &str) -> Value {
+        let mut res_vec: Vec<TestMetricOutput> = Vec::new(); 
+        for target in targets {
+            let metric = match target.addr.contains("[") {
+                true => JsonParser::get_sum_of_metrics_in_array(target, json),
+                false => JsonParser::get_metric(target, json),
+            };
+            res_vec.push(TestMetricOutput::new_with_slices(&target.id, &target.json_type, metric));
+        }  
+        serde_json::to_value(res_vec).unwrap_or(Value::Null)
+    }
+    fn get_sum_of_metrics_in_array(target: &TestMetric, json: &str) -> Value {
+        if target.addr.is_empty() {
+            return Value::Null;
+        }
+
+        let mut vec_value: Vec<Value> = Vec::new();
+        let mut array_key = String::new();
+        let mut value_json: Value = serde_json::from_str(json).unwrap_or(Value::Null);
+
+        let target_attr_vec = target.addr
+            .split_terminator('.')
+            .collect::<Vec<&str>>();
+        // for keys in [] brackets
+        let mut key_tag = String::new();
+
+        for (global_idx, &key) in target_attr_vec.iter().enumerate() {
+            // if array 
+            let key_checked = if key.contains('[') {
+                let key_idx = key.find("[").unwrap();
+                key_tag = key.chars()
+                    .enumerate()
+                    .filter(|(idx, chr)| *idx > key_idx && *chr != ']')
+                    .map(|(_, chr)| chr)
+                    .collect::<String>();
+                dbg!(&key_tag);
+                key.chars()
+                    .enumerate()
+                    .filter(|(idx, _)| *idx < key_idx)
+                    .map(|(_, chr)| chr)
+                    .collect::<String>()
+                // dbg!(value_json.get(&array_key).unwrap_or(&Value::Null));
+                // value_json = value_json.get(array_key).unwrap_or(&Value::Null).clone();
+                // continue;
+                // new_key.as_str()
+                // dbg!(key);       APPROVED 
+            // TODO: need to check key in [] type of [KEY]
+            } else {key.to_owned()};
+            
+            // if already array 
+            match value_json.get(key_checked) {
+                Some(val) => {
+                    match val {
+                        Value::Array(array) => {
+                            // form new target array
+                            let new_array_target = target_attr_vec
+                                .iter()
+                                .enumerate()
+                                .filter(|(idx, _)| *idx > global_idx)
+                                .map(|(_, &chr)| chr.to_owned())
+                                .collect::<Vec<String>>();
+                            // get_values_in_array
+                            // get_tags_in_array
+                            // // slice_tags_with_values
+                            // dbg!(&array);
+                            // dbg!(&new_array_target);
+                            let res_arr = Self::get_values_in_array(array, &new_array_target);
+                            if &key_tag == "" {
+                                return res_arr.into();
+                            }
+                            return Self::slice_with_tags_in_array(array, &res_arr, &key_tag).into()
+                            
+                        },
+                        _ => value_json = val.clone(),
+                    }
+                },
+                None => return Value::Null,
+            }
+        }
+        value_json
+    }
+
+    fn slice_with_tags_in_array(array: &Vec<Value>, metrics: &Vec<Value>, tag_name: &str) -> Vec<Value> {
+        if tag_name.is_empty() {
+            return metrics.clone();
+        }
+        // array[0].as_object().unwrap_or(json!(Value::Null))
+        let mut values: Vec<Value> = Vec::new();
+        array.iter()
+            .enumerate()
+            .map(|(idx, val)| {
+                let val = val.get(tag_name).unwrap_or(&Value::Null).clone();
+                (serde_json::from_value::<serde_json::Map<String, Value>>(json!({tag_name: val})), 
+                serde_json::from_value::<serde_json::Map<String, Value>>(metrics[idx].clone()))
+            })
+            .for_each(|(key, val)| {
+                // dbg!(&key);
+                if key.is_ok() && val.is_ok() {
+                    let mut key = key.unwrap();
+                    let mut val = val.unwrap();
+                    key.append(&mut val);
+                    values.push(json!(key));
+                }
+            });
+        if values.len() == 0 {
+            return metrics.clone();
+        }
+        values
+    }
+    fn get_values_in_array(array: &Vec<Value>, fields: &Vec<String>) -> Vec<Value> {
+        let mut values: Vec<Value> = Vec::new();
+        for obj in array {
+            // dbg!(obj);
+            let mut obrez = obj.clone();
+            for field in fields {
+                obrez = obrez.get(field).unwrap_or(&Value::Null).clone();
+                match obrez {
+                    Value::Object(_) => {continue},
+                    _ => {
+                        values.push(json!({field: obrez.clone()}));
+                    },
+                    // None => {values.push(Value::Null)},
+                }
+            }
+        }
+        values
+    }
+
+    fn get_metric(target: &TestMetric, json: &str) -> Value {
+        if target.addr.is_empty() {
+            return Value::Null;
+        }
+        let mut value_json: Value = serde_json::from_str(json).unwrap_or(Value::Null);
+
+        let target_attr_vec = target.addr
+            .split_terminator('.')
+            .collect::<Vec<&str>>();
+        for key in target_attr_vec {
+            match value_json.get(key) {
+                Some(val) => value_json = val.clone(),
+                None => return Value::Null,
+            }
+        }
+        value_json    
+    }
+}
+
+
+// pub struct TestMetric {
+//     pub id : String,
+//     pub json_type : String,
+//     pub addr : String,
+// }
+
+// #[derive(Serialize)]
+// struct TestMetricOutput {
+//     id : String,
+//     json_type : String,
+//     value : Value,
+// }
+// impl TestMetricOutput {
+//     fn new_with_slices(id : &str, json_type : &str, value : Value) -> Self {
+//         TestMetricOutput {
+//             id : id.to_string(),
+//             json_type : json_type.to_string(),
+//             value : value,
+//         }
+//     } 
+// }
\ No newline at end of file
diff --git a/crates/api-grub/src/main.rs b/crates/api-grub/src/main.rs
index 2fe4a95..5997ae8 100644
--- a/crates/api-grub/src/main.rs
+++ b/crates/api-grub/src/main.rs
@@ -1,6 +1,7 @@
 mod config;
 mod net;
 mod logger;
+mod json;
 
 use anyhow::Result;
 use integr_structs::api::ApiConfigV2;
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index c062da7..7712b28 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -144,4 +144,29 @@ impl ProcessedEndpoint {
         let val = ProcessedEndpoint::new(&keys.id, &keys.name, &keys.url, &keys.method,hm);
         Ok(to_string_pretty(&val)?)
     }
+}
+
+pub mod v3 {
+    pub use super::*;
+    pub struct TestMetric {
+        pub id : String,
+        pub json_type : String,
+        pub addr : String,
+    }
+    
+    #[derive(Serialize)]
+    pub struct TestMetricOutput {
+        id : String,
+        json_type : String,
+        value : Value,
+    }
+    impl TestMetricOutput {
+        pub fn new_with_slices(id : &str, json_type : &str, value : Value) -> Self {
+            TestMetricOutput {
+                id : id.to_string(),
+                json_type : json_type.to_string(),
+                value : value,
+            }
+        } 
+    }
 }
\ No newline at end of file
-- 
2.40.1


From abfb21f03b31ff50e71c8be128f2165c5bf9e01e Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 10:27:43 +0300
Subject: [PATCH 25/54] - dbg and + serde rename

---
 crates/api-grub/src/json.rs      | 2 +-
 crates/integr-structs/src/api.rs | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/crates/api-grub/src/json.rs b/crates/api-grub/src/json.rs
index f0f64d6..58bb968 100644
--- a/crates/api-grub/src/json.rs
+++ b/crates/api-grub/src/json.rs
@@ -40,7 +40,7 @@ impl JsonParser {
                     .filter(|(idx, chr)| *idx > key_idx && *chr != ']')
                     .map(|(_, chr)| chr)
                     .collect::<String>();
-                dbg!(&key_tag);
+                // dbg!(&key_tag);
                 key.chars()
                     .enumerate()
                     .filter(|(idx, _)| *idx < key_idx)
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 7712b28..97e96f5 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -148,15 +148,20 @@ impl ProcessedEndpoint {
 
 pub mod v3 {
     pub use super::*;
+    
+    // in config
+    #[derive(Deserialize)]  
     pub struct TestMetric {
         pub id : String,
+        #[serde(rename = "type")]
         pub json_type : String,
         pub addr : String,
     }
     
-    #[derive(Serialize)]
+    #[derive(Serialize, Deserialize)]
     pub struct TestMetricOutput {
         id : String,
+        #[serde(rename = "type")]
         json_type : String,
         value : Value,
     }
-- 
2.40.1


From 8630827118b20df172e4e4e82b227c298743f651 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 12:20:54 +0300
Subject: [PATCH 26/54] refactor + async tasks for mods

---
 crates/api-grub/src/export.rs    |  54 +++++++++++++++++
 crates/api-grub/src/json.rs      |  35 ++---------
 crates/api-grub/src/main.rs      |  34 +++++++++--
 crates/api-grub/src/net.rs       | 100 ++++++++-----------------------
 crates/integr-structs/src/api.rs |  36 +++++++++--
 template_global_config.json      |  61 +++++++++----------
 6 files changed, 178 insertions(+), 142 deletions(-)
 create mode 100644 crates/api-grub/src/export.rs

diff --git a/crates/api-grub/src/export.rs b/crates/api-grub/src/export.rs
new file mode 100644
index 0000000..ee73421
--- /dev/null
+++ b/crates/api-grub/src/export.rs
@@ -0,0 +1,54 @@
+use deadpool_postgres::{Config, Pool, Runtime, Client as PgClient};
+use tokio_postgres::NoTls;
+use std::env;
+use anyhow::{Error, Result};
+use log::{info, error};
+
+pub struct Exporter {
+    pool : Option<Pool>,
+}
+
+impl Exporter {
+    fn config_construct() -> Result<Config> {
+        let mut cfg = Config::new();
+        cfg.host = Some(env::var("DB_HOST")?);
+        cfg.dbname = Some(env::var("DB_DBNAME")?);
+        cfg.user = Some(env::var("DB_USER")?);
+        cfg.password = Some(env::var("DB_PASSWORD")?);
+        Ok(cfg)
+    }
+    fn pool_construct() -> Option<Pool> {
+        return match Self::config_construct() {
+            Ok(config) => {
+                if let Ok(pool) = config.create_pool(Some(Runtime::Tokio1), NoTls) {
+                    info!("Connected to PostgreSQL");
+                    return Some(pool);
+                }
+                None
+            },
+            Err(_) => {
+                error!("Bad DB credentials or it's unreachable");
+                None
+            },
+        } 
+    } 
+    pub fn is_no_connection(&self) -> bool { self.pool.is_none() }
+    pub fn init() -> Self {
+        Self {
+            pool : Self::pool_construct()
+        }
+    }
+    pub async fn get_connection_from_pool(&self) -> Option<PgClient> {
+        if let Some(pool) = &self.pool {
+            return Some(pool.get().await.ok()?);
+        }
+        None
+    } 
+    pub async fn export_data(client: PgClient, metrics: &str) -> Result<()> {
+        // client.
+        let query = client.prepare_cached("INSERT INTO metrics (body) VALUES ($1);").await?; 
+        let _ = client.query(&query, &[&metrics]).await?;
+        Ok(())
+    }
+
+}
\ No newline at end of file
diff --git a/crates/api-grub/src/json.rs b/crates/api-grub/src/json.rs
index 58bb968..c8c6c12 100644
--- a/crates/api-grub/src/json.rs
+++ b/crates/api-grub/src/json.rs
@@ -1,22 +1,22 @@
 // use serde::{de::value, Serialize};
 use serde_json::{json, Value};
-use integr_structs::api::v3::{TestMetric, TestMetricOutput};
+use integr_structs::api::v3::{Metric, MetricOutput};
 
 pub struct JsonParser;
 
 impl JsonParser {
-    pub fn parse(targets: &Vec<TestMetric>, json: &str) -> Value {
-        let mut res_vec: Vec<TestMetricOutput> = Vec::new(); 
+    pub fn parse(targets: &Vec<Metric>, json: &str) -> Value {
+        let mut res_vec: Vec<MetricOutput> = Vec::new(); 
         for target in targets {
             let metric = match target.addr.contains("[") {
                 true => JsonParser::get_sum_of_metrics_in_array(target, json),
                 false => JsonParser::get_metric(target, json),
             };
-            res_vec.push(TestMetricOutput::new_with_slices(&target.id, &target.json_type, metric));
+            res_vec.push(MetricOutput::new_with_slices(&target.id, &target.json_type, metric));
         }  
         serde_json::to_value(res_vec).unwrap_or(Value::Null)
     }
-    fn get_sum_of_metrics_in_array(target: &TestMetric, json: &str) -> Value {
+    fn get_sum_of_metrics_in_array(target: &Metric, json: &str) -> Value {
         if target.addr.is_empty() {
             return Value::Null;
         }
@@ -133,7 +133,7 @@ impl JsonParser {
         values
     }
 
-    fn get_metric(target: &TestMetric, json: &str) -> Value {
+    fn get_metric(target: &Metric, json: &str) -> Value {
         if target.addr.is_empty() {
             return Value::Null;
         }
@@ -151,26 +151,3 @@ impl JsonParser {
         value_json    
     }
 }
-
-
-// pub struct TestMetric {
-//     pub id : String,
-//     pub json_type : String,
-//     pub addr : String,
-// }
-
-// #[derive(Serialize)]
-// struct TestMetricOutput {
-//     id : String,
-//     json_type : String,
-//     value : Value,
-// }
-// impl TestMetricOutput {
-//     fn new_with_slices(id : &str, json_type : &str, value : Value) -> Self {
-//         TestMetricOutput {
-//             id : id.to_string(),
-//             json_type : json_type.to_string(),
-//             value : value,
-//         }
-//     } 
-// }
\ No newline at end of file
diff --git a/crates/api-grub/src/main.rs b/crates/api-grub/src/main.rs
index 5997ae8..f35511c 100644
--- a/crates/api-grub/src/main.rs
+++ b/crates/api-grub/src/main.rs
@@ -2,14 +2,16 @@ mod config;
 mod net;
 mod logger;
 mod json;
+mod export;
 
 use anyhow::Result;
 use integr_structs::api::ApiConfigV2;
 use logger::setup_logger;
-use log::{info, warn};
+// use log::{info, warn};
 use config::{pull_local_config, init_config_grub_mechanism};
 use net::init_api_grub_mechanism;
 use tokio::sync::mpsc;
+use log::{error, info, warn};
 
 #[tokio::main(flavor = "multi_thread")]
 async fn main() -> Result<()>{
@@ -23,10 +25,34 @@ async fn main() -> Result<()>{
     let (tx, mut rx) = mpsc::channel::<ApiConfigV2>(1);
     // futures
     // todo : rewrite with spawn
-    let config_fut = init_config_grub_mechanism(&tx);
-    let grub_fut = init_api_grub_mechanism(config, &mut rx);
+    // let config_fut = init_config_grub_mechanism(&tx);
+    // let grub_fut = init_api_grub_mechanism(config, &mut rx);
 
-    let _ = tokio::join!(config_fut, grub_fut);
+    let event_config = tokio::spawn(async move {
+        match init_config_grub_mechanism(&tx).await {
+            Ok(_) => {
+                info!("Config task deinitialized");
+            },
+            Err(er) => {
+                error!("Config task returned an error : {}", er);
+            },
+        }
+    });
+    let event_grub = tokio::spawn(async move {
+        match init_api_grub_mechanism(config, &mut rx).await {
+            Ok(_) => {
+                info!("Grabing task deinitialized");
+            },
+            Err(er) => {
+                error!("Grabing task returned an error : {}", er);
+            },
+        }
+    });
+    let events_handler = vec![event_config, event_grub];
+    for event in events_handler {
+        let _ = event.await;
+    }
+    // let _ = tokio::join!(config_fut, grub_fut);
 
     Ok(())
 }
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index b7b48bd..61a394a 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -8,62 +8,42 @@ use reqwest::{Client, Method};
 use std::sync::Arc;
 use tokio::task::JoinHandle;
 // use tokio::sync::Mutex;
-use deadpool_postgres::{Config, Pool, Runtime, Client as PgClient};
-use tokio_postgres::NoTls;
 use dotenv::dotenv;
-use std::env;
+use crate::json::JsonParser;
+use crate::export::Exporter;
+use integr_structs::api::v3::Config;
 
 // type BufferType = Arc<Mutex<Vec<String>>>; 
 
-struct Exporter {
-    pool : Option<Pool>,
-}
+// for api info pulling 
+pub async fn init_api_grub_mechanism(config: ApiConfigV2, rx: &mut Receiver<ApiConfigV2>) -> Result<()> {
+    info!("Initializing API-info grubbing mechanism...");
+    info!("Loading vars from .env file if exists...");
+    let _ = dotenv().ok();
 
-impl Exporter {
-    fn config_construct() -> Result<Config> {
-        let mut cfg = Config::new();
-        cfg.host = Some(env::var("DB_HOST")?);
-        cfg.dbname = Some(env::var("DB_DBNAME")?);
-        cfg.user = Some(env::var("DB_USER")?);
-        cfg.password = Some(env::var("DB_PASSWORD")?);
-        Ok(cfg)
-    }
-    fn pool_construct() -> Option<Pool> {
-        return match Self::config_construct() {
-            Ok(config) => {
-                if let Ok(pool) = config.create_pool(Some(Runtime::Tokio1), NoTls) {
-                    info!("Connected to PostgreSQL");
-                    return Some(pool);
+    let mut config = config;
+    let mut poller = ApiPoll::new(&mut config).await;
+    let client = Exporter::init(); 
+    let shared_pool = Arc::new(client);
+    loop {
+        let shared_pool = shared_pool.clone();
+        if poller.is_default().await {
+            sleep(Duration::from_secs(5)).await;
+        } else {
+            if rx.len() > 0 {
+                if let Some(conf) = rx.recv().await {
+                    poller.change_config(conf).await;
+                    info!("Config changed");
                 }
-                None
-            },
-            Err(_) => {
-                error!("Bad DB credentials or it's unreachable");
-                None
-            },
-        } 
-    } 
-    pub fn is_no_connection(&self) -> bool { self.pool.is_none() }
-    pub fn init() -> Self {
-        Self {
-            pool : Self::pool_construct()
+            }
+            info!("Data from API: {:?}", poller.process_polling(shared_pool).await);
+            sleep(Duration::from_secs(poller.get_delay().await as u64)).await;
         }
     }
-    pub async fn get_connection_from_pool(&self) -> Option<PgClient> {
-        if let Some(pool) = &self.pool {
-            return Some(pool.get().await.ok()?);
-        }
-        None
-    } 
-    pub async fn export_data(client: PgClient, metrics: &str) -> Result<()> {
-        // client.
-        let query = client.prepare_cached("INSERT INTO metrics (body) VALUES ($1);").await?; 
-        let _ = client.query(&query, &[&metrics]).await?;
-        Ok(())
-    }
-
+    // Ok(())
 }
 
+
 struct RestMethod;
 
 impl RestMethod {
@@ -187,34 +167,6 @@ impl<'a> ApiPoll<'a> {
     }
 }
 
-// for api info pulling 
-pub async fn init_api_grub_mechanism(config: ApiConfigV2, rx: &mut Receiver<ApiConfigV2>) -> Result<()> {
-    info!("Initializing API-info grubbing mechanism...");
-    info!("Loading vars from .env file if exists...");
-    let _ = dotenv().ok();
-
-    let mut config = config;
-    let mut poller = ApiPoll::new(&mut config).await;
-    let client = Exporter::init(); 
-    let shared_pool = Arc::new(client);
-    loop {
-        let shared_pool = shared_pool.clone();
-        if poller.is_default().await {
-            sleep(Duration::from_secs(5)).await;
-        } else {
-            if rx.len() > 0 {
-                if let Some(conf) = rx.recv().await {
-                    poller.change_config(conf).await;
-                    info!("Config changed");
-                }
-            }
-            info!("Data from API: {:?}", poller.process_polling(shared_pool).await);
-            sleep(Duration::from_secs(poller.get_delay().await as u64)).await;
-        }
-    }
-    // Ok(())
-}
-
 #[cfg(test)]
 mod net_unittests {
     use super::*;
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 97e96f5..4563655 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -151,23 +151,49 @@ pub mod v3 {
     
     // in config
     #[derive(Deserialize)]  
-    pub struct TestMetric {
+    pub struct Metric {
         pub id : String,
         #[serde(rename = "type")]
         pub json_type : String,
         pub addr : String,
     }
-    
+    #[derive(Deserialize)]
+    pub struct Metrics {
+        pub name : String,
+        pub url : String,
+        #[serde(default)]
+        pub measure : Vec<Metric>
+    }
+
+    #[derive(Deserialize)]
+    pub struct ConfigEndpoint {
+        ip : String,
+        login : String,
+        #[serde(rename = "pass")]
+        password : String,
+        api_key : String,
+        period : String,
+        timeout : String,
+        #[serde(default)]
+        metrics : Vec<Metrics>, 
+    }
+
+    #[derive(Deserialize)]
+    pub struct Config {
+        config : Vec<ConfigEndpoint>,
+    }
+
+    // to prometheus and nmns
     #[derive(Serialize, Deserialize)]
-    pub struct TestMetricOutput {
+    pub struct MetricOutput {
         id : String,
         #[serde(rename = "type")]
         json_type : String,
         value : Value,
     }
-    impl TestMetricOutput {
+    impl MetricOutput {
         pub fn new_with_slices(id : &str, json_type : &str, value : Value) -> Self {
-            TestMetricOutput {
+            MetricOutput {
                 id : id.to_string(),
                 json_type : json_type.to_string(),
                 value : value,
diff --git a/template_global_config.json b/template_global_config.json
index fe911ce..0b5e33f 100644
--- a/template_global_config.json
+++ b/template_global_config.json
@@ -1,31 +1,32 @@
-{ 
-	"id" : 1 ,
-	"template" : 	
-		[{
-			"id" :"mock_api_1", 
-			"name" : "Mock / ",
-			"url" : "http://127.0.0.1:8081/",
-			"method" : "GET",
-			"measure" : 
-				[
-					"operation", "response", "empty_field"
-				]
-		},
+{
+    "config":  [     
 		{
-			"id" :"mock_api_2", 
-			"name" : "Mock /ping ",
-			"url" : "http://127.0.0.1:8081/ping",
-			"method" : "GET",
-			"measure" : 
-				[
-					"operation", "response", "empty_field"
-				]
-		}
-		],
-	"ip_address" : 	"127.0.0.1:8081",
-	"login" : "",
-	"pass" : "" ,
-	"api_key" : 	"908c709827bd40n98r7209837x98273",
-	"period" : 		10,
-	"timeout" : 2
-}
+			"id":"demo_vcs_vinteo_dev_api", 
+			"login" : "",
+			"pass" : "",
+			"api_key" : "6fe8b0db-62b4-4065-9c1e-441ec4228341.9acec20bd17d7178f332896f8c006452877a22b8627d089105ed39c5baef9711",
+			"period" : "",
+			"timeout" : "3",
+			"metrics" : [
+				{
+					"name": "conferences", 
+					"url": "https://demo.vcs.vinteo.dev/api/v1/conferences",
+					"measure": 	[
+						{ "id":"number",  "type": "text",  "addr": "data.conferences[].number" },
+						{ "id":"total",  "type": "integer",  "addr": "data.total" },
+						{ "id":"participants_total",  "type": "integer",  "addr": "data.conferences[].participants.total" },
+						{ "id":"parts_total_in_each",  "type": "integer",  "addr": "data.conferences[description].participants.total" },
+						{ "id":"participants_online",  "type": "integer",  "addr": "data.conferences[].participants.online" }
+					]
+				},
+				{
+					"name": "abonents", 
+					"url": "https://demo.vcs.vinteo.dev/api/v1/accounts",
+					"measure": 	[
+						{ "id":"total",	"type": "integer", "addr": "data.total" }
+					]
+				}
+			]
+        }
+    ]
+}
\ No newline at end of file
-- 
2.40.1


From 0fe75be43bd1231ba4da0e1e0c144f7af500f4e6 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 12:31:52 +0300
Subject: [PATCH 27/54] final conf structs and +creds struct to contain refs on
 existing values

---
 crates/integr-structs/src/api.rs | 36 ++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 4563655..f26850b 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -183,6 +183,42 @@ pub mod v3 {
         config : Vec<ConfigEndpoint>,
     }
 
+    impl Default for Config {
+        fn default() -> Self {
+            Self {
+                config : Vec::new()
+            }
+        }
+    }
+
+    impl Config {
+        pub async fn is_default(&self) -> bool {
+            self.config.is_empty()
+        }
+    }
+
+    pub struct Credentials<'a> {
+        ip : &'a str,
+        login : &'a str,
+        password : &'a str,
+        api_key : &'a str,
+        period : &'a str,
+        timeout : &'a str,
+    }
+
+    impl<'a> Credentials<'a> {
+        pub fn from_config_endpoint(endpoint: &'a ConfigEndpoint) -> Credentials<'a> {
+            Self {
+                ip : &endpoint.ip,
+                login : &endpoint.login,
+                password : &endpoint.password,
+                api_key : &endpoint.api_key,
+                period : &endpoint.period,
+                timeout : &endpoint.timeout,
+            }
+        }
+    }
+
     // to prometheus and nmns
     #[derive(Serialize, Deserialize)]
     pub struct MetricOutput {
-- 
2.40.1


From 8362b50bcbb6acae78a034b1403f74fb7bc03f48 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 12:53:21 +0300
Subject: [PATCH 28/54] readme and config update

---
 README.md       |  8 +++----
 config_api.json | 64 ++++++++++++++++++++++++-------------------------
 2 files changed, 35 insertions(+), 37 deletions(-)

diff --git a/README.md b/README.md
index 072cfc6..46b067c 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@
 
 | Crate (submodule)   |  Progress  |
 |---|---|
-|`api-grub`   | ✅✅✅✅✅✅✅✅✅🔲  |
-|`config-delivery`   | ✅✅✅✅✅✅✅🔲🔲🔲  |
-|`integrs-structs`   | ✅✅✅✅✅✅✅✅🔲🔲  |
-|`preproc`   | ✅✅✅❌❌❌❌❌❌❌  | (разработка временно остановлена)
+|`api-grub`   | ✅✅✅✅✅✅✅🛠️🛠️🛠️  |
+|`config-delivery`   | ✅✅✅✅✅✅✅🛠️🛠️🛠️  |
+|`integrs-structs`   | ✅✅✅✅✅✅✅✅✅✅  |
+|`preproc` [temp-deprecated]   | ✅✅✅❌❌❌❌❌❌❌  | (разработка временно остановлена)
diff --git a/config_api.json b/config_api.json
index d5be22f..0b5e33f 100644
--- a/config_api.json
+++ b/config_api.json
@@ -1,34 +1,32 @@
-{ 
-	"id" : 1 ,
-	"template" : 	
-		[{
-			"id" :"mock_api_1", 
-			"name" : "Mock / ",
-			"url" : "http://127.0.0.1:8081/",
-			"method" : "GET",
-			"measure" : 
-				[
-					"response", "test_metric_1", "test_metric_2",
-					"test_metric_3", "test_metric_4", "test_metric_5"
-				]
-		},
+{
+    "config":  [     
 		{
-			"id" :"mock_api_2", 
-			"name" : "Mock /ping ",
-			"url" : "http://127.0.0.1:8081/ping",
-			"method" : "GET",
-			"measure" : 
-				[
-					"response", "test_metric_1", "test_metric_2",
-					"test_metric_3", "test_metric_4", "test_metric_5",
-					"empty_field"
-				]
-		}
-		],
-	"ip_address" : 	"127.0.0.1:8081",
-	"login" : "",
-	"pass" : "" ,
-	"api_key" : 	"908c709827bd40n98r7209837x98273",
-	"period" : 		10,
-	"timeout" : 10
-}
+			"id":"demo_vcs_vinteo_dev_api", 
+			"login" : "",
+			"pass" : "",
+			"api_key" : "6fe8b0db-62b4-4065-9c1e-441ec4228341.9acec20bd17d7178f332896f8c006452877a22b8627d089105ed39c5baef9711",
+			"period" : "",
+			"timeout" : "3",
+			"metrics" : [
+				{
+					"name": "conferences", 
+					"url": "https://demo.vcs.vinteo.dev/api/v1/conferences",
+					"measure": 	[
+						{ "id":"number",  "type": "text",  "addr": "data.conferences[].number" },
+						{ "id":"total",  "type": "integer",  "addr": "data.total" },
+						{ "id":"participants_total",  "type": "integer",  "addr": "data.conferences[].participants.total" },
+						{ "id":"parts_total_in_each",  "type": "integer",  "addr": "data.conferences[description].participants.total" },
+						{ "id":"participants_online",  "type": "integer",  "addr": "data.conferences[].participants.online" }
+					]
+				},
+				{
+					"name": "abonents", 
+					"url": "https://demo.vcs.vinteo.dev/api/v1/accounts",
+					"measure": 	[
+						{ "id":"total",	"type": "integer", "addr": "data.total" }
+					]
+				}
+			]
+        }
+    ]
+}
\ No newline at end of file
-- 
2.40.1


From 3ebf40aa64e18faa8c688eaa19f744c73ee025bc Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 13:01:07 +0300
Subject: [PATCH 29/54] bugged: config v3

---
 crates/api-grub/src/config.rs    | 13 +++++++------
 crates/api-grub/src/main.rs      |  5 +++--
 crates/integr-structs/src/api.rs |  8 ++++----
 3 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/crates/api-grub/src/config.rs b/crates/api-grub/src/config.rs
index 11fe491..b945d31 100644
--- a/crates/api-grub/src/config.rs
+++ b/crates/api-grub/src/config.rs
@@ -10,12 +10,13 @@ use tokio::{io::AsyncReadExt, net::UnixListener};
 use tokio::time::{sleep, Duration};
 use std::result::Result::Ok as stdOk;
 use tokio::sync::mpsc::Sender;
+use integr_structs::api::v3::Config;
 
 const CONFIG_PATH: &str = "config_api.json";
 const SOCKET_PATH: &str = "api-grub.sock";
 
 // todo! rewrite to use current_exe
-pub async fn pull_local_config() -> Result<ApiConfigV2> {
+pub async fn pull_local_config() -> Result<Config> {
     // let conf_path = std::env::current_exe()?;
     let path = Path::new(CONFIG_PATH);
     // return match conf_path.parent() {
@@ -28,7 +29,7 @@ pub async fn pull_local_config() -> Result<ApiConfigV2> {
     //     None => Err(Error::msg("No local conf was found")) 
     // }
     if path.exists() && path.is_file() {
-        let config: ApiConfigV2 = from_str(
+        let config: Config = from_str(
             &fs::read_to_string(CONFIG_PATH)?
         )?;
         Ok(config)
@@ -39,7 +40,7 @@ pub async fn pull_local_config() -> Result<ApiConfigV2> {
 
 // for config pulling
 // ++++ reader to channel 
-pub async fn init_config_grub_mechanism(tx: &Sender<ApiConfigV2>) -> Result<()> {
+pub async fn init_config_grub_mechanism(tx: &Sender<Config>) -> Result<()> {
     info!("Initializing Unix-Socket listening for pulling new configs...");
     let server = init_unix_listener().await?;
     // 
@@ -51,7 +52,7 @@ pub async fn init_config_grub_mechanism(tx: &Sender<ApiConfigV2>) -> Result<()>
             if let Err(er) =  stream.read_to_string(&mut buffer).await {
                 warn!("Cannot read config from stream due to {}", er);
             } else {
-                let config: Result<ApiConfigV2, serde_json::Error> = from_str(&buffer);
+                let config: Result<Config, serde_json::Error> = from_str(&buffer);
                 if let stdOk(conf) = config {
                     info!("New config was pulled from Unix-Stream. Saving it locally and sharing with API-grub module...");
                     if let Err(er) = save_new_config(&buffer).await {
@@ -97,13 +98,13 @@ mod config_unittests {
     #[test]
     async fn check_save_new_config() {
         use std::fs;
-        use integr_structs::api::ApiConfigV2;
+        use integr_structs::api::v3::Config;
         use serde_json::to_string;
         
         let test_config_path  = "test_config_api.json";
 
         // config gen  
-        let config = to_string::<ApiConfigV2>(&ApiConfigV2::default());
+        let config = to_string::<Config>(&Config::default());
         assert!(config.is_ok());
         let config = config.unwrap();
 
diff --git a/crates/api-grub/src/main.rs b/crates/api-grub/src/main.rs
index f35511c..1db6f64 100644
--- a/crates/api-grub/src/main.rs
+++ b/crates/api-grub/src/main.rs
@@ -6,6 +6,7 @@ mod export;
 
 use anyhow::Result;
 use integr_structs::api::ApiConfigV2;
+use integr_structs::api::v3::Config;
 use logger::setup_logger;
 // use log::{info, warn};
 use config::{pull_local_config, init_config_grub_mechanism};
@@ -57,7 +58,7 @@ async fn main() -> Result<()>{
     Ok(())
 }
 
-async fn get_config() -> ApiConfigV2 {
+async fn get_config() -> Config {
     return match pull_local_config().await {
         Ok(conf) => {
             info!("Local config was loaded");
@@ -65,7 +66,7 @@ async fn get_config() -> ApiConfigV2 {
         },
         Err(er) => {
             warn!("Cannot get local config due to {}", er);
-            ApiConfigV2::default()
+            Config::default()
         }
     }
 }
\ No newline at end of file
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index f26850b..02ca610 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -150,14 +150,14 @@ pub mod v3 {
     pub use super::*;
     
     // in config
-    #[derive(Deserialize)]  
+    #[derive(Serialize, Deserialize)]  
     pub struct Metric {
         pub id : String,
         #[serde(rename = "type")]
         pub json_type : String,
         pub addr : String,
     }
-    #[derive(Deserialize)]
+    #[derive(Serialize, Deserialize)]
     pub struct Metrics {
         pub name : String,
         pub url : String,
@@ -165,7 +165,7 @@ pub mod v3 {
         pub measure : Vec<Metric>
     }
 
-    #[derive(Deserialize)]
+    #[derive(Serialize, Deserialize)]
     pub struct ConfigEndpoint {
         ip : String,
         login : String,
@@ -178,7 +178,7 @@ pub mod v3 {
         metrics : Vec<Metrics>, 
     }
 
-    #[derive(Deserialize)]
+    #[derive(Serialize, Deserialize)]
     pub struct Config {
         config : Vec<ConfigEndpoint>,
     }
-- 
2.40.1


From 5d0a3621669ec2bdabb53f9d3fc3408ce798ecac Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 15:07:59 +0300
Subject: [PATCH 30/54] local config + json mod fixes

---
 config_api.json             | 2 +-
 crates/api-grub/src/json.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/config_api.json b/config_api.json
index 0b5e33f..d216deb 100644
--- a/config_api.json
+++ b/config_api.json
@@ -1,7 +1,7 @@
 {
     "config":  [     
 		{
-			"id":"demo_vcs_vinteo_dev_api", 
+			"id":"zvks", 
 			"login" : "",
 			"pass" : "",
 			"api_key" : "6fe8b0db-62b4-4065-9c1e-441ec4228341.9acec20bd17d7178f332896f8c006452877a22b8627d089105ed39c5baef9711",
diff --git a/crates/api-grub/src/json.rs b/crates/api-grub/src/json.rs
index c8c6c12..2cc3289 100644
--- a/crates/api-grub/src/json.rs
+++ b/crates/api-grub/src/json.rs
@@ -12,7 +12,7 @@ impl JsonParser {
                 true => JsonParser::get_sum_of_metrics_in_array(target, json),
                 false => JsonParser::get_metric(target, json),
             };
-            res_vec.push(MetricOutput::new_with_slices(&target.id, &target.json_type, metric));
+            res_vec.push(MetricOutput::new_with_slices(&target.id, &target.json_type, &target.addr, metric));
         }  
         serde_json::to_value(res_vec).unwrap_or(Value::Null)
     }
-- 
2.40.1


From e669f95c8215bdc041a35d924e836e5a5f84ee77 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 15:27:57 +0300
Subject: [PATCH 31/54] + prometheus exporter sending

---
 .env.example                  |  6 +++++-
 crates/api-grub/src/export.rs | 16 ++++++++++++++--
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/.env.example b/.env.example
index a8a5abb..78b0f00 100644
--- a/.env.example
+++ b/.env.example
@@ -2,7 +2,11 @@ CONFIG_SERVER_CREDS = "ws://ip.ip.ip.ip:port"
 API_GRUBBER_SOCKET = "api-grubber.sock"
 PREPROC_SOCKET = "preproc.sock"
 
+# PostgreSQL connection [DEPRECATED]
 DB_HOST = "ip.addr.postgresql.server"
 DB_USER = "db_user"
 DB_PASSWORD = "db_user_password"
-DB_DBNAME = "db_name"1
\ No newline at end of file
+DB_DBNAME = "db_name"1
+
+# Prometheus-Exporter info
+EXPORTER_URL = "ip.ip.ip.ip:port" 
\ No newline at end of file
diff --git a/crates/api-grub/src/export.rs b/crates/api-grub/src/export.rs
index ee73421..06e94d2 100644
--- a/crates/api-grub/src/export.rs
+++ b/crates/api-grub/src/export.rs
@@ -1,7 +1,8 @@
 use deadpool_postgres::{Config, Pool, Runtime, Client as PgClient};
+use reqwest::Client;
 use tokio_postgres::NoTls;
 use std::env;
-use anyhow::{Error, Result};
+use anyhow::{Result};
 use log::{info, error};
 
 pub struct Exporter {
@@ -35,7 +36,7 @@ impl Exporter {
     pub fn is_no_connection(&self) -> bool { self.pool.is_none() }
     pub fn init() -> Self {
         Self {
-            pool : Self::pool_construct()
+            pool : Self::pool_construct(),
         }
     }
     pub async fn get_connection_from_pool(&self) -> Option<PgClient> {
@@ -50,5 +51,16 @@ impl Exporter {
         let _ = client.query(&query, &[&metrics]).await?;
         Ok(())
     }
+    pub async fn export_metrics(metrics: &str) -> Result<()> {
+        let url = env::var("EXPORTER_URL")?;
+        // let req = Request::new(Method::PUT, 
+        //     Url::parse(metrics)?);
+        let req = Client::new()
+            .put(url)
+            .json(metrics)
+            .send().await;
+        req?;
+        Ok(())
+    }
 
 }
\ No newline at end of file
-- 
2.40.1


From c7bc0d6ff516cf24f54916bccd94bad09460a379 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 16:32:04 +0300
Subject: [PATCH 32/54] process_polling update + config structs fix

---
 crates/api-grub/src/main.rs      |   2 +-
 crates/api-grub/src/net.rs       | 278 +++++++++++++++++--------------
 crates/integr-structs/src/api.rs |  57 ++++---
 3 files changed, 190 insertions(+), 147 deletions(-)

diff --git a/crates/api-grub/src/main.rs b/crates/api-grub/src/main.rs
index 1db6f64..f7a79bc 100644
--- a/crates/api-grub/src/main.rs
+++ b/crates/api-grub/src/main.rs
@@ -23,7 +23,7 @@ async fn main() -> Result<()>{
     setup_logger().await?;
     let config = get_config().await;
     // config update channel
-    let (tx, mut rx) = mpsc::channel::<ApiConfigV2>(1);
+    let (tx, mut rx) = mpsc::channel::<Config>(1);
     // futures
     // todo : rewrite with spawn
     // let config_fut = init_config_grub_mechanism(&tx);
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index 61a394a..a6b80ff 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -10,23 +10,24 @@ use tokio::task::JoinHandle;
 // use tokio::sync::Mutex;
 use dotenv::dotenv;
 use crate::json::JsonParser;
-use crate::export::Exporter;
-use integr_structs::api::v3::Config;
+use crate::export::{self, Exporter};
+use integr_structs::api::v3::{Config, ConfigEndpoint, Credentials};
 
 // type BufferType = Arc<Mutex<Vec<String>>>; 
 
 // for api info pulling 
-pub async fn init_api_grub_mechanism(config: ApiConfigV2, rx: &mut Receiver<ApiConfigV2>) -> Result<()> {
-    info!("Initializing API-info grubbing mechanism...");
-    info!("Loading vars from .env file if exists...");
+pub async fn init_api_grub_mechanism(config: Config, rx: &mut Receiver<Config>) -> Result<()> {
+    info!("Initializing API-info grubbing mechanism :");
+    info!("1) Loading vars from .env file if exists...");
     let _ = dotenv().ok();
 
     let mut config = config;
     let mut poller = ApiPoll::new(&mut config).await;
+    info!("2) Api-Poller has initialized");
     let client = Exporter::init(); 
+    info!("3) Exporter has initialized");
     let shared_pool = Arc::new(client);
     loop {
-        let shared_pool = shared_pool.clone();
         if poller.is_default().await {
             sleep(Duration::from_secs(5)).await;
         } else {
@@ -36,8 +37,9 @@ pub async fn init_api_grub_mechanism(config: ApiConfigV2, rx: &mut Receiver<ApiC
                     info!("Config changed");
                 }
             }
+            let shared_pool = shared_pool.clone();
             info!("Data from API: {:?}", poller.process_polling(shared_pool).await);
-            sleep(Duration::from_secs(poller.get_delay().await as u64)).await;
+            // sleep(Duration::from_secs(poller.get_delay().await as u64)).await;
         }
     }
     // Ok(())
@@ -62,156 +64,188 @@ impl RestMethod {
     } 
 }
 struct ApiPoll<'a> {
-    config : &'a mut ApiConfigV2,
+    config : &'a mut Config,
     client : Client,
 }
 
 impl<'a> ApiPoll<'a> {
-    pub async fn new(poll_cfg : &'a mut ApiConfigV2) -> Self {
+    pub async fn new(poll_cfg : &'a mut Config) -> Self {
         Self {
             config : poll_cfg,
             client : Client::new(),
         }
     }
     // can be weak and with bug test needed
-    pub async fn change_config(&mut self, conf: ApiConfigV2) {
+    pub async fn change_config(&mut self, conf: Config) {
         *self.config = conf;
     }
     pub async fn is_default(&self) -> bool {
-        self.config.template.len() == 0
+        self.config.is_default().await
+    }
+    // pub async fn get_delay(&self) -> u32 {
+    //     self.config.timeout
+    // }
+    pub async fn process_endpoint(
+        client : Arc<Client>, 
+        config : Arc<ConfigEndpoint>,
+        creds : Credentials,
+        exporter : Arc<Exporter>
+    ) -> Result<()> {
+
+        Ok(())
     }
     pub async fn process_polling(&self, exporter: Arc<Exporter>) -> Result<()> {
         // let buffer: BufferType = Arc::new(Mutex::new(vec![]));
-        let mut join_handles: Vec<JoinHandle<Result<()>>> = vec![];
+        // let mut join_handles: Vec<JoinHandle<Result<()>>> = vec![];
         let client = Arc::new(self.client.clone());
-        let template = Arc::new(self.config.template.clone());
+        let config = Arc::new(self.config.clone());
+        let endpoints: Vec<Arc<ConfigEndpoint>> = ConfigEndpoint::from_config(config.clone());
+        let mut join_handles: Vec<JoinHandle<Result<()>>> = vec![];
 
-        if self.is_default().await { return Err(Error::msg("Default config with no endpoints")) }
-
-        // TODO: rewrite nextly to async 
-        for point in template.iter() {
-            let point = Arc::new(point.clone());
-            // let buffer = buffer.clone();
+        for (idx, _) in config.config.iter().enumerate() {
+            // let for_creds = endpoints[idx].clone();
+            let creds = Credentials::from_config_endpoint(endpoints[idx].clone());
+            let endpoint = endpoints[idx].clone();
             let client = client.clone();
             let exporter = exporter.clone();
-            let endpoint_processer = tokio::spawn(async move {
-                let point = point.clone();
-                match client.request(RestMethod::from_str(&point.method).await, &point.url).send().await {
-                    Ok(resp) => {
-                        if !resp.status().is_success() {
-                            error!("ErrorCode in Response from API. Check configuration");
-                            return Err(Error::msg("Error during sending request"));
-                        }
-                        if let Ok(text) = resp.text().await {
-                            // 
-                            let metrics = ProcessedEndpoint::from_target_response(&text, &point)?;
-                            // dbg!(&metrics);
-                            println!("{}", &metrics);
-                            // 
-                            if let Some(conn) = exporter.get_connection_from_pool().await {
-                                
-                                // TEST: to exporter 
-                                let res = client.request(
-                                    RestMethod::from_str("post").await,
-                                    "http://192.168.2.34:9101/update")
-                                .json(&metrics)
-                                .send().await;
-                                if let Err(er) = res {
-                                    error!("Cannot send data to exporter due to: {}", er);
-                                } else {
-                                    println!("{:?}", res.unwrap().text().await);
-                                }
-
-                                if let Err(er) = Exporter::export_data(conn, &metrics).await {
-                                    error!("Cannot export data to DB during to: {}", er);
-                                    return Err(Error::msg("Error during exporting data to DB"));
-                                }
-                            } else {
-                                if !exporter.is_no_connection() {
-                                    return Err(Error::msg("Error during getting connection from pool"));
-                                }
-                            }
-
-                            // let mut buffer = buffer.lock().await;
-                            // buffer.push(text);
-                        } else {
-                            error!("{}: {} - Error with extracting text field from Response", &point.method.to_uppercase(), &point.url);
-                            return Err(Error::msg("Error with extracting text field from Response"));
-                        }
-                    },
-                    Err(_) => {
-                        error!("{}: {} endpoint is unreachable", &point.method.to_uppercase(), &point.url);
-                        return Err(Error::msg("Endpoint is unreachable"));
-                    },
-                }
-                Ok(())
+            let join_handler = tokio::spawn(async move {
+                Self::process_endpoint(
+                    client, 
+                    endpoint, 
+                    creds, 
+                    exporter.clone()
+                ).await
             });
-            join_handles.push(endpoint_processer);
+            join_handles.push(join_handler);
         }
-
         for i in join_handles {
             let _ = i.await;
         }
+        // let template = Arc::new(self.config.template.clone());
 
-        // let buffer = buffer.lock().await;
-        // match &buffer.len() {
-        //     0 => Err(Error::msg("Error due to API grubbing. Check config" )),
-        //     _ => {
+        // if self.is_default().await { return Err(Error::msg("Default config with no endpoints")) }
+
+        // // TODO: rewrite nextly to async 
+        // for point in template.iter() {
+        //     let point = Arc::new(point.clone());
+        //     // let buffer = buffer.clone();
+        //     let client = client.clone();
+        //     let exporter = exporter.clone();
+        //     let endpoint_processer = tokio::spawn(async move {
+        //         let point = point.clone();
+        //         match client.request(RestMethod::from_str(&point.method).await, &point.url).send().await {
+        //             Ok(resp) => {
+        //                 if !resp.status().is_success() {
+        //                     error!("ErrorCode in Response from API. Check configuration");
+        //                     return Err(Error::msg("Error during sending request"));
+        //                 }
+        //                 if let Ok(text) = resp.text().await {
+        //                     // 
+        //                     let metrics = ProcessedEndpoint::from_target_response(&text, &point)?;
+        //                     // dbg!(&metrics);
+        //                     println!("{}", &metrics);
+        //                     // 
+        //                     if let Some(conn) = exporter.get_connection_from_pool().await {
+                                
+        //                         // TEST: to exporter 
+        //                         let res = client.request(
+        //                             RestMethod::from_str("post").await,
+        //                             "http://192.168.2.34:9101/update")
+        //                         .json(&metrics)
+        //                         .send().await;
+        //                         if let Err(er) = res {
+        //                             error!("Cannot send data to exporter due to: {}", er);
+        //                         } else {
+        //                             println!("{:?}", res.unwrap().text().await);
+        //                         }
+
+        //                         if let Err(er) = Exporter::export_data(conn, &metrics).await {
+        //                             error!("Cannot export data to DB during to: {}", er);
+        //                             return Err(Error::msg("Error during exporting data to DB"));
+        //                         }
+        //                     } else {
+        //                         if !exporter.is_no_connection() {
+        //                             return Err(Error::msg("Error during getting connection from pool"));
+        //                         }
+        //                     }
+
+        //                     // let mut buffer = buffer.lock().await;
+        //                     // buffer.push(text);
+        //                 } else {
+        //                     error!("{}: {} - Error with extracting text field from Response", &point.method.to_uppercase(), &point.url);
+        //                     return Err(Error::msg("Error with extracting text field from Response"));
+        //                 }
+        //             },
+        //             Err(_) => {
+        //                 error!("{}: {} endpoint is unreachable", &point.method.to_uppercase(), &point.url);
+        //                 return Err(Error::msg("Endpoint is unreachable"));
+        //             },
+        //         }
         //         Ok(())
-        //     },
+        //     });
+        //     join_handles.push(endpoint_processer);
         // }
+
+        // for i in join_handles {
+        //     let _ = i.await;
+        // }
+
+        // // let buffer = buffer.lock().await;
+        // // match &buffer.len() {
+        // //     0 => Err(Error::msg("Error due to API grubbing. Check config" )),
+        // //     _ => {
+        // //         Ok(())
+        // //     },
+        // // }
         Ok(())
     }
-    pub async fn get_delay(&self) -> u32 {
-        self.config.timeout
-    }
 }
 
-#[cfg(test)]
-mod net_unittests {
-    use super::*;
-    use tokio::test;
+// #[cfg(test)]
+// mod net_unittests {
+//     use super::*;
+//     use tokio::test;
     
-    #[test]
-    async fn check_str_to_rest_method() {
-        assert_eq!(RestMethod::from_str("get").await, Method::GET);
-        assert_eq!(RestMethod::from_str("post").await, Method::POST);
-        assert_eq!(RestMethod::from_str("patch").await, Method::PATCH);
-        assert_eq!(RestMethod::from_str("put").await, Method::PUT);
-        assert_eq!(RestMethod::from_str("delete").await, Method::DELETE);
-        assert_eq!(RestMethod::from_str("invalid_method").await, Method::GET);
-    } 
-    #[test]
-    async fn check_api_poll_change_config() {
-        let mut conf1 = ApiConfigV2::default();
-        let conf2 = ApiConfigV2::pattern();
-        let mut poll = ApiPoll::new(&mut conf1).await;
-        poll.change_config(conf2).await;
-        assert_eq!(poll.config.timeout, 1)
-    }
+//     #[test]
+//     async fn check_str_to_rest_method() {
+//         assert_eq!(RestMethod::from_str("get").await, Method::GET);
+//         assert_eq!(RestMethod::from_str("post").await, Method::POST);
+//         assert_eq!(RestMethod::from_str("patch").await, Method::PATCH);
+//         assert_eq!(RestMethod::from_str("put").await, Method::PUT);
+//         assert_eq!(RestMethod::from_str("delete").await, Method::DELETE);
+//         assert_eq!(RestMethod::from_str("invalid_method").await, Method::GET);
+//     } 
+//     #[test]
+//     async fn check_api_poll_change_config() {
+//         let mut conf1 = ApiConfigV2::default();
+//         let conf2 = ApiConfigV2::pattern();
+//         let mut poll = ApiPoll::new(&mut conf1).await;
+//         poll.change_config(conf2).await;
+//         assert_eq!(poll.config.timeout, 1)
+//     }
 
-    #[test]
-    async fn check_api_poll_is_default() {
-        let mut conf1 = ApiConfigV2::default();
-        let poll = ApiPoll::new(&mut conf1).await;
-        assert!(poll.is_default().await)
-    }
+//     #[test]
+//     async fn check_api_poll_is_default() {
+//         let mut conf1 = ApiConfigV2::default();
+//         let poll = ApiPoll::new(&mut conf1).await;
+//         assert!(poll.is_default().await)
+//     }
 
-    #[test]
-    async fn check_api_grubbing_mechanism_on_public_one() {
-        use log::{set_max_level, LevelFilter};
+//     #[test]
+//     async fn check_api_grubbing_mechanism_on_public_one() {
+//         use log::{set_max_level, LevelFilter};
 
-        set_max_level(LevelFilter::Off);
-        let mut conf1 = ApiConfigV2::pattern();
-        let conf2 = ApiConfigV2::default(); 
-        let exporter = Arc::new(Exporter::init());
+//         set_max_level(LevelFilter::Off);
+//         let mut conf1 = ApiConfigV2::pattern();
+//         let conf2 = ApiConfigV2::default(); 
+//         let exporter = Arc::new(Exporter::init());
 
-        let mut poll = ApiPoll::new(&mut conf1).await;
-        assert!(poll.process_polling(exporter.clone()).await.is_ok());
+//         let mut poll = ApiPoll::new(&mut conf1).await;
+//         assert!(poll.process_polling(exporter.clone()).await.is_ok());
 
-        dbg!(&poll.config);
-        poll.change_config(conf2).await;
-        dbg!(&poll.config);
-        assert!(poll.process_polling(exporter.clone()).await.is_err());
-    }
-}
\ No newline at end of file
+//         dbg!(&poll.config);
+//         poll.change_config(conf2).await;
+//         dbg!(&poll.config);
+//         assert!(poll.process_polling(exporter.clone()).await.is_err());
+//     }
+// }
\ No newline at end of file
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 02ca610..03086e0 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -1,7 +1,9 @@
+use core::sync;
 use std::collections::HashMap;
 use serde::{Serialize, Deserialize};
 use serde_json::{ to_string_pretty, Value };
 use anyhow::Result;
+use std::sync::Arc;
 
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -150,14 +152,14 @@ pub mod v3 {
     pub use super::*;
     
     // in config
-    #[derive(Serialize, Deserialize)]  
+    #[derive(Serialize, Deserialize, Clone)]  
     pub struct Metric {
         pub id : String,
         #[serde(rename = "type")]
         pub json_type : String,
         pub addr : String,
     }
-    #[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize, Clone)]
     pub struct Metrics {
         pub name : String,
         pub url : String,
@@ -165,9 +167,9 @@ pub mod v3 {
         pub measure : Vec<Metric>
     }
 
-    #[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize, Clone)]
     pub struct ConfigEndpoint {
-        ip : String,
+        id : String,
         login : String,
         #[serde(rename = "pass")]
         password : String,
@@ -177,10 +179,27 @@ pub mod v3 {
         #[serde(default)]
         metrics : Vec<Metrics>, 
     }
+     impl ConfigEndpoint {
+        pub fn from_config(config: Arc<Config>) -> Vec<Arc<Self>> {
+            let mut result: Vec<Arc<ConfigEndpoint>> = Vec::new();
+            config.config
+                .iter()
+                .for_each(|el| {
+                    result.push(Arc::new(el.clone()))
+                });
+            result
+        }
+        pub fn get_period(&self) -> Option<u32> {
+            self.period.parse().ok()
+        }
+        pub fn get_timeout(&self) -> Option<u32> {
+            self.timeout.parse().ok()
+        }
+     }
 
-    #[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize, Clone)]
     pub struct Config {
-        config : Vec<ConfigEndpoint>,
+        pub config : Vec<ConfigEndpoint>,
     }
 
     impl Default for Config {
@@ -197,25 +216,13 @@ pub mod v3 {
         }
     }
 
-    pub struct Credentials<'a> {
-        ip : &'a str,
-        login : &'a str,
-        password : &'a str,
-        api_key : &'a str,
-        period : &'a str,
-        timeout : &'a str,
+    pub struct Credentials {
+        endpoint : Arc<ConfigEndpoint>,
     }
 
-    impl<'a> Credentials<'a> {
-        pub fn from_config_endpoint(endpoint: &'a ConfigEndpoint) -> Credentials<'a> {
-            Self {
-                ip : &endpoint.ip,
-                login : &endpoint.login,
-                password : &endpoint.password,
-                api_key : &endpoint.api_key,
-                period : &endpoint.period,
-                timeout : &endpoint.timeout,
-            }
+    impl Credentials {
+        pub fn from_config_endpoint(endpoint: Arc<ConfigEndpoint>) -> Credentials {
+            Self { endpoint }
         }
     }
 
@@ -225,13 +232,15 @@ pub mod v3 {
         id : String,
         #[serde(rename = "type")]
         json_type : String,
+        addr : String,
         value : Value,
     }
     impl MetricOutput {
-        pub fn new_with_slices(id : &str, json_type : &str, value : Value) -> Self {
+        pub fn new_with_slices(id : &str, json_type : &str, addr: &str,value : Value) -> Self {
             MetricOutput {
                 id : id.to_string(),
                 json_type : json_type.to_string(),
+                addr : addr.to_string(),
                 value : value,
             }
         } 
-- 
2.40.1


From 847fd1595df2b7e5e403c5a1e4bbd26525909f9e Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 19:49:33 +0300
Subject: [PATCH 33/54] alomost done

---
 config_api.json                  |   2 +-
 crates/api-grub/src/net.rs       | 126 +++++++++++++++++++++++++++++--
 crates/integr-structs/src/api.rs |  37 ++++++---
 3 files changed, 144 insertions(+), 21 deletions(-)

diff --git a/config_api.json b/config_api.json
index d216deb..f88bdfa 100644
--- a/config_api.json
+++ b/config_api.json
@@ -6,7 +6,7 @@
 			"pass" : "",
 			"api_key" : "6fe8b0db-62b4-4065-9c1e-441ec4228341.9acec20bd17d7178f332896f8c006452877a22b8627d089105ed39c5baef9711",
 			"period" : "",
-			"timeout" : "3",
+			"timeout" : "10",
 			"metrics" : [
 				{
 					"name": "conferences", 
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index a6b80ff..33f3457 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -2,16 +2,17 @@
 use anyhow::{Error, Result};
 use integr_structs::api::{ApiConfigV2, ProcessedEndpoint};
 use log::{error, info};
+use serde_json::Value;
 use tokio::sync::mpsc::Receiver;
 use tokio::time::{sleep, Duration};
-use reqwest::{Client, Method};
+use reqwest::{Client, Method, RequestBuilder};
 use std::sync::Arc;
 use tokio::task::JoinHandle;
 // use tokio::sync::Mutex;
 use dotenv::dotenv;
 use crate::json::JsonParser;
 use crate::export::{self, Exporter};
-use integr_structs::api::v3::{Config, ConfigEndpoint, Credentials};
+use integr_structs::api::v3::{Config, ConfigEndpoint, Credentials, Metrics};
 
 // type BufferType = Arc<Mutex<Vec<String>>>; 
 
@@ -85,19 +86,127 @@ impl<'a> ApiPoll<'a> {
     // pub async fn get_delay(&self) -> u32 {
     //     self.config.timeout
     // }
+    pub async fn process_metrics(
+        service_id: Arc<String>,
+        metrics: Arc<Metrics>,
+        creds: Credentials,
+        // exporter: Arc<Exporter>
+    ) -> Result<()> {
+        // processing metrics 
+        let mut req = Client::new()
+            .get(&metrics.url);
+        let login = creds.endpoint.login.clone();
+        let password = creds.endpoint.password.clone();
+        let api_key = creds.endpoint.api_key.clone();
+        if !login.is_empty() && !password.is_empty() {
+            dbg!("kjgbkasgksjd");
+            req = req.basic_auth(login, Some(password));
+        }
+        if !api_key.is_empty() {
+            req = req.bearer_auth(&api_key);
+            // req = req.header("authorization", "bearer ");
+
+            req = req.header("accept", "application/json");
+            req = req.header("x-api-key", &api_key);
+            
+            // req = req.query(&["Bearer", "6fe8b0db-62b4-4065-9c1e-441ec4228341.9acec20bd17d7178f332896f8c006452877a22b8627d089105ed39c5baef9711"])
+        }
+        dbg!(&req);
+        // let (client, res) = req.build_split();
+        // let res = res.unwrap();
+        // res.url_mut().is_special()
+
+        
+
+        // dbg!(client);
+        // dbg!(res);
+        // todo!();
+        
+        match req.send().await {
+            Ok(resp) => {
+                dbg!(&resp);
+                if let Ok(response) = resp.text().await {
+                    match serde_json::from_str::<Value>(&response) {
+                        Err(er) => {error!("Bad JSON in response. Error: {}", er);},
+                        Ok(_) => {
+                            let endpoint_name = &metrics.name;
+                            let preproc = JsonParser::parse(&metrics.measure, &response);
+                            let metrics: String = serde_json::from_value(preproc.clone())
+                                .unwrap_or({
+                                    error!("Cannot parse grabbed metrics data to String");
+                                    String::from(r#""value" : null"#)
+                                });
+                            dbg!(&metrics);
+                            match Exporter::export_metrics(&metrics).await {
+                                Ok(_) => {
+                                    info!("Successfully imported metrics data to Prometheus");
+                                },
+                                Err(er) => {
+                                    error!("Failed to export data to Prometheus due to {}", er);
+                                },                            
+                            }
+                        },
+                    }
+                } else {
+                    error!("Bad response from {}. No data", &metrics.url);
+                }
+            },       
+            Err(er) => {
+                error!("Cannot API data from {} due to : {}", &metrics.url, er);
+            },
+        }
+        Ok(())
+    }
     pub async fn process_endpoint(
-        client : Arc<Client>, 
+        // client : Arc<Client>, 
         config : Arc<ConfigEndpoint>,
         creds : Credentials,
-        exporter : Arc<Exporter>
+        // exporter : Arc<Exporter>
     ) -> Result<()> {
+        // 
+        let period = config.get_period().unwrap_or(0);
+        let timeout = config.get_timeout().unwrap_or(5);
+        let metrics = Arc::new(config.metrics.clone());
+        let service_id = Arc::new(config.id.clone());
+        loop {
+            // let exporter = exporter.clone();
+            let creds = creds.clone();
+            let metrics = metrics.clone();
+            let service_id = service_id.clone();
+            let mut jh = Vec::<JoinHandle::<Result<()>>>::new();
+            
+            for idx in 0..metrics.len() {
+                // let exporter = exporter.clone();
+                let creds = creds.clone();
+                let metrics = metrics.clone();
+                let service_id = service_id.clone();
+                let event = tokio::spawn(async move {
+                    Self::process_metrics(
+                        service_id.clone(), 
+                        metrics[idx].clone().into(),
+                        creds.clone(),
+                        // exporter.clone()
+                    ).await
+                });
+                jh.push(event);
+            }
+            info!("Initializing another {} subjob(s) for `{}` service", 
+                jh.len(),
+                &service_id
+            );
 
+            for i in jh {
+                let _ = i.await;
+            }
+            // processing 
+            sleep(Duration::from_secs(timeout)).await
+        }
         Ok(())
     }
     pub async fn process_polling(&self, exporter: Arc<Exporter>) -> Result<()> {
         // let buffer: BufferType = Arc::new(Mutex::new(vec![]));
         // let mut join_handles: Vec<JoinHandle<Result<()>>> = vec![];
-        let client = Arc::new(self.client.clone());
+        // let client = Arc::new(self.client.clone());
         let config = Arc::new(self.config.clone());
         let endpoints: Vec<Arc<ConfigEndpoint>> = ConfigEndpoint::from_config(config.clone());
         let mut join_handles: Vec<JoinHandle<Result<()>>> = vec![];
@@ -106,18 +215,19 @@ impl<'a> ApiPoll<'a> {
             // let for_creds = endpoints[idx].clone();
             let creds = Credentials::from_config_endpoint(endpoints[idx].clone());
             let endpoint = endpoints[idx].clone();
-            let client = client.clone();
+            // let client = client.clone();
             let exporter = exporter.clone();
             let join_handler = tokio::spawn(async move {
                 Self::process_endpoint(
-                    client, 
+                    // client, 
                     endpoint, 
                     creds, 
-                    exporter.clone()
+                    // exporter.clone()
                 ).await
             });
             join_handles.push(join_handler);
         }
+        info!("Initializing {} task(s) for current config", join_handles.len());
         for i in join_handles {
             let _ = i.await;
         }
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 03086e0..024a410 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -152,14 +152,14 @@ pub mod v3 {
     pub use super::*;
     
     // in config
-    #[derive(Serialize, Deserialize, Clone)]  
+    #[derive(Serialize, Deserialize, Clone, Debug)]  
     pub struct Metric {
         pub id : String,
         #[serde(rename = "type")]
         pub json_type : String,
         pub addr : String,
     }
-    #[derive(Serialize, Deserialize, Clone)]
+    #[derive(Serialize, Deserialize, Clone, Debug)]
     pub struct Metrics {
         pub name : String,
         pub url : String,
@@ -167,17 +167,17 @@ pub mod v3 {
         pub measure : Vec<Metric>
     }
 
-    #[derive(Serialize, Deserialize, Clone)]
+    #[derive(Serialize, Deserialize, Clone, Debug)]
     pub struct ConfigEndpoint {
-        id : String,
-        login : String,
+        pub id : String,
+        pub login : String,
         #[serde(rename = "pass")]
-        password : String,
-        api_key : String,
+        pub password : String,
+        pub api_key : String,
         period : String,
         timeout : String,
         #[serde(default)]
-        metrics : Vec<Metrics>, 
+        pub metrics : Vec<Metrics>, 
     }
      impl ConfigEndpoint {
         pub fn from_config(config: Arc<Config>) -> Vec<Arc<Self>> {
@@ -192,12 +192,12 @@ pub mod v3 {
         pub fn get_period(&self) -> Option<u32> {
             self.period.parse().ok()
         }
-        pub fn get_timeout(&self) -> Option<u32> {
+        pub fn get_timeout(&self) -> Option<u64> {
             self.timeout.parse().ok()
         }
      }
 
-    #[derive(Serialize, Deserialize, Clone)]
+    #[derive(Serialize, Deserialize, Clone, Debug)]
     pub struct Config {
         pub config : Vec<ConfigEndpoint>,
     }
@@ -216,18 +216,24 @@ pub mod v3 {
         }
     }
 
+    #[derive(Clone)]
     pub struct Credentials {
-        endpoint : Arc<ConfigEndpoint>,
+        pub endpoint : Arc<ConfigEndpoint>,
     }
 
     impl Credentials {
         pub fn from_config_endpoint(endpoint: Arc<ConfigEndpoint>) -> Credentials {
             Self { endpoint }
         }
+        // pub fn clone(self) -> Self {
+        //     Self { 
+        //         endpoint : self.endpoint.clone()
+        //     }
+        // }
     }
 
     // to prometheus and nmns
-    #[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize, Debug)]
     pub struct MetricOutput {
         id : String,
         #[serde(rename = "type")]
@@ -245,4 +251,11 @@ pub mod v3 {
             }
         } 
     }
+
+    #[derive(Serialize, Deserialize, Debug)]
+    pub struct PrometheusMetrics {
+        service_name: String,
+        endpoint_name: String,
+        metrics: Value,
+    }
 }
\ No newline at end of file
-- 
2.40.1


From 60c31e1a5f0a2b40d434b261d657979a0c2ae158 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 20:23:15 +0300
Subject: [PATCH 34/54] fixed net

---
 crates/api-grub/src/net.rs       | 37 ++++++++++++++++++++------------
 crates/integr-structs/src/api.rs |  1 +
 2 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index 33f3457..0595588 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -93,17 +93,22 @@ impl<'a> ApiPoll<'a> {
         // exporter: Arc<Exporter>
     ) -> Result<()> {
         // processing metrics 
-        let mut req = Client::new()
-            .get(&metrics.url);
+        // let mut req = Client::new()
+        //     // .user_agent("api_grub/integration_module")
+        //     .get(&metrics.url);
+        let client = Client::builder()
+            .user_agent("api_grub/integration_module");
+        let mut req = client.build().unwrap().get(&metrics.url);
+
         let login = creds.endpoint.login.clone();
         let password = creds.endpoint.password.clone();
         let api_key = creds.endpoint.api_key.clone();
-        if !login.is_empty() && !password.is_empty() {
-            dbg!("kjgbkasgksjd");
-            req = req.basic_auth(login, Some(password));
-        }
+        // if !login.is_empty() && !password.is_empty() {
+        //     dbg!("kjgbkasgksjd");
+        //     req = req.basic_auth(login, Some(password));
+        // }
         if !api_key.is_empty() {
-            req = req.bearer_auth(&api_key);
+            // req = req.bearer_auth(&api_key);
             // req = req.header("authorization", "bearer ");
 
             req = req.header("accept", "application/json");
@@ -111,7 +116,7 @@ impl<'a> ApiPoll<'a> {
             
             // req = req.query(&["Bearer", "6fe8b0db-62b4-4065-9c1e-441ec4228341.9acec20bd17d7178f332896f8c006452877a22b8627d089105ed39c5baef9711"])
         }
-        dbg!(&req);
+        // dbg!(&req);
         // let (client, res) = req.build_split();
         // let res = res.unwrap();
         // res.url_mut().is_special()
@@ -124,19 +129,23 @@ impl<'a> ApiPoll<'a> {
         
         match req.send().await {
             Ok(resp) => {
-                dbg!(&resp);
+                // dbg!(&resp.text().await);
                 if let Ok(response) = resp.text().await {
-                    match serde_json::from_str::<Value>(&response) {
-                        Err(er) => {error!("Bad JSON in response. Error: {}", er);},
+                    match serde_json::to_value(&response) {
+                        Err(er) => {
+                            error!("Bad JSON in response. Error: {}", er);
+                        },
                         Ok(_) => {
                             let endpoint_name = &metrics.name;
                             let preproc = JsonParser::parse(&metrics.measure, &response);
-                            let metrics: String = serde_json::from_value(preproc.clone())
-                                .unwrap_or({
+                            // dbg!(serde_json::to_string_pretty(&preproc));
+
+                            let metrics = serde_json::to_string_pretty(&preproc)
+                                .unwrap_or_else(|_| {
                                     error!("Cannot parse grabbed metrics data to String");
                                     String::from(r#""value" : null"#)
                                 });
-                            dbg!(&metrics);
+                            // dbg!(&metrics);
                             match Exporter::export_metrics(&metrics).await {
                                 Ok(_) => {
                                     info!("Successfully imported metrics data to Prometheus");
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 024a410..6e035c4 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -258,4 +258,5 @@ pub mod v3 {
         endpoint_name: String,
         metrics: Value,
     }
+    
 }
\ No newline at end of file
-- 
2.40.1


From fe7aaaaef350a435121b67d7f2b82a703fab89da Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 13 Feb 2025 20:25:25 +0300
Subject: [PATCH 35/54] #1

---
 crates/api-grub/src/net.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index 0595588..dbc6438 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -145,7 +145,6 @@ impl<'a> ApiPoll<'a> {
                                     error!("Cannot parse grabbed metrics data to String");
                                     String::from(r#""value" : null"#)
                                 });
-                            // dbg!(&metrics);
                             match Exporter::export_metrics(&metrics).await {
                                 Ok(_) => {
                                     info!("Successfully imported metrics data to Prometheus");
-- 
2.40.1


From 32ab2342368e8ed42d17a27a9db346f715440858 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Fri, 14 Feb 2025 12:32:30 +0300
Subject: [PATCH 36/54] api grub set up

---
 config_api.json                  |  2 +-
 crates/api-grub/src/export.rs    |  4 +-
 crates/api-grub/src/net.rs       | 95 +++++---------------------------
 crates/integr-structs/src/api.rs | 10 +++-
 4 files changed, 25 insertions(+), 86 deletions(-)

diff --git a/config_api.json b/config_api.json
index f88bdfa..d9d25fa 100644
--- a/config_api.json
+++ b/config_api.json
@@ -6,7 +6,7 @@
 			"pass" : "",
 			"api_key" : "6fe8b0db-62b4-4065-9c1e-441ec4228341.9acec20bd17d7178f332896f8c006452877a22b8627d089105ed39c5baef9711",
 			"period" : "",
-			"timeout" : "10",
+			"timeout" : "5",
 			"metrics" : [
 				{
 					"name": "conferences", 
diff --git a/crates/api-grub/src/export.rs b/crates/api-grub/src/export.rs
index 06e94d2..84dfc93 100644
--- a/crates/api-grub/src/export.rs
+++ b/crates/api-grub/src/export.rs
@@ -51,7 +51,7 @@ impl Exporter {
         let _ = client.query(&query, &[&metrics]).await?;
         Ok(())
     }
-    pub async fn export_metrics(metrics: &str) -> Result<()> {
+    pub async fn export_metrics(metrics: &str) -> Result<usize> {
         let url = env::var("EXPORTER_URL")?;
         // let req = Request::new(Method::PUT, 
         //     Url::parse(metrics)?);
@@ -60,7 +60,7 @@ impl Exporter {
             .json(metrics)
             .send().await;
         req?;
-        Ok(())
+        Ok(metrics.as_bytes().len())
     }
 
 }
\ No newline at end of file
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index dbc6438..70057b9 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -12,7 +12,7 @@ use tokio::task::JoinHandle;
 use dotenv::dotenv;
 use crate::json::JsonParser;
 use crate::export::{self, Exporter};
-use integr_structs::api::v3::{Config, ConfigEndpoint, Credentials, Metrics};
+use integr_structs::api::v3::{Config, ConfigEndpoint, Credentials, Metrics, PrometheusMetrics};
 
 // type BufferType = Arc<Mutex<Vec<String>>>; 
 
@@ -139,15 +139,24 @@ impl<'a> ApiPoll<'a> {
                             let endpoint_name = &metrics.name;
                             let preproc = JsonParser::parse(&metrics.measure, &response);
                             // dbg!(serde_json::to_string_pretty(&preproc));
+                            let preproc = PrometheusMetrics::new(&service_id, endpoint_name, preproc);
+
 
                             let metrics = serde_json::to_string_pretty(&preproc)
                                 .unwrap_or_else(|_| {
                                     error!("Cannot parse grabbed metrics data to String");
-                                    String::from(r#""value" : null"#)
+                                    String::from(r#"
+                                    {
+                                        "service_name" : null,
+                                        "endpoint_name" : null,
+                                        "value" : null
+                                    }
+                                    "#)
                                 });
+                            println!("{}", &metrics);
                             match Exporter::export_metrics(&metrics).await {
-                                Ok(_) => {
-                                    info!("Successfully imported metrics data to Prometheus");
+                                Ok(bytes) => {
+                                    info!("Successfully imported {} bytes of metrics data to Prometheus", bytes);
                                 },
                                 Err(er) => {
                                     error!("Failed to export data to Prometheus due to {}", er);
@@ -184,7 +193,6 @@ impl<'a> ApiPoll<'a> {
             let mut jh = Vec::<JoinHandle::<Result<()>>>::new();
             
             for idx in 0..metrics.len() {
-                // let exporter = exporter.clone();
                 let creds = creds.clone();
                 let metrics = metrics.clone();
                 let service_id = service_id.clone();
@@ -193,7 +201,6 @@ impl<'a> ApiPoll<'a> {
                         service_id.clone(), 
                         metrics[idx].clone().into(),
                         creds.clone(),
-                        // exporter.clone()
                     ).await
                 });
                 jh.push(event);
@@ -239,82 +246,6 @@ impl<'a> ApiPoll<'a> {
         for i in join_handles {
             let _ = i.await;
         }
-        // let template = Arc::new(self.config.template.clone());
-
-        // if self.is_default().await { return Err(Error::msg("Default config with no endpoints")) }
-
-        // // TODO: rewrite nextly to async 
-        // for point in template.iter() {
-        //     let point = Arc::new(point.clone());
-        //     // let buffer = buffer.clone();
-        //     let client = client.clone();
-        //     let exporter = exporter.clone();
-        //     let endpoint_processer = tokio::spawn(async move {
-        //         let point = point.clone();
-        //         match client.request(RestMethod::from_str(&point.method).await, &point.url).send().await {
-        //             Ok(resp) => {
-        //                 if !resp.status().is_success() {
-        //                     error!("ErrorCode in Response from API. Check configuration");
-        //                     return Err(Error::msg("Error during sending request"));
-        //                 }
-        //                 if let Ok(text) = resp.text().await {
-        //                     // 
-        //                     let metrics = ProcessedEndpoint::from_target_response(&text, &point)?;
-        //                     // dbg!(&metrics);
-        //                     println!("{}", &metrics);
-        //                     // 
-        //                     if let Some(conn) = exporter.get_connection_from_pool().await {
-                                
-        //                         // TEST: to exporter 
-        //                         let res = client.request(
-        //                             RestMethod::from_str("post").await,
-        //                             "http://192.168.2.34:9101/update")
-        //                         .json(&metrics)
-        //                         .send().await;
-        //                         if let Err(er) = res {
-        //                             error!("Cannot send data to exporter due to: {}", er);
-        //                         } else {
-        //                             println!("{:?}", res.unwrap().text().await);
-        //                         }
-
-        //                         if let Err(er) = Exporter::export_data(conn, &metrics).await {
-        //                             error!("Cannot export data to DB during to: {}", er);
-        //                             return Err(Error::msg("Error during exporting data to DB"));
-        //                         }
-        //                     } else {
-        //                         if !exporter.is_no_connection() {
-        //                             return Err(Error::msg("Error during getting connection from pool"));
-        //                         }
-        //                     }
-
-        //                     // let mut buffer = buffer.lock().await;
-        //                     // buffer.push(text);
-        //                 } else {
-        //                     error!("{}: {} - Error with extracting text field from Response", &point.method.to_uppercase(), &point.url);
-        //                     return Err(Error::msg("Error with extracting text field from Response"));
-        //                 }
-        //             },
-        //             Err(_) => {
-        //                 error!("{}: {} endpoint is unreachable", &point.method.to_uppercase(), &point.url);
-        //                 return Err(Error::msg("Endpoint is unreachable"));
-        //             },
-        //         }
-        //         Ok(())
-        //     });
-        //     join_handles.push(endpoint_processer);
-        // }
-
-        // for i in join_handles {
-        //     let _ = i.await;
-        // }
-
-        // // let buffer = buffer.lock().await;
-        // // match &buffer.len() {
-        // //     0 => Err(Error::msg("Error due to API grubbing. Check config" )),
-        // //     _ => {
-        // //         Ok(())
-        // //     },
-        // // }
         Ok(())
     }
 }
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 6e035c4..260df18 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -258,5 +258,13 @@ pub mod v3 {
         endpoint_name: String,
         metrics: Value,
     }
-    
+    impl PrometheusMetrics {
+        pub fn new(service: &str, endpoint: &str, metrics: Value) -> Self {
+            Self { 
+                service_name: service.to_string(), 
+                endpoint_name: endpoint.to_string(),
+                metrics: metrics 
+            }
+        }
+    }
 }
\ No newline at end of file
-- 
2.40.1


From 39ad05c21cf952f95947312983206a7a9742c7ba Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Fri, 14 Feb 2025 14:06:13 +0300
Subject: [PATCH 37/54] fixed metrics export + getting it on exporter

---
 crates/api-grub/src/export.rs    | 14 ++++--
 crates/api-grub/src/net.rs       | 28 +++++------
 crates/exporter/Cargo.toml       |  7 +++
 crates/exporter/src/endpoints.rs | 68 +++++++++++++++++++++++++++
 crates/exporter/src/main.rs      | 80 +++++++++++++-------------------
 crates/integr-structs/src/api.rs |  6 +++
 6 files changed, 136 insertions(+), 67 deletions(-)
 create mode 100644 crates/exporter/src/endpoints.rs

diff --git a/crates/api-grub/src/export.rs b/crates/api-grub/src/export.rs
index 84dfc93..4f183c7 100644
--- a/crates/api-grub/src/export.rs
+++ b/crates/api-grub/src/export.rs
@@ -1,4 +1,5 @@
 use deadpool_postgres::{Config, Pool, Runtime, Client as PgClient};
+use integr_structs::api::v3::PrometheusMetrics;
 use reqwest::Client;
 use tokio_postgres::NoTls;
 use std::env;
@@ -51,16 +52,19 @@ impl Exporter {
         let _ = client.query(&query, &[&metrics]).await?;
         Ok(())
     }
-    pub async fn export_metrics(metrics: &str) -> Result<usize> {
+    pub async fn export_metrics(metrics: PrometheusMetrics) -> Result<usize> {
         let url = env::var("EXPORTER_URL")?;
         // let req = Request::new(Method::PUT, 
         //     Url::parse(metrics)?);
         let req = Client::new()
-            .put(url)
-            .json(metrics)
+            .post(url)
+            .json(&metrics)
             .send().await;
-        req?;
-        Ok(metrics.as_bytes().len())
+        // dbg!(&req);
+        // dbg!(&req.unwrap().text().await);
+        // todo : rewrite with status code wrapping
+        req?; 
+        Ok(metrics.get_bytes_len())
     }
 
 }
\ No newline at end of file
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index 70057b9..a4326d3 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -142,21 +142,21 @@ impl<'a> ApiPoll<'a> {
                             let preproc = PrometheusMetrics::new(&service_id, endpoint_name, preproc);
 
 
-                            let metrics = serde_json::to_string_pretty(&preproc)
-                                .unwrap_or_else(|_| {
-                                    error!("Cannot parse grabbed metrics data to String");
-                                    String::from(r#"
-                                    {
-                                        "service_name" : null,
-                                        "endpoint_name" : null,
-                                        "value" : null
-                                    }
-                                    "#)
-                                });
-                            println!("{}", &metrics);
-                            match Exporter::export_metrics(&metrics).await {
+                            // let metrics = serde_json::to_string_pretty(&preproc)
+                            //     .unwrap_or_else(|_| {
+                            //         error!("Cannot parse grabbed metrics data to String");
+                            //         String::from(r#"
+                            //         {
+                            //             "service_name" : null,
+                            //             "endpoint_name" : null,
+                            //             "value" : null
+                            //         }
+                            //         "#)
+                            //     });
+                            // println!("{}", &metrics);
+                            match Exporter::export_metrics(preproc).await {
                                 Ok(bytes) => {
-                                    info!("Successfully imported {} bytes of metrics data to Prometheus", bytes);
+                                    info!("Successfully exported {} bytes of metrics data to Prometheus", bytes);
                                 },
                                 Err(er) => {
                                     error!("Failed to export data to Prometheus due to {}", er);
diff --git a/crates/exporter/Cargo.toml b/crates/exporter/Cargo.toml
index a3f0402..af3b5f0 100644
--- a/crates/exporter/Cargo.toml
+++ b/crates/exporter/Cargo.toml
@@ -7,4 +7,11 @@ edition = "2021"
 axum = "0.8.1"
 prometheus = "0.13.4"
 tokio = { version = "1.43.0", features = ["full"] }
+integr-structs = {path = "../integr-structs"}
+anyhow = "1.0.95"
+chrono = "0.4.39"
+tracing = "0.1.41"
+tracing-subscriber = "0.3.19"
+serde = { version = "1.0.217", features = ["derive"] }
+serde_json = "1.0.138"
 
diff --git a/crates/exporter/src/endpoints.rs b/crates/exporter/src/endpoints.rs
new file mode 100644
index 0000000..0deeb39
--- /dev/null
+++ b/crates/exporter/src/endpoints.rs
@@ -0,0 +1,68 @@
+use axum::{
+    body::Body, extract::{Json, Request, State}, http::{self, HeaderMap, Response as Resp}, response::{IntoResponse, Response}, routing::get, Router
+};
+use integr_structs::api::v3::PrometheusMetrics;
+use prometheus::{core::{Collector, Metric}, proto::{Quantile, Summary}, Counter, Encoder, Opts, Registry, TextEncoder};
+use std::sync::{Arc, Mutex};
+use crate::AppState;
+// use log::{warn, info, error};
+use tracing::{info, error, warn, debug};
+
+pub async fn update_metrics(
+    State(state): State<Arc<AppState>>,
+    Json(request) : Json<PrometheusMetrics>
+) -> impl IntoResponse {
+    info!("post on /update");
+//     let resp = Response::new("body");
+    debug!("{:?}", &request);
+// //     resp
+//     let mut header_map = HeaderMap::new();
+//     header_map.insert(http::header::CONTENT_TYPE, 
+//         "text/plain".parse().unwrap());
+
+    (http::StatusCode::ACCEPTED, "Ok")
+}
+
+pub async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
+    let encoder = TextEncoder::new();
+    let mut buffer = Vec::new();
+    // 
+    let mut fm = prometheus::proto::MetricFamily::new();
+    // prometheus::Registry::
+    let mut met = prometheus::proto::Metric::new(); 
+    let mutex_guard = state.sum.lock().unwrap();
+    met.set_summary(mutex_guard.clone());
+    // let metric = met.take_label();
+    fm.set_metric(vec![met].into());
+    fm.set_help("example summary".to_string());
+    fm.set_name("example_summary".to_string());
+    fm.set_field_type(prometheus::proto::MetricType::SUMMARY);
+    
+    let mut metric_families = state.registry.gather();
+    metric_families.push(fm);
+    encoder.encode(&metric_families, &mut buffer).unwrap();
+    String::from_utf8(buffer).unwrap()
+}
+
+pub async fn increment_handler(State(state): State<Arc<AppState>>) -> &'static str {
+    let mut counter = state.counter.lock().unwrap();
+    counter.inc();
+    "Counter incremented"
+}
+
+pub async fn summary_handler(State(state): State<Arc<AppState>>) -> &'static str {
+    let mut sum = state.sum.lock().unwrap();
+    let qs = sum.get_quantile();
+    let new_qs: Vec<Quantile> = qs
+        .into_iter()
+        .enumerate()
+        .map(|(idx, q)| {
+            let mut q = q.to_owned();
+            q.set_value(q.get_value() + idx as f64);
+            // q.set_quantile(q.get_quantile() * 2.0);
+            q
+        })
+        .collect();
+    sum.set_quantile(new_qs.into());
+    "Summary changed"
+}
diff --git a/crates/exporter/src/main.rs b/crates/exporter/src/main.rs
index 93bcb8b..d4b6086 100644
--- a/crates/exporter/src/main.rs
+++ b/crates/exporter/src/main.rs
@@ -1,7 +1,24 @@
-use axum::{extract::State, routing::get, Router};
-use prometheus::{proto::{Histogram, Quantile, Summary}, Counter, Encoder, Opts, Registry, TextEncoder};
+mod endpoints;
+// mod logger;
+
+// use logger::setup_logger;
+use axum::{
+    extract::State, 
+    routing::{get, post}, 
+    Router};
+use prometheus::{
+    core::{Collector, Metric}, 
+    proto::{Quantile, Summary}, 
+    Counter, 
+    Encoder,
+    Opts, 
+    Registry, 
+    TextEncoder};
 use std::sync::{Arc, Mutex};
+use endpoints::*;
 use tokio::net::TcpListener;
+// use log::{warn, info, error};
+use tracing::{info, error, warn, debug};
 
 struct AppState {
     registry: Registry,
@@ -9,53 +26,9 @@ struct AppState {
     sum : Mutex<Summary>,
 }
 
-async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
-    let encoder = TextEncoder::new();
-    let mut buffer = Vec::new();
-    // 
-    let mut fm = prometheus::proto::MetricFamily::new();
-    // prometheus::Registry::
-    let mut met = prometheus::proto::Metric::new(); 
-    let mutex_guard = state.sum.lock().unwrap();
-    met.set_summary(mutex_guard.clone());
-    // let metric = met.take_label();
-    fm.set_metric(vec![met].into());
-    fm.set_help("example summary".to_string());
-    fm.set_name("example_summary".to_string());
-    fm.set_field_type(prometheus::proto::MetricType::SUMMARY);
-    
-    let mut metric_families = state.registry.gather();
-    metric_families.push(fm);
-    encoder.encode(&metric_families, &mut buffer).unwrap();
-    String::from_utf8(buffer).unwrap()
-}
-
-async fn increment_handler(State(state): State<Arc<AppState>>) -> &'static str {
-    let mut counter = state.counter.lock().unwrap();
-    counter.inc();
-    "Counter incremented"
-}
-
-async fn summary_handler(State(state): State<Arc<AppState>>) -> &'static str {
-    let mut sum = state.sum.lock().unwrap();
-    let qs = sum.get_quantile();
-    let new_qs: Vec<Quantile> = qs
-        .into_iter()
-        .enumerate()
-        .map(|(idx, q)| {
-            let mut q = q.to_owned();
-            q.set_value(q.get_value() + idx as f64);
-            // q.set_quantile(q.get_quantile() * 2.0);
-            q
-        })
-        .collect();
-    sum.set_quantile(new_qs.into());
-    "Summary changed"
-}
-
-
 #[tokio::main]
 async fn main() {
+    // let _ = setup_logger().await;
     let registry = Registry::new();
     let counter_opts = Opts::new("example_counter", "Пример счётчика");
     // let histogram_opts = Opts::new("example_histogram", "Пример histogram");
@@ -79,6 +52,7 @@ async fn main() {
     sunops.set_quantile(vq.into());
 
     let counter = Counter::with_opts(counter_opts).unwrap();
+    // counter.desc()
     registry.register(Box::new(counter.clone())).unwrap();
     // registry.register(Box::new(prometheus::proto::MetricFamily::));
     // registry.register(Box::new(sunops.clone())).unwrap();
@@ -90,12 +64,22 @@ async fn main() {
         sum : Mutex::new(sunops)
     });
 
+    // info!("Configurating 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();
+    let listener = TcpListener::bind("127.0.0.1:9100").await.unwrap();
+    info!("Serving on ...:9100");
     axum::serve(listener, app).await.unwrap();
 }
\ No newline at end of file
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 260df18..f9ca124 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -266,5 +266,11 @@ pub mod v3 {
                 metrics: metrics 
             }
         }
+        pub fn get_bytes_len(&self) -> usize {
+            let str_metrics = serde_json::to_vec(self).unwrap_or_else(
+                |_| Vec::new()
+            );
+            str_metrics.len()
+        }
     }
 }
\ No newline at end of file
-- 
2.40.1


From 3eb8e749b5fa7720631b885386ebbce619664c4d Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Fri, 14 Feb 2025 18:44:08 +0300
Subject: [PATCH 38/54] PROMETHEUSv1

---
 crates/api-grub/src/export.rs    |   1 +
 crates/api-grub/src/json.rs      |   4 +-
 crates/api-grub/src/net.rs       |  14 ---
 crates/exporter/src/endpoints.rs | 130 ++++++++++++++--------
 crates/exporter/src/main.rs      |  57 +++++-----
 crates/exporter/src/metrics.rs   | 181 +++++++++++++++++++++++++++++++
 crates/integr-structs/src/api.rs |  12 +-
 7 files changed, 297 insertions(+), 102 deletions(-)
 create mode 100644 crates/exporter/src/metrics.rs

diff --git a/crates/api-grub/src/export.rs b/crates/api-grub/src/export.rs
index 4f183c7..88dfaf4 100644
--- a/crates/api-grub/src/export.rs
+++ b/crates/api-grub/src/export.rs
@@ -56,6 +56,7 @@ impl Exporter {
         let url = env::var("EXPORTER_URL")?;
         // let req = Request::new(Method::PUT, 
         //     Url::parse(metrics)?);
+        dbg!(&metrics);
         let req = Client::new()
             .post(url)
             .json(&metrics)
diff --git a/crates/api-grub/src/json.rs b/crates/api-grub/src/json.rs
index 2cc3289..6208724 100644
--- a/crates/api-grub/src/json.rs
+++ b/crates/api-grub/src/json.rs
@@ -5,7 +5,7 @@ use integr_structs::api::v3::{Metric, MetricOutput};
 pub struct JsonParser;
 
 impl JsonParser {
-    pub fn parse(targets: &Vec<Metric>, json: &str) -> Value {
+    pub fn parse(targets: &Vec<Metric>, json: &str) -> Vec<MetricOutput> {
         let mut res_vec: Vec<MetricOutput> = Vec::new(); 
         for target in targets {
             let metric = match target.addr.contains("[") {
@@ -14,7 +14,7 @@ impl JsonParser {
             };
             res_vec.push(MetricOutput::new_with_slices(&target.id, &target.json_type, &target.addr, metric));
         }  
-        serde_json::to_value(res_vec).unwrap_or(Value::Null)
+        res_vec
     }
     fn get_sum_of_metrics_in_array(target: &Metric, json: &str) -> Value {
         if target.addr.is_empty() {
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index a4326d3..82887a3 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -140,20 +140,6 @@ impl<'a> ApiPoll<'a> {
                             let preproc = JsonParser::parse(&metrics.measure, &response);
                             // dbg!(serde_json::to_string_pretty(&preproc));
                             let preproc = PrometheusMetrics::new(&service_id, endpoint_name, preproc);
-
-
-                            // let metrics = serde_json::to_string_pretty(&preproc)
-                            //     .unwrap_or_else(|_| {
-                            //         error!("Cannot parse grabbed metrics data to String");
-                            //         String::from(r#"
-                            //         {
-                            //             "service_name" : null,
-                            //             "endpoint_name" : null,
-                            //             "value" : null
-                            //         }
-                            //         "#)
-                            //     });
-                            // println!("{}", &metrics);
                             match Exporter::export_metrics(preproc).await {
                                 Ok(bytes) => {
                                     info!("Successfully exported {} bytes of metrics data to Prometheus", bytes);
diff --git a/crates/exporter/src/endpoints.rs b/crates/exporter/src/endpoints.rs
index 0deeb39..c76ecce 100644
--- a/crates/exporter/src/endpoints.rs
+++ b/crates/exporter/src/endpoints.rs
@@ -1,12 +1,15 @@
-use axum::{
-    body::Body, extract::{Json, Request, State}, http::{self, HeaderMap, Response as Resp}, response::{IntoResponse, Response}, routing::get, Router
+use axum::{ 
+    extract::{Json, State}, 
+    response::IntoResponse,
+    http
 };
 use integr_structs::api::v3::PrometheusMetrics;
-use prometheus::{core::{Collector, Metric}, proto::{Quantile, Summary}, Counter, Encoder, Opts, Registry, TextEncoder};
-use std::sync::{Arc, Mutex};
+use prometheus::{Encoder, Registry, TextEncoder, Gauge};
+use std::sync::{Arc, MutexGuard};
 use crate::AppState;
 // use log::{warn, info, error};
-use tracing::{info, error, warn, debug};
+use tracing::{info, error, warn};
+use crate::metrics::{MetricsProcesser, MetricsValueType};
 
 pub async fn update_metrics(
     State(state): State<Arc<AppState>>,
@@ -14,55 +17,86 @@ pub async fn update_metrics(
 ) -> impl IntoResponse {
     info!("post on /update");
 //     let resp = Response::new("body");
-    debug!("{:?}", &request);
-// //     resp
-//     let mut header_map = HeaderMap::new();
-//     header_map.insert(http::header::CONTENT_TYPE, 
-//         "text/plain".parse().unwrap());
+    // println!("{:?}", request);
+    // debug!("{:?}", MetricsProcesser::get_type_of_value(&request));
+    let service = &request.service_name;
+    let endpoint = &request.endpoint_name;
+
+    for i in request.metrics {
+        // debug!("{:?}", &i);
+        // debug!("{:?}", MetricsProcesser::get_type_of_value(&i));
+        let metric_name = format!("{}_{}_{}", service, endpoint, &i.id);
+        match MetricsProcesser::get_type_of_value(&i) {
+            MetricsValueType::Array | 
+            MetricsValueType::TaggedArray => {
+
+            },
+            MetricsValueType::Number => {
+                let gauge = MetricsProcesser::gauge_from_number(
+                    &i, 
+                    &metric_name
+                );
+                if let Some(gauge) = gauge {
+                    match state.registry.lock() {
+                        Err(er) => {
+                            error!("Cannot lock Metric Registry due to {} ", er)
+                        },
+                        Ok(registry) => {
+                            update_or_insert_metric(
+                                gauge, 
+                                registry,
+                                &metric_name
+                            );
+                        },
+                    }
+                }
+                // dbg!(gauge);
+            },
+            MetricsValueType::ArrayOfStrings => {
+                warn!("String arrays are unsupported, ignoring ...");
+            },
+            _ => {
+                warn!("Unrecognized metric type was supplied, ignoring ...");
+            }
+        }
+    }
 
     (http::StatusCode::ACCEPTED, "Ok")
 }
 
 pub async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
-    let encoder = TextEncoder::new();
-    let mut buffer = Vec::new();
-    // 
-    let mut fm = prometheus::proto::MetricFamily::new();
-    // prometheus::Registry::
-    let mut met = prometheus::proto::Metric::new(); 
-    let mutex_guard = state.sum.lock().unwrap();
-    met.set_summary(mutex_guard.clone());
-    // let metric = met.take_label();
-    fm.set_metric(vec![met].into());
-    fm.set_help("example summary".to_string());
-    fm.set_name("example_summary".to_string());
-    fm.set_field_type(prometheus::proto::MetricType::SUMMARY);
+    let registry = state.registry.lock();
     
-    let mut metric_families = state.registry.gather();
-    metric_families.push(fm);
-    encoder.encode(&metric_families, &mut buffer).unwrap();
-    String::from_utf8(buffer).unwrap()
+    return match registry {
+        Ok(registry) => {
+            let encoder = TextEncoder::new();
+            let mut buffer = Vec::new();
+            let metric_families = registry.gather();
+            encoder.encode(&metric_families, &mut buffer).unwrap();
+            String::from_utf8(buffer).unwrap()
+        },
+        Err(er) => {
+            format!("Cannot lock Metric Registry due to {} ", er)
+        } 
+    }
 }
 
-pub async fn increment_handler(State(state): State<Arc<AppState>>) -> &'static str {
-    let mut counter = state.counter.lock().unwrap();
-    counter.inc();
-    "Counter incremented"
-}
-
-pub async fn summary_handler(State(state): State<Arc<AppState>>) -> &'static str {
-    let mut sum = state.sum.lock().unwrap();
-    let qs = sum.get_quantile();
-    let new_qs: Vec<Quantile> = qs
-        .into_iter()
-        .enumerate()
-        .map(|(idx, q)| {
-            let mut q = q.to_owned();
-            q.set_value(q.get_value() + idx as f64);
-            // q.set_quantile(q.get_quantile() * 2.0);
-            q
-        })
-        .collect();
-    sum.set_quantile(new_qs.into());
-    "Summary changed"
+pub fn update_or_insert_metric<'a>(
+    metric: Gauge, 
+    registry: MutexGuard<'a, Registry>,
+    metric_name: &str
+) {
+    // let mut counter = 0;
+    match registry.register(Box::new(metric)) {
+        Ok(_) => {
+            info!("Metric `{}` was added!", metric_name);
+        },
+        Err(_er) => {
+            // update
+        },
+    }
+    // registry.gather()
+    //     .iter()
+    //     .filter(|fam| fam.get_name().)
+         
 }
diff --git a/crates/exporter/src/main.rs b/crates/exporter/src/main.rs
index d4b6086..7bc1b19 100644
--- a/crates/exporter/src/main.rs
+++ b/crates/exporter/src/main.rs
@@ -1,67 +1,60 @@
 mod endpoints;
 // mod logger;
+mod metrics;
 
 // use logger::setup_logger;
 use axum::{
-    extract::State, 
     routing::{get, post}, 
     Router};
-use prometheus::{
-    core::{Collector, Metric}, 
-    proto::{Quantile, Summary}, 
-    Counter, 
-    Encoder,
-    Opts, 
-    Registry, 
-    TextEncoder};
+use prometheus::Registry;
 use std::sync::{Arc, Mutex};
 use endpoints::*;
 use tokio::net::TcpListener;
 // use log::{warn, info, error};
-use tracing::{info, error, warn, debug};
+use tracing::info;
 
 struct AppState {
-    registry: Registry,
-    counter: Mutex<Counter>,
-    sum : Mutex<Summary>,
+    registry: Mutex<Registry>,
+    // counter: Mutex<Counter>,
+    // sum : Mutex<Summary>,
 }
 
 #[tokio::main]
 async fn main() {
     // let _ = setup_logger().await;
     let registry = Registry::new();
-    let counter_opts = Opts::new("example_counter", "Пример счётчика");
+    // let counter_opts = Opts::new("example_counter", "Пример счётчика");
     // let histogram_opts = Opts::new("example_histogram", "Пример histogram");
 
-    use prometheus::proto::{Summary, Quantile};
+    // use prometheus::proto::{Summary, Quantile};
     // use prometheus::proto::
 
     // let guage = prometheus::ProtobufEncoder::new();
 
 
 
-    let mut sunops = Summary::new();
-    let mut q1 = Quantile::new();
-    let mut q2 = Quantile::new();
+    // let mut sunops = Summary::new();
+    // let mut q1 = Quantile::new();
+    // let mut q2 = Quantile::new();
 
-    q1.set_quantile(25.0);
-    q2.set_quantile(75.0);
-    // prometheus::proto::Metric::
+    // q1.set_quantile(25.0);
+    // q2.set_quantile(75.0);
+    // // prometheus::proto::Metric::
 
-    let vq = vec![q1, q2];
-    sunops.set_quantile(vq.into());
+    // let vq = vec![q1, q2];
+    // sunops.set_quantile(vq.into());
 
-    let counter = Counter::with_opts(counter_opts).unwrap();
-    // counter.desc()
-    registry.register(Box::new(counter.clone())).unwrap();
+    // let counter = Counter::with_opts(counter_opts).unwrap();
+    // // counter.desc()
+    // registry.register(Box::new(counter.clone())).unwrap();
     // registry.register(Box::new(prometheus::proto::MetricFamily::));
     // registry.register(Box::new(sunops.clone())).unwrap();
     
 
     let state = Arc::new(AppState {
-        registry,
-        counter: Mutex::new(counter),
-        sum : Mutex::new(sunops)
+        registry: Mutex::new(registry),
+        // counter: Mutex::new(counter),
+        // sum : Mutex::new(sunops)
     });
 
     // info!("Configurating Web-Server...");
@@ -74,12 +67,12 @@ async fn main() {
 
     let app = Router::new()
         .route("/metrics", get(metrics_handler))
-        .route("/increment", get(increment_handler))
-        .route("/sum", get(summary_handler))
+        // .route("/increment", get(increment_handler))
+        // .route("/sum", get(summary_handler))
         .route("/update", post(update_metrics))
         .with_state(state.clone());
 
-    let listener = TcpListener::bind("127.0.0.1:9100").await.unwrap();
+    let listener = TcpListener::bind("0.0.0.0:9100").await.unwrap();
     info!("Serving on ...:9100");
     axum::serve(listener, app).await.unwrap();
 }
\ No newline at end of file
diff --git a/crates/exporter/src/metrics.rs b/crates/exporter/src/metrics.rs
new file mode 100644
index 0000000..5b94562
--- /dev/null
+++ b/crates/exporter/src/metrics.rs
@@ -0,0 +1,181 @@
+// use serde_json::;
+use integr_structs::api::v3::MetricOutput;
+use serde_json::{Map, Value};
+use prometheus::Gauge;
+use tracing::error;
+
+#[derive(Debug)]
+pub enum MetricsValueType { 
+    Number,
+    Array,
+    TaggedArray,
+    ArrayOfStrings,
+    None,
+}
+
+pub struct MetricsProcesser;
+
+
+impl MetricsProcesser {
+
+    pub fn get_type_of_value(metrics: &MetricOutput) -> MetricsValueType {
+        if Self::is_number(metrics) {
+            return MetricsValueType::Number;
+        }
+        else if Self::is_array(metrics) {
+            if Self::is_tagged_array(metrics) {
+                return MetricsValueType::TaggedArray;
+            }
+            if Self::is_array_of_string_values(metrics) {
+                return MetricsValueType::ArrayOfStrings;
+            }
+            return MetricsValueType::Array;
+        }
+        MetricsValueType::None
+    }
+    pub fn gauge_from_number(
+        metric: &MetricOutput,
+        metric_name: &str,
+    ) -> Option<Gauge> {        
+        let gauge = Gauge::new(
+            metric_name,
+            &metric.id
+        );
+
+        match gauge {
+            Ok(gauge) => {
+            //     let value = metric.value.as_number().unwrap_or({
+            //         error!("Cannot convert {} metric value to f64 type. Value was set to 0.0", &metric_name);
+            //     });
+                // let value = value.as_f64()
+                let val = match metric.value.as_number() {
+                    Some(val) => {
+                        val.as_f64().unwrap_or_else(||
+                            0.0
+                        )
+                    },
+                    None => {
+                        error!("Cannot convert {} metric value to f64 type. Value was set to 0.0", &metric_name);
+                        0.0
+                    },
+                };
+                gauge.set(val);
+                return Some(gauge);
+            },
+            Err(er) => error!("Cannot create Gauge metric {} due to {}", &metric_name, er),
+        }
+        
+        None
+    }
+    pub fn gauge_from_map_metrics(
+        map: &Map<String, Value>, 
+        service: &str,
+        endpoint: &str
+    ) -> Option<Gauge> {
+        let map = map.clone();
+        let help: String = map.keys()
+            .enumerate()
+            .map(|(idx, key)| {
+                if idx == 1 {
+                    return key.to_owned();
+                }
+                "".to_owned()
+            })
+            .collect();
+        let name = format!("{}_{}_{}", service, endpoint, &help);
+        if map.len() > 1 {
+            // tagged 
+            if map.len() > 2 {
+                error!("Cannot create Gauge {}. It can be only 1 tag", &name);
+            } else {
+                let mut label_name = String::new();
+                let mut label_value = String::new();
+                let mut metric_value = 0.0;
+                map.iter()
+                    .enumerate()
+                    .for_each(|(idx, (key, value))|{
+                        if idx == 0 {
+                            label_name = key.to_owned();
+                            label_value = value.as_str()
+                                .unwrap_or("")
+                                .to_owned();
+                        } else {
+                            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 {
+                    Ok(vec) => {
+                        // vec.get_metric_with_label_values(vals)
+                        match vec.get_metric_with_label_values(&[&label_value]) {
+                            Ok(metric) => {
+                                metric.set(metric_value);  // Устанавливаем значение метрики
+                                return Some(metric.clone());  // Возвращаем `Gauge`
+                            },
+                            Err(er) => {
+                                error!("Cannot create Gauge {} due to {}", &name, er);
+                            },
+                        }
+                    },
+                    Err(er) => error!("Cannot create Gauge {} due to {}", &name, er),
+                }
+            }
+        } else {
+            // not-tagged 
+            let metric = Gauge::new(&name, &help);
+            match metric {
+                Ok(gauge) => {
+                    let mut value = 0.0;
+                    map.values()
+                        .map(|val| val.clone().as_f64())
+                        .for_each(|val| {
+                            value = val.unwrap_or(0.0)
+                        });
+                    gauge.set(value);
+                    return Some(gauge);
+                },
+                Err(er) => {
+                    error!("Cannot create Gauge {} due to {}", &name, er);
+                }
+            }
+        }
+        None
+    }
+    pub fn get_value_as_vec_map(metrics: &MetricOutput) -> Vec<Map<String, Value>>{
+        let mut vec: Vec<Map<String, Value>> = Vec::new();
+        let arr =  metrics.value.as_array().unwrap();
+        arr.iter()
+            .for_each(|a| {
+                vec.push(serde_json::from_value(a.clone()).unwrap());
+            });
+        vec
+    }
+    pub fn is_array_of_string_values(metrics: &MetricOutput) -> bool {
+        let arr = metrics.value.clone();
+        let arr = arr.as_array().unwrap();
+        let map: Map<String, Value> = serde_json::from_value(
+            arr[0].clone()
+        ).unwrap();
+        map.values()
+            .all(|val| val.is_string())
+    }
+    // fn is_valid(metrics: &PrometheusMetrics) -> bool {
+    //     false
+    // }
+    fn is_array(metrics: &MetricOutput) -> bool {
+        metrics.value.is_array()
+    }
+    fn is_tagged_array(metrics: &MetricOutput) -> bool {
+        let arr = metrics.value.as_array().unwrap();
+        let map: Map<String, Value> = serde_json::from_value(arr[0].clone()).unwrap();
+        map.len() > 1
+    }
+    fn is_number(metrics: &MetricOutput) -> bool {
+        metrics
+            .value.is_number()
+    }
+}
\ No newline at end of file
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index f9ca124..4a824f0 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -235,11 +235,11 @@ pub mod v3 {
     // to prometheus and nmns
     #[derive(Serialize, Deserialize, Debug)]
     pub struct MetricOutput {
-        id : String,
+        pub id : String,
         #[serde(rename = "type")]
         json_type : String,
         addr : String,
-        value : Value,
+        pub value : Value,
     }
     impl MetricOutput {
         pub fn new_with_slices(id : &str, json_type : &str, addr: &str,value : Value) -> Self {
@@ -254,12 +254,12 @@ pub mod v3 {
 
     #[derive(Serialize, Deserialize, Debug)]
     pub struct PrometheusMetrics {
-        service_name: String,
-        endpoint_name: String,
-        metrics: Value,
+        pub service_name: String,
+        pub endpoint_name: String,
+        pub metrics: Vec<MetricOutput>,
     }
     impl PrometheusMetrics {
-        pub fn new(service: &str, endpoint: &str, metrics: Value) -> Self {
+        pub fn new(service: &str, endpoint: &str, metrics: Vec<MetricOutput>) -> Self {
             Self { 
                 service_name: service.to_string(), 
                 endpoint_name: endpoint.to_string(),
-- 
2.40.1


From 000ca7c3c2e518cbb286ee2cae3ad24bf40befb5 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 18 Feb 2025 13:18:37 +0300
Subject: [PATCH 39/54] exporter migration

---
 Cargo.toml                       |   2 +-
 crates/api-grub/src/export.rs    |   2 +-
 crates/exporter/Cargo.toml       |  17 ---
 crates/exporter/Dockerfile       |  17 ---
 crates/exporter/src/endpoints.rs | 102 -----------------
 crates/exporter/src/main.rs      |  78 -------------
 crates/exporter/src/metrics.rs   | 181 -------------------------------
 7 files changed, 2 insertions(+), 397 deletions(-)
 delete mode 100644 crates/exporter/Cargo.toml
 delete mode 100644 crates/exporter/Dockerfile
 delete mode 100644 crates/exporter/src/endpoints.rs
 delete mode 100644 crates/exporter/src/main.rs
 delete mode 100644 crates/exporter/src/metrics.rs

diff --git a/Cargo.toml b/Cargo.toml
index 6b81d58..bbeed62 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [workspace]
 resolver = "2"
 members = [
-    "crates/api-grub", "crates/config-delivery", "crates/exporter", "crates/integr-structs", "crates/preproc", 
+    "crates/api-grub", "crates/config-delivery", "crates/integr-structs", "crates/preproc", 
 ]
 
 [profile.dev]
diff --git a/crates/api-grub/src/export.rs b/crates/api-grub/src/export.rs
index 88dfaf4..ed7ef88 100644
--- a/crates/api-grub/src/export.rs
+++ b/crates/api-grub/src/export.rs
@@ -56,7 +56,7 @@ impl Exporter {
         let url = env::var("EXPORTER_URL")?;
         // let req = Request::new(Method::PUT, 
         //     Url::parse(metrics)?);
-        dbg!(&metrics);
+        // dbg!(&metrics);
         let req = Client::new()
             .post(url)
             .json(&metrics)
diff --git a/crates/exporter/Cargo.toml b/crates/exporter/Cargo.toml
deleted file mode 100644
index af3b5f0..0000000
--- a/crates/exporter/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "exporter"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-axum = "0.8.1"
-prometheus = "0.13.4"
-tokio = { version = "1.43.0", features = ["full"] }
-integr-structs = {path = "../integr-structs"}
-anyhow = "1.0.95"
-chrono = "0.4.39"
-tracing = "0.1.41"
-tracing-subscriber = "0.3.19"
-serde = { version = "1.0.217", features = ["derive"] }
-serde_json = "1.0.138"
-
diff --git a/crates/exporter/Dockerfile b/crates/exporter/Dockerfile
deleted file mode 100644
index 8d003bd..0000000
--- a/crates/exporter/Dockerfile
+++ /dev/null
@@ -1,17 +0,0 @@
-FROM rust:1.75 AS builder
-
-WORKDIR /app
-
-COPY . .
-
-RUN cargo build --release
-
-FROM debian:bullseye-slim
-
-WORKDIR /app
-# RUN sudo apt update
-# RUN sudo apt install libc6
-COPY --from=builder /app/target/release/exporter /app/server
-EXPOSE 9100
-
-CMD ["/app/server"]
diff --git a/crates/exporter/src/endpoints.rs b/crates/exporter/src/endpoints.rs
deleted file mode 100644
index c76ecce..0000000
--- a/crates/exporter/src/endpoints.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use axum::{ 
-    extract::{Json, State}, 
-    response::IntoResponse,
-    http
-};
-use integr_structs::api::v3::PrometheusMetrics;
-use prometheus::{Encoder, Registry, TextEncoder, Gauge};
-use std::sync::{Arc, MutexGuard};
-use crate::AppState;
-// use log::{warn, info, error};
-use tracing::{info, error, warn};
-use crate::metrics::{MetricsProcesser, MetricsValueType};
-
-pub async fn update_metrics(
-    State(state): State<Arc<AppState>>,
-    Json(request) : Json<PrometheusMetrics>
-) -> impl IntoResponse {
-    info!("post on /update");
-//     let resp = Response::new("body");
-    // println!("{:?}", request);
-    // debug!("{:?}", MetricsProcesser::get_type_of_value(&request));
-    let service = &request.service_name;
-    let endpoint = &request.endpoint_name;
-
-    for i in request.metrics {
-        // debug!("{:?}", &i);
-        // debug!("{:?}", MetricsProcesser::get_type_of_value(&i));
-        let metric_name = format!("{}_{}_{}", service, endpoint, &i.id);
-        match MetricsProcesser::get_type_of_value(&i) {
-            MetricsValueType::Array | 
-            MetricsValueType::TaggedArray => {
-
-            },
-            MetricsValueType::Number => {
-                let gauge = MetricsProcesser::gauge_from_number(
-                    &i, 
-                    &metric_name
-                );
-                if let Some(gauge) = gauge {
-                    match state.registry.lock() {
-                        Err(er) => {
-                            error!("Cannot lock Metric Registry due to {} ", er)
-                        },
-                        Ok(registry) => {
-                            update_or_insert_metric(
-                                gauge, 
-                                registry,
-                                &metric_name
-                            );
-                        },
-                    }
-                }
-                // dbg!(gauge);
-            },
-            MetricsValueType::ArrayOfStrings => {
-                warn!("String arrays are unsupported, ignoring ...");
-            },
-            _ => {
-                warn!("Unrecognized metric type was supplied, ignoring ...");
-            }
-        }
-    }
-
-    (http::StatusCode::ACCEPTED, "Ok")
-}
-
-pub async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
-    let registry = state.registry.lock();
-    
-    return match registry {
-        Ok(registry) => {
-            let encoder = TextEncoder::new();
-            let mut buffer = Vec::new();
-            let metric_families = registry.gather();
-            encoder.encode(&metric_families, &mut buffer).unwrap();
-            String::from_utf8(buffer).unwrap()
-        },
-        Err(er) => {
-            format!("Cannot lock Metric Registry due to {} ", er)
-        } 
-    }
-}
-
-pub fn update_or_insert_metric<'a>(
-    metric: Gauge, 
-    registry: MutexGuard<'a, Registry>,
-    metric_name: &str
-) {
-    // let mut counter = 0;
-    match registry.register(Box::new(metric)) {
-        Ok(_) => {
-            info!("Metric `{}` was added!", metric_name);
-        },
-        Err(_er) => {
-            // update
-        },
-    }
-    // registry.gather()
-    //     .iter()
-    //     .filter(|fam| fam.get_name().)
-         
-}
diff --git a/crates/exporter/src/main.rs b/crates/exporter/src/main.rs
deleted file mode 100644
index 7bc1b19..0000000
--- a/crates/exporter/src/main.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-mod endpoints;
-// mod logger;
-mod metrics;
-
-// use logger::setup_logger;
-use axum::{
-    routing::{get, post}, 
-    Router};
-use prometheus::Registry;
-use std::sync::{Arc, Mutex};
-use endpoints::*;
-use tokio::net::TcpListener;
-// use log::{warn, info, error};
-use tracing::info;
-
-struct AppState {
-    registry: Mutex<Registry>,
-    // counter: Mutex<Counter>,
-    // sum : Mutex<Summary>,
-}
-
-#[tokio::main]
-async fn main() {
-    // let _ = setup_logger().await;
-    let registry = Registry::new();
-    // let counter_opts = Opts::new("example_counter", "Пример счётчика");
-    // let histogram_opts = Opts::new("example_histogram", "Пример histogram");
-
-    // use prometheus::proto::{Summary, Quantile};
-    // use prometheus::proto::
-
-    // let guage = prometheus::ProtobufEncoder::new();
-
-
-
-    // let mut sunops = Summary::new();
-    // let mut q1 = Quantile::new();
-    // let mut q2 = Quantile::new();
-
-    // q1.set_quantile(25.0);
-    // q2.set_quantile(75.0);
-    // // prometheus::proto::Metric::
-
-    // let vq = vec![q1, q2];
-    // sunops.set_quantile(vq.into());
-
-    // let counter = Counter::with_opts(counter_opts).unwrap();
-    // // counter.desc()
-    // registry.register(Box::new(counter.clone())).unwrap();
-    // registry.register(Box::new(prometheus::proto::MetricFamily::));
-    // registry.register(Box::new(sunops.clone())).unwrap();
-    
-
-    let state = Arc::new(AppState {
-        registry: Mutex::new(registry),
-        // counter: Mutex::new(counter),
-        // sum : Mutex::new(sunops)
-    });
-
-    // info!("Configurating 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.unwrap();
-}
\ No newline at end of file
diff --git a/crates/exporter/src/metrics.rs b/crates/exporter/src/metrics.rs
deleted file mode 100644
index 5b94562..0000000
--- a/crates/exporter/src/metrics.rs
+++ /dev/null
@@ -1,181 +0,0 @@
-// use serde_json::;
-use integr_structs::api::v3::MetricOutput;
-use serde_json::{Map, Value};
-use prometheus::Gauge;
-use tracing::error;
-
-#[derive(Debug)]
-pub enum MetricsValueType { 
-    Number,
-    Array,
-    TaggedArray,
-    ArrayOfStrings,
-    None,
-}
-
-pub struct MetricsProcesser;
-
-
-impl MetricsProcesser {
-
-    pub fn get_type_of_value(metrics: &MetricOutput) -> MetricsValueType {
-        if Self::is_number(metrics) {
-            return MetricsValueType::Number;
-        }
-        else if Self::is_array(metrics) {
-            if Self::is_tagged_array(metrics) {
-                return MetricsValueType::TaggedArray;
-            }
-            if Self::is_array_of_string_values(metrics) {
-                return MetricsValueType::ArrayOfStrings;
-            }
-            return MetricsValueType::Array;
-        }
-        MetricsValueType::None
-    }
-    pub fn gauge_from_number(
-        metric: &MetricOutput,
-        metric_name: &str,
-    ) -> Option<Gauge> {        
-        let gauge = Gauge::new(
-            metric_name,
-            &metric.id
-        );
-
-        match gauge {
-            Ok(gauge) => {
-            //     let value = metric.value.as_number().unwrap_or({
-            //         error!("Cannot convert {} metric value to f64 type. Value was set to 0.0", &metric_name);
-            //     });
-                // let value = value.as_f64()
-                let val = match metric.value.as_number() {
-                    Some(val) => {
-                        val.as_f64().unwrap_or_else(||
-                            0.0
-                        )
-                    },
-                    None => {
-                        error!("Cannot convert {} metric value to f64 type. Value was set to 0.0", &metric_name);
-                        0.0
-                    },
-                };
-                gauge.set(val);
-                return Some(gauge);
-            },
-            Err(er) => error!("Cannot create Gauge metric {} due to {}", &metric_name, er),
-        }
-        
-        None
-    }
-    pub fn gauge_from_map_metrics(
-        map: &Map<String, Value>, 
-        service: &str,
-        endpoint: &str
-    ) -> Option<Gauge> {
-        let map = map.clone();
-        let help: String = map.keys()
-            .enumerate()
-            .map(|(idx, key)| {
-                if idx == 1 {
-                    return key.to_owned();
-                }
-                "".to_owned()
-            })
-            .collect();
-        let name = format!("{}_{}_{}", service, endpoint, &help);
-        if map.len() > 1 {
-            // tagged 
-            if map.len() > 2 {
-                error!("Cannot create Gauge {}. It can be only 1 tag", &name);
-            } else {
-                let mut label_name = String::new();
-                let mut label_value = String::new();
-                let mut metric_value = 0.0;
-                map.iter()
-                    .enumerate()
-                    .for_each(|(idx, (key, value))|{
-                        if idx == 0 {
-                            label_name = key.to_owned();
-                            label_value = value.as_str()
-                                .unwrap_or("")
-                                .to_owned();
-                        } else {
-                            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 {
-                    Ok(vec) => {
-                        // vec.get_metric_with_label_values(vals)
-                        match vec.get_metric_with_label_values(&[&label_value]) {
-                            Ok(metric) => {
-                                metric.set(metric_value);  // Устанавливаем значение метрики
-                                return Some(metric.clone());  // Возвращаем `Gauge`
-                            },
-                            Err(er) => {
-                                error!("Cannot create Gauge {} due to {}", &name, er);
-                            },
-                        }
-                    },
-                    Err(er) => error!("Cannot create Gauge {} due to {}", &name, er),
-                }
-            }
-        } else {
-            // not-tagged 
-            let metric = Gauge::new(&name, &help);
-            match metric {
-                Ok(gauge) => {
-                    let mut value = 0.0;
-                    map.values()
-                        .map(|val| val.clone().as_f64())
-                        .for_each(|val| {
-                            value = val.unwrap_or(0.0)
-                        });
-                    gauge.set(value);
-                    return Some(gauge);
-                },
-                Err(er) => {
-                    error!("Cannot create Gauge {} due to {}", &name, er);
-                }
-            }
-        }
-        None
-    }
-    pub fn get_value_as_vec_map(metrics: &MetricOutput) -> Vec<Map<String, Value>>{
-        let mut vec: Vec<Map<String, Value>> = Vec::new();
-        let arr =  metrics.value.as_array().unwrap();
-        arr.iter()
-            .for_each(|a| {
-                vec.push(serde_json::from_value(a.clone()).unwrap());
-            });
-        vec
-    }
-    pub fn is_array_of_string_values(metrics: &MetricOutput) -> bool {
-        let arr = metrics.value.clone();
-        let arr = arr.as_array().unwrap();
-        let map: Map<String, Value> = serde_json::from_value(
-            arr[0].clone()
-        ).unwrap();
-        map.values()
-            .all(|val| val.is_string())
-    }
-    // fn is_valid(metrics: &PrometheusMetrics) -> bool {
-    //     false
-    // }
-    fn is_array(metrics: &MetricOutput) -> bool {
-        metrics.value.is_array()
-    }
-    fn is_tagged_array(metrics: &MetricOutput) -> bool {
-        let arr = metrics.value.as_array().unwrap();
-        let map: Map<String, Value> = serde_json::from_value(arr[0].clone()).unwrap();
-        map.len() > 1
-    }
-    fn is_number(metrics: &MetricOutput) -> bool {
-        metrics
-            .value.is_number()
-    }
-}
\ No newline at end of file
-- 
2.40.1


From e8677b87540d00ac9584628b9eab8d1b9f5d28d8 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 18 Feb 2025 13:45:43 +0300
Subject: [PATCH 40/54] config-delivery migration

---
 Cargo.toml                                |  2 +-
 crates/config-delivery/Cargo.toml         | 17 ------
 crates/config-delivery/src/delivery.rs    | 73 -----------------------
 crates/config-delivery/src/integration.rs | 20 -------
 crates/config-delivery/src/logger.rs      | 50 ----------------
 crates/config-delivery/src/main.rs        | 46 --------------
 6 files changed, 1 insertion(+), 207 deletions(-)
 delete mode 100644 crates/config-delivery/Cargo.toml
 delete mode 100644 crates/config-delivery/src/delivery.rs
 delete mode 100644 crates/config-delivery/src/integration.rs
 delete mode 100644 crates/config-delivery/src/logger.rs
 delete mode 100644 crates/config-delivery/src/main.rs

diff --git a/Cargo.toml b/Cargo.toml
index bbeed62..8f70c37 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [workspace]
 resolver = "2"
 members = [
-    "crates/api-grub", "crates/config-delivery", "crates/integr-structs", "crates/preproc", 
+    "crates/api-grub", "crates/integr-structs", "crates/preproc", 
 ]
 
 [profile.dev]
diff --git a/crates/config-delivery/Cargo.toml b/crates/config-delivery/Cargo.toml
deleted file mode 100644
index d6686e7..0000000
--- a/crates/config-delivery/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "config-delivery"
-version = "0.3.4"
-edition = "2021"
-
-[dependencies]
-dotenv = "0.15.0"
-rand = "0.8.5"
-serde = { version = "1.0.217", features = ["derive"] }
-serde_json = "1.0.135"
-tokio = { version = "1.43.0", features = ["full"] }
-tokio-websockets = { version = "^0.11.0", features = ["client", "openssl", "rand"] }
-integr-structs = {path = "../integr-structs"}
-anyhow = "1.0.95"
-env_logger = "0.11.6"
-log = "0.4.25"
-chrono = "0.4.39"
diff --git a/crates/config-delivery/src/delivery.rs b/crates/config-delivery/src/delivery.rs
deleted file mode 100644
index 6226764..0000000
--- a/crates/config-delivery/src/delivery.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-// mod to communicate with api-grub and preproc services
-// using Unix-Socket Client
-
-use anyhow::{Error, Result};
-use integr_structs::api::ApiConfigV2;
-use tokio::time::{sleep, Duration};
-use tokio::net::UnixStream;
-use std::env;
-use tokio::sync::mpsc::Receiver;
-use log::{info, error};
-use serde_json::to_string_pretty;
-
-#[derive(Debug)]
-enum UnixSocketConsumer {
-    ApiGrubber,
-    Preproc,
-}
-// to create us-client
-struct UnixSocketClient;  
-// to catch new configs from integr submod
-type ConfigGateway = Receiver<ApiConfigV2>;
-
-pub async fn init_delivery_mech(rx: ConfigGateway) -> Result<()> {
-    let mut rx = rx; 
-    loop {
-        while rx.is_empty() {
-            continue;
-        };
-        info!("New config was pulled. Redirecting it ...");
-        let config = rx.recv().await.unwrap();
-        match UnixSocketConsumer::ApiGrubber.get_stream_object().await {
-            Ok(socket) => {
-                socket.try_write(to_string_pretty(&config)?.as_bytes())?;
-                info!("New api config was pulled");
-            },
-            Err(er) => {
-                error!("Cannot coonect to ApiGrubber Unix-Socket due to {er}");
-            }
-        }
-        sleep(Duration::from_secs(3)).await;
-    }
-    // let api_sock = UnixSocketConsumer::ApiGrubber.get_stream_object().await?;
-    // let preproc_sock = UnixSocketConsumer::Preproc.get_stream_object().await?;
-}
-
-impl UnixSocketConsumer {
-    pub async fn get_stream_object(&self) -> Result<UnixStream> {
-        let socket_file = match self {
-            UnixSocketConsumer::ApiGrubber => env::var("API_GRUBBER_SOCKET")?,
-            UnixSocketConsumer::Preproc => env::var("PREPROC_SOCKET")?,
-        };
-        UnixStream::connect(socket_file).await.or_else(|_| Err(Error::msg(format!("Cannot create {:?} Unix-Socket client", self))))
-    } 
-}
-
-// async fn check_unix_socket_file(path: &str) -> bool {
-//     std::path::Path::new(path).exists()
-// }
-
-#[cfg(test)]
-mod delivery_unittests {
-    #[allow(unused_imports)]
-    use super::*;
-    use tokio::test;
-
-    // 
-    #[test]
-    async fn check_api_unix_socket_client_creation() { assert!(true); }
-    
-    #[test]
-    async fn check_preproc_unix_socket_client_creation() { assert!(true); }
-    // 
-}
\ No newline at end of file
diff --git a/crates/config-delivery/src/integration.rs b/crates/config-delivery/src/integration.rs
deleted file mode 100644
index bf883a7..0000000
--- a/crates/config-delivery/src/integration.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use std::sync::Arc;
-
-use tokio::sync::mpsc::Sender;
-use integr_structs::api::ApiConfigV2;
-use anyhow::Result;
-use tokio::time::{sleep, Duration};
-// mock 
-
-type Worker = Arc<Sender<ApiConfigV2>>;
-
-#[allow(dead_code, unused_variables)]
-pub async fn init_integration_mech(tx: Worker) -> Result<()> {
-    loop {
-        sleep(Duration::from_secs(5)).await;
-        let conf = ApiConfigV2::default();
-        tx.send(conf).await?;
-    }
-    // Ok(())
-}
-
diff --git a/crates/config-delivery/src/logger.rs b/crates/config-delivery/src/logger.rs
deleted file mode 100644
index 6578b44..0000000
--- a/crates/config-delivery/src/logger.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use chrono::Local;
-use env_logger::Builder;
-use log::LevelFilter;
-use std::io::Write;
-use anyhow::Result;
-use log::info;
-
-pub async fn setup_logger() -> Result<()> {
-    Builder::new()
-        .format(move |buf, record| {
-            writeln!(
-                buf,
-                "|{}| {} [{}] - {}",
-                "config-delivery",
-                Local::now().format("%d-%m-%Y %H:%M:%S"),
-                record.level(),
-                record.args(),
-            )
-        })
-        .filter(None, LevelFilter::Info)
-        .target(env_logger::Target::Stdout)
-        .init();
-
-    info!("Logger configured");
-    Ok(())
-}
-
-
-#[cfg(test)]
-mod logger_unittests {
-    use tokio::test;
-    use super::*;
-    #[test]
-    async fn check_logger_builder() {
-        Builder::new()
-        .format(move |buf, record| {
-            writeln!(
-                buf,
-                "|{}| {} [{}] - {}",
-                "config-delivery",
-                Local::now().format("%d-%m-%Y %H:%M:%S"),
-                record.level(),
-                record.args(),
-            )
-        })
-        .filter(None, LevelFilter::Info)
-        .target(env_logger::Target::Stdout)
-        .init();
-    }
-}
\ No newline at end of file
diff --git a/crates/config-delivery/src/main.rs b/crates/config-delivery/src/main.rs
deleted file mode 100644
index e5955b7..0000000
--- a/crates/config-delivery/src/main.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-mod delivery;
-mod integration;
-mod logger;
-
-use integr_structs::api::ApiConfigV2;
-use logger::setup_logger;
-use dotenv::dotenv;
-use anyhow::Result;
-use tokio::sync::mpsc;
-use log::{info, error};  
-use integration::init_integration_mech;
-use delivery::init_delivery_mech;
-use std::sync::Arc;
-
-// Arch :
-// 1) 2 Unix-Socket client (for api grub and preproc)                          :: i think its a continious process for events when services are unavailable
-// 2) mpsc beetween `delivery` and `integration`                               ::
-// 3) websocket client in `integration` to pull configs from Monitoring System ::
-
-#[tokio::main(flavor = "multi_thread")]
-async fn main() -> Result<()> {
-    let _ = setup_logger().await?;
-    info!("Pulling env vars from .env file if exists ...");
-    dotenv().ok();
-
-    let (tx, rx) = mpsc::channel::<ApiConfigV2>(1);
-    let tx = Arc::new(tx);
-    let integr_jh = tokio::spawn(
-        async move {
-            if let Err(er) = init_integration_mech(tx).await {
-                error!("Error in integration submodule during to: {}", er);
-            }
-        }
-    );
-    let deliv_future = tokio::spawn(async move {
-        if let Err(er) = init_delivery_mech(rx).await {
-            error!("Error in delivery submodule during to: {}", er);
-        }
-    });
-    // for deliv adding
-    // let action_vec: Vec<JoinHandle<()>> = vec![integr_jh, deliv_future];
-    for event in vec![integr_jh, deliv_future] {
-        let _ = event.await;
-    }
-    Ok(())
-}
-- 
2.40.1


From bc6435e4026cd3c791d5a3bc3991142ea9fdbd95 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 18 Feb 2025 13:52:20 +0300
Subject: [PATCH 41/54] no clone on strings

---
 crates/api-grub/src/net.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index 82887a3..226e5a5 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -100,9 +100,9 @@ impl<'a> ApiPoll<'a> {
             .user_agent("api_grub/integration_module");
         let mut req = client.build().unwrap().get(&metrics.url);
 
-        let login = creds.endpoint.login.clone();
-        let password = creds.endpoint.password.clone();
-        let api_key = creds.endpoint.api_key.clone();
+        let login = &creds.endpoint.login;
+        let password = &creds.endpoint.password;
+        let api_key = &creds.endpoint.api_key;
         // if !login.is_empty() && !password.is_empty() {
         //     dbg!("kjgbkasgksjd");
         //     req = req.basic_auth(login, Some(password));
@@ -112,7 +112,7 @@ impl<'a> ApiPoll<'a> {
             // req = req.header("authorization", "bearer ");
 
             req = req.header("accept", "application/json");
-            req = req.header("x-api-key", &api_key);
+            req = req.header("x-api-key", api_key);
             
             // req = req.query(&["Bearer", "6fe8b0db-62b4-4065-9c1e-441ec4228341.9acec20bd17d7178f332896f8c006452877a22b8627d089105ed39c5baef9711"])
         }
-- 
2.40.1


From ce7987eb99bc51510f6de7b136642c9e25d2a6a3 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 18 Feb 2025 13:54:26 +0300
Subject: [PATCH 42/54] uncomment basic auth mech

---
 crates/api-grub/src/net.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index 226e5a5..eb9425a 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -103,10 +103,11 @@ impl<'a> ApiPoll<'a> {
         let login = &creds.endpoint.login;
         let password = &creds.endpoint.password;
         let api_key = &creds.endpoint.api_key;
-        // if !login.is_empty() && !password.is_empty() {
-        //     dbg!("kjgbkasgksjd");
-        //     req = req.basic_auth(login, Some(password));
-        // }
+        
+        if !login.is_empty() && !password.is_empty() {
+            // dbg!("kjgbkasgksjd");
+            req = req.basic_auth(login, Some(password));
+        }
         if !api_key.is_empty() {
             // req = req.bearer_auth(&api_key);
             // req = req.header("authorization", "bearer ");
-- 
2.40.1


From b30e940df7533a790cd5aea8d9810caed96095e7 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Tue, 18 Feb 2025 16:06:41 +0300
Subject: [PATCH 43/54] egn user-agent + refactor

---
 .env.example               |  6 ++----
 crates/api-grub/Cargo.toml |  2 ++
 crates/api-grub/src/net.rs | 20 ++++++++++++++------
 3 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/.env.example b/.env.example
index 78b0f00..7a5d489 100644
--- a/.env.example
+++ b/.env.example
@@ -1,6 +1,4 @@
-CONFIG_SERVER_CREDS = "ws://ip.ip.ip.ip:port"
-API_GRUBBER_SOCKET = "api-grubber.sock"
-PREPROC_SOCKET = "preproc.sock"
+# Template .env for API grabber
 
 # PostgreSQL connection [DEPRECATED]
 DB_HOST = "ip.addr.postgresql.server"
@@ -9,4 +7,4 @@ DB_PASSWORD = "db_user_password"
 DB_DBNAME = "db_name"1
 
 # Prometheus-Exporter info
-EXPORTER_URL = "ip.ip.ip.ip:port" 
\ No newline at end of file
+EXPORTER_URL = "http(s)://ip.ip.ip.ip:port"
\ No newline at end of file
diff --git a/crates/api-grub/Cargo.toml b/crates/api-grub/Cargo.toml
index cf61de9..f9d14ee 100644
--- a/crates/api-grub/Cargo.toml
+++ b/crates/api-grub/Cargo.toml
@@ -16,3 +16,5 @@ reqwest = { version = "0.12.12", features = ["rustls-tls", "json"] }
 deadpool-postgres = { version = "0.14.1", features = ["serde"] }
 tokio-postgres = "0.7.12"
 dotenv = "0.15.0"
+md5 = "0.7.0"
+rand = "0.9.0"
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index eb9425a..5434b6c 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -1,18 +1,20 @@
 // module to handle unix-socket connection + pulling info from api 
-use anyhow::{Error, Result};
-use integr_structs::api::{ApiConfigV2, ProcessedEndpoint};
+use anyhow::Result;
+// use integr_structs::api::{ApiConfigV2, ProcessedEndpoint};
 use log::{error, info};
-use serde_json::Value;
+use rand::random;
 use tokio::sync::mpsc::Receiver;
 use tokio::time::{sleep, Duration};
-use reqwest::{Client, Method, RequestBuilder};
+use reqwest::{Client, Method};
+use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 use tokio::task::JoinHandle;
 // use tokio::sync::Mutex;
 use dotenv::dotenv;
 use crate::json::JsonParser;
-use crate::export::{self, Exporter};
+use crate::export::Exporter;
 use integr_structs::api::v3::{Config, ConfigEndpoint, Credentials, Metrics, PrometheusMetrics};
+use md5::compute;
 
 // type BufferType = Arc<Mutex<Vec<String>>>; 
 
@@ -96,8 +98,14 @@ impl<'a> ApiPoll<'a> {
         // let mut req = Client::new()
         //     // .user_agent("api_grub/integration_module")
         //     .get(&metrics.url);
+        use std::hash::DefaultHasher;
+
+        let rand  = random::<char>();
+        let mut hash = DefaultHasher::new();
+        rand.hash(&mut hash);
+
         let client = Client::builder()
-            .user_agent("api_grub/integration_module");
+            .user_agent(format!("api-grabber-{}", hash.finish()));
         let mut req = client.build().unwrap().get(&metrics.url);
 
         let login = &creds.endpoint.login;
-- 
2.40.1


From 6228b2393d8a3aff9396f137887607531c455047 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Fri, 21 Feb 2025 14:18:48 +0300
Subject: [PATCH 44/54] tagged array creation rework

---
 crates/api-grub/src/json.rs | 20 +++++++++++---------
 crates/api-grub/src/net.rs  |  2 +-
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/crates/api-grub/src/json.rs b/crates/api-grub/src/json.rs
index 6208724..c6ecedd 100644
--- a/crates/api-grub/src/json.rs
+++ b/crates/api-grub/src/json.rs
@@ -21,8 +21,8 @@ impl JsonParser {
             return Value::Null;
         }
 
-        let mut vec_value: Vec<Value> = Vec::new();
-        let mut array_key = String::new();
+        // let mut vec_value: Vec<Value> = Vec::new();
+        // let mut array_key = String::new();
         let mut value_json: Value = serde_json::from_str(json).unwrap_or(Value::Null);
 
         let target_attr_vec = target.addr
@@ -97,16 +97,18 @@ impl JsonParser {
             .enumerate()
             .map(|(idx, val)| {
                 let val = val.get(tag_name).unwrap_or(&Value::Null).clone();
-                (serde_json::from_value::<serde_json::Map<String, Value>>(json!({tag_name: val})), 
+                (serde_json::from_value::<serde_json::Map<String, Value>>(
+                    json!({"tag_name": tag_name, "tag_value": val})
+                ), 
                 serde_json::from_value::<serde_json::Map<String, Value>>(metrics[idx].clone()))
             })
-            .for_each(|(key, val)| {
-                // dbg!(&key);
-                if key.is_ok() && val.is_ok() {
-                    let mut key = key.unwrap();
+            .for_each(|(tags, val)| {
+                if val.is_ok() && tags.is_ok() {
+                    let mut tags = tags.unwrap();
                     let mut val = val.unwrap();
-                    key.append(&mut val);
-                    values.push(json!(key));
+                    tags.append(&mut val);
+                    dbg!(&tags);
+                    values.push(json!(tags));
                 }
             });
         if values.len() == 0 {
diff --git a/crates/api-grub/src/net.rs b/crates/api-grub/src/net.rs
index 5434b6c..8b21b39 100644
--- a/crates/api-grub/src/net.rs
+++ b/crates/api-grub/src/net.rs
@@ -14,7 +14,7 @@ use dotenv::dotenv;
 use crate::json::JsonParser;
 use crate::export::Exporter;
 use integr_structs::api::v3::{Config, ConfigEndpoint, Credentials, Metrics, PrometheusMetrics};
-use md5::compute;
+// use md5::compute;
 
 // type BufferType = Arc<Mutex<Vec<String>>>; 
 
-- 
2.40.1


From a758db9bb4560b642c48bd889d10f95efcb9903f Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 27 Feb 2025 12:53:31 +0300
Subject: [PATCH 45/54] migration: structs

---
 crates/integr-structs/Cargo.toml |   1 +
 crates/integr-structs/src/api.rs | 136 ++++++++++++++++++++++++++++++-
 2 files changed, 136 insertions(+), 1 deletion(-)

diff --git a/crates/integr-structs/Cargo.toml b/crates/integr-structs/Cargo.toml
index 9183deb..d510ba7 100644
--- a/crates/integr-structs/Cargo.toml
+++ b/crates/integr-structs/Cargo.toml
@@ -5,5 +5,6 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0.95"
+chrono = "0.4.40"
 serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.135"
diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 4a824f0..a943b6e 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -1,9 +1,10 @@
-use core::sync;
 use std::collections::HashMap;
 use serde::{Serialize, Deserialize};
 use serde_json::{ to_string_pretty, Value };
 use anyhow::Result;
 use std::sync::Arc;
+use std::fmt::Display;
+use chrono::{DateTime, Local};
 
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -273,4 +274,137 @@ pub mod v3 {
             str_metrics.len()
         }
     }
+}
+
+
+pub mod enode_monitoring {
+    use super::*;
+
+    #[derive(Debug, Serialize)]
+    pub struct ForTokenCredentials {
+        login : String,
+        password : String,
+        pub ts : String,
+    }
+
+    impl ForTokenCredentials {
+        pub fn new(login: &str, pass: &str) -> Self {
+            Self {
+                login : login.to_owned(),
+                password : pass.to_owned(),
+                ts : format!("{}", DateTime::timestamp(&Local::now())),
+            }
+        }
+    }
+
+    pub mod cmdb {
+        use super::*;
+
+        #[derive(Debug, Serialize)]
+        pub struct Query {
+            id : Vec<String>,
+            data : Data,
+            #[serde(rename = "postQuery")]
+            post_query : String,
+            #[serde(rename = "enableActions")]
+            enable_actions : bool,
+            ts : usize
+        }
+        impl Default for Query {
+            fn default() -> Self {
+                Self {
+                    id : vec!["/measures/device$18".to_owned()],
+                    data : Data::default(),
+                    post_query : "links".to_owned(),
+                    enable_actions : false,
+                    ts : 1740060679399
+                }
+            }
+        }
+        #[derive(Debug, Serialize)]
+        struct Data {
+            links : Links,
+            fields : Vec<String>,
+        }
+        impl Default for Data {
+            fn default() -> Self {
+                Self {
+                    links : Links::default(),
+                    fields : vec![ "$id".to_owned(), "id".to_owned(), "cls".to_owned(), "name".to_owned()]
+                }
+            }
+        }
+        #[derive(Debug, Serialize)]
+        struct Links {
+            flatten : bool,
+            filter : Filter,
+        }
+        impl Default for Links {
+            fn default() -> Self {
+                Self {
+                    flatten : true,
+                    filter : Filter::default()
+                }
+            }
+        }
+        #[derive(Debug, Serialize)]
+        struct Filter {
+            cls : String,
+        }
+        impl Default for Filter {
+            fn default() -> Self {
+                Self {
+                    cls : "measure".to_owned()
+                }
+            }
+        }
+    }
+
+    // "{\"access_token\":\"5BNQsmiGFQRNA651HeQxZekYgYUAWZ4e\",\"role\":\"administrator\",\"startRT\":\"2025-02-25T09:03:27.581Z\",\"login\":\"admin\",\"push_active\":null,\"$id\":\"systemuser$1\"}",
+    #[derive(Debug, Deserialize)]
+    pub struct AuthResponse {
+        pub access_token : String,
+        // role : String,
+        // startRT : String,
+        // login : String,
+        // push_active : Value,
+        // #[serde(rename = "$id")]
+        // id : String,
+    }
+
+    pub trait GenericUrl {
+        fn display(&self) -> String;
+    }
+
+    impl<T> GenericUrl for [T] 
+    where T : Display {
+        fn display(&self) -> String {
+            let mut vec: Vec<String> = Vec::new();
+            vec.push("%5B".to_owned());
+            self.iter()
+            .enumerate()
+            .for_each(|(id, val)| {
+                if id > 0 {
+                    vec.push(",".to_owned());
+                }
+                vec.push(format!("%22{}%22", val));
+            });
+            vec.push("%5D".to_owned());
+            vec.concat()
+        }
+    }
+
+    pub fn get_chunk_size(total_measures: usize) -> usize {
+        match total_measures {
+            0..=144 => total_measures,   
+            145..=288 => total_measures / 4,
+            289..=432 => total_measures / 5,
+            433..=576 => total_measures / 6,
+            577..=720 => total_measures / 7,
+            721..=864 => total_measures / 8,
+            865..=1008 => total_measures / 9, 
+            _ => total_measures / 10,
+        }
+    }
+
 }
\ No newline at end of file
-- 
2.40.1


From fa47771cff29c699b4ffeba5a5471afbd19e2368 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 27 Feb 2025 12:57:46 +0300
Subject: [PATCH 46/54] enode monitoring pattern constructor for prom metrics

---
 crates/integr-structs/src/api.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index a943b6e..3995621 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -267,6 +267,13 @@ pub mod v3 {
                 metrics: metrics 
             }
         }
+        pub async fn new_zvks(metrics: Vec<MetricOutput>) -> Self {
+            Self {
+                service_name : "zvks".to_owned(),
+                endpoint_name : "apiforsnmp".to_owned(),
+                metrics : metrics,
+            }
+        }
         pub fn get_bytes_len(&self) -> usize {
             let str_metrics = serde_json::to_vec(self).unwrap_or_else(
                 |_| Vec::new()
-- 
2.40.1


From 644b18cfd7ca009256e0e10eb80ed92405cf8857 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 27 Feb 2025 12:59:32 +0300
Subject: [PATCH 47/54] api fix

---
 crates/integr-structs/src/api.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 3995621..140f212 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -238,7 +238,7 @@ pub mod v3 {
     pub struct MetricOutput {
         pub id : String,
         #[serde(rename = "type")]
-        json_type : String,
+        pub json_type : String,
         addr : String,
         pub value : Value,
     }
-- 
2.40.1


From 2adb706a696ae9a8efc33bdc74c19c85638a1407 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 27 Feb 2025 12:59:56 +0300
Subject: [PATCH 48/54] api fix #2

---
 crates/integr-structs/src/api.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/integr-structs/src/api.rs b/crates/integr-structs/src/api.rs
index 140f212..0c646f8 100644
--- a/crates/integr-structs/src/api.rs
+++ b/crates/integr-structs/src/api.rs
@@ -239,7 +239,7 @@ pub mod v3 {
         pub id : String,
         #[serde(rename = "type")]
         pub json_type : String,
-        addr : String,
+        pub addr : String,
         pub value : Value,
     }
     impl MetricOutput {
-- 
2.40.1


From 6297ea2a50af3af4b7e965bdc611bc3dd2a6a770 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 27 Feb 2025 13:00:23 +0300
Subject: [PATCH 49/54] migration: monitoring module

---
 crates/api-grub/src/monitoring.rs | 243 ++++++++++++++++++++++++++++++
 1 file changed, 243 insertions(+)
 create mode 100644 crates/api-grub/src/monitoring.rs

diff --git a/crates/api-grub/src/monitoring.rs b/crates/api-grub/src/monitoring.rs
new file mode 100644
index 0000000..b77c141
--- /dev/null
+++ b/crates/api-grub/src/monitoring.rs
@@ -0,0 +1,243 @@
+use std::env;
+use anyhow::Error;
+use serde_json::{Map, Value};
+use reqwest::Client;
+use tokio::sync::Semaphore;
+use std::sync::Arc;
+// use crate::structs::{AuthResponse, ForTokenCredentials, GenericUrl};
+use integr_structs::api::enode_monitoring::{AuthResponse, ForTokenCredentials, GenericUrl, get_chunk_size};
+// use crate::structs::cmdb::Query;
+use integr_structs::api::enode_monitoring::cmdb::Query;
+use tokio::task::JoinHandle;
+// use crate::structs::get_chunk_size;
+use std::pin::Pin;
+use std::future::Future;
+use integr_structs::api::v3::{MetricOutput, PrometheusMetrics};
+// use chrono::{Local, DateTime};
+
+pub async fn get_metrics_from_monitoring(duration: usize, delay: usize) -> anyhow::Result<()> {
+    let timer = tokio::time::Instant::now();
+    loop {
+        if duration != 0 && timer.elapsed() >= tokio::time::Duration::from_secs(duration as u64) {
+            break;
+        }
+        let mut a = MonitoringImporter::new().await;
+        a.start_session().await?;
+        let vec = a.get_metrics_list().await?;
+        let _ = a.get_measure_info(Arc::new(vec)).await;
+        a.close_session().await?;
+        tokio::time::sleep(tokio::time::Duration::from_secs(delay as u64)).await
+    }
+    Ok(())
+}
+
+#[derive(Debug, Clone)]
+pub struct MonitoringImporter {
+    ip : String,
+    login : String,
+    password : String, 
+    access_token : String,
+    ts : String,
+}
+
+impl MonitoringImporter {
+    pub async fn new() -> Self {
+        MonitoringImporter {
+            ip : env::var("ENODE_MONITORING_IP").unwrap_or_else(|_| String::new()),
+            login : env::var("ENODE_MONITORING_LOGIN").unwrap_or_else(|_| String::new()),
+            password : env::var("ENODE_MONITORING_PASSWORD").unwrap_or_else(|_| String::new()),
+            access_token : String::new(),
+            ts : String::new(),
+        }
+    }
+    async fn is_valid(&self) -> bool {
+        !self.ip.is_empty() && !self.login.is_empty() && !self.password.is_empty() 
+    }
+    async fn set_ts(&mut self, ts: &str) {
+        self.ts = ts.to_owned();
+    }
+    pub async fn start_session(&mut self) -> anyhow::Result<()> {
+        if !self.is_valid().await {
+            return Err(Error::msg("Invalid eNODE-Monitoring configuration"));
+        }
+        let client = Client::new();
+        let url = format!("http://{}/e-data-front/auth/login", self.ip);
+        let fortoken = ForTokenCredentials::new(&self.login, &self.password);
+        // dbg!(&fortoken);
+        let client = client
+            .post(url)
+            .header("Content-Type", "application/json")
+            .json(&fortoken);
+        let resp =  client.send().await?;
+        let auth = resp.json::<AuthResponse>().await?;
+        // dbg!(&auth);
+        self.set_ts(&fortoken.ts).await;
+        
+        self.access_token = auth.access_token.to_owned();
+
+        Ok(())
+    }
+    pub async fn close_session(&mut self) -> anyhow::Result<()> {
+        let client = Client::new();
+        let url = format!("http://{}/e-data-front/auth/logout", self.ip);
+        let client = client
+            .post(url)
+            .header("Content-Type", "application/json")
+            .header("access-token", &self.access_token);
+        
+        let _ = client.send().await?;
+        
+        self.access_token.clear();
+        Ok(())
+    }
+    pub async fn get_metrics_list(&self) -> anyhow::Result<Vec<String>> {
+        let client = Client::new();
+        let mut vec: Vec<String> = Vec::new();
+        let url = format!("http://{}/e-cmdb/api/query", self.ip);
+        let client = client
+            .post(url)
+            .header("Content-Type", "application/json")
+            .header("access-token", &self.access_token)
+            .json(&Query::default());
+        let resp = client.send().await?.text().await?;
+        // dbg!(&resp.text().await);
+        let resp: Value = serde_json::from_str(&resp)?;
+        if let Some(arr) = resp.as_array() {
+            for measure in arr {
+                let id = measure.get("id");
+                let cls = measure.get("cls");
+                if id.is_some() && cls.is_some() {
+                    // todo: later wait for Vaitaliy call of classification
+                    let id = id.unwrap().as_i64().unwrap_or_default();
+                    let cls = cls.unwrap().as_str().unwrap_or_else(|| "");
+                    if cls.is_empty() {
+                        return Err(Error::msg("Invalid JSON in response. Wrong types of fields (`id` or `cls`)"));
+                    }
+                    // let measure_name = format!("{}${}", cls, id);
+                    vec.push(format!("{}${}", cls, id));
+                }
+            }
+            // dbg!(vec);
+        } else {
+            return Err(Error::msg("Invalid JSON in response"));
+        }
+        Ok(vec)
+    }
+    pub async fn get_measure_info(&self, measures: Arc<Vec<String>>) -> anyhow::Result<()> {
+        let mut sys = sysinfo::System::new();
+        sys.refresh_cpu_all();
+        //  adaptive permition on task spawm to prevent system overload
+        let sem = Arc::new(Semaphore::new(sys.cpus().len()));
+        let mut jh_vec = Vec::new();
+        let client = Arc::new(Client::new());
+        let measures = measures.clone();
+        let arc = Arc::new(self.clone());
+        // dbg!(&measures.display());
+        
+        // dbg!(&measures.len());
+        for measure in measures.chunks(get_chunk_size(measures.len())) {
+            let permit = sem.clone();
+            let arc = arc.clone();
+            let client = client.clone();
+            let measure = Arc::new(measure.display());
+
+            let _permit = permit.acquire().await.unwrap();
+
+            let jh: JoinHandle<anyhow::Result<PrometheusMetrics>> = tokio::spawn(async move {
+                Self::process_endpoint(measure.clone(), client.clone(), arc.clone()).await
+                
+            });
+            jh_vec.push(jh);
+        }
+        let mut vals = Vec::new();
+        for event in jh_vec {
+            match event.await {
+                Ok(val) => {
+                    if let Ok(val) = val {
+                        vals.push(val);
+                    }
+                },
+                Err(er) => println!("Fatal error on async task: {}", er),
+            }
+        }
+        // dbg!(&vals);
+        // dbg!(&vals.len());
+        Ok(())
+    }
+    async fn process_endpoint(measure: Arc<String>, client: Arc<Client>, arc: Arc<Self>) -> anyhow::Result<PrometheusMetrics> {        
+        let resp = client
+            .get(format!("http://{}/e-nms/mirror/measure/{}", arc.ip, &measure))
+            .header("Content-Type", "application/json")
+            .header("access-token", &arc.access_token)
+            .send().await?
+            .text().await?;
+            tokio::task::yield_now().await;
+
+            let resp: Value = serde_json::from_str(&resp)?;
+            // let a = Self::extract_metric_data(resp);
+
+            Ok(
+                PrometheusMetrics::new_zvks(Self::extract_metric_data(resp).await?).await
+            )
+    }
+    fn extract_metric_data(json: Value) -> Pin<Box<dyn Future<Output = anyhow::Result<Vec<MetricOutput>>> + Send>> {
+        Box::pin(async move {
+            return match json {
+                Value::Object(obj) => {
+                    // let resp: Value = serde_json::from_str(&obj)?;
+                    return Ok(vec![Self::process_value(&obj).await?])
+                },
+                Value::Array(arr) => {
+                    let mut vec = Vec::new();
+                    for obj in arr {
+                        if let Ok(mut val) = Self::extract_metric_data(obj).await {
+                            // vec.push(val);
+                            vec.append(&mut val);
+                        }
+                    }
+                    return Ok(vec)
+                },
+                _ => Err(Error::msg("Invalid JSON format")),
+            }
+        })
+    } 
+    async fn process_value(obj : &Map<String, Value>) -> anyhow::Result<MetricOutput> {
+        let id = obj.get("id");
+            let val = obj.get("value");
+
+            if id.is_none() || val.is_none() {
+                return Err(Error::msg("Cannot get values of fields `id` and `value` from JSON Response"))
+            }
+            let id = id.unwrap().as_str().unwrap_or_else(|| "");
+            let val = val.unwrap();
+
+            if id.is_empty() {
+                return Err(Error::msg("Empty `id` field. Invalid JSON response"))
+            }
+            // pub struct MetricOutput {
+            //     pub id : String,
+            //     #[serde(rename = "type")]
+            //     json_type : String,
+            //     addr : String,
+            //     pub value : Value,
+            // }
+
+            Ok(MetricOutput {
+                id : id.to_owned(), 
+                json_type : match val {
+                    Value::Number(val) => {
+                        if val.is_i64() {
+                            "i64".to_owned()
+                        } else if val.is_u64() {
+                            "u64".to_owned()
+                        } else {
+                            "f64".to_owned()
+                        }
+                    },
+                    _ => "unknown".to_owned(),
+                }, 
+                addr : "enode.monitoring.api".to_owned(), 
+                value : val.clone()
+            })
+    }
+}
\ No newline at end of file
-- 
2.40.1


From 32a43f9ed80cf9c8c61b9200d4b6ca90f659742a Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 27 Feb 2025 13:00:42 +0300
Subject: [PATCH 50/54] sysinfo + refactor main

---
 crates/api-grub/Cargo.toml  | 1 +
 crates/api-grub/src/main.rs | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/api-grub/Cargo.toml b/crates/api-grub/Cargo.toml
index f9d14ee..eb9fc44 100644
--- a/crates/api-grub/Cargo.toml
+++ b/crates/api-grub/Cargo.toml
@@ -18,3 +18,4 @@ tokio-postgres = "0.7.12"
 dotenv = "0.15.0"
 md5 = "0.7.0"
 rand = "0.9.0"
+sysinfo = "0.33.1"
diff --git a/crates/api-grub/src/main.rs b/crates/api-grub/src/main.rs
index f7a79bc..ee9b2dd 100644
--- a/crates/api-grub/src/main.rs
+++ b/crates/api-grub/src/main.rs
@@ -3,9 +3,10 @@ mod net;
 mod logger;
 mod json;
 mod export;
+mod monitoring;
 
 use anyhow::Result;
-use integr_structs::api::ApiConfigV2;
+// use integr_structs::api::ApiConfigV2;
 use integr_structs::api::v3::Config;
 use logger::setup_logger;
 // use log::{info, warn};
-- 
2.40.1


From a68b31d076da81dc7ee427146c611d81c90dd529 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 27 Feb 2025 13:03:58 +0300
Subject: [PATCH 51/54] env vars update

---
 .env.example | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/.env.example b/.env.example
index 7a5d489..2604f9a 100644
--- a/.env.example
+++ b/.env.example
@@ -7,4 +7,9 @@ DB_PASSWORD = "db_user_password"
 DB_DBNAME = "db_name"1
 
 # Prometheus-Exporter info
-EXPORTER_URL = "http(s)://ip.ip.ip.ip:port"
\ No newline at end of file
+EXPORTER_URL = "http(s)://ip.ip.ip.ip:port"
+
+# eNODE.Monitoring configuration
+ENODE_MONITORING_IP = "ip.ip.ip.ip"
+ENODE_MONITORING_LOGIN = "admin_user_enode_monitoring" # admin user is required
+ENODE_MONITORING_PASSWORD = "admin_password_enode_monitoring" # # admin password is required
\ No newline at end of file
-- 
2.40.1


From ad4ce178a990c3cb252ac48b9df1b84aa45c9c3a Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Thu, 27 Feb 2025 13:18:28 +0300
Subject: [PATCH 52/54] final fix

---
 crates/api-grub/src/main.rs       | 31 ++++++++++++++++++++-----------
 crates/api-grub/src/monitoring.rs |  9 +++++++--
 2 files changed, 27 insertions(+), 13 deletions(-)

diff --git a/crates/api-grub/src/main.rs b/crates/api-grub/src/main.rs
index ee9b2dd..cac81e3 100644
--- a/crates/api-grub/src/main.rs
+++ b/crates/api-grub/src/main.rs
@@ -14,13 +14,11 @@ use config::{pull_local_config, init_config_grub_mechanism};
 use net::init_api_grub_mechanism;
 use tokio::sync::mpsc;
 use log::{error, info, warn};
+use monitoring::get_metrics_from_monitoring;
 
 #[tokio::main(flavor = "multi_thread")]
 async fn main() -> Result<()>{
-    // 3 coroutines
-    // 1) unix-socket coroutine (for config updating)
-    // 2) api coroutine
-    // 3) ?
+    dotenv::dotenv().ok();
     setup_logger().await?;
     let config = get_config().await;
     // config update channel
@@ -41,13 +39,24 @@ async fn main() -> Result<()>{
         }
     });
     let event_grub = tokio::spawn(async move {
-        match init_api_grub_mechanism(config, &mut rx).await {
-            Ok(_) => {
-                info!("Grabing task deinitialized");
-            },
-            Err(er) => {
-                error!("Grabing task returned an error : {}", er);
-            },
+        if std::env::var("ENODE_MONITORING_IP").is_ok() {
+            match get_metrics_from_monitoring(0, 5).await {
+                Ok(_) => {
+                    info!("Grabing (eNODE.Monitoring) task deinitialized");
+                },
+                Err(er) => {
+                    error!("Grabing task returned an error : {}", er);
+                },
+            }
+        } else {
+            match init_api_grub_mechanism(config, &mut rx).await {
+                Ok(_) => {
+                    info!("Grabing task deinitialized");
+                },
+                Err(er) => {
+                    error!("Grabing task returned an error : {}", er);
+                },
+            }
         }
     });
     let events_handler = vec![event_config, event_grub];
diff --git a/crates/api-grub/src/monitoring.rs b/crates/api-grub/src/monitoring.rs
index b77c141..dfcc5b8 100644
--- a/crates/api-grub/src/monitoring.rs
+++ b/crates/api-grub/src/monitoring.rs
@@ -13,6 +13,7 @@ use tokio::task::JoinHandle;
 use std::pin::Pin;
 use std::future::Future;
 use integr_structs::api::v3::{MetricOutput, PrometheusMetrics};
+use log::{error, info, warn};
 // use chrono::{Local, DateTime};
 
 pub async fn get_metrics_from_monitoring(duration: usize, delay: usize) -> anyhow::Result<()> {
@@ -149,12 +150,16 @@ impl MonitoringImporter {
             });
             jh_vec.push(jh);
         }
-        let mut vals = Vec::new();
+        // let mut vals = Vec::new();
         for event in jh_vec {
             match event.await {
                 Ok(val) => {
                     if let Ok(val) = val {
-                        vals.push(val);
+                        match crate::export::Exporter::export_metrics(val).await {
+                            Ok(bytes) => info!("Successfully transmitted {} bytes to the Prometehus exporter", bytes),
+                            Err(er) => error!("Cannot export data to the Prometehus exporter due to : `{}`", er),
+                        }
+                        // vals.push(val);
                     }
                 },
                 Err(er) => println!("Fatal error on async task: {}", er),
-- 
2.40.1


From 940b2e1c03f9661afd37b2743c0751ce0b58d990 Mon Sep 17 00:00:00 2001
From: yuobrezkov <yurakirin9545@gmail.com>
Date: Fri, 28 Feb 2025 15:36:36 +0300
Subject: [PATCH 53/54] Added Jenkinsfile and Dockerfile

---
 Dockerfile                 | 18 +++++++++
 Jenkinsfile                | 80 ++++++++++++++++++++++++++++++++++++++
 crates/api-grub/Cargo.toml |  1 +
 3 files changed, 99 insertions(+)
 create mode 100644 Dockerfile
 create mode 100644 Jenkinsfile

diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..5215521
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,18 @@
+FROM rust:1.84 AS builder
+WORKDIR /app
+
+RUN apt update && apt install -y musl-tools
+RUN rustup target add x86_64-unknown-linux-musl
+
+COPY . .
+RUN cargo test
+RUN cargo build --release --target=x86_64-unknown-linux-musl
+
+FROM alpine:latest
+WORKDIR /app
+
+COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/api-grub /app/api-grub
+RUN apk add --no-cache ca-certificates
+
+
+ENTRYPOINT ["/app/api-grub"]
\ No newline at end of file
diff --git a/Jenkinsfile b/Jenkinsfile
new file mode 100644
index 0000000..2e83346
--- /dev/null
+++ b/Jenkinsfile
@@ -0,0 +1,80 @@
+pipeline {
+    agent any
+    environment {
+        REGISTRY_NAME = 'registry.entcor/trust-module'
+        IMAGE_NAME = "integration-module"
+        GITEA_REPOSITORY_URL = "http://git.entcor/api/v1/repos/" 
+    }
+
+    stages {
+        stage('Init variables') {
+            when {
+                expression { env.CHANGE_BRANCH?.startsWith('rc') }
+            }
+            steps {
+                script {
+                    env.IMAGE_TAG = sh(script: "git describe --tags --abbrev=0", returnStdout: true).trim()
+                }
+            }
+        }
+        stage('Build tagged image and run tests') {
+            when {
+                expression { env.CHANGE_BRANCH?.startsWith('rc') }
+            }
+            steps {
+                script {
+                    try {
+                        def image = docker.build("${env.IMAGE_NAME}:${env.IMAGE_TAG}")
+                        sh "docker tag ${env.IMAGE_NAME}:${env.IMAGE_TAG} ${env.REGISTRY_NAME}/${env.IMAGE_NAME}:${env.IMAGE_TAG}"
+                    } catch (Exception e) {
+                        error("Tests failed: ${e.message}")
+                    }
+                }
+            }
+        }
+        stage ('Push docker image to registry') {
+            when {
+                expression { env.CHANGE_BRANCH?.startsWith('rc') }
+            }
+            steps {
+                script {
+                    docker.withRegistry('https://registry.entcor/harbor/', 'harbor-credentials-id') {
+                        docker.image("${env.REGISTRY_NAME}/${env.IMAGE_NAME}:${env.IMAGE_TAG}").push()
+                    }
+                }
+            }
+        }
+    }
+    post {
+        always {
+            script {
+                echo "Cleaning up workspace..."
+                sh "rm -rf ${env.WORKSPACE}/rc/ || true"
+            }
+        }
+        success {
+            script {
+                if (env.CHANGE_BRANCH?.startsWith('rc')) { 
+                    echo "Attempting to merge PR ${env.CHANGE_ID} into master..."
+                    withCredentials([usernamePassword(credentialsId: 'gitea_creds', usernameVariable: 'GITEA_USER', passwordVariable: 'GITEA_PASS')]) {
+                        def prId = env.CHANGE_ID
+                        sh """
+                        curl -X POST \
+                             -u "${GITEA_USER}:${GITEA_PASS}" \
+                             -H "Content-Type: application/json" \
+                             -d '{"do":"merge"}' \
+                             http://git.entcor/api/v1/repos/deployer3000/integration-module/pulls/${prId}/merge
+                        """
+                        echo "PR ${prId} merged successfully into master!"
+                    }
+                }
+            }
+        }
+        failure {
+            echo "Pipeline failed. Check the logs for details."
+        }
+        aborted {
+            echo "Pipeline was aborted."
+        }
+    }
+}
\ No newline at end of file
diff --git a/crates/api-grub/Cargo.toml b/crates/api-grub/Cargo.toml
index eb9fc44..0e54639 100644
--- a/crates/api-grub/Cargo.toml
+++ b/crates/api-grub/Cargo.toml
@@ -19,3 +19,4 @@ dotenv = "0.15.0"
 md5 = "0.7.0"
 rand = "0.9.0"
 sysinfo = "0.33.1"
+openssl = { version = "0.10", features = ["vendored"] }
-- 
2.40.1


From c2c5781f62ea1801b7673bfbfd76e1e007e6c026 Mon Sep 17 00:00:00 2001
From: prplV <maseeeeeeeed@gmail.com>
Date: Fri, 28 Feb 2025 16:23:47 +0300
Subject: [PATCH 54/54] session independency (almost)

---
 crates/api-grub/src/monitoring.rs | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/crates/api-grub/src/monitoring.rs b/crates/api-grub/src/monitoring.rs
index dfcc5b8..d637746 100644
--- a/crates/api-grub/src/monitoring.rs
+++ b/crates/api-grub/src/monitoring.rs
@@ -18,16 +18,22 @@ use log::{error, info, warn};
 
 pub async fn get_metrics_from_monitoring(duration: usize, delay: usize) -> anyhow::Result<()> {
     let timer = tokio::time::Instant::now();
-    loop {
-        if duration != 0 && timer.elapsed() >= tokio::time::Duration::from_secs(duration as u64) {
-            break;
-        }
+    'outer: loop {
         let mut a = MonitoringImporter::new().await;
         a.start_session().await?;
-        let vec = a.get_metrics_list().await?;
-        let _ = a.get_measure_info(Arc::new(vec)).await;
-        a.close_session().await?;
-        tokio::time::sleep(tokio::time::Duration::from_secs(delay as u64)).await
+        'inner: loop {
+            if duration != 0 && timer.elapsed() >= tokio::time::Duration::from_secs(duration as u64) {
+                break 'outer;
+            }
+            let vec = a.get_metrics_list().await.unwrap_or_else(|_| vec![]);
+            if vec.is_empty() {
+                warn!("Session dropped, creating new ...");
+                break 'inner;
+            }
+            let _ = a.get_measure_info(Arc::new(vec)).await;
+            // a.close_session().await?;
+            tokio::time::sleep(tokio::time::Duration::from_secs(delay as u64)).await
+        }
     }
     Ok(())
 }
-- 
2.40.1