From 8cd28e17181124a1a0af122f3550e5a8e7877a8d Mon Sep 17 00:00:00 2001
From: Christian Schwarz <me@cschwarz.com>
Date: Wed, 29 Nov 2023 15:34:46 +0000
Subject: [PATCH] logical size calculation: make .current_size() infallible
 (#5999)

... by panicking on overflow;

It was made fallible initially due to in-confidence in logical size
calculation. However, the error has never happened since I am at Neon.

Let's stop worrying about this by converting the overflow check into a panic.
---
 pageserver/src/tenant/timeline.rs              | 8 +++-----
 pageserver/src/tenant/timeline/logical_size.rs | 8 ++++----
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/pageserver/src/tenant/timeline.rs b/pageserver/src/tenant/timeline.rs
index 341ec3e255..2eaf015dd4 100644
--- a/pageserver/src/tenant/timeline.rs
+++ b/pageserver/src/tenant/timeline.rs
@@ -859,7 +859,7 @@ impl Timeline {
         self: &Arc<Self>,
         ctx: &RequestContext,
     ) -> anyhow::Result<(u64, bool)> {
-        let current_size = self.current_logical_size.current_size()?;
+        let current_size = self.current_logical_size.current_size();
         debug!("Current size: {current_size:?}");
 
         let mut is_exact = true;
@@ -2057,16 +2057,14 @@ impl Timeline {
         // one value while current_logical_size is set to the
         // other.
         match logical_size.current_size() {
-            Ok(CurrentLogicalSize::Exact(new_current_size)) => self
+            CurrentLogicalSize::Exact(new_current_size) => self
                 .metrics
                 .current_logical_size_gauge
                 .set(new_current_size),
-            Ok(CurrentLogicalSize::Approximate(_)) => {
+            CurrentLogicalSize::Approximate(_) => {
                 // don't update the gauge yet, this allows us not to update the gauge back and
                 // forth between the initial size calculation task.
             }
-            // this is overflow
-            Err(e) => error!("Failed to compute current logical size for metrics update: {e:?}"),
         }
     }
 
diff --git a/pageserver/src/tenant/timeline/logical_size.rs b/pageserver/src/tenant/timeline/logical_size.rs
index 43d8faeb0b..ec93955254 100644
--- a/pageserver/src/tenant/timeline/logical_size.rs
+++ b/pageserver/src/tenant/timeline/logical_size.rs
@@ -102,23 +102,23 @@ impl LogicalSize {
         }
     }
 
-    pub(super) fn current_size(&self) -> anyhow::Result<CurrentLogicalSize> {
+    pub(super) fn current_size(&self) -> CurrentLogicalSize {
         let size_increment: i64 = self.size_added_after_initial.load(AtomicOrdering::Acquire);
         //                  ^^^ keep this type explicit so that the casts in this function break if
         //                  we change the type.
         match self.initial_logical_size.get() {
             Some((initial_size, _)) => {
                 crate::metrics::initial_logical_size::CALLS.exact.inc();
-                initial_size.checked_add_signed(size_increment)
+                CurrentLogicalSize::Exact(initial_size.checked_add_signed(size_increment)
                     .with_context(|| format!("Overflow during logical size calculation, initial_size: {initial_size}, size_increment: {size_increment}"))
-                    .map(CurrentLogicalSize::Exact)
+                    .unwrap())
             }
             None => {
                 crate::metrics::initial_logical_size::CALLS
                     .approximate
                     .inc();
                 let non_negative_size_increment = u64::try_from(size_increment).unwrap_or(0);
-                Ok(CurrentLogicalSize::Approximate(non_negative_size_increment))
+                CurrentLogicalSize::Approximate(non_negative_size_increment)
             }
         }
     }