railwatch 0.8.1 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c621aa5be8712487e490453e9b62ab5d3f75666b951270d50acf77b00ad03a29
-  data.tar.gz: 5464f54bb6968924b1155456dcd22c5dada112980760340beb74632a169d5791
+  metadata.gz: 6426edd02fd2bb306da28aa55723598581751003cce2b10371fdabb5d5a726c7
+  data.tar.gz: 44f256ceff92b14dd0534e0f260f6d8d8b9fb4294e357091c25ec3e0eb3b3ef3
 SHA512:
-  metadata.gz: 035642f4a96ae1803f01079f618315a7c1ff54657f6111f52071ae32896782118a40e3f7075ddfb60910625899e589c5cea8f5b3b7c999af42211d097eb2e161
-  data.tar.gz: 4dc2f2217692fa974f06c7c2c7b487896206a0cefccd7301f9802d3eb192dc47900bdfdf96a9a07809d86b41c6a59292fc0df27382b7636167331fcb59c02978
+  metadata.gz: bdb8ba9db502d460a3a653a52238728993807fe5b374823d08f8418b865a1a0d6c0a39f18809a9a00fe95c96952f6a3db4d0337bb3b544e85e63c835830b5e62
+  data.tar.gz: 0ef6f54e5da09ae2b3fc7048ae8b9b4d50fbda878dbb42220c98236345054db8b6b24134e41c7eedf8d13d13f843f4405b0f037d3dd8e6e6caa3cb5d2a6f6d0e

data/CHANGELOG.md

@@ -6,6 +6,23 @@
      filled in by the release commit, which is also the only commit that
      touches lib/railwatch/version.rb and Gemfile.lock. See CONTRIBUTING.md. -->
 
+## 0.8.3 (2026-09-23)
+
+- Filtering jobs by `class:` seeks the class's group (a job's group is
+  the digest of its class name) instead of walking every job in the
+  window: 715 ms over a week on the platform's own tenant, now 9 ms, and
+  one MCP search took 49 s.
+- The Scheduled tasks page and the missed-task check read each task's
+  newest schedule with one index seek per key. The single grouped query
+  they used read every scheduled run kept (10 s once, 185 ms warm).
+
+## 0.8.2 (2026-09-23)
+
+- The Profiles page's profiled share counts only the executions inside
+  its window. A window starting or ending mid-hour counted the whole of
+  its first and last hours, because a rollup holds its whole hour; the
+  partial hours are now counted from the rows.
+
 ## 0.8.1 (2026-09-23)
 
 - The Tenants page reads only through the tenant-led indexes. Sparklines

data/app/controllers/railwatch/profiles_controller.rb

@@ -30,16 +30,18 @@ module Railwatch
     private
 
     # How many executions the window holds, as the profiled share's
-    # denominator. Every kind is rolled up, so the whole hours come from a
-    # few hundred rollup rows rather than counting every execution (1.2 s
-    # over a week of the platform's own); only the part of the first hour
-    # inside the window is counted from the rows.
+    # denominator. Every kind is rolled up, so whole hours come from a few
+    # hundred rollup rows rather than counting every execution (1.2 s over a
+    # week of the platform's own). A rollup holds its whole hour, so the
+    # partial hours at either end of the window are counted from the rows.
     def executions_in(from, to)
-      whole = from.beginning_of_hour == from ? from : from.beginning_of_hour + 1.hour
-      return Telemetry::Execution.between(from, to).count if whole >= to
+      first = from.beginning_of_hour == from ? from : from.beginning_of_hour + 1.hour
+      last = to.beginning_of_hour
+      return Telemetry::Execution.between(from, to).count if first >= last
 
-      Telemetry::Execution.where(occurred_at: from...whole).count +
-        Telemetry::Rollup.for_type(Telemetry::Execution::KINDS).between(whole, to).sum(:count)
+      Telemetry::Execution.where(occurred_at: from...first).count +
+        Telemetry::Rollup.for_type(Telemetry::Execution::KINDS).where(bucket: first...last).sum(:count) +
+        Telemetry::Execution.where(occurred_at: last..to).count
     end
 
     # Rows arrive newest-first, so the head of each group is the profile the

data/app/models/railwatch/filter_query.rb

