dispatch_policy 0.2.0 → 0.3.0

data/app/assets/stylesheets/dispatch_policy/application.css

@@ -0,0 +1,157 @@
+/* dispatch_policy: minimal flat dashboard */
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+  font-size: 14px;
+  color: #1a1a1a;
+  background: #f6f7fa;
+}
+
+a, a:visited { color: #1f4ed8; text-decoration: none; }
+a:hover { text-decoration: underline; }
+code { font-family: "SFMono-Regular", Menlo, monospace; font-size: 13px; background: #eef2f7; padding: 1px 4px; border-radius: 3px; }
+
+.dp-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 12px 28px;
+  background: #1d2330;
+  color: #f6f7fa;
+  border-bottom: 1px solid #0e1218;
+}
+.dp-header a { color: #f6f7fa; }
+.dp-logo { font-weight: 600; font-size: 16px; letter-spacing: 0.4px; }
+.dp-nav { flex: 1; }
+.dp-nav a { margin-left: 22px; opacity: 0.85; }
+.dp-nav a:hover { opacity: 1; text-decoration: none; }
+
+.dp-refresh {
+  display: flex; align-items: center; gap: 6px;
+  font-size: 12px; color: rgba(246, 247, 250, 0.7);
+}
+.dp-refresh-label {
+  margin-right: 4px; text-transform: uppercase; letter-spacing: 0.6px; font-size: 10.5px;
+}
+.dp-refresh-btn {
+  background: transparent; color: rgba(246, 247, 250, 0.85);
+  border: 1px solid rgba(246, 247, 250, 0.25);
+  padding: 3px 9px; border-radius: 3px;
+  font-size: 12px; cursor: pointer;
+  font-variant-numeric: tabular-nums;
+}
+.dp-refresh-btn:hover { background: rgba(246, 247, 250, 0.08); }
+.dp-refresh-btn.dp-refresh-active {
+  background: rgba(246, 247, 250, 0.92); color: #1d2330;
+  border-color: rgba(246, 247, 250, 0.92); font-weight: 600;
+}
+
+.dp-main { max-width: 1200px; margin: 24px auto; padding: 0 28px 64px; }
+.dp-footer {
+  display: flex; gap: 24px; justify-content: space-between;
+  max-width: 1200px; margin: 0 auto; padding: 12px 28px 24px;
+  color: #6b7280; font-size: 12px;
+}
+
+h1 { font-size: 22px; margin: 0 0 18px; font-weight: 600; }
+h2 { font-size: 15px; margin: 24px 0 10px; font-weight: 600; color: #374151; text-transform: uppercase; letter-spacing: 0.6px; }
+
+.dp-stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); gap: 12px; margin-bottom: 18px; }
+.dp-stat {
+  background: #fff; border: 1px solid #e3e6ec; border-radius: 6px;
+  padding: 14px 16px; display: flex; flex-direction: column; gap: 6px;
+}
+.dp-stat-label { color: #6b7280; font-size: 11px; text-transform: uppercase; letter-spacing: 0.6px; }
+.dp-stat-value { font-size: 22px; font-weight: 600; }
+
+.dp-section { background: #fff; border: 1px solid #e3e6ec; border-radius: 6px; padding: 16px 20px; margin: 14px 0; }
+
+.dp-table { width: 100%; border-collapse: collapse; font-size: 13px; }
+.dp-table th, .dp-table td { text-align: left; padding: 8px 10px; border-bottom: 1px solid #eef0f4; }
+.dp-table th { background: #f1f3f7; font-weight: 600; color: #374151; }
+.dp-table tr:hover td { background: #fafbfd; }
+.dp-num { text-align: right; font-variant-numeric: tabular-nums; }
+
+.dp-empty { color: #6b7280; font-style: italic; padding: 6px 0; }
+
+.dp-flash { padding: 10px 16px; border-radius: 0; font-size: 13px; }
+.dp-flash-ok { background: #e8f6ee; color: #14532d; border-bottom: 1px solid #c7e6d3; }
+.dp-flash-err { background: #fbe7e6; color: #7a1d1d; border-bottom: 1px solid #f0c2bf; }
+
+.dp-warn { color: #b45309; }
+.dp-row-paused td { background: #fffbe9; }
+
+.dp-list { margin: 0; padding-left: 20px; }
+.dp-list li { margin: 3px 0; }
+
+.dp-link { color: #1f4ed8; }
+
+.dp-form-inline { display: inline-block; margin-right: 6px; }
+.dp-btn {
+  background: #fff; border: 1px solid #cfd5df; padding: 6px 12px;
+  font-size: 13px; border-radius: 4px; color: #1a1a1a; cursor: pointer;
+}
+.dp-btn:hover { background: #eef1f6; }
+.dp-btn-ok { border-color: #2f9e58; color: #14532d; background: #f1faf3; }
+.dp-btn-ok:hover { background: #def0e3; }
+.dp-btn-warn { border-color: #d05858; color: #7a1d1d; background: #fdf2f1; }
+.dp-btn-warn:hover { background: #f7dcd9; }
+
+.dp-input {
+  padding: 6px 10px; border: 1px solid #cfd5df; border-radius: 4px;
+  font-size: 13px; min-width: 240px;
+}
+.dp-search-form { margin-bottom: 14px; }
+
+.dp-json {
+  background: #0f1116; color: #c4cad6; padding: 12px 14px;
+  border-radius: 6px; overflow-x: auto;
+  font-family: "SFMono-Regular", Menlo, monospace; font-size: 12.5px; line-height: 1.45;
+}
+
+.dp-hint {
+  font-size: 12.5px; color: #6b7280; margin-top: 8px;
+  border-left: 3px solid #cfd5df; padding: 6px 12px; background: #fafbfd;
+  border-radius: 0 4px 4px 0;
+}
+.dp-hint code { background: #eef2f7; }
+
+.dp-spark {
+  margin-top: 10px; font-size: 13px; color: #374151;
+}
+.dp-spark code {
+  font-family: "SFMono-Regular", Menlo, monospace; font-size: 16px;
+  background: #1d2330; color: #f6f7fa; padding: 2px 8px; letter-spacing: 1px;
+}
+
+.dp-hint-list { padding-left: 0; list-style: none; }
+.dp-hint-list li {
+  margin: 8px 0; padding: 10px 14px;
+  border-left: 4px solid #cfd5df; background: #fafbfd;
+  border-radius: 0 4px 4px 0;
+  font-size: 13px; line-height: 1.5;
+}
+.dp-hint-list li.dp-hint-info     { border-left-color: #1f4ed8; background: #eff4ff; }
+.dp-hint-list li.dp-hint-warn     { border-left-color: #b45309; background: #fff7e6; }
+.dp-hint-list li.dp-hint-critical { border-left-color: #b91c1c; background: #fbe7e6; }
+.dp-hint-badge {
+  display: inline-block; margin-right: 8px; padding: 1px 7px;
+  font-size: 10.5px; font-weight: 700; letter-spacing: 0.5px;
+  border-radius: 3px; color: #fff; background: #6b7280;
+  vertical-align: 1px;
+}
+.dp-hint-info     .dp-hint-badge { background: #1f4ed8; }
+.dp-hint-warn     .dp-hint-badge { background: #b45309; }
+.dp-hint-critical .dp-hint-badge { background: #b91c1c; }
+
+.dp-pagination {
+  display: flex; justify-content: space-between; align-items: center;
+  padding: 14px 0; gap: 12px; flex-wrap: wrap;
+}
+.dp-pagination-info { color: #6b7280; font-size: 13px; font-variant-numeric: tabular-nums; }
+.dp-pagination-nav  { display: flex; gap: 6px; }
+.dp-pagination-nav  .dp-btn { padding: 4px 10px; font-size: 12.5px; text-decoration: none; }
+.dp-btn-disabled    { opacity: 0.4; cursor: default; pointer-events: none; }

data/app/controllers/dispatch_policy/application_controller.rb

@@ -4,6 +4,50 @@ module DispatchPolicy
   class ApplicationController < ActionController::Base
     protect_from_forgery with: :exception
 
-    layout "dispatch_policy/application"
+    helper_method :format_time, :format_count, :format_duration_seconds,
+                  :format_duration_ms, :sparkline, :registered_policies
+
+    private
+
+    def registered_policies
+      DispatchPolicy.registry.each.to_a
+    end
+
+    def format_time(time)
+      return "—" unless time
+      time.utc.strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    def format_count(value)
+      return "0" if value.nil?
+      value.to_i.to_s.reverse.scan(/\d{1,3}/).join(",").reverse
+    end
+
+    def format_duration_seconds(seconds)
+      return "—" if seconds.nil?
+      s = seconds.to_f
+      return "%.0fms" % (s * 1000) if s < 1
+      return "%.1fs"  % s          if s < 60
+      return "%.1fm"  % (s / 60)   if s < 3600
+      "%.1fh" % (s / 3600)
+    end
+
+    def format_duration_ms(ms)
+      return "—" if ms.nil?
+      format_duration_seconds(ms.to_f / 1000.0)
+    end
+
+    BARS = %w[▁ ▂ ▃ ▄ ▅ ▆ ▇ █].freeze
+
+    def sparkline(values, width: 30)
+      return "" if values.nil? || values.empty?
+
+      data = values.map(&:to_i)
+      data = data.last(width)
+      max  = data.max
+      return BARS.first * data.size if max.nil? || max.zero?
+
+      data.map { |v| BARS[((v.to_f / max) * (BARS.size - 1)).round] }.join
+    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