fix: Track connection time and reset connection metric

Author: gonzalezzfelipe

bootstrap/feature/main.tf

@@ -28,12 +28,13 @@ variable "api_key_salt" {
   default = "ogmios-salt"
 }
 
-variable "dcu_per_frame" {
+variable "dcu_per_second" {
   type = map(string)
   default = {
-    "mainnet" = "10"
-    "preprod" = "5"
-    "preview" = "5"
+    "mainnet"        = "1"
+    "preprod"        = "1"
+    "preview"        = "1"
+    "vector-testnet" = "1"
   }
 }
 

bootstrap/feature/operator.tf

@@ -67,8 +67,8 @@ resource "kubernetes_deployment_v1" "ogmios_operator" {
           }
 
           env {
-            name  = "DCU_PER_FRAME"
-            value = "mainnet=${var.dcu_per_frame["mainnet"]},preprod=${var.dcu_per_frame["preprod"]},preview=${var.dcu_per_frame["preview"]},vector-testnet=${var.dcu_per_frame["vector-testnet"]}"
+            name  = "DCU_PER_SECOND"
+            value = "mainnet=${var.dcu_per_second["mainnet"]},preprod=${var.dcu_per_second["preprod"]},preview=${var.dcu_per_second["preview"]},vector-testnet=${var.dcu_per_second["vector-testnet"]}"
           }
 
           env {

bootstrap/main.tf

@@ -21,7 +21,7 @@ module "ogmios_v1_feature" {
   metrics_delay      = var.metrics_delay
   extension_name     = var.extension_name
   api_key_salt       = var.api_key_salt
-  dcu_per_frame      = var.dcu_per_frame
+  dcu_per_second     = var.dcu_per_second
 }
 
 module "ogmios_v1_proxy" {

bootstrap/variables.tf

@@ -34,12 +34,13 @@ variable "api_key_salt" {
   default = "ogmios-salt"
 }
 
-variable "dcu_per_frame" {
+variable "dcu_per_second" {
   type = map(string)
   default = {
-    "mainnet" = "10"
-    "preprod" = "5"
-    "preview" = "5"
+    "mainnet"        = "1"
+    "preprod"        = "1"
+    "preview"        = "1"
+    "vector-testnet" = "1"
   }
 }
 

operator/src/config.rs

@@ -14,7 +14,7 @@ pub struct Config {
     pub dns_zone: String,
     pub extension_name: String,
     pub api_key_salt: String,
-    pub dcu_per_frame: HashMap<String, f64>,
+    pub dcu_per_second: HashMap<String, f64>,
     pub metrics_delay: Duration,
     pub prometheus_url: String,
 }
@@ -24,14 +24,14 @@ impl Config {
         let dns_zone = env::var("DNS_ZONE").unwrap_or("demeter.run".into());
         let extension_name = env::var("EXTENSION_NAME").unwrap_or("ogmios-m1".into());
         let api_key_salt = env::var("API_KEY_SALT").unwrap_or("ogmios-salt".into());
-        let dcu_per_frame = env::var("DCU_PER_FRAME")
-            .expect("DCU_PER_FRAME must be set")
+        let dcu_per_second = env::var("DCU_PER_SECOND")
+            .expect("DCU_PER_SECOND must be set")
             .split(',')
             .map(|pair| {
                 let parts: Vec<&str> = pair.split('=').collect();
                 let dcu = parts[1]
                     .parse::<f64>()
-                    .expect("DCU_PER_FRAME must be NETWORK=NUMBER");
+                    .expect("DCU_PER_SECOND must be NETWORK=NUMBER");
 
                 (parts[0].into(), dcu)
             })
@@ -49,7 +49,7 @@ impl Config {
             dns_zone,
             extension_name,
             api_key_salt,
-            dcu_per_frame,
+            dcu_per_second,
             metrics_delay,
             prometheus_url,
         }

operator/src/metrics.rs

@@ -117,29 +117,30 @@ pub async fn run_metrics_collector(state: Arc<State>) {
             tokio::time::sleep(config.metrics_delay).await;
 
             let end = Utc::now();
-            let start = (end - last_execution).num_seconds();
+            let interval = (end - last_execution).num_seconds();
 
             last_execution = end;
 
             let query = format!(
-                "sum by (consumer, route, tier) (increase(ogmios_proxy_ws_total_frame[{start}s] @ {}))",
+                "sum by (consumer, route, tier) (avg_over_time(ogmios_proxy_total_frame[{interval}s] @ {}))",
                 end.timestamp_millis() / 1000
             );
 
-            let result = client
+            let response = match client
                 .get(format!("{}/query?query={query}", config.prometheus_url))
                 .send()
-                .await;
-
-            if let Err(err) = result {
-                error!(error = err.to_string(), "error to make prometheus request");
-                state
-                    .metrics
-                    .metrics_failure(&Error::HttpError(err.to_string()));
-                continue;
-            }
+                .await
+            {
+                Ok(response) => response,
+                Err(err) => {
+                    error!(error = err.to_string(), "error to make prometheus request");
+                    state
+                        .metrics
+                        .metrics_failure(&Error::HttpError(err.to_string()));
+                    continue;
+                }
+            };
 
-            let response = result.unwrap();
             let status = response.status();
             if status.is_client_error() || status.is_server_error() {
                 error!(status = status.to_string(), "request status code fail");
@@ -176,25 +177,27 @@ pub async fn run_metrics_collector(state: Arc<State>) {
                 let network_captures = network_captures.unwrap();
                 let network = network_captures.get(1).unwrap().as_str();
 
-                let dcu_per_frame = config.dcu_per_frame.get(network);
-                if dcu_per_frame.is_none() {
+                let dcu_per_second = config.dcu_per_second.get(network);
+                if dcu_per_second.is_none() {
                     let error = Error::ConfigError(format!(
-                        "dcu_per_frame not configured to {} network",
+                        "dcu_per_package not configured to {} network",
                         network
                     ));
                     error!(error = error.to_string());
                     state.metrics.metrics_failure(&error);
                     continue;
                 }
-                let dcu_per_frame = dcu_per_frame.unwrap();
 
-                let dcu = result.value * dcu_per_frame;
-                state.metrics.count_dcu_consumed(project, network, dcu);
+                let dcu_per_second = dcu_per_second.unwrap();
+                let total_exec_time = result.value * (interval as f64);
 
+                let dcu = total_exec_time * dcu_per_second;
+
+                state.metrics.count_dcu_consumed(project, network, dcu);
                 if let Some(tier) = result.metric.tier {
                     state
                         .metrics
-                        .count_usage(project, resource_name, &tier, result.value);
+                        .count_usage(project, resource_name, &tier, total_exec_time);
                 }
             }
         }

proxy/src/metrics.rs

@@ -31,7 +31,7 @@ impl Metrics {
 
         let ws_total_connection = IntGaugeVec::new(
             opts!(
-                "ogmios_proxy_ws_total_connection",
+                "ogmios_proxy_total_connection",
                 "total of websocket connection",
             ),
             &["namespace", "instance", "route", "consumer", "tier"],