refactor(server): observe events for eps after ingesting all the events, not for each kind

server/src/api.rs

···
 use std::{
-    collections::VecDeque,
     fmt::Display,
     net::SocketAddr,
     ops::{Bound, Deref, RangeBounds},

server/src/db/mod.rs

···
     }
 
     pub fn ingest_events(&self, events: impl Iterator<Item = EventRecord>) -> AppResult<()> {
+        let mut seen_events = 0;
         for (key, chunk) in events.chunk_by(|event| event.nsid.clone()).into_iter() {
             let mut counts = self.get_count(&key)?;
-            let mut count = 0;
             self.ensure_handle(&key).queue(chunk.inspect(|e| {
                 // increment count
                 counts.last_seen = e.timestamp;
···
                 } else {
                     counts.count += 1;
                 }
-                count += 1;
+                seen_events += 1;
             }));
-            self.eps.observe(count);
             self.insert_count(&key, &counts)?;
             if self.event_broadcaster.receiver_count() > 0 {
                 let _ = self.event_broadcaster.send((key, counts));
             }
         }
+        self.eps.observe(seen_events);
         Ok(())
     }
 

server/src/main.rs

···
         move || {
             let mut buffer = Vec::new();
             loop {
-                let read = event_rx.blocking_recv_many(&mut buffer, 100);
+                let read = event_rx.blocking_recv_many(&mut buffer, 500);
                 if let Err(err) = db.ingest_events(buffer.drain(..)) {
                     tracing::error!("failed to ingest events: {}", err);
                 }