From 506829156784e87fd482b0b102540ea4a3c9f777 Mon Sep 17 00:00:00 2001 From: DanConwayDev Date: Fri, 9 Jan 2026 20:51:57 +0000 Subject: refactor(sync): parameterize rejected index metrics by event type Replace duplicate metrics methods (announcements vs states) with unified methods using IntGaugeVec/IntCounterVec with an event_type label: - update_rejected_hot_cache_size(event_type, size) - record_rejected_hot_cache_hit(event_type) - record_rejected_hot_cache_miss(event_type) - record_rejected_hot_cache_expired(event_type, count) - update_rejected_cold_index_size(event_type, size) - record_rejected_cold_index_expired(event_type, count) - record_rejected_invalidation(event_type, count) Prometheus labels remain separate (event_type="announcement" vs event_type="state") but implementation is now unified. Phase 4 of rejected events index refactoring. --- src/sync/metrics.rs | 379 ++++++++++++++++++++++++---------------------------- 1 file changed, 171 insertions(+), 208 deletions(-) (limited to 'src/sync') diff --git a/src/sync/metrics.rs b/src/sync/metrics.rs index 2ed983e..aacfa2c 100644 --- a/src/sync/metrics.rs +++ b/src/sync/metrics.rs @@ -41,37 +41,21 @@ pub struct SyncMetrics { /// Relays marked as dead relays_dead_total: IntGauge, - // === Rejected Announcements Index Metrics === - /// Current number of entries in hot cache - rejected_announcements_hot_cache_current: IntGauge, - /// Total hot cache hits (events re-processed from cache) - rejected_announcements_hot_cache_hits_total: IntCounter, - /// Total hot cache misses (events not in cache) - rejected_announcements_hot_cache_misses_total: IntCounter, - /// Total expired entries removed from hot cache - rejected_announcements_hot_cache_expired_total: IntCounter, - /// Current number of entries in cold index - rejected_announcements_cold_index_current: IntGauge, - /// Total cold index entries expired and removed - rejected_announcements_cold_index_expired_total: IntCounter, - /// Total invalidations (maintainer announcements invalidated) - rejected_announcements_invalidated_total: IntCounter, - - // === Rejected States Index Metrics === - /// Current number of state events in hot cache - rejected_states_hot_cache_current: IntGauge, - /// Total hot cache hits (state events re-processed from cache) - rejected_states_hot_cache_hits_total: IntCounter, - /// Total hot cache misses (state events not in cache) - rejected_states_hot_cache_misses_total: IntCounter, - /// Total expired state events removed from hot cache - rejected_states_hot_cache_expired_total: IntCounter, - /// Current number of state event entries in cold index - rejected_states_cold_index_current: IntGauge, - /// Total state event cold index entries expired and removed - rejected_states_cold_index_expired_total: IntCounter, - /// Total state event invalidations - rejected_states_invalidated_total: IntCounter, + // === Rejected Events Index Metrics (unified with event_type label) === + /// Current number of entries in hot cache (by event_type: announcement, state) + rejected_hot_cache_current: IntGaugeVec, + /// Total hot cache hits (by event_type: announcement, state) + rejected_hot_cache_hits_total: IntCounterVec, + /// Total hot cache misses (by event_type: announcement, state) + rejected_hot_cache_misses_total: IntCounterVec, + /// Total expired entries removed from hot cache (by event_type: announcement, state) + rejected_hot_cache_expired_total: IntCounterVec, + /// Current number of entries in cold index (by event_type: announcement, state) + rejected_cold_index_current: IntGaugeVec, + /// Total cold index entries expired and removed (by event_type: announcement, state) + rejected_cold_index_expired_total: IntCounterVec, + /// Total invalidations (by event_type: announcement, state) + rejected_invalidated_total: IntCounterVec, } impl SyncMetrics { @@ -145,99 +129,69 @@ impl SyncMetrics { ))?; registry.register(Box::new(relays_dead_total.clone()))?; - // Rejected announcements metrics - let rejected_announcements_hot_cache_current = IntGauge::with_opts(Opts::new( - "ngit_sync_rejected_announcements_hot_cache_current", - "Current number of entries in hot cache (full events, 2 min expiry)", - ))?; - registry.register(Box::new(rejected_announcements_hot_cache_current.clone()))?; - - let rejected_announcements_hot_cache_hits_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_announcements_hot_cache_hits_total", - "Total hot cache hits (events re-processed from cache)", - ))?; - registry.register(Box::new( - rejected_announcements_hot_cache_hits_total.clone(), - ))?; - - let rejected_announcements_hot_cache_misses_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_announcements_hot_cache_misses_total", - "Total hot cache misses (events not in cache when invalidated)", - ))?; - registry.register(Box::new( - rejected_announcements_hot_cache_misses_total.clone(), - ))?; - - let rejected_announcements_hot_cache_expired_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_announcements_hot_cache_expired_total", - "Total expired entries removed from hot cache", - ))?; - registry.register(Box::new( - rejected_announcements_hot_cache_expired_total.clone(), - ))?; - - let rejected_announcements_cold_index_current = IntGauge::with_opts(Opts::new( - "ngit_sync_rejected_announcements_cold_index_current", - "Current number of entries in cold index (metadata only, 7 day expiry)", - ))?; - registry.register(Box::new(rejected_announcements_cold_index_current.clone()))?; - - let rejected_announcements_cold_index_expired_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_announcements_cold_index_expired_total", - "Total expired entries removed from cold index", - ))?; - registry.register(Box::new( - rejected_announcements_cold_index_expired_total.clone(), - ))?; - - let rejected_announcements_invalidated_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_announcements_invalidated_total", - "Total invalidations (maintainer announcements invalidated when owner accepted)", - ))?; - registry.register(Box::new(rejected_announcements_invalidated_total.clone()))?; - - // Rejected states metrics - let rejected_states_hot_cache_current = IntGauge::with_opts(Opts::new( - "ngit_sync_rejected_states_hot_cache_current", - "Current number of state events in hot cache (full events, 2 min expiry)", - ))?; - registry.register(Box::new(rejected_states_hot_cache_current.clone()))?; + // Rejected events metrics (unified with event_type label) + let rejected_hot_cache_current = IntGaugeVec::new( + Opts::new( + "ngit_sync_rejected_hot_cache_current", + "Current number of entries in hot cache (full events, 2 min expiry)", + ), + &["event_type"], + )?; + registry.register(Box::new(rejected_hot_cache_current.clone()))?; - let rejected_states_hot_cache_hits_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_states_hot_cache_hits_total", - "Total hot cache hits (state events re-processed from cache)", - ))?; - registry.register(Box::new(rejected_states_hot_cache_hits_total.clone()))?; + let rejected_hot_cache_hits_total = IntCounterVec::new( + Opts::new( + "ngit_sync_rejected_hot_cache_hits_total", + "Total hot cache hits (events re-processed from cache)", + ), + &["event_type"], + )?; + registry.register(Box::new(rejected_hot_cache_hits_total.clone()))?; - let rejected_states_hot_cache_misses_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_states_hot_cache_misses_total", - "Total hot cache misses (state events not in cache when invalidated)", - ))?; - registry.register(Box::new(rejected_states_hot_cache_misses_total.clone()))?; + let rejected_hot_cache_misses_total = IntCounterVec::new( + Opts::new( + "ngit_sync_rejected_hot_cache_misses_total", + "Total hot cache misses (events not in cache when invalidated)", + ), + &["event_type"], + )?; + registry.register(Box::new(rejected_hot_cache_misses_total.clone()))?; - let rejected_states_hot_cache_expired_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_states_hot_cache_expired_total", - "Total expired state events removed from hot cache", - ))?; - registry.register(Box::new(rejected_states_hot_cache_expired_total.clone()))?; + let rejected_hot_cache_expired_total = IntCounterVec::new( + Opts::new( + "ngit_sync_rejected_hot_cache_expired_total", + "Total expired entries removed from hot cache", + ), + &["event_type"], + )?; + registry.register(Box::new(rejected_hot_cache_expired_total.clone()))?; - let rejected_states_cold_index_current = IntGauge::with_opts(Opts::new( - "ngit_sync_rejected_states_cold_index_current", - "Current number of state event entries in cold index (metadata only, 7 day expiry)", - ))?; - registry.register(Box::new(rejected_states_cold_index_current.clone()))?; + let rejected_cold_index_current = IntGaugeVec::new( + Opts::new( + "ngit_sync_rejected_cold_index_current", + "Current number of entries in cold index (metadata only, 7 day expiry)", + ), + &["event_type"], + )?; + registry.register(Box::new(rejected_cold_index_current.clone()))?; - let rejected_states_cold_index_expired_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_states_cold_index_expired_total", - "Total state event cold index entries expired and removed", - ))?; - registry.register(Box::new(rejected_states_cold_index_expired_total.clone()))?; + let rejected_cold_index_expired_total = IntCounterVec::new( + Opts::new( + "ngit_sync_rejected_cold_index_expired_total", + "Total expired entries removed from cold index", + ), + &["event_type"], + )?; + registry.register(Box::new(rejected_cold_index_expired_total.clone()))?; - let rejected_states_invalidated_total = IntCounter::with_opts(Opts::new( - "ngit_sync_rejected_states_invalidated_total", - "Total state event invalidations (when announcements accepted)", - ))?; - registry.register(Box::new(rejected_states_invalidated_total.clone()))?; + let rejected_invalidated_total = IntCounterVec::new( + Opts::new( + "ngit_sync_rejected_invalidated_total", + "Total invalidations (events invalidated when dependencies resolved)", + ), + &["event_type"], + )?; + registry.register(Box::new(rejected_invalidated_total.clone()))?; Ok(Self { relay_connected, @@ -248,20 +202,13 @@ impl SyncMetrics { relays_tracked_total, relays_connected_total, relays_dead_total, - rejected_announcements_hot_cache_current, - rejected_announcements_hot_cache_hits_total, - rejected_announcements_hot_cache_misses_total, - rejected_announcements_hot_cache_expired_total, - rejected_announcements_cold_index_current, - rejected_announcements_cold_index_expired_total, - rejected_announcements_invalidated_total, - rejected_states_hot_cache_current, - rejected_states_hot_cache_hits_total, - rejected_states_hot_cache_misses_total, - rejected_states_hot_cache_expired_total, - rejected_states_cold_index_current, - rejected_states_cold_index_expired_total, - rejected_states_invalidated_total, + rejected_hot_cache_current, + rejected_hot_cache_hits_total, + rejected_hot_cache_misses_total, + rejected_hot_cache_expired_total, + rejected_cold_index_current, + rejected_cold_index_expired_total, + rejected_invalidated_total, }) } @@ -434,86 +381,89 @@ impl SyncMetrics { self.relays_dead_total.get() } - // === Rejected Announcements Recording Methods === + // === Rejected Events Recording Methods (unified with event_type parameter) === - /// Update hot cache current size gauge. - pub fn update_hot_cache_size(&self, size: usize) { - self.rejected_announcements_hot_cache_current + /// Update hot cache current size gauge for a specific event type. + /// + /// # Arguments + /// + /// * `event_type` - Either "announcement" or "state" + /// * `size` - Current number of entries + pub fn update_rejected_hot_cache_size(&self, event_type: &str, size: usize) { + self.rejected_hot_cache_current + .with_label_values(&[event_type]) .set(size as i64); } - /// Record hot cache hit (event re-processed from cache). - pub fn record_hot_cache_hit(&self) { - self.rejected_announcements_hot_cache_hits_total.inc(); + /// Record hot cache hit for a specific event type. + /// + /// # Arguments + /// + /// * `event_type` - Either "announcement" or "state" + pub fn record_rejected_hot_cache_hit(&self, event_type: &str) { + self.rejected_hot_cache_hits_total + .with_label_values(&[event_type]) + .inc(); } - /// Record hot cache miss (event not in cache when invalidated). - pub fn record_hot_cache_miss(&self) { - self.rejected_announcements_hot_cache_misses_total.inc(); + /// Record hot cache miss for a specific event type. + /// + /// # Arguments + /// + /// * `event_type` - Either "announcement" or "state" + pub fn record_rejected_hot_cache_miss(&self, event_type: &str) { + self.rejected_hot_cache_misses_total + .with_label_values(&[event_type]) + .inc(); } - /// Record hot cache expired entries. - pub fn record_hot_cache_expired(&self, count: usize) { - self.rejected_announcements_hot_cache_expired_total + /// Record hot cache expired entries for a specific event type. + /// + /// # Arguments + /// + /// * `event_type` - Either "announcement" or "state" + /// * `count` - Number of expired entries + pub fn record_rejected_hot_cache_expired(&self, event_type: &str, count: usize) { + self.rejected_hot_cache_expired_total + .with_label_values(&[event_type]) .inc_by(count as u64); } - /// Update cold index current size gauge. - pub fn update_cold_index_size(&self, size: usize) { - self.rejected_announcements_cold_index_current + /// Update cold index current size gauge for a specific event type. + /// + /// # Arguments + /// + /// * `event_type` - Either "announcement" or "state" + /// * `size` - Current number of entries + pub fn update_rejected_cold_index_size(&self, event_type: &str, size: usize) { + self.rejected_cold_index_current + .with_label_values(&[event_type]) .set(size as i64); } - /// Record cold index expired entries. - pub fn record_cold_index_expired(&self, count: usize) { - self.rejected_announcements_cold_index_expired_total - .inc_by(count as u64); - } - - /// Record invalidation (maintainer announcement invalidated). - pub fn record_invalidation(&self, count: usize) { - self.rejected_announcements_invalidated_total - .inc_by(count as u64); - } - - // === Rejected States Recording Methods === - - /// Update state events hot cache current size gauge. - pub fn update_states_hot_cache_size(&self, size: usize) { - self.rejected_states_hot_cache_current.set(size as i64); - } - - /// Record state event hot cache hit (event re-processed from cache). - pub fn record_states_hot_cache_hit(&self) { - self.rejected_states_hot_cache_hits_total.inc(); - } - - /// Record state event hot cache miss (event not in cache when invalidated). - pub fn record_states_hot_cache_miss(&self) { - self.rejected_states_hot_cache_misses_total.inc(); - } - - /// Record state event hot cache expired entries. - pub fn record_states_hot_cache_expired(&self, count: usize) { - self.rejected_states_hot_cache_expired_total + /// Record cold index expired entries for a specific event type. + /// + /// # Arguments + /// + /// * `event_type` - Either "announcement" or "state" + /// * `count` - Number of expired entries + pub fn record_rejected_cold_index_expired(&self, event_type: &str, count: usize) { + self.rejected_cold_index_expired_total + .with_label_values(&[event_type]) .inc_by(count as u64); } - /// Update state events cold index current size gauge. - pub fn update_states_cold_index_size(&self, size: usize) { - self.rejected_states_cold_index_current.set(size as i64); - } - - /// Record state event cold index expired entries. - pub fn record_states_cold_index_expired(&self, count: usize) { - self.rejected_states_cold_index_expired_total + /// Record invalidation for a specific event type. + /// + /// # Arguments + /// + /// * `event_type` - Either "announcement" or "state" + /// * `count` - Number of invalidated entries + pub fn record_rejected_invalidation(&self, event_type: &str, count: usize) { + self.rejected_invalidated_total + .with_label_values(&[event_type]) .inc_by(count as u64); } - - /// Record state event invalidation. - pub fn record_states_invalidation(&self, count: usize) { - self.rejected_states_invalidated_total.inc_by(count as u64); - } } #[cfg(test)] @@ -618,23 +568,36 @@ mod tests { } #[test] - fn test_rejected_announcements_metrics() { + fn test_rejected_events_metrics() { let registry = create_test_registry(); let metrics = SyncMetrics::register(®istry).unwrap(); - // Test hot cache metrics - metrics.update_hot_cache_size(10); - metrics.record_hot_cache_hit(); - metrics.record_hot_cache_hit(); - metrics.record_hot_cache_miss(); - metrics.record_hot_cache_expired(5); - - // Test cold index metrics - metrics.update_cold_index_size(100); - metrics.record_cold_index_expired(10); - - // Test invalidation metrics - metrics.record_invalidation(3); - metrics.record_invalidation(2); + // Test announcement hot cache metrics + metrics.update_rejected_hot_cache_size("announcement", 10); + metrics.record_rejected_hot_cache_hit("announcement"); + metrics.record_rejected_hot_cache_hit("announcement"); + metrics.record_rejected_hot_cache_miss("announcement"); + metrics.record_rejected_hot_cache_expired("announcement", 5); + + // Test announcement cold index metrics + metrics.update_rejected_cold_index_size("announcement", 100); + metrics.record_rejected_cold_index_expired("announcement", 10); + + // Test announcement invalidation metrics + metrics.record_rejected_invalidation("announcement", 3); + metrics.record_rejected_invalidation("announcement", 2); + + // Test state hot cache metrics + metrics.update_rejected_hot_cache_size("state", 20); + metrics.record_rejected_hot_cache_hit("state"); + metrics.record_rejected_hot_cache_miss("state"); + metrics.record_rejected_hot_cache_expired("state", 3); + + // Test state cold index metrics + metrics.update_rejected_cold_index_size("state", 50); + metrics.record_rejected_cold_index_expired("state", 5); + + // Test state invalidation metrics + metrics.record_rejected_invalidation("state", 1); } } -- cgit v1.2.3