feat: remove dcu variable and configurations

Author: mduthey

bootstrap/feature/main.tf

@@ -23,17 +23,6 @@ variable "metrics_delay" {
   default     = "30"
 }
 
-variable "dcu_per_second" {
-  type = map(string)
-  default = {
-    "mainnet"        = "1"
-    "preprod"        = "1"
-    "preview"        = "1"
-    "sanchonet"      = "1"
-    "vector-testnet" = "1"
-  }
-}
-
 variable "resources" {
   type = object({
     limits = object({

bootstrap/feature/operator.tf

@@ -71,11 +71,6 @@ resource "kubernetes_deployment_v1" "operator" {
             value = var.metrics_delay
           }
 
-          env {
-            name  = "DCU_PER_SECOND"
-            value = "mainnet=${var.dcu_per_second["mainnet"]},preprod=${var.dcu_per_second["preprod"]},preview=${var.dcu_per_second["preview"]},sanchonet=${var.dcu_per_second["sanchonet"]},vector-testnet=${var.dcu_per_second["vector-testnet"]}"
-          }
-
           resources {
             limits = {
               cpu    = var.resources.limits.cpu

bootstrap/variables.tf

@@ -32,17 +32,6 @@ variable "api_key_salt" {
   type = string
 }
 
-variable "dcu_per_second" {
-  type = map(string)
-  default = {
-    "mainnet"        = "1"
-    "preprod"        = "1"
-    "preview"        = "1"
-    "sanchonet"      = "1"
-    "vector-testnet" = "1"
-  }
-}
-
 variable "metrics_delay" {
   type    = number
   default = 60

examples/manifest.yaml

@@ -320,8 +320,6 @@ spec:
               value: "60"
             - name: PROMETHEUS_URL
               value: "http://prometheus/api/v1"
-            - name: DCU_PER_SECOND
-              value: "preview=5,preprod=5,mainnet=5"
 ---
 apiVersion: v1
 kind: Service

operator/README.md

@@ -15,7 +15,6 @@ The controller will create a TLSroute on project namespace and a grant on node n
 | API_KEY_SALT   | cardano-node-salt |
 | METRICS_DELAY  | 5                 |
 | PROMETHEUS_URL |                   |
-| DCU_PER_SECOND | NETWORK=NUMBER    |
 
 ## Commands
 

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_second: HashMap<String, f64>,
 }
 
 impl Config {
@@ -32,18 +31,6 @@ impl Config {
                     .expect("METRICS_DELAY must be a number"),
             ),
             prometheus_url: env::var("PROMETHEUS_URL").expect("PROMETHEUS_URL must be set"),
-            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_SECOND must be NETWORK=NUMBER");
-
-                    (parts[0].into(), dcu)
-                })
-                .collect(),
         }
     }
 }

operator/src/metrics.rs

@@ -15,20 +15,13 @@ use crate::{get_config, CardanoNodePort, Config, Error, 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"],
@@ -54,7 +47,6 @@ impl Default for Metrics {
         .unwrap();
 
         Metrics {
-            dcu,
             usage,
             reconcile_failures,
             metrics_failures,
@@ -66,7 +58,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)
@@ -84,22 +75,6 @@ impl Metrics {
             .inc()
     }
 
-    pub fn count_dcu_consumed(&self, project: &str, network: &str, dcu: f64) {
-        let service = format!("{}-{}", CardanoNodePort::kind(&()), network);
-        let service_type = format!(
-            "{}.{}",
-            CardanoNodePort::plural(&()),
-            CardanoNodePort::group(&())
-        );
-        let tenancy = "proxy";
-
-        let dcu: u64 = dcu.ceil() as u64;
-
-        self.dcu
-            .with_label_values::<&str>(&[project, &service, &service_type, tenancy])
-            .inc_by(dcu);
-    }
-
     pub fn count_usage(&self, project: &str, resource_name: &str, tier: &str, value: f64) {
         let feature = &CardanoNodePort::kind(&());
         let value: u64 = value.ceil() as u64;
@@ -228,27 +203,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 dcu_per_second = config.dcu_per_second.get(network);
-                if dcu_per_second.is_none() {
-                    let error = Error::ConfigError(format!(
-                        "dcu_per_package not configured to {} network",
-                        network
-                    ));
-                    error!(error = error.to_string());
-                    state.metrics.metrics_failure(&error);
-                    continue;
-                }
-
-                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