sentiero 1.0.0.alpha1

data/lib/sentiero/analytics/frustration_analyzer.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require_relative "analyzer"
+require_relative "frustration/detectors"
+
+module Sentiero
+  module Analytics
+    # Cross-session frustration signals per page URL: rage clicks (bursts at
+    # the same spot) and dead clicks (clicks the page never responds to), plus
+    # top rage-clicked elements and per-incident replay links.
+    #
+    # Detection itself lives in Frustration::Detectors (pure Ruby ports of the
+    # JS detectors, frontend/src/dashboard/frustration.js, pinned by ported
+    # tests so the two can't drift). Over the detectors' raw dead clicks this
+    # class layers cross-session aggregation and a de-noising pass: an
+    # app-level custom event in the dead window counts as a page response; the
+    # final click of a segment navigated away from is withdrawn; an
+    # error-coincident dead click is kept and tagged kind: "error".
+    class FrustrationAnalyzer < Analyzer
+      # Custom-event tag carrying the clicked element's CSS selector.
+      CLICK_TAG = "__click"
+
+      # Recorder-internal annotation prefix and the browser JS-error tag;
+      # neither proves the page responded to a click.
+      INTERNAL_TAG_PREFIX = "__"
+      ERROR_TAG = "error"
+
+      # Max ms a "__click" annotation may sit from a rage cluster's first
+      # click and still be attributed to it.
+      NEAREST_CLICK_TOLERANCE_MS = 500
+
+      # Accumulation caps during the scan (sessions scan newest-first).
+      MAX_URLS = 200
+      MAX_SELECTORS_PER_URL = 200
+      MAX_INCIDENTS_PER_URL = 20
+      TOP_SELECTORS_LIMIT = 10
+
+      # Stable entry point for callers outside this class (EngagementAnalyzer,
+      # PageReportAnalyzer) that only need raw detection, not the cross-session
+      # aggregation below.
+      def self.detect_frustration_events(events) = Frustration::Detectors.detect_frustration_events(events)
+
+      # Detectors run over the FULL window (their response semantics span page
+      # boundaries by design); each incident is then attributed to the page
+      # segment its click happened on.
+      def analyze(limit: nil, since: nil, until_time: nil)
+        pages = {}
+        accumulation_capped = false
+
+        _scanned, hit_cap = scan_sessions(limit: limit, since: since, until_time: until_time) do |summary, window_id, events|
+          incidents = Frustration::Detectors.detect_frustration_events(events)
+          next if incidents.empty?
+
+          segments = page_segments(events)
+          incidents = refine_incidents(incidents, segments)
+          next if incidents.empty?
+
+          annotations = click_annotations(events)
+
+          incidents.each do |incident|
+            page = page_for(pages, incident[:url])
+            unless page
+              accumulation_capped = true
+              next
+            end
+
+            accumulation_capped = true unless record_incident(page, incident, summary[:session_id], window_id, annotations)
+            page[:session_ids][summary[:session_id]] = true
+          end
+        end
+
+        {
+          pages: pages.transform_values { |page| summarize(page) },
+          was_truncated: accumulation_capped || hit_cap
+        }
+      end
+
+      private
+
+      def page_segments(events)
+        segments = []
+        each_page_segment(events) do |url, segment, _anchor|
+          segments << [url, segment]
+        end
+        segments
+      end
+
+      # Attributes each incident to its click's segment and de-noises dead clicks
+      # (class-comment rules). Object identity (not timestamp) locates the segment,
+      # avoiding mis-attribution at a same-millisecond Meta boundary. Drops
+      # incidents on URL-less segments or withdrawn by the de-noise rules.
+      def refine_incidents(incidents, segments)
+        incidents.filter_map do |incident|
+          index = segments.index { |(_url, segment)| segment.any? { |e| e.equal?(incident[:event]) } }
+          url = index && segments[index][0]
+          next nil unless url
+
+          kind = nil
+          if incident[:subtype] == "dead_click"
+            segment = segments[index][1]
+            next nil if custom_response?(segment, incident[:timestamp])
+
+            if error_coincident?(segment, incident[:timestamp])
+              kind = "error"
+            elsif navigated_away_final_click?(segments, index, incident[:event])
+              next nil
+            end
+          end
+
+          incident.merge(url: url, kind: kind)
+        end
+      end
+
+      # An app-level custom event in the dead window means the page reacted
+      # (the pure detectors only see META/mutation/input).
+      def custom_response?(segment, click_ts)
+        any_custom_in_window?(segment, click_ts) do |tag|
+          !tag.start_with?(INTERNAL_TAG_PREFIX) && tag != ERROR_TAG
+        end
+      end
+
+      def error_coincident?(segment, click_ts)
+        any_custom_in_window?(segment, click_ts) { |tag| tag == ERROR_TAG }
+      end
+
+      # Any CUSTOM event whose tag satisfies the block within [click_ts, +DEAD_WINDOW_MS].
+      # Same-tick INclusive: the recorder emits navigation/error customs in the same
+      # tick as the native click, which the detectors' strictly-after rule would miss.
+      def any_custom_in_window?(segment, click_ts)
+        deadline = click_ts + Frustration::Detectors::DEAD_WINDOW_MS
+        segment.any? do |event|
+          next false unless event["type"] == CUSTOM
+
+          ts = event["timestamp"]
+          next false unless ts.is_a?(Numeric) && ts >= click_ts && ts <= deadline
+
+          tag = event.dig("data", "tag")
+          tag.is_a?(String) && yield(tag)
+        end
+      end
+
+      # The last click of a segment that's navigated away from likely CAUSED a
+      # navigation slower than the dead window, so its dead verdict is withdrawn.
+      # The window's FINAL segment is exempt: a window that just ends proves no
+      # navigation, and the inert-button bounce is the signal this page exists for.
+      def navigated_away_final_click?(segments, index, event)
+        return false if index >= segments.size - 1
+
+        # Reuse the detectors' click? so "last click" can't drift from theirs.
+        last_click = segments[index][1].reverse_each.find { |e| Frustration::Detectors.click?(e) }
+        last_click.equal?(event)
+      end
+
+      # Page accumulator for a URL, or nil when the URL-row cap is full.
+      def page_for(pages, url)
+        bounded_fetch(pages, url, MAX_URLS) do
+          {rage_count: 0, dead_count: 0, session_ids: {}, selectors: Hash.new(0), incidents: []}
+        end
+      end
+
+      # [timestamp, selector] pairs from the window's "__click" annotations.
+      def click_annotations(events)
+        events.filter_map do |event|
+          next unless event["type"] == CUSTOM
+          data = event["data"]
+          next unless data.is_a?(Hash) && data["tag"] == CLICK_TAG
+
+          selector = data.dig("payload", "selector")
+          next unless selector.is_a?(String) && !selector.empty?
+          next unless event["timestamp"].is_a?(Numeric)
+
+          [event["timestamp"], selector]
+        end
+      end
+
+      # Returns false when the per-URL selector cap swallowed a new selector (the
+      # only lossy path — the incident-row cap is a display bound, counts stay complete).
+      def record_incident(page, incident, session_id, window_id, annotations)
+        selector = nil
+        selector_capped = false
+
+        if incident[:subtype] == "rage_click"
+          page[:rage_count] += 1
+          selector = nearest_selector(annotations, incident[:timestamp])
+          if selector
+            if page[:selectors].key?(selector) || page[:selectors].size < MAX_SELECTORS_PER_URL
+              page[:selectors][selector] += 1
+            else
+              selector_capped = true
+            end
+          end
+        else
+          page[:dead_count] += 1
+        end
+
+        if page[:incidents].size < MAX_INCIDENTS_PER_URL
+          page[:incidents] << {
+            subtype: incident[:subtype],
+            session_id: session_id,
+            window_id: window_id,
+            offset_ms: [incident[:offset], 0].max.round,
+            count: incident[:count],
+            selector: selector,
+            kind: incident[:kind]
+          }
+        end
+
+        !selector_capped
+      end
+
+      # Selector of the "__click" annotation nearest timestamp within
+      # NEAREST_CLICK_TOLERANCE_MS; nil when nothing is close enough.
+      def nearest_selector(annotations, timestamp)
+        nearest = annotations.min_by { |(ts, _selector)| (ts - timestamp).abs }
+        return nil unless nearest
+        ((nearest[0] - timestamp).abs <= NEAREST_CLICK_TOLERANCE_MS) ? nearest[1] : nil
+      end
+
+      def summarize(page)
+        {
+          rage_count: page[:rage_count],
+          dead_count: page[:dead_count],
+          sessions_affected: page[:session_ids].size,
+          top_selectors: top_selectors(page[:selectors]),
+          incidents: page[:incidents]
+        }
+      end
+
+      def top_selectors(selectors)
+        top_counts(selectors, limit: TOP_SELECTORS_LIMIT)
+          .map { |selector, count| {selector: selector, count: count} }
+      end
+    end
+  end
+end

