dispatch_policy 0.2.0 → 0.3.0

data/lib/dispatch_policy/dispatch_context.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module DispatchPolicy
-  class DispatchContext
-    def initialize(policy:, batch:)
-      @policy     = policy
-      @cache      = {}
-      @partitions = Hash.new { |h, k| h[k] = {} }
-      batch.each { |staged| resolve_for(staged) }
-    end
-
-    def for(staged)
-      @cache[staged.id]
-    end
-
-    def record_partitions(pairs, gate:)
-      pairs.each { |staged, partition_key| @partitions[staged.id][gate.to_sym] = partition_key.to_s }
-    end
-
-    def partitions_for(staged)
-      @partitions[staged.id]
-    end
-
-    def primary_partition_for(staged)
-      @partitions[staged.id].values.first
-    end
-
-    private
-
-    def resolve_for(staged)
-      cached = staged.context
-      if cached.is_a?(Hash) && cached.present?
-        @cache[staged.id] = cached.symbolize_keys
-        return
-      end
-
-      # Fallback: recompute from the serialized args. Hit on rows staged
-      # before the context column existed, or when context_builder
-      # legitimately returned an empty hash.
-      raw  = (staged.arguments || {})["arguments"] || []
-      args = begin
-        ActiveJob::Arguments.deserialize(raw)
-      rescue StandardError => e
-        Rails.logger&.warn(
-          "[DispatchPolicy] could not deserialize args for staged=#{staged.id} " \
-          "(policy=#{staged.policy_name}): #{e.class}: #{e.message}"
-        )
-        raw
-      end
-      @cache[staged.id] = @policy.context_builder.call(args)
-    end
-  end
-end

data/lib/dispatch_policy/dispatchable.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module DispatchPolicy
-  module Dispatchable
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def dispatch_policy(&block)
-        @dispatch_policy = DispatchPolicy::Policy.new(self, &block)
-      end
-
-      def dispatch_policy?
-        !@dispatch_policy.nil?
-      end
-
-      def resolved_dispatch_policy
-        @dispatch_policy
-      end
-
-      # Walk up the ancestor chain so subclasses inherit the parent policy.
-      def inherited(subclass)
-        super
-        subclass.instance_variable_set(:@dispatch_policy, @dispatch_policy)
-      end
-    end
-
-    included do
-      attr_accessor :_dispatch_partitions, :_dispatch_admitted_at
-
-      around_perform do |job, block|
-        # queue_lag = admitted_at → perform_start. Pure signal for "is the
-        # adapter queue building up?" (high = admitting too fast) vs "are
-        # workers idle?" (near zero = ready for more). Measured BEFORE
-        # block.call so perform duration doesn't pollute it.
-        admitted_at   = job._dispatch_admitted_at
-        perform_start = Time.current
-        queue_lag_ms  = admitted_at ? ((perform_start - admitted_at) * 1000).to_i : 0
-
-        succeeded = false
-        begin
-          block.call
-          succeeded = true
-        ensure
-          duration_ms = ((Time.current - perform_start) * 1000).to_i
-          policy_name = job.class.resolved_dispatch_policy&.name
-
-          if job._dispatch_partitions.present?
-            DispatchPolicy::Tick.release(
-              policy_name: policy_name,
-              partitions:  job._dispatch_partitions
-            )
-
-            # Let adaptive gates update their AIMD state first; the
-            # generic observation below then captures the resulting
-            # current_max alongside lag + duration for the chart.
-            policy = job.class.resolved_dispatch_policy
-            job._dispatch_partitions.each do |gate_name, partition_key|
-              gate = policy&.gates&.find { |g| g.name == gate_name.to_sym }
-              next unless gate.is_a?(DispatchPolicy::Gates::AdaptiveConcurrency)
-              gate.record_observation(
-                partition_key: partition_key,
-                queue_lag_ms:  queue_lag_ms,
-                succeeded:     succeeded
-              )
-            end
-
-            # Generic observation per unique partition. Every gate with
-            # partition_by (adaptive or not) gets a sparkline this way,
-            # plus :fair_time_share reads consumed_ms from here.
-            job._dispatch_partitions.values.uniq.each do |partition_key|
-              current_max = DispatchPolicy::AdaptiveConcurrencyStats.current_max_for(
-                policy_name:   policy_name,
-                partition_key: partition_key
-              )
-              DispatchPolicy::PartitionObservation.observe!(
-                policy_name:   policy_name,
-                partition_key: partition_key,
-                queue_lag_ms:  queue_lag_ms,
-                duration_ms:   duration_ms,
-                current_max:   current_max
-              )
-            end
-          end
-          DispatchPolicy::StagedJob.mark_completed_by_active_job_id(job.job_id)
-        end
-      end
-    end
-
-    def enqueue(options = {})
-      return super unless self.class.dispatch_policy?
-      if options[:_bypass_staging]
-        return super(options.except(:_bypass_staging))
-      end
-      return super unless DispatchPolicy.enabled?
-
-      # Mirror Active Job's scheduling option handling before staging.
-      self.scheduled_at = options[:wait].seconds.from_now if options[:wait]
-      self.scheduled_at = options[:wait_until] if options[:wait_until]
-      self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
-      self.priority     = options[:priority].to_i if options[:priority]
-
-      DispatchPolicy::StagedJob.stage!(
-        job_instance: self,
-        policy:       self.class.resolved_dispatch_policy
-      )
-      self
-    end
-
-    def serialize
-      super.merge(
-        "_dispatch_partitions"  => _dispatch_partitions || {},
-        "_dispatch_admitted_at" => _dispatch_admitted_at&.iso8601(6)
-      )
-    end
-
-    def deserialize(job_data)
-      super
-      self._dispatch_partitions  = job_data["_dispatch_partitions"]
-      ts                         = job_data["_dispatch_admitted_at"]
-      self._dispatch_admitted_at = ts ? Time.iso8601(ts) : nil
-    end
-  end
-end

data/lib/dispatch_policy/gates/fair_interleave.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module DispatchPolicy
-  module Gates
-    class FairInterleave < Gate
-      def configure(**_); end
-
-      def filter(batch, context)
-        groups = batch.group_by do |staged|
-          if @partition_by
-            partition_key_for(context.for(staged))
-          else
-            context.primary_partition_for(staged) || staged.id
-          end
-        end
-        interleaved = []
-        loop do
-          taken = false
-          groups.each_value do |g|
-            next if g.empty?
-            interleaved << g.shift
-            taken = true
-          end
-          break unless taken
-        end
-        interleaved
-      end
-    end
-
-    Gate.register(:fair_interleave, FairInterleave)
-  end
-end

data/lib/dispatch_policy/gates/global_cap.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module DispatchPolicy
-  module Gates
-    class GlobalCap < Gate
-      def configure(max:)
-        @max = max
-      end
-
-      def tracks_inflight?
-        true
-      end
-
-      def filter(batch, context)
-        limit     = resolve(@max, nil).to_i
-        in_flight = PartitionInflightCount.total_for(policy_name: policy.name, gate_name: name)
-        capacity  = [ limit - in_flight, 0 ].max
-        head      = batch.first(capacity)
-        context.record_partitions(head.map { |s| [ s, "default" ] }, gate: name)
-        head
-      end
-    end
-
-    Gate.register(:global_cap, GlobalCap)
-  end
-end