Fix CODE_STYLE.md violations and IN_FLIGHT_OTHER_SOURCE label bug

- Fix variable shadowing in __counter/gauge/histogram_get_or_register
  by renaming inner variables to recorder_counter/gauge/histogram
- Rename abbreviation `mi` to `metric_info` in __metric_extension! macro
- Add debug_assert for strictly ascending histogram bucket boundaries
- Add debug_assert for NaN in GaugeGuard::new/increment/decrement
- Document surprising GaugeGuard::decrement behavior with negative delta
- Fix IN_FLIGHT_OTHER_SOURCE using "pulsar_source" instead of
  "other_source" as its component label (copy-paste bug)

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: Mallets

quickwit/quickwit-common/src/metrics.rs

@@ -108,7 +108,7 @@ pub static IN_FLIGHT_PULSAR_SOURCE: LazyLock<Gauge> =
     LazyLock::new(|| in_flight_data_gauge("pulsar_source"));
 
 pub static IN_FLIGHT_OTHER_SOURCE: LazyLock<Gauge> =
-    LazyLock::new(|| in_flight_data_gauge("pulsar_source"));
+    LazyLock::new(|| in_flight_data_gauge("other_source"));
 
 fn in_flight_data_gauge(component: &'static str) -> Gauge {
     gauge!(parent: IN_FLIGHT_DATA_BYTES, "component" => component)

quickwit/quickwit-metrics/src/counter.rs

@@ -43,19 +43,17 @@ pub fn __counter_get_or_register(
         metrics::Metadata<'static>,
     ),
 ) -> Counter {
-    let inner = COUNTERS
+    let counter_arc = COUNTERS
         .entry(hash)
         .or_insert_with(|| {
             let (info, key, metadata) = build();
-            // Register with the installed recorder (e.g. Prometheus).
-            let inner =
+            let recorder_counter =
                 metrics::with_recorder(|recorder| recorder.register_counter(&key, &metadata));
-            let counter_inner = CounterInner::new(hash, info, key, inner);
-            Arc::new(counter_inner)
+            Arc::new(CounterInner::new(hash, info, key, recorder_counter))
         })
         .value()
         .clone(); // Arc::clone — cheap reference count bump.
-    Counter(inner)
+    Counter(counter_arc)
 }
 
 /// Internal storage for a single counter metric.

quickwit/quickwit-metrics/src/gauge.rs

@@ -44,18 +44,17 @@ pub fn __gauge_get_or_register(
         metrics::Metadata<'static>,
     ),
 ) -> Gauge {
-    let inner = GAUGES
+    let gauge_arc = GAUGES
         .entry(hash)
         .or_insert_with(|| {
             let (info, key, metadata) = build();
-            // Register with the installed recorder (e.g. Prometheus).
-            let inner = metrics::with_recorder(|recorder| recorder.register_gauge(&key, &metadata));
-            let gauge_inner = GaugeInner::new(hash, info, key, inner);
-            Arc::new(gauge_inner)
+            let recorder_gauge =
+                metrics::with_recorder(|recorder| recorder.register_gauge(&key, &metadata));
+            Arc::new(GaugeInner::new(hash, info, key, recorder_gauge))
         })
         .value()
         .clone(); // Arc::clone — cheap reference count bump.
-    Gauge(inner)
+    Gauge(gauge_arc)
 }
 
 /// Internal storage for a single gauge metric.
@@ -250,12 +249,20 @@ impl GaugeGuard {
     }
 
     /// Adds `delta` to the gauge and to the value this guard tracks.
+    ///
+    /// NOTE: if the cumulative effect of `increment` and `decrement` calls makes the
+    /// tracked delta negative, the guard's drop will effectively *increment*
+    /// the gauge (subtracting a negative value).
     pub fn increment(&self, delta: f64) {
         self.delta.fetch_add(delta, Ordering::Relaxed);
         self.gauge.increment(delta);
     }
 
     /// Subtracts `delta` from the gauge and from the value this guard tracks.
+    ///
+    /// NOTE: if the cumulative effect of `increment` and `decrement` calls makes the
+    /// tracked delta negative, the guard's drop will effectively *increment*
+    /// the gauge (subtracting a negative value).
     pub fn decrement(&self, delta: f64) {
         self.delta.fetch_sub(delta, Ordering::Relaxed);
         self.gauge.decrement(delta);

quickwit/quickwit-metrics/src/histogram.rs

@@ -58,19 +58,17 @@ pub fn __histogram_get_or_register(
         metrics::Metadata<'static>,
     ),
 ) -> Histogram {
-    let inner = HISTOGRAMS
+    let histogram_arc = HISTOGRAMS
         .entry(hash)
         .or_insert_with(|| {
             let (config, key, metadata) = build();
-            // Register with the installed recorder (e.g. Prometheus).
-            let inner =
+            let recorder_histogram =
                 metrics::with_recorder(|recorder| recorder.register_histogram(&key, &metadata));
-            let histogram_inner = HistogramInner::new(hash, config, key, inner);
-            Arc::new(histogram_inner)
+            Arc::new(HistogramInner::new(hash, config, key, recorder_histogram))
         })
         .value()
         .clone(); // Arc::clone — cheap reference count bump.
-    Histogram(inner)
+    Histogram(histogram_arc)
 }
 
 /// Internal storage for a single histogram metric.

quickwit/quickwit-metrics/src/inner.rs

@@ -240,10 +240,10 @@ macro_rules! __metric_extension {
                 all_labels.extend(parent_key.labels().cloned());
                 all_labels.extend($labels_iter);
 
-                let mi = $metric_info;
-                let key = $crate::__metrics::Key::from_parts(mi.key_name, all_labels);
+                let metric_info = $metric_info;
+                let key = $crate::__metrics::Key::from_parts(metric_info.key_name, all_labels);
 
-                ($parent.__info(), key, mi.metadata.clone())
+                ($parent.__info(), key, metric_info.metadata.clone())
             });
             *slot = Some((hash, metric.clone()));
             metric

quickwit/quickwit-metrics/src/lib.rs

@@ -381,7 +381,13 @@ pub fn metrics_info() -> impl Iterator<Item = &'static MetricInfo> {
 /// Use this to configure per-metric bucket boundaries on your exporter
 /// before any histogram is accessed.
 pub fn histogram_buckets() -> impl Iterator<Item = (&'static str, Vec<f64>)> {
-    inventory::iter::<HistogramConfig>
-        .into_iter()
-        .map(|c| (c.info.key_name, (c.buckets_fn)()))
+    inventory::iter::<HistogramConfig>.into_iter().map(|c| {
+        let buckets = (c.buckets_fn)();
+        debug_assert!(
+            buckets.is_sorted(),
+            "histogram buckets for `{}` must be sorted in strictly ascending order",
+            c.info.key_name,
+        );
+        (c.info.key_name, buckets)
+    })
 }