feat: remove dcu variable and configurations (demeter-run#93)

mduthey · web-flow · commit 56e7456417b3 · 2025-12-16T10:12:34.000-03:00
diff --git a/bootstrap/feature/main.tf b/bootstrap/feature/main.tf
@@ -10,24 +10,6 @@ variable "metrics_delay" {
   default     = "60"
 }
 
-variable "per_min_dcus" {
-  default = {
-    "mainnet" : 36,
-    "default" : 16,
-  }
-}
-
-variable "per_request_dcus" {
-  default = {
-    "mainnet" : 10,
-    "default" : 5,
-  }
-}
-
-variable "track_dcu_usage" {
-  default = "true"
-}
-
 variable "api_key_salt" {
   type = string
 }
diff --git a/bootstrap/feature/operator.tf b/bootstrap/feature/operator.tf
@@ -50,16 +50,6 @@ resource "kubernetes_deployment_v1" "operator" {
             value = var.metrics_delay
           }
 
-          env {
-            name  = "DCU_PER_REQUEST"
-            value = "mainnet=${var.per_request_dcus["mainnet"]},preprod=${var.per_request_dcus["default"]},preview=${var.per_request_dcus["default"]},sanchonet=${var.per_request_dcus["default"]}"
-          }
-
-          env {
-            name  = "TRACK_DCU_USAGE"
-            value = var.track_dcu_usage
-          }
-
           env {
             name  = "API_KEY_SALT"
             value = var.api_key_salt
diff --git a/bootstrap/main.tf b/bootstrap/main.tf
@@ -12,7 +12,6 @@ module "kupo_feature" {
   extension_subdomain = var.extension_subdomain
   dns_zone            = var.dns_zone
   api_key_salt        = var.api_key_salt
-  per_request_dcus    = var.per_request_dcus
   namespace           = var.namespace
   resources           = var.operator_resources
   tolerations         = var.operator_tolerations
diff --git a/bootstrap/variables.tf b/bootstrap/variables.tf
@@ -56,24 +56,6 @@ variable "metrics_delay" {
   default     = "60"
 }
 
-variable "per_min_dcus" {
-  default = {
-    "mainnet" : 36,
-    "default" : 16,
-  }
-}
-
-variable "per_request_dcus" {
-  default = {
-    "mainnet" : 10,
-    "default" : 5,
-  }
-}
-
-variable "track_dcu_usage" {
-  default = "true"
-}
-
 variable "api_key_salt" {
   type = string
 }
diff --git a/examples/manifest.yaml b/examples/manifest.yaml
@@ -322,8 +322,6 @@ spec:
               value: "40"
             - name: PROMETHEUS_URL
               value: "http://prometheus/api/v1"
-            - name: DCU_PER_REQUEST
-              value: "preview=5,preprod=5,mainnet=5"
 ---
 apiVersion: v1
 kind: Service
diff --git a/operator/README.md b/operator/README.md
@@ -11,7 +11,6 @@ This operator will create a key into the CRD to allow Kupo to be accessed extern
 | API_KEY_SALT         | kupo-salt                     |
 | METRICS_DELAY        | 40                            |
 | PROMETHEUS_URL       |                               |
-| DCU_PER_REQUEST        | preview=5,preprod=5,mainnet=5 |
 | DEFAULT_KUPO_VERSION | 2                             |
 
 ## Port CRD
diff --git a/operator/src/config.rs b/operator/src/config.rs
@@ -1,5 +1,5 @@
 use lazy_static::lazy_static;
-use std::{collections::HashMap, env, time::Duration};
+use std::{env, time::Duration};
 
 lazy_static! {
     static ref CONTROLLER_CONFIG: Config = Config::from_env();
@@ -16,7 +16,6 @@ pub struct Config {
     pub api_key_salt: String,
     pub metrics_delay: Duration,
     pub prometheus_url: String,
-    pub dcu_per_request: HashMap<String, f64>,
     pub default_kupo_version: String,
 }
 
@@ -33,18 +32,6 @@ impl Config {
                     .expect("METRICS_DELAY must be a number"),
             ),
             prometheus_url: env::var("PROMETHEUS_URL").expect("PROMETHEUS_URL must be set"),
-            dcu_per_request: env::var("DCU_PER_REQUEST")
-                .expect("DCU_PER_REQUEST must be set")
-                .split(',')
-                .map(|pair| {
-                    let parts: Vec<&str> = pair.split('=').collect();
-                    let dcu = parts[1]
-                        .parse::<f64>()
-                        .expect("DCU_PER_REQUEST must be NETWORK=NUMBER");
-
-                    (parts[0].into(), dcu)
-                })
-                .collect(),
             default_kupo_version: env::var("DEFAULT_KUPO_VERSION").unwrap_or("v2".into()),
         }
     }
diff --git a/operator/src/main.rs b/operator/src/main.rs
@@ -13,7 +13,6 @@ async fn main() -> io::Result<()> {
     let state = Arc::new(State::default());
 
     metrics_collector::run_metrics_collector(state.clone());
-    metrics_collector::run_kong_metrics_collector(state.clone());
     metrics_collector::run_metrics_server(state.clone());
 
     controller::run(state.clone()).await;
diff --git a/operator/src/metrics.rs b/operator/src/metrics.rs
@@ -14,20 +14,13 @@ use crate::{get_config, Config, Error, KupoPort, State};
 
 #[derive(Clone)]
 pub struct Metrics {
-    pub dcu: IntCounterVec,
     pub usage: IntCounterVec,
     pub reconcile_failures: IntCounterVec,
     pub metrics_failures: IntCounterVec,
 }
 
 impl Default for Metrics {
     fn default() -> Self {
-        let dcu = IntCounterVec::new(
-            opts!("dmtr_consumed_dcus", "quantity of dcu consumed",),
-            &["project", "service", "service_type", "tenancy"],
-        )
-        .unwrap();
-
         let usage = IntCounterVec::new(
             opts!("usage", "Feature usage",),
             &["feature", "project", "resource_name", "tier"],
@@ -53,7 +46,6 @@ impl Default for Metrics {
         .unwrap();
 
         Metrics {
-            dcu,
             usage,
             reconcile_failures,
             metrics_failures,
@@ -65,7 +57,6 @@ impl Metrics {
     pub fn register(self, registry: &Registry) -> Result<Self, prometheus::Error> {
         registry.register(Box::new(self.reconcile_failures.clone()))?;
         registry.register(Box::new(self.metrics_failures.clone()))?;
-        registry.register(Box::new(self.dcu.clone()))?;
         registry.register(Box::new(self.usage.clone()))?;
 
         Ok(self)
@@ -83,18 +74,6 @@ impl Metrics {
             .inc()
     }
 
-    pub fn count_dcu_consumed(&self, project: &str, network: &str, dcu: f64) {
-        let service = format!("{}-{}", KupoPort::kind(&()), network);
-        let service_type = format!("{}.{}", KupoPort::plural(&()), KupoPort::group(&()));
-        let tenancy = "proxy";
-
-        let dcu: u64 = dcu.ceil() as u64;
-
-        self.dcu
-            .with_label_values(&[project, &service, &service_type, tenancy])
-            .inc_by(dcu);
-    }
-
     pub fn count_usage(&self, project: &str, resource_name: &str, tier: &str, value: f64) {
         let feature = &KupoPort::kind(&());
         let value: u64 = value.ceil() as u64;
@@ -248,24 +227,8 @@ pub fn run_metrics_collector(state: Arc<State>) {
                     warn!(instance, "invalid network to the regex");
                     continue;
                 }
-                let network_captures = network_captures.unwrap();
-                let network = network_captures.get(1).unwrap().as_str();
                 let tier = result.metric.tier.unwrap();
 
-                let dcu_per_request = config.dcu_per_request.get(network);
-                if dcu_per_request.is_none() {
-                    let error = Error::ConfigError(format!(
-                        "dcu_per_request not configured to {} network",
-                        network
-                    ));
-                    error!(error = error.to_string());
-                    state.metrics.metrics_failure(&error);
-                    continue;
-                }
-                let dcu_per_request = dcu_per_request.unwrap();
-
-                let dcu = result.value * dcu_per_request;
-                state.metrics.count_dcu_consumed(project, network, dcu);
                 state
                     .metrics
                     .count_usage(project, resource_name, &tier, result.value);
@@ -274,74 +237,6 @@ pub fn run_metrics_collector(state: Arc<State>) {
     });
 }
 
-#[instrument("kong metrics collector run", skip_all)]
-pub fn run_kong_metrics_collector(state: Arc<State>) {
-    tokio::spawn(async move {
-        info!("collecting kong metrics running");
-
-        let config = get_config();
-        let regex = Regex::new(r"(.+)\.(\w+)-.+").unwrap();
-        let mut last_execution = Utc::now();
-
-        loop {
-            tokio::time::sleep(config.metrics_delay).await;
-
-            let end = Utc::now();
-            let start = (end - last_execution).num_seconds();
-
-            last_execution = end;
-
-            let query = format!(
-                    "sum by (consumer) (increase(kong_http_requests_total{{service='kupo-v1-ingress-kong-proxy', code!~\"429|401|503\"}}[{start}s] @ {}))",
-                    end.timestamp_millis() / 1000
-                );
-
-            let response = collect_prometheus_metrics(config, query).await;
-            if let Err(err) = response {
-                error!(error = err.to_string(), "error to make prometheus request");
-                state.metrics.metrics_failure(&err);
-                continue;
-            }
-            let response = response.unwrap();
-
-            for result in response.data.result {
-                if result.value == 0.0 || result.metric.consumer.is_none() {
-                    continue;
-                }
-
-                let consumer = result.metric.consumer.unwrap();
-
-                let captures = regex.captures(&consumer);
-                if captures.is_none() {
-                    warn!(consumer, "invalid consumer to the regex");
-                    continue;
-                }
-
-                let captures = captures.unwrap();
-                let namespace = captures.get(1).unwrap().as_str();
-                let network = captures.get(2).unwrap().as_str();
-
-                let dcu_per_request = config.dcu_per_request.get(network);
-                if dcu_per_request.is_none() {
-                    let error = Error::ConfigError(format!(
-                        "dcu_per_request not configured to {} network",
-                        network
-                    ));
-                    error!(error = error.to_string());
-                    state.metrics.metrics_failure(&error);
-                    continue;
-                }
-                let dcu_per_request = dcu_per_request.unwrap();
-
-                let dcu = result.value * dcu_per_request;
-
-                let project = namespace.split_once("prj-").unwrap().1;
-                state.metrics.count_dcu_consumed(project, network, dcu);
-            }
-        }
-    });
-}
-
 #[derive(Debug, Deserialize)]
 struct PrometheusDataResultMetric {
     consumer: Option<String>,
