Simplify handling of stats and sinsp configuration

Author: Molter73

collector/lib/CollectorConfig.cpp

@@ -2,7 +2,6 @@
 
 #include <filesystem>
 #include <optional>
-#include <sstream>
 
 #include <libsinsp/sinsp.h>
 
@@ -50,9 +49,18 @@ BoolEnvVar collect_connection_status("ROX_COLLECT_CONNECTION_STATUS", true);
 
 BoolEnvVar enable_external_ips("ROX_ENABLE_EXTERNAL_IPS", false);
 
+// Stats and metrics configuration
 BoolEnvVar enable_connection_stats("ROX_COLLECTOR_ENABLE_CONNECTION_STATS", true);
-
 BoolEnvVar enable_detailed_metrics("ROX_COLLECTOR_ENABLE_DETAILED_METRICS", true);
+StringListEnvVar connection_stats_quantiles("ROX_COLLECTOR_CONNECTION_STATS_QUANTILES");
+DoubleEnvVar connection_stats_error("ROX_COLLECTOR_CONNECTION_STATS_ERROR", 0.01);
+UIntEnvVar connection_stats_window("ROX_COLLECTOR_CONNECTION_STATS_WINDOW", 60);
+
+// Sinsp configuration
+UIntEnvVar sinsp_cpu_per_buffer("ROX_COLLECTOR_SINSP_CPU_PER_BUFFER", DEFAULT_CPU_FOR_EACH_BUFFER);
+UIntEnvVar sinsp_buffer_size("ROX_COLLECTOR_SINSP_BUFFER_SIZE", DEFAULT_DRIVER_BUFFER_BYTES_DIM);
+UIntEnvVar sinsp_total_buffer_size("ROX_COLLECTOR_SINSP_TOTAL_BUFFER_SIZE", 512 * 1024 * 1024);
+UIntEnvVar sinsp_thread_cache_size("ROX_COLLECTOR_SINSP_TOTAL_BUFFER_SIZE", 32768);
 
 BoolEnvVar enable_runtime_config("ROX_COLLECTOR_RUNTIME_CONFIG_ENABLED", false);
 
@@ -98,7 +106,13 @@ CollectorConfig::CollectorConfig(CollectorArgs* args)
       use_docker_ce_(use_docker_ce),
       use_podman_ce_(use_podman_ce),
       enable_introspection_(enable_introspection),
