@@ -235,7 +235,8 @@ the total; a nonzero value that does not fall means an instance is hung, not a l
 ## Metrics
 
 `GET /metrics` on `--metrics HOST:PORT` returns Prometheus text (`selene_` prefix, content type
-`text/plain; version=0.0.4`); only that path is served.
+`text/plain; version=0.0.4`); only that path is served. Store series are built when scraped, on the store thread; if it
+does not answer within 1 s the previous store text is served.
 
 | Series | Meaning | Alert on |
 |---|---|---|
 
@@ -180,7 +180,6 @@ pub fn serve(config: Config, stop: Arc<AtomicBool>) -> Result<()> {
     }
     // Bind every listener before any thread starts, so a startup failure leaves no threads
     // and no locks behind; the guard below also removes the socket it creates.
-    let metrics_text = Arc::new(Mutex::new(String::new()));
     let metrics_address = config.metrics.map(|address| address.to_string());
     let metrics_listener = bind_metrics(metrics_address.as_deref())?;
     let network_listener = match config.listen {
@@ -211,12 +210,11 @@ pub fn serve(config: Config, stop: Arc<AtomicBool>) -> Result<()> {
     if let Some(listener) = metrics_listener {
         cleanup.metrics = Some(serve_metrics(
             listener,
-            metrics_text.clone(),
+            commands.clone(),
             pool_handle.shared.clone(),
             stop.clone(),
         ));
     }
-    let owner_metrics = metrics_text.clone();
     let region_error = Arc::new(Mutex::new(None));
     let owner_error = region_error.clone();
     let owner_stop = stop.clone();
@@ -253,7 +251,6 @@ pub fn serve(config: Config, stop: Arc<AtomicBool>) -> Result<()> {
                 }
             }
             store.pump();
-            *owner_metrics.lock().unwrap() = store.metrics_text();
         }
     }));
     let stop_notice = Arc::new(Notify::new());
@@ -454,11 +451,12 @@ fn bind_metrics(address: Option<&str>) -> Result<Option<TcpListener>> {
 
 fn serve_metrics(
     listener: TcpListener,
-    text: Arc<Mutex<String>>,
+    commands: tokio::sync::mpsc::Sender<StoreCommand>,
     pool: Arc<crate::pool::Shared>,
     stop: Arc<AtomicBool>,
 ) -> thread::JoinHandle<()> {
     thread::spawn(move || {
+        let mut store_text = String::new();
         while !stop.load(Ordering::Acquire) {
             match listener.accept() {
                 Ok((mut stream, _)) => {
@@ -468,7 +466,17 @@ fn serve_metrics(
                     let count = stream.read(&mut request).unwrap_or(0);
                     let (status, body) = if request[..count].starts_with(b"GET /metrics ") {
                         ("200 OK", {
-                            let mut body = text.lock().unwrap().clone();
+                            // The owner builds the store's text at scrape time; if it does
+                            // not answer within 1 s, the last text is served again.
+                            let (reply, text) = std::sync::mpsc::channel();
+                            if let Some(fresh) = commands
+                                .try_send(StoreCommand::Metrics { reply })
+                                .ok()
+                                .and_then(|()| text.recv_timeout(Duration::from_secs(1)).ok())
+                            {
+                                store_text = fresh;
+                            }
+                            let mut body = store_text.clone();
                             body.push_str(&pool.metrics.lock().unwrap());
                             body
                         })
 
@@ -12,7 +12,7 @@
 
 use crate::Key;
 use flare_selene::shared::Tier;
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeSet, HashMap};
 
 pub type InstanceId = [u8; 16];
 pub type Bucket = [u8; 16];
@@ -42,7 +42,7 @@ pub type EntryRef = (SourceId, Key, Tier);
 #[derive(Default)]
 pub struct ScopeIndex {
     sources: HashMap<SourceId, HashMap<(Key, Tier), Entry>>,
-    buckets: HashMap<Bucket, HashSet<EntryRef>>,
+    buckets: HashMap<Bucket, BTreeSet<EntryRef>>,
     entries: usize,
 }
 
@@ -119,14 +119,8 @@ impl ScopeIndex {
     }
 
     /// The entries whose bucket is `bucket`, in a stable order.
-    pub fn in_bucket(&self, bucket: &Bucket) -> Vec<EntryRef> {
-        let mut refs: Vec<EntryRef> = self
-            .buckets
-            .get(bucket)
-            .map(|set| set.iter().copied().collect())
-            .unwrap_or_default();
-        refs.sort_unstable();
-        refs
+    pub fn in_bucket(&self, bucket: &Bucket) -> impl Iterator<Item = EntryRef> + '_ {
+        self.buckets.get(bucket).into_iter().flatten().copied()
     }
 
     fn drop_bucket(&mut self, source: SourceId, entry: &Entry) {
@@ -257,7 +251,7 @@ mod tests {
         assert_eq!(index.get(SOURCE, entry.key, Tier::Dram).unwrap().bytes, 77);
         assert!(index.remove(SOURCE, entry.key, Tier::Dram));
         assert!(!index.remove(SOURCE, entry.key, Tier::Dram));
-        assert!(index.in_bucket(&[9; 16]).is_empty());
+        assert!(index.in_bucket(&[9; 16]).next().is_none());
     }
 
     #[test]
@@ -279,7 +273,7 @@ mod tests {
         index.upsert(SOURCE, entry(256, 2, Some((128, 1)), 2, Tier::Dram));
         index.replace(SOURCE, [entry(64, 7, None, 1, Tier::Dram)]);
         assert_eq!(index.len(), 1);
-        assert_eq!(index.in_bucket(&[9; 16]).len(), 1);
+        assert_eq!(index.in_bucket(&[9; 16]).count(), 1);
         assert_eq!(index.clear(SOURCE), 1);
         assert_eq!(index.len(), 0);
         assert!(index.sources.is_empty());