dispatch_policy 0.2.0 → 0.4.0

data/app/controllers/dispatch_policy/assets_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DispatchPolicy
+  # Serves vendored static assets at content-addressed URLs so browsers
+  # can cache them forever. The digest is part of the URL, not a query
+  # string, so caches keyed on path alone still bust on upgrade.
+  class AssetsController < ApplicationController
+    skip_forgery_protection
+
+    def turbo
+      serve(Assets::TURBO_BODY, Assets::TURBO_DIGEST, "application/javascript")
+    end
+
+    def logo
+      serve(Assets::LOGO_SMALL_BODY, Assets::LOGO_SMALL_DIGEST, "image/svg+xml")
+    end
+
+    private
+
+    def serve(body, digest, content_type)
+      if params[:digest] != digest
+        head :not_found
+        return
+      end
+
+      response.headers["Cache-Control"] = "public, max-age=31536000, immutable"
+      response.headers["ETag"]          = %("#{digest}")
+      send_data body, type: content_type, disposition: "inline"
+    end
+  end
+end

data/app/controllers/dispatch_policy/dashboard_controller.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DispatchPolicy
+  class DashboardController < ApplicationController
+    WINDOWS = { "1m" => 60, "5m" => 5 * 60, "15m" => 15 * 60 }.freeze
+
+    def index
+      @totals = {
+        staged:        StagedJob.count,
+        partitions:    Partition.count,
+        active_parts:  Partition.active.count,
+        paused_parts:  Partition.paused.count,
+        in_flight:     InflightJob.count
+      }
+
+      now = Time.current
+      @windows = WINDOWS.transform_values { |secs| Repository.tick_summary(since: now - secs) }
+      @round_trip = Repository.partition_round_trip_stats
+
+      # Pending trend: 30 minutes of 1-min buckets aggregated across
+      # all policies. Used for the sparkline + arrow on the overview.
+      @pending_buckets = Repository.tick_samples_buckets(since: now - 30 * 60, bucket_seconds: 60)
+      @pending_trend   = Repository.trend_direction(@pending_buckets.map { |b| b[:pending_total] })
+
+      # Capacity headroom: live admit rate vs configured adapter ceiling,
+      # avg tick wall vs tick_max_duration. These two ratios are the
+      # operator's quickest "should I shard?" signal.
+      cfg = DispatchPolicy.config
+      @capacity = {
+        admitted_per_minute:    @windows["1m"][:jobs_admitted],
+        admitted_per_second:    @windows["1m"][:jobs_admitted] / 60.0,
+        adapter_target_jps:     cfg.adapter_throughput_target,
+        avg_tick_ms:            @windows["1m"][:avg_duration_ms],
+        max_tick_ms:            @windows["1m"][:max_duration_ms],
+        tick_max_duration_ms:   cfg.tick_max_duration.to_i * 1000
+      }
+
+      @hints = OperatorHints.for(
+        tick_max_duration_ms: @capacity[:tick_max_duration_ms],
+        avg_tick_ms:          @capacity[:avg_tick_ms],
+        max_tick_ms:          @capacity[:max_tick_ms],
+        pending_total:        @totals[:staged],
+        admitted_per_minute:  @capacity[:admitted_per_minute],
+        forward_failures:     @windows["1m"][:forward_failures],
+        jobs_admitted:        @windows["1m"][:jobs_admitted],
+        active_partitions:    @round_trip[:active_partitions],
+        never_checked:        @round_trip[:never_checked],
+        in_backoff:           @round_trip[:in_backoff],
+        total_partitions:     @totals[:partitions],
+        adapter_target_jps:   @capacity[:adapter_target_jps],
+        pending_trend:        @pending_trend
+      )
+
+      pending_by_policy = Partition
+        .group(:policy_name)
+        .pluck(:policy_name, Arel.sql("SUM(pending_count)::int"), Arel.sql("MAX(last_admit_at)"))
+        .to_h { |name, pending, last_admit| [name, { pending: pending || 0, last_admit_at: last_admit }] }
+
+      in_flight_by_policy = InflightJob.group(:policy_name).count
+
+      one_min_ago = now - 60
+      five_min_ago = now - 300
+
+      names = (pending_by_policy.keys + in_flight_by_policy.keys).uniq.sort
+      @policies = names.map do |name|
+        info  = pending_by_policy[name] || {}
+        m1    = Repository.tick_summary(policy_name: name, since: one_min_ago)
+        m5    = Repository.tick_summary(policy_name: name, since: five_min_ago)
+        rs    = Repository.denied_reasons_summary(policy_name: name, since: one_min_ago)
+        rt    = Repository.partition_round_trip_stats(policy_name: name)
+
+        {
+          name:           name,
+          pending:        info[:pending] || 0,
+          in_flight:      in_flight_by_policy[name] || 0,
+          last_admit_at:  info[:last_admit_at],
+          admitted_1m:    m1[:jobs_admitted],
+          admitted_5m:    m5[:jobs_admitted],
+          ticks_1m:       m1[:ticks],
+          avg_tick_ms_1m: m1[:avg_duration_ms],
+          forward_failures_1m: m1[:forward_failures],
+          oldest_age_seconds:  rt[:oldest_age_seconds],
+          p95_age_seconds:     rt[:p95_age_seconds],
+          in_backoff:          rt[:in_backoff],
+          top_denial_reason:   rs.first&.first,
+          top_denial_count:    rs.first&.last
+        }
+      end
+    end
+  end
+end