-      track_send_recv_(track_send_recv) {
+      track_send_recv_(track_send_recv),
+      connection_stats_error_(connection_stats_error),
+      connection_stats_window_(connection_stats_window),
+      sinsp_cpu_per_buffer_(sinsp_cpu_per_buffer),
+      sinsp_buffer_size_(sinsp_buffer_size),
+      sinsp_total_buffer_size_(sinsp_total_buffer_size),
+      sinsp_thread_cache_size_(sinsp_thread_cache_size) {
   // Get hostname
   hostname_ = GetHostname();
   if (hostname_.empty()) {
@@ -118,8 +132,7 @@ CollectorConfig::CollectorConfig(CollectorArgs* args)
   HandleArgs(args);
   HandleNetworkConfig();
   HandleAfterglowEnvVars();
-  HandleConnectionStatsEnvVars();
-  HandleSinspEnvVars();
+  HandleConnectionStatsQuantiles();
   HandleConfig(config_file.value());
 
   host_config_ = ProcessHostHeuristics(*this);
@@ -290,17 +303,12 @@ void CollectorConfig::HandleAfterglowEnvVars() {
   CLOG(INFO) << "Afterglow is " << (enable_afterglow_ ? "enabled" : "disabled");
 }
 
-void CollectorConfig::HandleConnectionStatsEnvVars() {
-  const char* envvar;
-
+void CollectorConfig::HandleConnectionStatsQuantiles() {
   connection_stats_quantiles_ = {0.50, 0.90, 0.95};
 
-  if ((envvar = std::getenv("ROX_COLLECTOR_CONNECTION_STATS_QUANTILES")) != NULL) {
+  if (connection_stats_quantiles.hasValue()) {
     connection_stats_quantiles_.clear();
-    std::stringstream quantiles(envvar);
-    while (quantiles.good()) {
-      std::string quantile;
-      std::getline(quantiles, quantile, ',');
+    for (const auto& quantile : connection_stats_quantiles.value()) {
       try {
         double v = std::stod(quantile);
         connection_stats_quantiles_.push_back(v);
@@ -310,69 +318,6 @@ void CollectorConfig::HandleConnectionStatsEnvVars() {
       }
     }
   }
-
-  if ((envvar = std::getenv("ROX_COLLECTOR_CONNECTION_STATS_ERROR")) != NULL) {
-    try {
-      connection_stats_error_ = std::stod(envvar);
-      CLOG(INFO) << "Connection statistics error value: " << connection_stats_error_;
-    } catch (...) {
-      CLOG(ERROR) << "Invalid quantile error value: '" << envvar << "'";
-    }
-  }
-
-  if ((envvar = std::getenv("ROX_COLLECTOR_CONNECTION_STATS_WINDOW")) != NULL) {
-    try {
-      connection_stats_window_ = std::stoi(envvar);
-      CLOG(INFO) << "Connection statistics window: " << connection_stats_window_;
-    } catch (...) {
-      CLOG(ERROR) << "Invalid window length value: '" << envvar << "'";
-    }
-  }
-}
-
-void CollectorConfig::HandleSinspEnvVars() {
-  const char* envvar;
-
-  sinsp_cpu_per_buffer_ = DEFAULT_CPU_FOR_EACH_BUFFER;
-  sinsp_buffer_size_ = DEFAULT_DRIVER_BUFFER_BYTES_DIM;
-  // the default values for sinsp_thread_cache_size_, sinsp_total_buffer_size_
-  // are not picked up from Falco, but set in the CollectorConfig class.
-
-  if ((envvar = std::getenv("ROX_COLLECTOR_SINSP_CPU_PER_BUFFER")) != NULL) {
-    try {
-      sinsp_cpu_per_buffer_ = std::stoi(envvar);
-      CLOG(INFO) << "Sinsp cpu per buffer: " << sinsp_cpu_per_buffer_;
-    } catch (...) {
-      CLOG(ERROR) << "Invalid cpu per buffer value: '" << envvar << "'";
-    }
-  }
-
-  if ((envvar = std::getenv("ROX_COLLECTOR_SINSP_BUFFER_SIZE")) != NULL) {
-    try {
-      sinsp_buffer_size_ = std::stoll(envvar);
-      CLOG(INFO) << "Sinsp buffer size: " << sinsp_buffer_size_;
-    } catch (...) {
-      CLOG(ERROR) << "Invalid buffer size value: '" << envvar << "'";
-    }
-  }
-
-  if ((envvar = std::getenv("ROX_COLLECTOR_SINSP_TOTAL_BUFFER_SIZE")) != NULL) {
-    try {
-      sinsp_total_buffer_size_ = std::stoll(envvar);
-      CLOG(INFO) << "Sinsp total buffer size: " << sinsp_total_buffer_size_;
-    } catch (...) {
-      CLOG(ERROR) << "Invalid total buffer size value: '" << envvar << "'";
-    }
-  }
-
-  if ((envvar = std::getenv("ROX_COLLECTOR_SINSP_THREAD_CACHE_SIZE")) != NULL) {
-    try {
-      sinsp_thread_cache_size_ = std::stoll(envvar);
-      CLOG(INFO) << "Sinsp thread cache size: " << sinsp_thread_cache_size_;
-    } catch (...) {
-      CLOG(ERROR) << "Invalid thread cache size value: '" << envvar << "'";
-    }
-  }
 }
 
 bool CollectorConfig::YamlConfigToConfig(YAML::Node& yamlConfig) {

collector/lib/CollectorConfig.h

@@ -141,14 +141,14 @@ class CollectorConfig {
   std::vector<std::string> syscalls_;
   std::string hostname_;
   std::string host_proc_;
-  bool disable_network_flows_ = false;
+  bool disable_network_flows_;
   bool scrape_listen_endpoints_;
   UnorderedSet<L4ProtoPortPair> ignored_l4proto_port_pairs_;
   std::vector<IPNet> ignored_networks_;
   std::vector<IPNet> non_aggregated_networks_;
 
   HostConfig host_config_;
-  int64_t afterglow_period_micros_ = 300'000'000;  // 5 minutes in microseconds
+  int64_t afterglow_period_micros_;
   bool enable_afterglow_ = false;
   bool enable_core_dump_;
   bool enable_processes_listening_on_ports_;
@@ -163,26 +163,26 @@ class CollectorConfig {
   bool enable_introspection_;
   bool track_send_recv_;
   std::vector<double> connection_stats_quantiles_;
-  double connection_stats_error_ = 0.01;
-  unsigned int connection_stats_window_ = 60;
+  double connection_stats_error_;
+  unsigned int connection_stats_window_;
 
   // URL to the GRPC server
   std::optional<std::string> grpc_server_;
 
   // One ring buffer will be initialized for this many CPUs
-  unsigned int sinsp_cpu_per_buffer_ = 0;
+  unsigned int sinsp_cpu_per_buffer_;
   // Size of one ring buffer, in bytes.
-  unsigned int sinsp_buffer_size_ = 0;
+  unsigned int sinsp_buffer_size_;
   // Allowed size of all ring buffers, in bytes. The default value 512Mi is
   // based on the default memory limit set of the Collector DaemonSet, which is
   // 1Gi.
-  unsigned int sinsp_total_buffer_size_ = 512 * 1024 * 1024;
+  unsigned int sinsp_total_buffer_size_;
 
   // Max size of the thread cache. This parameter essentially translated into
   // the upper boundary for memory consumption. Note that Falco puts it's own
   // upper limit on top of this value, m_thread_table_absolute_max_size, which
   // is 2^17 (131072) and twice as large.
-  unsigned int sinsp_thread_cache_size_ = 32768;
+  unsigned int sinsp_thread_cache_size_;
 
   std::optional<TlsConfig> tls_config_;
 
@@ -198,8 +198,7 @@ class CollectorConfig {
   // Methods for complex configurations
   void HandleNetworkConfig();
   void HandleAfterglowEnvVars();
-  void HandleConnectionStatsEnvVars();
-  void HandleSinspEnvVars();
+  void HandleConnectionStatsQuantiles();
   bool YamlConfigToConfig(YAML::Node& yamlConfig);
   void HandleConfig(const std::filesystem::path& filePath);
 

collector/lib/EnvVar.h

@@ -104,6 +104,13 @@ struct ParseInt {
   }
 };
 
+struct ParseUInt {
+  bool operator()(unsigned int* out, const std::string& str_val) {
+    *out = std::stoul(str_val);
+    return true;
+  }
+};
+
 struct ParsePath {
   bool operator()(std::filesystem::path* out, const std::string& str_val) {
     *out = str_val;
@@ -117,14 +124,23 @@ struct ParseFloat {
     return true;
   }
 };
+
+struct ParseDouble {
+  bool operator()(double* out, const std::string& str_val) {
+    *out = std::stod(str_val);
+    return true;
+  }
+};
 }  // namespace internal
 
 using BoolEnvVar = EnvVar<bool, internal::ParseBool>;
 using StringListEnvVar = EnvVar<std::vector<std::string>, internal::ParseStringList>;
 using StringEnvVar = EnvVar<std::string, internal::ParseString>;
 using IntEnvVar = EnvVar<int, internal::ParseInt>;
+using UIntEnvVar = EnvVar<unsigned int, internal::ParseUInt>;
 using PathEnvVar = EnvVar<std::filesystem::path, internal::ParsePath>;
 using FloatEnvVar = EnvVar<float, internal::ParseFloat>;
+using DoubleEnvVar = EnvVar<double, internal::ParseDouble>;
 
 }  // namespace collector