@@ -125,7 +125,19 @@ module Railwatch
       outcome = fields["outcome"].presence || fields["status"].presence
       scope = scope.where(queue: fields["queue"]) if fields["queue"].present?
       scope = scope.where(outcome: outcome) if outcome
-      scope = scope.where(name: fields["class"]) if fields["class"].present?
+      # A job's group is the digest of its class name, and group_hash is
+      # indexed with occurred_at; name is not, so class: alone walked every
+      # job in the window (49 s for a week through MCP). Not every group
+      # follows that rule -- Solid Queue's pruned attempts are named
+      # "(pruned)" under the SolidQueue::Pruned group -- so the window's
+      # rollups supply any other group recorded under the name, and the last
+      # FRESH_NAMES, which rollups have not caught up with, match by name.
+      if fields["class"].present?
+        name = fields["class"]
+        groups = [ Record.group_hash(name) ] |
+                 Telemetry::Rollup.for_type("job_attempt").between(range.begin, range.end).where(name: name).distinct.pluck(:group_hash)
+        scope = scope.merge(Telemetry::Execution.in_groups_or_fresh("job_attempt", groups, range)).where(name: name)
+      end
       scope = scope.where(job_id: fields["job_id"]) if fields["job_id"].present?
       return scope unless text.present?
       scope.merge(Telemetry::Execution.named_like("job_attempt", text, range, previews: true))

data/app/models/railwatch/telemetry/execution.rb

@@ -61,6 +61,19 @@ module Railwatch
           .where(ids.map { |branch| "#{quoted_table_name}.id IN (#{branch.select(:id).to_sql})" }.join(" OR "))
       end
 
+      # Executions of `kind` in `range` that are in one of `groups`, or recent
+      # enough (FRESH_NAMES) that their rollup may not exist yet. Each branch
+      # names its index and the outer lookup is by rowid, as in named_like:
+      # an OR over the two conditions made SQLite walk the whole window.
+      def self.in_groups_or_fresh(kind, groups, range)
+        by_group = indexed_by("index_executions_on_group_hash_and_occurred_at").where(group_hash: groups, occurred_at: range, kind: kind)
+        fresh = where(kind: kind, occurred_at: [ range.begin, range.end - FRESH_NAMES ].max..range.end)
+        return where(kind: kind, occurred_at: range).where(group_hash: groups).or(fresh) unless TelemetryRecord.sqlite?
+
+        from("#{quoted_table_name} NOT INDEXED").where(kind: kind, occurred_at: range)
+          .where([ by_group, fresh ].map { |branch| "#{quoted_table_name}.id IN (#{branch.select(:id).to_sql})" }.join(" OR "))
+      end
+
       def self.indexed_by(index) = unscoped.from("#{quoted_table_name} INDEXED BY #{index}")
       private_class_method :indexed_by
 
@@ -74,14 +87,17 @@ module Railwatch
         KINDS.flat_map { |kind| where(kind: kind, occurred_at: time..).distinct.pluck(:server) }.uniq
       end
 
-      # The schedule string each task key last ran with, in one query: the
-      # newest scheduled_task row per key carries it in detail. The scheduled
-      # tasks page and CheckScheduledTasksJob both used to look it up per key.
+      # The schedule string each task key last ran with: the newest
+      # scheduled_task row per key carries it in detail. A task's runs share
+      # its group (the digest of its key), so that row is the last entry of
+      # its group_hash index -- one seek per key, a few dozen keys. A single
+      # MAX(id) GROUP BY task_key read every scheduled run ever kept instead:
+      # 10 s on the platform's own tenant.
       def self.latest_schedules(keys)
-        return {} if keys.empty?
-        latest = scheduled.where(task_key: keys).group(:task_key).select(:task_key, Arel.sql("MAX(id) AS id"))
-        scheduled.where(id: latest.map(&:id))
-          .pluck(:task_key, Arel.sql("json_extract(detail, '$.schedule')")).to_h
+        keys.index_with do |key|
+          scheduled.where(group_hash: Record.group_hash(key), task_key: key).order(occurred_at: :desc)
+            .pick(Arel.sql("json_extract(detail, '$.schedule')"))
+        end.compact
       end
 
       CHILDREN = {

data/lib/railwatch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Railwatch
-  VERSION = "0.8.1"
+  VERSION = "0.8.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railwatch
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.3
 platform: ruby
 authors:
 - Cole Robertson