data/app/controllers/dispatch_policy/partitions_controller.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module DispatchPolicy
+  class PartitionsController < ApplicationController
+    before_action :find_partition, only: %i[show drain admit]
+
+    DRAIN_MAX_PER_REQUEST = 10_000
+    DRAIN_BATCH_SIZE      = 200
+
+    PAGE_SIZE = 100
+
+    def index
+      base = Partition.all
+      base = base.for_policy(params[:policy]) if params[:policy].present?
+      base = base.for_shard(params[:shard])   if params[:shard].present?
+      base = base.where("partition_key ILIKE ?", "%#{params[:q]}%") if params[:q].present?
+      base = base.where("pending_count > 0")                         if params[:only_pending] == "1"
+
+      @sort = DispatchPolicy::CursorPagination::SORTS.key?(params[:sort]) ? params[:sort] : DispatchPolicy::CursorPagination::DEFAULT_SORT
+      sort_def = DispatchPolicy::CursorPagination.sort_for(@sort)
+
+      @total  = base.count   # cheap on indexed columns; nice to display
+      @cursor = DispatchPolicy::CursorPagination.decode(params[:cursor])
+
+      paginated = DispatchPolicy::CursorPagination.apply(base, @sort, @cursor)
+                                                   .order(Arel.sql(sort_def[:sql_order]))
+                                                   .limit(PAGE_SIZE + 1)
+                                                   .to_a
+
+      @has_more   = paginated.size > PAGE_SIZE
+      @partitions = paginated.first(PAGE_SIZE)
+      @next_cursor =
+        if @has_more && @partitions.any?
+          v, id = DispatchPolicy::CursorPagination.extract(@partitions.last, @sort)
+          DispatchPolicy::CursorPagination.encode(v, id)
+        end
+
+      @policy        = params[:policy]
+      @shard         = params[:shard]
+      @query         = params[:q]
+      @only_pending  = params[:only_pending] == "1"
+
+      shards_scope = Partition.all
+      shards_scope = shards_scope.for_policy(params[:policy]) if params[:policy].present?
+      @shards      = shards_scope.distinct.pluck(:shard).sort
+    end
+
+    # Build URL params preserving filters, replacing the cursor.
+    def pagination_params(overrides = {})
+      {
+        policy:        @policy.presence,
+        shard:         @shard.presence,
+        q:             @query.presence,
+        sort:          (@sort if @sort != DispatchPolicy::CursorPagination::DEFAULT_SORT),
+        only_pending:  ("1" if @only_pending),
+        cursor:        nil
+      }.compact.merge(overrides)
+    end
+    helper_method :pagination_params
+
+    def show
+      @recent_jobs = StagedJob
+        .for_partition(@partition.policy_name, @partition.partition_key)
+        .order(:scheduled_at, :id)
+        .limit(50)
+      @inflight = InflightJob.where(policy_name: @partition.policy_name).limit(50)
+    end
+
+    def admit
+      count = Integer(params[:count] || 1)
+      rows = Repository.claim_staged_jobs!(
+        policy_name:      @partition.policy_name,
+        partition_key:    @partition.partition_key,
+        limit:            count,
+        gate_state_patch: {},
+        retry_after:      nil
+      )
+      forwarded = rows.size - Forwarder.dispatch(rows).size
+      redirect_to partition_path(@partition), notice: "Forwarded #{forwarded} job(s)."
+    end
+
+    # Empties the partition by force-admitting every staged job through the
+    # forwarder, bypassing all gates. Bounded at DRAIN_MAX_PER_REQUEST so a
+    # huge backlog can't time the controller out — the operator clicks again
+    # for the next batch.
+    def drain
+      drained, remaining = self.class.drain_partition!(@partition)
+      notice = if remaining.positive?
+        "Drained #{drained} job(s); #{remaining} still pending — click drain again to continue."
+      else
+        "Drained #{drained} job(s); partition empty."
+      end
+      redirect_to partition_path(@partition), notice: notice
+    end
+
+    def self.drain_partition!(partition)
+      drained = 0
+      while drained < DRAIN_MAX_PER_REQUEST
+        batch_limit = [DRAIN_BATCH_SIZE, DRAIN_MAX_PER_REQUEST - drained].min
+        rows = Repository.claim_staged_jobs!(
+          policy_name:      partition.policy_name,
+          partition_key:    partition.partition_key,
+          limit:            batch_limit,
+          gate_state_patch: {},
+          retry_after:      nil
+        )
+        break if rows.empty?
+
+        Forwarder.dispatch(rows)
+        drained += rows.size
+      end
+      remaining = partition.class.where(id: partition.id).pick(:pending_count) || 0
+      [drained, remaining]
+    end
+
+    private
+
+    def find_partition
+      @partition = Partition.find(params[:id])
+    end
+  end
+end

