railwatch 0.8.2 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3e41b1890c573cc71fe35d7a9ac134dc3964e4250126bd7c898132800ba47d9
-  data.tar.gz: 84f59bb0bc68c014618c564533b0f3a5266062b1fac93a252a5a41c3632f0136
+  metadata.gz: f52b89a567e0ac0a05281db9b77499961ee7abf9cbfbf663070600d8885818a3
+  data.tar.gz: 05cdb2e7d19bf73edb2dd80550b1a59bf39c83ad24b951c7f7d43b3ddee9a850
 SHA512:
-  metadata.gz: 4472da6ecdbb054cd17cae2a31cf3d1f0a5a6237e4964af2c9da04fa2b754a95a7aa91c268dd43ef9a29791762b82c2edffb446557b0f2b6b5a3a47f6b504a8c
-  data.tar.gz: 276639c1d1f4c9632892a419f83443407a41af5e33c062a426e50bf9a3f5fa8daf039b267157c14079e2c826dbd5b025e0a2e955d43450d28b59be31637fb6b4
+  metadata.gz: d3d4c4f9698de7d6f522d4c171962e959efccd4435ff07e036505ced415aaa43e4b134df949f18c61952c4b22738d7074f49afcc1209cf1088fe41ea6cae564b
+  data.tar.gz: 8f4c96092fc3a62f3538667c4d4f2e40de420e9f2ccacf7305b0b4b4fd99ca9b098cb830cced5b9def8a618d3d1e16e24e478d4461f2599e0047121b79e2df2e

data/CHANGELOG.md

@@ -6,6 +6,24 @@
      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.4 (2026-09-23)
+
+- A `class:` filter for a job class with many attempts in the window
+  walks the window again, where the newest page comes first. 0.8.3
+  gathered and sorted every attempt of the class through its group:
+  10 s for the platform's 93,000 RollupJob attempts over 30 days, 2 ms by
+  walking.
+
+## 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

data/app/models/railwatch/filter_query.rb

@@ -125,7 +125,28 @@ 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.
+      #
+      # A class with many attempts in the window is the opposite case: the
+      # newest page is in the first rows of the walk (2 ms), while the seek
+      # gathers and sorts every attempt (10 s for 93,000 RollupJobs over 30
+      # days). The rollups say how many there are, so a common class walks.
+      if fields["class"].present?
+        name = fields["class"]
+        rollups = Telemetry::Rollup.for_type("job_attempt").between(range.begin, range.end).where(name: name)
+        scope = if rollups.sum(:count) >= Telemetry::Execution::DENSE_MATCHES
+          scope.where(name: name)
+        else
+          groups = [ Record.group_hash(name) ] | rollups.distinct.pluck(:group_hash)
+          scope.merge(Telemetry::Execution.in_groups_or_fresh("job_attempt", groups, range)).where(name: name)
+        end
+      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.2"
+  VERSION = "0.8.4"
 end

metadata

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