railwatch 0.8.2 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3e41b1890c573cc71fe35d7a9ac134dc3964e4250126bd7c898132800ba47d9
-  data.tar.gz: 84f59bb0bc68c014618c564533b0f3a5266062b1fac93a252a5a41c3632f0136
+  metadata.gz: 6426edd02fd2bb306da28aa55723598581751003cce2b10371fdabb5d5a726c7
+  data.tar.gz: 44f256ceff92b14dd0534e0f260f6d8d8b9fb4294e357091c25ec3e0eb3b3ef3
 SHA512:
-  metadata.gz: 4472da6ecdbb054cd17cae2a31cf3d1f0a5a6237e4964af2c9da04fa2b754a95a7aa91c268dd43ef9a29791762b82c2edffb446557b0f2b6b5a3a47f6b504a8c
-  data.tar.gz: 276639c1d1f4c9632892a419f83443407a41af5e33c062a426e50bf9a3f5fa8daf039b267157c14079e2c826dbd5b025e0a2e955d43450d28b59be31637fb6b4
+  metadata.gz: bdb8ba9db502d460a3a653a52238728993807fe5b374823d08f8418b865a1a0d6c0a39f18809a9a00fe95c96952f6a3db4d0337bb3b544e85e63c835830b5e62
+  data.tar.gz: 0ef6f54e5da09ae2b3fc7048ae8b9b4d50fbda878dbb42220c98236345054db8b6b24134e41c7eedf8d13d13f843f4405b0f037d3dd8e6e6caa3cb5d2a6f6d0e

data/CHANGELOG.md

@@ -6,6 +6,16 @@
      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

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.2"
+  VERSION = "0.8.3"
 end

metadata

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