data/app/controllers/dispatch_policy/policies_controller.rb

@@ -2,294 +2,121 @@
 
 module DispatchPolicy
   class PoliciesController < ApplicationController
-    STALE_PENDING_THRESHOLD = 1.hour
-    PARTITION_LIST_PAGE_SIZE = 25
+    before_action :find_policy, only: %i[show pause resume drain]
 
-    before_action :load_policy, only: :show
+    DRAIN_MAX_PER_REQUEST = 10_000
 
     def index
-      @policies = DispatchPolicy.registry.map do |name, job_class|
-        scope   = StagedJob.where(policy_name: name)
-        pending = scope.pending
+      registry_names = DispatchPolicy.registry.names
+      db_names       = Partition.distinct.pluck(:policy_name)
+      names          = (registry_names + db_names).uniq.sort
+
+      in_flight_by_policy = InflightJob.where(policy_name: names).group(:policy_name).count
+
+      @rows = names.map do |name|
+        partitions = Partition.for_policy(name)
         {
-          name:            name,
-          job_class:       job_class,
-          policy:          job_class.resolved_dispatch_policy,
-          pending_count:   pending.count,
-          admitted_count:  scope.admitted.count,
-          completed_24h:   scope.completed.where(completed_at: 24.hours.ago..).count,
-          oldest_pending:  pending.minimum(:staged_at),
-          stale_threshold: STALE_PENDING_THRESHOLD
+          name:           name,
+          registered:     registry_names.include?(name),
+          pending:        partitions.sum(:pending_count),
+          in_flight:      in_flight_by_policy[name] || 0,
+          partitions:     partitions.count,
+          paused_count:   partitions.paused.count
         }
-      end.sort_by { |p| -p[:pending_count] }
-
-      @active_partitions = PartitionInflightCount.where("in_flight > 0").count
-      @expired_leases    = StagedJob.expired_leases.count
+      end
     end
 
     def show
