Drop the extraneous total_* fields

The values in the `total_*` counters are manipulated identically to the other
fields, so we can drop them now.

Author: bruceg

lib/vector-buffers/src/buffer_usage_data.rs

@@ -27,8 +27,6 @@ fn update_counter(counter: &AtomicU64, delta: u64) {
 struct CategorySnapshot {
     event_count: u64,
     event_byte_size: u64,
-    total_count: u64,
-    total_byte_size: u64,
 }
 
 impl CategorySnapshot {
@@ -48,17 +46,13 @@ impl CategorySnapshot {
 struct CategoryMetrics {
     event_count: AtomicU64,
     event_byte_size: AtomicU64,
-    total_count: AtomicU64,
-    total_byte_size: AtomicU64,
 }
 
 impl CategoryMetrics {
     /// Increments the event count and byte size by the given amounts.
     fn increment(&self, event_count: u64, event_byte_size: u64) {
         update_counter(&self.event_count, event_count);
         update_counter(&self.event_byte_size, event_byte_size);
-        update_counter(&self.total_count, event_count);
-        update_counter(&self.total_byte_size, event_byte_size);
     }
 
     /// Sets the event count and event byte size to the given amount.
@@ -68,18 +62,13 @@ impl CategoryMetrics {
         self.event_count.store(event_count, Ordering::Release);
         self.event_byte_size
             .store(event_byte_size, Ordering::Release);
-        self.total_count.store(event_count, Ordering::Release);
-        self.total_byte_size
-            .store(event_byte_size, Ordering::Release);
     }
 
     /// Gets a snapshot of the event count and event byte size.
     fn get(&self) -> CategorySnapshot {
         CategorySnapshot {
             event_count: self.event_count.load(Ordering::Acquire),
             event_byte_size: self.event_byte_size.load(Ordering::Acquire),
-            total_count: self.total_count.load(Ordering::Acquire),
-            total_byte_size: self.total_byte_size.load(Ordering::Acquire),
         }
     }
 
@@ -93,8 +82,6 @@ impl CategoryMetrics {
         CategorySnapshot {
             event_count: self.event_count.swap(0, Ordering::AcqRel),
             event_byte_size: self.event_byte_size.swap(0, Ordering::AcqRel),
-            total_count: self.total_count.swap(0, Ordering::AcqRel),
-            total_byte_size: self.total_byte_size.swap(0, Ordering::AcqRel),
         }
     }
 }
@@ -291,8 +278,6 @@ impl BufferUsage {
                             idx: stage.idx,
                             count: received.event_count,
                             byte_size: received.event_byte_size,
-                            total_count: received.total_count,
-                            total_byte_size: received.total_byte_size,
                         });
                     }
 
@@ -303,8 +288,6 @@ impl BufferUsage {
                             idx: stage.idx,
                             count: sent.event_count,
                             byte_size: sent.event_byte_size,
-                            total_count: sent.total_count,
-                            total_byte_size: sent.total_byte_size,
                         });
                     }
 
@@ -317,8 +300,6 @@ impl BufferUsage {
                             reason: "corrupted_events",
                             count: dropped.event_count,
                             byte_size: dropped.event_byte_size,
-                            total_count: dropped.total_count,
-                            total_byte_size: dropped.total_byte_size,
                         });
                     }
 
@@ -331,8 +312,6 @@ impl BufferUsage {
                             reason: "drop_newest",
                             count: dropped_intentional.event_count,
                             byte_size: dropped_intentional.event_byte_size,
-                            total_count: dropped_intentional.total_count,
-                            total_byte_size: dropped_intentional.total_byte_size,
                         });
                     }
                 }

lib/vector-buffers/src/internal_events.rs

@@ -50,8 +50,6 @@ pub struct BufferEventsReceived {
     pub idx: usize,
     pub count: u64,
     pub byte_size: u64,
-    pub total_count: u64,
-    pub total_byte_size: u64,
 }
 
 impl InternalEvent for BufferEventsReceived {
@@ -74,13 +72,13 @@ impl InternalEvent for BufferEventsReceived {
             "buffer_id" => self.buffer_id.clone(),
             "stage" => self.idx.to_string()
         )
-        .set(u64_to_f64_safe(self.total_count));
+        .set(u64_to_f64_safe(self.count));
         gauge!(
             "buffer_byte_size",
             "buffer_id" => self.buffer_id,
             "stage" => self.idx.to_string()
         )
-        .set(u64_to_f64_safe(self.total_byte_size));
+        .set(u64_to_f64_safe(self.byte_size));
     }
 }
 
@@ -89,8 +87,6 @@ pub struct BufferEventsSent {
     pub idx: usize,
     pub count: u64,
     pub byte_size: u64,
-    pub total_count: u64,
-    pub total_byte_size: u64,
 }
 
 impl InternalEvent for BufferEventsSent {
@@ -111,13 +107,13 @@ impl InternalEvent for BufferEventsSent {
             "buffer_id" => self.buffer_id.clone(),
             "stage" => self.idx.to_string()
         )
-        .set(u64_to_f64_safe(self.total_count));
+        .set(u64_to_f64_safe(self.count));
         gauge!(
             "buffer_byte_size",
             "buffer_id" => self.buffer_id,
             "stage" => self.idx.to_string()
         )
-        .set(u64_to_f64_safe(self.total_byte_size));
+        .set(u64_to_f64_safe(self.byte_size));
     }
 }
 
@@ -126,8 +122,6 @@ pub struct BufferEventsDropped {
     pub idx: usize,
     pub count: u64,
     pub byte_size: u64,
-    pub total_count: u64,
-    pub total_byte_size: u64,
     pub intentional: bool,
     pub reason: &'static str,
 }
@@ -168,13 +162,13 @@ impl InternalEvent for BufferEventsDropped {
             "buffer_id" => self.buffer_id.clone(),
             "stage" => self.idx.to_string()
         )
-        .set(u64_to_f64_safe(self.total_count));
+        .set(u64_to_f64_safe(self.count));
         gauge!(
             "buffer_byte_size",
             "buffer_id" => self.buffer_id,
             "stage" => self.idx.to_string()
         )
-        .set(u64_to_f64_safe(self.total_byte_size));
+        .set(u64_to_f64_safe(self.byte_size));
     }
 }