data/lib/sentiero/analytics/funnel_analyzer.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative "analyzer"
+
+module Sentiero
+  module Analytics
+    # Custom-event funnel: ordered step conversion across sessions. A session
+    # reaches step N+1 only when an event with that tag occurs strictly after
+    # the step-N match. Greedy-earliest chain matching is optimal for subsequence
+    # reachability, so "how far did this session get" is exact.
+    class FunnelAnalyzer < Analyzer
+      # Excluded as a funnel step; has its own ErrorDiscovery surface.
+      ERROR_TAG = "error"
+
+      # Prefix of recorder-internal annotation tags (__perf, __click, ...).
+      INTERNAL_TAG_PREFIX = "__"
+
+      MAX_STEPS = 3
+
+      MAX_TAGS = 200
+
+      # Bounds per-session memory.
+      MAX_STEP_EVENTS_PER_SESSION = 100
+
+      MAX_EXAMPLES_PER_STEP = 10
+
+      class << self
+        def internal_tag?(tag)
+          !tag.is_a?(String) || tag.empty? || tag.start_with?(INTERNAL_TAG_PREFIX) || tag == ERROR_TAG
+        end
+
+        def usable_steps(tags)
+          Array(tags).reject { |tag| internal_tag?(tag) }.first(MAX_STEPS)
+        end
+      end
+
+      # Fewer than 2 usable steps yields steps: [] but still collects vocabulary.
+      def analyze(steps = [], limit: nil, since: nil, until_time: nil)
+        steps = self.class.usable_steps(steps)
+        steps = [] if steps.size < 2
+        step_set = steps.uniq
+
+        tags = {}
+        sessions = {}
+        accumulation_capped = false
+
+        _scanned, hit_cap = scan_sessions(limit: limit, since: since, until_time: until_time) do |summary, window_id, events|
+          session_id = summary[:session_id]
+
+          anchor = events.first&.fetch("timestamp", nil)
+          events.each do |event|
+            tag = custom_tag(event)
+            next unless tag
+
+            accumulation_capped = true unless tally_tag(tags, tag)
+            next if steps.empty? || !step_set.include?(tag)
+            next unless event["timestamp"].is_a?(Numeric)
+
+            entries = sessions[session_id] ||= []
+            if entries.size >= MAX_STEP_EVENTS_PER_SESSION
+              accumulation_capped = true
+              next
+            end
+
+            entries << {
+              tag: tag,
+              timestamp: event["timestamp"],
+              window_id: window_id,
+              offset_ms: offset_ms(anchor, event["timestamp"])
+            }
+          end
+        end
+
+        {
+          tags: tags.keys.sort,
+          steps: summarize_steps(steps, sessions),
+          was_truncated: accumulation_capped || hit_cap
+        }
+      end
+
+      private
+
+      def custom_tag(event)
+        return nil unless event.is_a?(Hash) && event["type"] == CUSTOM
+        data = event["data"]
+        return nil unless data.is_a?(Hash)
+        tag = data["tag"]
+        self.class.internal_tag?(tag) ? nil : tag
+      end
+
+      # Returns false for a new tag past MAX_TAGS (signals truncation).
+      def tally_tag(tags, tag)
+        return true if tags.key?(tag)
+        return false if tags.size >= MAX_TAGS
+        tags[tag] = true
+        true
+      end
+
+      def summarize_steps(steps, sessions)
+        return [] if steps.empty?
+
+        counts = Array.new(steps.size, 0)
+        inter_times = Array.new(steps.size) { [] }
+        examples = Array.new(steps.size) { [] }
+
+        sessions.each do |session_id, entries|
+          matches = chain(steps, entries)
+          next if matches.empty?
+
+          reached = matches.size
+          (0...reached).each { |i| counts[i] += 1 }
+          (1...reached).each { |i| inter_times[i] << matches[i][:timestamp] - matches[i - 1][:timestamp] }
+
+          next unless reached < steps.size # converted sessions never drop off
+
+          step_examples = examples[reached - 1]
+          if step_examples.size < MAX_EXAMPLES_PER_STEP
+            last = matches[reached - 1]
+            step_examples << {session_id: session_id, window_id: last[:window_id], offset_ms: last[:offset_ms]}
+          end
+        end
+
+        step_one = counts[0]
+        steps.each_with_index.map do |tag, i|
+          {
+            tag: tag,
+            sessions: counts[i],
+            conversion_pct: step_one.zero? ? nil : (counts[i].to_f / step_one * 100).round(1),
+            median_ms_from_previous: i.zero? ? nil : median(inter_times[i]),
+            drop_off_examples: examples[i]
+          }
+        end
+      end
+
+      # Greedy earliest chain over time-sorted step events: an event matches when
+      # its tag is the next pending step and its timestamp is strictly after the
+      # previous match.
+      def chain(steps, entries)
+        matches = []
+        last_ts = nil
+
+        entries.sort_by { |entry| entry[:timestamp] }.each do |entry|
+          break if matches.size >= steps.size
+          next unless entry[:tag] == steps[matches.size]
+          next unless last_ts.nil? || entry[:timestamp] > last_ts
+
+          matches << entry
+          last_ts = entry[:timestamp]
+        end
+
+        matches
+      end
+
+      def median(values)
+        return nil if values.empty?
+        percentile(values.sort, 50)
+      end
+    end
+  end
+end