-      scope = StagedJob.where(policy_name: @policy_name)
-      @pending_count           = scope.pending.count
-      @pending_eligible_count  = scope.pending.where("not_before_at IS NULL OR not_before_at <= ?", Time.current).count
-      @pending_scheduled_count = @pending_count - @pending_eligible_count
-      @admitted_count          = scope.admitted.count
-      @completed_24h           = scope.completed.where(completed_at: 24.hours.ago..).count
-
-      all_breakdown = partition_breakdown(scope)
-
-      # "Watched" subset (passed via ?watch=a,b,c; the JS layer syncs it
-      # with localStorage so the choice sticks across reloads).
-      @watched_keys        = (params[:watch] || "").split(",").map(&:strip).reject(&:empty?)
-      @partition_breakdown = @watched_keys.any? ? all_breakdown.select { |r| @watched_keys.include?(r[:partition]) } : []
-
-      # Browsable list of every active partition with filter + sort + pagination.
-      @partition_search = params[:q].to_s.strip
-      @partition_page   = [ params[:page].to_i, 1 ].max
-      @partition_sort   = %w[source partition pending in_flight completed_24h last_enqueued_at last_dispatched_at].include?(params[:sort]) ? params[:sort] : "activity"
-      @partition_dir    = params[:dir] == "asc" ? "asc" : "desc"
-
-      list = all_breakdown
-      list = list.select { |r| r[:partition].to_s.downcase.include?(@partition_search.downcase) } if @partition_search.present?
-      list = sort_partition_list(list, @partition_sort, @partition_dir)
-
-      @partition_total_list = list.size
-      offset                = (@partition_page - 1) * PARTITION_LIST_PAGE_SIZE
-      @partition_list       = list[offset, PARTITION_LIST_PAGE_SIZE] || []
-
-      load_adaptive_chart_data
-      @throttle_buckets = ThrottleBucket
-        .where(policy_name: @policy_name).order(:gate_name, :partition_key).limit(50)
-      # Explicit select: don't load the `arguments` jsonb (job payload —
-      # may contain PII / tokens) into memory just to render six fields.
-      @pending_jobs = scope.pending
-        .select(:id, :dedupe_key, :round_robin_key, :priority, :staged_at, :not_before_at)
-        .order(:priority, :staged_at)
-        .limit(50)
-    end
-
-    private
-
-    def load_policy
-      @policy_name = params[:policy_name]
-      @job_class   = DispatchPolicy.registry[@policy_name] ||
-                     Tick.autoload_job_for(@policy_name)
-      raise ActiveRecord::RecordNotFound unless @job_class
-      @policy = @job_class.resolved_dispatch_policy
-    end
-
-    # Per-(source, partition) breakdown of pending-eligible / pending-scheduled
-    # / in-flight / completed-24h. A "source" is either a gate with a
-    # partition_by (uses gate.partition_key_for(context)) or the policy's
-    # round_robin_by declaration (uses the round_robin_key column directly).
-    # All four counts come from StagedJob groupings; PartitionInflightCount
-    # is an admission-time optimization, not the user-facing truth.
-    def partition_breakdown(scope)
-      sources = partition_sources
-      return [] if sources.empty?
-
-      now       = Time.current
-      now_iso   = now.iso8601
-      since_24h = 24.hours.ago.iso8601
-      limit     = DispatchPolicy.config.admin_partition_limit
-      @partition_breakdown_truncated = false
-
-      adaptive_stats = AdaptiveConcurrencyStats.where(policy_name: @policy_name)
-        .order(updated_at: :desc)
-        .limit(limit)
-        .pluck(:gate_name, :partition_key, :current_max, :ewma_latency_ms)
-        .each_with_object({}) { |(g, k, c, l), h|
-          h[[ g, k ]] = { current_max: c, ewma_latency_ms: l.to_f.round(1) }
-        }
-
-      rows = Hash.new { |h, k|
-        h[k] = {
-          source:             k[0],
-          partition:          k[1],
-          eligible:           0,
-          scheduled:          0,
-          in_flight:          0,
-          completed_24h:      0,
-          last_enqueued_at:   nil,
-          last_dispatched_at: nil,
-          current_max:        nil,
-          ewma_latency_ms:    nil
-        }
+      @policy_object = DispatchPolicy.registry.fetch(@policy_name)
+      @partitions    = Partition.for_policy(@policy_name)
+                                .order(Arel.sql("pending_count DESC, last_admit_at DESC NULLS LAST"))
+                                .limit(100)
+      @top_admitted  = Partition.for_policy(@policy_name)
+                                .order(total_admitted: :desc)
+                                .limit(20)
+
+      @totals = {
+        pending:    Partition.for_policy(@policy_name).sum(:pending_count),
+        in_flight:  InflightJob.where(policy_name: @policy_name).count,
+        partitions: Partition.for_policy(@policy_name).count
       }
 
-      # Each aggregation below is order-by-count + limited so that a
-      # policy with tens of thousands of distinct (context, round_robin_key)
-      # tuples can't pull megabytes of rows into memory per request. We
-      # show the top-N most-active partitions per axis and flip the
-      # truncation flag for the view banner.
-
-      # Activity timestamps bounded to the last 24h so the scan stays on
-      # an index-friendly slice of staged_jobs.
-      activity_rows = scope
-        .where("staged_at > ?", since_24h)
-        .group(:context, :round_robin_key)
-        .order(Arel.sql("MAX(staged_at) DESC"))
-        .limit(limit)
-        .pluck(
-          :context,
-          :round_robin_key,
-          Arel.sql("MAX(staged_at)"),
-          Arel.sql("MAX(admitted_at)")
-        )
-      @partition_breakdown_truncated = true if activity_rows.size >= limit
-
-      sources.each do |name, extract|
-        pending_counts = scope.pending.group(:context, :round_robin_key)
-          .order(Arel.sql("count(*) DESC"))
-          .limit(limit)
-          .pluck(
-            :context,
-            :round_robin_key,
-            Arel.sql("count(*) filter (where not_before_at is null or not_before_at <= '#{now_iso}')"),
-            Arel.sql("count(*) filter (where not_before_at > '#{now_iso}')")
-          )
-        @partition_breakdown_truncated = true if pending_counts.size >= limit
-        pending_counts.each do |ctx, rr_key, eligible, scheduled|
-          partition = extract.call(ctx, rr_key)
-          row = rows[[ name, partition ]]
-          row[:eligible]  += eligible
-          row[:scheduled] += scheduled
-        end
-
-        admitted_counts = scope.admitted.group(:context, :round_robin_key)
-          .order(Arel.sql("count(*) DESC"))
-          .limit(limit)
-          .pluck(:context, :round_robin_key, Arel.sql("count(*)"))
-        @partition_breakdown_truncated = true if admitted_counts.size >= limit
-        admitted_counts.each do |ctx, rr_key, in_flight|
-          partition = extract.call(ctx, rr_key)
-          rows[[ name, partition ]][:in_flight] += in_flight
-        end
-
-        completed_counts = scope.completed.where("completed_at > ?", since_24h)
-          .group(:context, :round_robin_key)
-          .order(Arel.sql("count(*) DESC"))
-          .limit(limit)
-          .pluck(:context, :round_robin_key, Arel.sql("count(*)"))
-        @partition_breakdown_truncated = true if completed_counts.size >= limit
-        completed_counts.each do |ctx, rr_key, completed|
-          partition = extract.call(ctx, rr_key)
-          rows[[ name, partition ]][:completed_24h] += completed
-        end
-
-        activity_rows.each do |ctx, rr_key, last_staged, last_admitted|
-          partition = extract.call(ctx, rr_key)
-          row       = rows[[ name, partition ]]
-          row[:last_enqueued_at]   = [ row[:last_enqueued_at], last_staged ].compact.max
-          row[:last_dispatched_at] = [ row[:last_dispatched_at], last_admitted ].compact.max
-        end
-      end
-
-      rows.each do |(source, partition), row|
-        stats = adaptive_stats[[ source, partition ]]
-        next unless stats
-        row[:current_max]     = stats[:current_max]
-        row[:ewma_latency_ms] = stats[:ewma_latency_ms]
-      end
-
-      # Two different sources (say round_robin_by account_id + a gate
-      # partitioned by account_id) producing the same partition key yield
-      # identical counts — collapse them into one row with a merged source
-      # label instead of listing the same numbers twice.
-      merged = rows.values
-        .reject { |r| r[:partition].nil? || r[:partition].empty? }
-        .group_by { |r| [ r[:partition], r[:eligible], r[:scheduled], r[:in_flight], r[:completed_24h] ] }
-        .map { |_, group|
-          base = group.first.dup
-          base[:source] = group.map { |r| r[:source] }.uniq.sort.join(" + ")
-          group.each do |r|
-            base[:current_max]        ||= r[:current_max]
-            base[:ewma_latency_ms]    ||= r[:ewma_latency_ms]
-            base[:last_enqueued_at]     = [ base[:last_enqueued_at], r[:last_enqueued_at] ].compact.max
-            base[:last_dispatched_at]   = [ base[:last_dispatched_at], r[:last_dispatched_at] ].compact.max
-          end
-          base
-        }
-
-      merged.sort_by { |r|
-        [ -(r[:eligible] + r[:scheduled] + r[:in_flight] + r[:completed_24h]), r[:source], r[:partition] ]
+      now = Time.current
+      @windows = {
+        "1m"  => Repository.tick_summary(policy_name: @policy_name, since: now - 60),
+        "5m"  => Repository.tick_summary(policy_name: @policy_name, since: now - 5 * 60),
+        "15m" => Repository.tick_summary(policy_name: @policy_name, since: now - 15 * 60)
+      }
+      @denied_reasons = Repository.denied_reasons_summary(policy_name: @policy_name, since: now - 15 * 60)
+      @round_trip     = Repository.partition_round_trip_stats(policy_name: @policy_name)
+      @sparkline      = Repository.tick_samples_buckets(policy_name: @policy_name, since: now - 30 * 60, bucket_seconds: 60)
+      @pending_trend  = Repository.trend_direction(@sparkline.map { |b| b[:pending_total] })
+
+      cfg = DispatchPolicy.config
+      @capacity = {
+        admitted_per_minute:  @windows["1m"][:jobs_admitted],
+        adapter_target_jps:   cfg.adapter_throughput_target,
+        avg_tick_ms:          @windows["1m"][:avg_duration_ms],
+        max_tick_ms:          @windows["1m"][:max_duration_ms],
+        tick_max_duration_ms: cfg.tick_max_duration.to_i * 1000
       }
-    end
 
-    def sort_partition_list(list, sort, dir)
-      # Put nulls at the bottom regardless of direction (Time#to_f on nil
-      # would crash; -Float::INFINITY sorts first, +Float::INFINITY last).
-      key =
-        case sort
-        when "source"             then ->(r) { [ r[:source], r[:partition] ] }
-        when "partition"          then ->(r) { r[:partition] }
-        when "pending"            then ->(r) { r[:eligible] + r[:scheduled] }
-        when "in_flight"          then ->(r) { r[:in_flight] }
-        when "completed_24h"      then ->(r) { r[:completed_24h] }
-        when "last_enqueued_at"   then ->(r) { r[:last_enqueued_at]&.to_f || 0 }
-        when "last_dispatched_at" then ->(r) { r[:last_dispatched_at]&.to_f || 0 }
-        else ->(r) { r[:eligible] + r[:scheduled] + r[:in_flight] + r[:completed_24h] }
-        end
-      sorted = list.sort_by(&key)
-      dir == "asc" ? sorted : sorted.reverse
+      @hints = OperatorHints.for(
+        tick_max_duration_ms: @capacity[:tick_max_duration_ms],
+        avg_tick_ms:          @capacity[:avg_tick_ms],
+        max_tick_ms:          @capacity[:max_tick_ms],
+        pending_total:        @totals[:pending],
+        admitted_per_minute:  @capacity[:admitted_per_minute],
+        forward_failures:     @windows["1m"][:forward_failures],
+        jobs_admitted:        @windows["1m"][:jobs_admitted],
+        active_partitions:    @round_trip[:active_partitions],
+        never_checked:        @round_trip[:never_checked],
+        in_backoff:           @round_trip[:in_backoff],
+        total_partitions:     @totals[:partitions],
+        adapter_target_jps:   @capacity[:adapter_target_jps],
+        pending_trend:        @pending_trend
+      )
     end
 
-    # Returns [[source_name, ->(ctx, rr_key) { partition_key }], ...]
-    # covering every partition-producing declaration on the policy: every
-    # gate with a partition_by, plus round_robin_by if declared.
-    def partition_sources
-      return [] unless @policy
+    def pause
+      Partition.for_policy(@policy_name).update_all(status: "paused", updated_at: Time.current)
+      redirect_to policy_path(@policy_name), notice: "Policy paused."
+    end
 
-      sources = @policy.gates.select(&:partition_by).map do |gate|
-        [ gate.name.to_s, ->(ctx, _rr) { gate.partition_key_for((ctx || {}).symbolize_keys) } ]
-      end
-      sources << [ "round_robin_by", ->(_ctx, rr) { rr } ] if @policy.round_robin?
-      sources
+    def resume
+      Partition.for_policy(@policy_name).update_all(status: "active", updated_at: Time.current)
+      redirect_to policy_path(@policy_name), notice: "Policy resumed."
     end
 
-    # Build chart data from PartitionObservation. Two queries:
-    # - Global aggregated (one row per minute): cheap even with 1000s of
-    #   partitions because we SUM/AVG in SQL, not in Ruby.
-    # - Per-partition sparkline data, scoped to only the partitions we're
-    #   going to actually render (breakdown's top N).
-    def load_adaptive_chart_data
-      last_minute   = Time.current.utc.beginning_of_minute
-      @chart_slots  = (0..59).map { |i| last_minute - (59 - i).minutes }
-      @chart_labels = @chart_slots.map { |t| t.strftime("%H:%M") }
-      slot_index    = @chart_slots.each_with_index.to_h
+    # Force-admits every staged job across every partition of the policy,
+    # bypassing all gates. Walks partitions in pending-DESC order so the
+    # busiest ones drain first. Bounded at DRAIN_MAX_PER_REQUEST per click.
+    def drain
+      drained = 0
+      Partition.for_policy(@policy_name)
+               .where("pending_count > 0")
+               .order(pending_count: :desc, id: :asc)
+               .limit(500)
+               .each do |partition|
+        break if drained >= DRAIN_MAX_PER_REQUEST
+
+        batch, _ = PartitionsController.drain_partition!(partition)
+        drained += batch
+      end
 
-      @adaptive_global    = Array.new(@chart_slots.size)
-      @completions_global = Array.new(@chart_slots.size, 0)
-      global_rows = PartitionObservation
-        .where(policy_name: @policy_name)
-        .where("minute_bucket >= ?", @chart_slots.first)
-        .group(:minute_bucket)
-        .pluck(:minute_bucket, Arel.sql("SUM(total_lag_ms)"), Arel.sql("SUM(observation_count)"))
-      global_rows.each do |bucket, total_lag, obs_count|
-        idx = slot_index[bucket.utc.beginning_of_minute]
-        next unless idx
-        @completions_global[idx] = obs_count
-        @adaptive_global[idx]    = obs_count.positive? ? (total_lag.to_f / obs_count).round(1) : nil
+      remaining = Partition.for_policy(@policy_name).sum(:pending_count)
+      notice = if remaining.positive?
+        "Drained #{drained} job(s) across this policy; #{remaining} still pending — click drain again to continue."
+      else
+        "Drained #{drained} job(s); policy fully drained."
       end
+      redirect_to policy_path(@policy_name), notice: notice
+    end
 
-      partition_keys = (@partition_breakdown || []).map { |r| r[:partition] }.uniq
-      @adaptive_samples    = {}
-      @completions_samples = {}
-      return if partition_keys.empty?
+    private
 
-      per_partition_lag    = Hash.new { |h, k| h[k] = Array.new(@chart_slots.size) }
-      per_partition_counts = Hash.new { |h, k| h[k] = Array.new(@chart_slots.size, 0) }
-      rows = PartitionObservation
-        .where(policy_name: @policy_name, partition_key: partition_keys)
-        .where("minute_bucket >= ?", @chart_slots.first)
-        .pluck(:partition_key, :minute_bucket, :total_lag_ms, :observation_count)
-      rows.each do |pk, bucket, total, count|
-        idx = slot_index[bucket.utc.beginning_of_minute]
-        next unless idx
-        per_partition_lag[pk][idx]    = count.positive? ? (total.to_f / count).round(1) : nil
-        per_partition_counts[pk][idx] = count
-      end
-      @adaptive_samples    = per_partition_lag
-      @completions_samples = per_partition_counts
+    def find_policy
+      @policy_name = params[:name]
     end
   end
 end

data/app/controllers/dispatch_policy/staged_jobs_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DispatchPolicy
+  class StagedJobsController < ApplicationController
+    def show
+      @job = StagedJob.find(params[:id])
+    end
+  end
+end