Fix

getsentry · iambriccardo · Jul 22, 2024 · Jul 15, 2024 · Jul 16, 2024 · Jul 16, 2024
commit 464ca43a82831eaaf8eda3309ba2c2eb26be8138
@@ -331,7 +331,7 @@ pub async fn handle_envelope(
         )
     }
 
-    if !state.memory_stat_config().has_enough_memory() {
+    if state.memory_checker().check_memory().is_exceeded() {
         return Err(BadStoreRequest::QueueFailed);
     };
 

@@ -26,7 +26,7 @@ use crate::services::relays::{RelayCache, RelayCacheService};
 use crate::services::store::StoreService;
 use crate::services::test_store::{TestStore, TestStoreService};
 use crate::services::upstream::{UpstreamRelay, UpstreamRelayService};
-use crate::utils::{MemoryStat, MemoryStatConfig};
+use crate::utils::{MemoryChecker, MemoryStat};
 
 /// Indicates the type of failure of the server.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, thiserror::Error)]
@@ -84,7 +84,7 @@ pub fn create_runtime(name: &str, threads: usize) -> Runtime {
 #[derive(Debug)]
 struct StateInner {
     config: Arc<Config>,
-    memory_stat_config: MemoryStatConfig,
+    memory_checker: MemoryChecker,
     registry: Registry,
 }
 
@@ -238,7 +238,7 @@ impl ServiceState {
 
         let state = StateInner {
             config: config.clone(),
-            memory_stat_config: memory_stat.with_config(config),
+            memory_checker: memory_stat.with_config(config),
             registry,
         };
 
@@ -252,11 +252,11 @@ impl ServiceState {
         &self.inner.config
     }
 
-    /// Returns a reference to the [`MemoryStatConfig`] which is a [`Config`] aware wrapper on the
+    /// Returns a reference to the [`MemoryChecker`] which is a [`Config`] aware wrapper on the
     /// [`MemoryStat`] which gives utility methods to determine whether memory usage is above
     /// thresholds set in the [`Config`].
-    pub fn memory_stat_config(&self) -> &MemoryStatConfig {
-        &self.inner.memory_stat_config
+    pub fn memory_checker(&self) -> &MemoryChecker {
+        &self.inner.memory_checker
     }
 
     /// Returns the address of the [`ProjectCache`] service.

@@ -10,7 +10,7 @@ use crate::services::metrics::{AcceptsMetrics, Aggregator};
 use crate::services::project_cache::{ProjectCache, SpoolHealth};
 use crate::services::upstream::{IsAuthenticated, UpstreamRelay};
 use crate::statsd::RelayTimers;
-use crate::utils::MemoryStatConfig;
+use crate::utils::{MemoryCheck, MemoryChecker};
 
 /// Checks whether Relay is alive and healthy based on its variant.
 #[derive(Clone, Copy, Debug, serde::Deserialize)]
@@ -83,7 +83,7 @@ impl StatusUpdate {
 #[derive(Debug)]
 pub struct HealthCheckService {
     config: Arc<Config>,
-    memory_stat_config: MemoryStatConfig,
+    memory_checker: MemoryChecker,
     aggregator: Addr<Aggregator>,
     upstream_relay: Addr<UpstreamRelay>,
     project_cache: Addr<ProjectCache>,
@@ -95,23 +95,22 @@ impl HealthCheckService {
     /// The service does not run. To run the service, use [`start`](Self::start).
     pub fn new(
         config: Arc<Config>,
-        memory_stat_config: MemoryStatConfig,
+        memory_checker: MemoryChecker,
         aggregator: Addr<Aggregator>,
         upstream_relay: Addr<UpstreamRelay>,
         project_cache: Addr<ProjectCache>,
     ) -> Self {
         Self {
             config,
-            memory_stat_config,
+            memory_checker,
             aggregator,
             upstream_relay,
             project_cache,
         }
     }
 
     fn system_memory_probe(&mut self) -> Status {
-        if !self.memory_stat_config.has_enough_memory_percent() {
-            let memory = self.memory_stat_config.memory_stat.memory();
+        if let MemoryCheck::Exceeded(memory) = self.memory_checker.check_memory_percent() {
             relay_log::error!(
                 "Not enough memory, {} / {} ({:.2}% >= {:.2}%)",
                 memory.used,
@@ -122,8 +121,7 @@ impl HealthCheckService {
             return Status::Unhealthy;
         }
 
-        if !self.memory_stat_config.has_enough_memory_bytes() {
-            let memory = self.memory_stat_config.memory_stat.memory();
+        if let MemoryCheck::Exceeded(memory) = self.memory_checker.check_memory_bytes() {
             relay_log::error!(
                 "Not enough memory, {} / {} ({} >= {})",
                 memory.used,

@@ -36,7 +36,7 @@ use crate::services::upstream::UpstreamRelay;
 
 use crate::statsd::{RelayCounters, RelayGauges, RelayHistograms, RelayTimers};
 use crate::utils::{
-    self, GarbageDisposal, ManagedEnvelope, MemoryStatConfig, RetryBackoff, SleepHandle,
+    self, GarbageDisposal, ManagedEnvelope, MemoryChecker, RetryBackoff, SleepHandle,
 };
 
 /// Requests a refresh of a project state from one of the available sources.
@@ -555,7 +555,7 @@ impl Services {
 #[derive(Debug)]
 struct ProjectCacheBroker {
     config: Arc<Config>,
-    memory_stat_config: MemoryStatConfig,
+    memory_checker: MemoryChecker,
     services: Services,
     metric_outcomes: MetricOutcomes,
     // Need hashbrown because extract_if is not stable in std yet.
@@ -851,7 +851,7 @@ impl ProjectCacheBroker {
         // state or we do not need one.
         if project_state.is_some()
             && (sampling_state.is_some() || sampling_key.is_none())
-            && self.memory_stat_config.has_enough_memory()
+            && self.memory_checker.check_memory().is_below()
             && self.global_config.is_ready()
         {
             return self.handle_processing(key, context);
@@ -1096,7 +1096,7 @@ impl ProjectCacheBroker {
 #[derive(Debug)]
 pub struct ProjectCacheService {
     config: Arc<Config>,
-    memory_stat_config: MemoryStatConfig,
+    memory_checker: MemoryChecker,
     services: Services,
     metric_outcomes: MetricOutcomes,
     redis: Option<RedisPool>,
@@ -1106,14 +1106,14 @@ impl ProjectCacheService {
     /// Creates a new `ProjectCacheService`.
     pub fn new(
         config: Arc<Config>,
-        memory_stat_config: MemoryStatConfig,
+        memory_checker: MemoryChecker,
         services: Services,
         metric_outcomes: MetricOutcomes,
         redis: Option<RedisPool>,
     ) -> Self {
         Self {
             config,
-            memory_stat_config,
+            memory_checker,
             services,
             metric_outcomes,
             redis,
@@ -1127,7 +1127,7 @@ impl Service for ProjectCacheService {
     fn spawn_handler(self, mut rx: relay_system::Receiver<Self::Interface>) {
         let Self {
             config,
-            memory_stat_config,
+            memory_checker,
             services,
             metric_outcomes,
             redis,
@@ -1151,7 +1151,7 @@ impl Service for ProjectCacheService {
                 test_store,
             };
             let buffer = match BufferService::create(
-                memory_stat_config.clone(),
+                memory_checker.clone(),
                 buffer_services,
                 config.clone(),
             )
@@ -1192,7 +1192,7 @@ impl Service for ProjectCacheService {
             // fetches via the project source.
             let mut broker = ProjectCacheBroker {
                 config: config.clone(),
-                memory_stat_config,
+                memory_checker,
                 projects: hashbrown::HashMap::new(),
                 garbage_disposal: GarbageDisposal::new(),
                 source: ProjectSource::start(
@@ -1334,27 +1334,24 @@ mod tests {
         }))
         .unwrap()
         .into();
-        let memory_stat_config = MemoryStat::new().with_config(config.clone());
+        let memory_checker = MemoryStat::new().with_config(config.clone());
         let buffer_services = spooler::Services {
             outcome_aggregator: services.outcome_aggregator.clone(),
             project_cache: services.project_cache.clone(),
             test_store: services.test_store.clone(),
         };
-        let buffer = match BufferService::create(
-            memory_stat_config.clone(),
-            buffer_services,
-            config.clone(),
-        )
-        .await
-        {
-            Ok(buffer) => buffer.start(),
-            Err(err) => {
-                relay_log::error!(error = &err as &dyn Error, "failed to start buffer service");
-                // NOTE: The process will exit with error if the buffer file could not be
-                // opened or the migrations could not be run.
-                std::process::exit(1);
-            }
-        };
+        let buffer =
+            match BufferService::create(memory_checker.clone(), buffer_services, config.clone())
+                .await
+            {
+                Ok(buffer) => buffer.start(),
+                Err(err) => {
+                    relay_log::error!(error = &err as &dyn Error, "failed to start buffer service");
+                    // NOTE: The process will exit with error if the buffer file could not be
+                    // opened or the migrations could not be run.
+                    std::process::exit(1);
+                }
+            };
 
         let metric_stats = MetricStats::new(
             Arc::new(Config::default()),
@@ -1367,7 +1364,7 @@ mod tests {
         (
             ProjectCacheBroker {
                 config: config.clone(),
-                memory_stat_config,
+                memory_checker,
                 projects: hashbrown::HashMap::new(),
                 garbage_disposal: GarbageDisposal::new(),
                 source: ProjectSource::start(config, services.upstream_relay.clone(), None),
-Original file line number
+Diff line change
@@ Expand Up / @@ -331,7 +331,7 @@ pub async fn handle_envelope( @@
             )
         }
-        if !state.memory_stat_config().has_enough_memory() {
+        if state.memory_checker().check_memory().is_exceeded() {
             return Err(BadStoreRequest::QueueFailed);
         };
@@ Expand Down @@