data/lib/sentiero/analytics/heatmap_analyzer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "analyzer"
+require_relative "collectors/click_collector"
+
+module Sentiero
+  module Analytics
+    # Aggregates click coordinates for a single page URL into a normalized density
+    # grid plus a most-clicked-elements table. The per-segment density math lives
+    # in ClickCollector (shared with PageReportAnalyzer).
+    class HeatmapAnalyzer < Analyzer
+      CLICK_TAG = ClickCollector::CLICK_TAG
+      GRID_SIZE = ClickCollector::GRID_SIZE
+
+      TOP_ELEMENTS_LIMIT = 20
+      MAX_URLS = 200
+
+      # Clicks are attributed per page segment (Meta-href boundaries).
+      def analyze(target_url, limit: nil, since: nil, until_time: nil)
+        clicks = ClickCollector.new
+        representative = nil
+
+        _scanned, hit_cap = scan_sessions(limit: limit, since: since, until_time: until_time) do |summary, window_id, events|
+          session_id = summary[:session_id]
+
+          each_page_segment(events) do |url, segment, _anchor|
+            next unless url == target_url
+
+            added = clicks.collect(segment)
+            representative ||= {session_id: session_id, window_id: window_id} unless added.nil?
+          end
+        end
+
+        {
+          clicks_by_bucket: clicks.buckets,
+          top_elements: top_elements(clicks.selectors),
+          total_clicks: clicks.total,
+          representative_window: representative,
+          was_truncated: hit_cap
+        }
+      end
+
+      def build_heatmap_table(since: nil, until_time: nil)
+        selectors_by_url = {}
+
+        scan_sessions(since: since, until_time: until_time) do |_summary, _window_id, events|
+          each_page_segment(events) do |url, segment, _anchor|
+            next unless url
+
+            selectors = selectors_by_url[url]
+            if selectors.nil?
+              next if selectors_by_url.size >= MAX_URLS
+              selectors = selectors_by_url[url] = Hash.new(0)
+            end
+            segment.each { |event| tally_selector(selectors, event) }
+          end
+        end
+
+        selectors_by_url
+          .sort_by { |url, _selectors| url }
+          .to_h { |url, selectors| [url, top_elements(selectors)] }
+      end
+
+      def recorded_urls
+        urls = {}
+
+        scan_sessions do |_summary, _window_id, events|
+          each_page_segment(events) do |url, _segment, _anchor|
+            urls[url] = true if url && (urls.key?(url) || urls.size < MAX_URLS)
+          end
+        end
+
+        urls.keys
+      end
+
+      private
+
+      def tally_selector(selectors, event)
+        return unless event["type"] == CUSTOM
+        data = event["data"]
+        return unless data.is_a?(Hash) && data["tag"] == CLICK_TAG
+
+        selector = data.dig("payload", "selector")
+        selectors[selector] += 1 if selector.is_a?(String) && !selector.empty?
+      end
+
+      def top_elements(selectors)
+        top_counts(selectors, limit: TOP_ELEMENTS_LIMIT)
+          .map { |selector, count| {selector: selector, count: count} }
+      end
+    end
+  end
+end

data/lib/sentiero/analytics/page_report_analyzer.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative "analyzer"
+require_relative "frustration_analyzer"
+require_relative "collectors/click_collector"
+require_relative "collectors/scroll_collector"
+require_relative "collectors/vitals_collector"
+require_relative "collectors/error_collector"
+require_relative "collectors/custom_tag_collector"
+require_relative "collectors/form_collector"
+require_relative "collectors/frustration_collector"
+
+module Sentiero
+  module Analytics
+    # Per-URL drill-down: composes the suite's metrics (heatmap, scroll, forms,
+    # vitals, frustration, errors, custom tags) for one URL into one report via
+    # ONE bounded Store#each_session_events scan. Per-segment math lives in
+    # shared Collectors::. Frustration is the exception: only detection is shared
+    # (FrustrationAnalyzer.detect_frustration_events); the cross-session
+    # aggregation differs, so this URL's attribution uses FrustrationCollector.
+    class PageReportAnalyzer < Analyzer
+      # Output bounds — each caps a collector (flips #capped on hit).
+      MAX_SELECTORS = 200
+      MAX_SAMPLES_PER_METRIC = 2000
+      MAX_ERROR_GROUPS = 200
+      MAX_ERROR_OCCURRENCES = 50
+      MAX_CUSTOM_TAGS = 200
+      MAX_FIELDS = 500
+
+      # Display limits.
+      TOP_ELEMENTS_LIMIT = 20
+      TOP_SELECTORS_LIMIT = 10
+
+      # since/until_time are epoch seconds. Every result key is always present.
+      def analyze(target_url, limit: nil, since: nil, until_time: nil)
+        acc = new_accumulator
+
+        _scanned, hit_cap = scan_sessions(limit: limit, since: since, until_time: until_time) do |summary, window_id, events|
+          session_id = summary[:session_id]
+
+          # Detect over the FULL window: frustration semantics span page
+          # boundaries. FrustrationCollector then attributes each incident to a
+          # segment by object identity.
+          frustration = FrustrationAnalyzer.detect_frustration_events(events)
+
+          segment_index = 0
+          last_index = nil
+          first_was_target = false
+          target_segments = 0
+
+          each_page_segment(events) do |url, segment, anchor|
+            matches = url == target_url
+            first_was_target = true if segment_index.zero? && matches
+            last_index = segment_index if matches
+            segment_index += 1
+
+            next unless matches
+
+            target_segments += 1
+            acc[:page_views] += 1
+            acc[:sessions][session_id] = true
+
+            collect_time_on_page(acc, segment)
+            collect_heatmap(acc, segment, session_id, window_id)
+            acc[:vitals].collect(segment, session_id: session_id, window_id: window_id, anchor: anchor)
+            acc[:errors].collect(segment, session_id: session_id, window_id: window_id, anchor: anchor)
+            acc[:custom_tags].collect(segment)
+            acc[:forms].collect(session_id, url, segment)
+            acc[:scroll].observe(target_url, segment)
+            acc[:frustration].collect(frustration, segment)
+          end
+
+          # entry/exit/bounce decided once per window from the segment order.
+          if target_segments.positive?
+            acc[:windows_on_page] += 1
+            acc[:entries] += 1 if first_was_target
+            acc[:exits] += 1 if last_index == segment_index - 1
+            acc[:bounces] += 1 if segment_index == 1 && first_was_target
+          end
+
+          # One scroll sample per (session, window): deepest wins.
+          acc[:scroll].flush_window
+        end
+
+        build_result(target_url, acc, hit_cap)
+      end
+
+      private
+
+      def new_accumulator
+        {
+          page_views: 0,
+          sessions: {},
+          dwell_samples: [],
+          windows_on_page: 0,
+          entries: 0,
+          exits: 0,
+          bounces: 0,
+          representative: nil,
+          clicks: ClickCollector.new(max_selectors: MAX_SELECTORS),
+          scroll: ScrollCollector.new,
+          vitals: VitalsCollector.new(max_samples: MAX_SAMPLES_PER_METRIC),
+          errors: ErrorCollector.new(max_groups: MAX_ERROR_GROUPS, max_occurrences: MAX_ERROR_OCCURRENCES),
+          custom_tags: CustomTagCollector.new(max_tags: MAX_CUSTOM_TAGS),
+          forms: FormCollector.new(max_fields: MAX_FIELDS),
+          frustration: FrustrationCollector.new(max_selectors: MAX_SELECTORS)
+        }
+      end
+
+      # An A→B→A revisit yields TWO target segments, hence TWO dwell samples —
+      # intended ("time on page per visit").
+      def collect_time_on_page(acc, segment)
+        timestamps = segment.filter_map { |e| e["timestamp"] if e["timestamp"].is_a?(Numeric) }
+        return if timestamps.size < 2
+        acc[:dwell_samples] << (timestamps.max - timestamps.min)
+      end
+
+      # A segment with no valid Meta width/height contributes zero clicks
+      # (collect returns nil) and never becomes the representative window.
+      def collect_heatmap(acc, segment, session_id, window_id)
+        added = acc[:clicks].collect(segment)
+        acc[:representative] ||= {session_id: session_id, window_id: window_id} unless added.nil?
+      end
+
+      def build_result(target_url, acc, hit_cap)
+        collectors = [acc[:clicks], acc[:scroll], acc[:vitals], acc[:errors], acc[:custom_tags], acc[:forms], acc[:frustration]]
+        {
+          url: target_url,
+          sessions: acc[:sessions].size,
+          page_views: acc[:page_views],
+          time_on_page: summarize_time_on_page(acc[:dwell_samples]),
+          entry_exit: {
+            entries: acc[:entries],
+            exits: acc[:exits],
+            bounce_rate: acc[:entries].zero? ? 0.0 : acc[:bounces].to_f / acc[:entries],
+            windows_on_page: acc[:windows_on_page]
+          },
+          heatmap: {
+            top_elements: top_selectors(acc[:clicks].selectors, TOP_ELEMENTS_LIMIT),
+            total_clicks: acc[:clicks].total,
+            representative_window: acc[:representative]
+          },
+          scroll: acc[:scroll].summarize(target_url),
+          forms: build_forms_section(acc[:forms]),
+          vitals: build_vitals_section(acc[:vitals]),
+          errors: acc[:errors].summarize,
+          frustration: {
+            rage_count: acc[:frustration].rage_count,
+            dead_count: acc[:frustration].dead_count,
+            top_selectors: top_selectors(acc[:frustration].selectors, TOP_SELECTORS_LIMIT)
+          },
+          custom_events: acc[:custom_tags].top(MAX_CUSTOM_TAGS),
+          was_truncated: collectors.any?(&:capped) || hit_cap
+        }
+      end
+
+      def summarize_time_on_page(samples)
+        return {mean_ms: nil, median_ms: nil, samples: 0} if samples.empty?
+
+        sorted = samples.sort
+        {
+          mean_ms: (samples.sum.to_f / samples.size).round,
+          median_ms: percentile(sorted, 50),
+          samples: samples.size
+        }
+      end
+
+      def build_forms_section(forms)
+        started = forms.started_count
+        {
+          started: started,
+          # "completed" here = session submitted on the target URL at all
+          # (submitted_count), not FormAnalyzer's stricter completed_count.
+          completed: forms.submitted_count,
+          completion_rate: started.zero? ? 0.0 : forms.submitted_count.to_f / started,
+          total_submits: forms.total_submits,
+          fields: forms.summarize_fields(started),
+          drop_off_fields: forms.summarize_drop_off
+        }
+      end
+
+      # The collector's worst-sample carries :value (WebVitalsAnalyzer needs it);
+      # the page report exposes only the replay-link coordinates.
+      def build_vitals_section(vitals)
+        result = vitals.summarize
+        result[:metrics].each_value do |metric|
+          metric[:worst] = metric[:worst]&.slice(:session_id, :window_id, :offset_ms)
+        end
+        result
+      end
+
+      def top_selectors(selectors, limit)
+        top_counts(selectors, limit: limit)
+          .map { |selector, count| {selector: selector, count: count} }
+      end
+    end
+  end
+end