pgbus 0.19.0 → 0.19.2

data/lib/pgbus/recurring/scheduler.rb

@@ -7,24 +7,33 @@ module Pgbus
     class Scheduler
       include Process::SignalHandler
 
-      attr_reader :schedule, :config
+      attr_reader :schedule, :config, :deploy_runner
 
       def initialize(config: Pgbus.configuration)
         @config = config
         @schedule = Schedule.new(config: config)
+        # Deploy tasks (issue #536) ride this loop: the scheduler is already
+        # the one-per-deployment process, dedup'd across the overlap window.
+        @deploy_runner = Deploy::Runner.new(config: config) if config.deploy_tasks_enabled && config.deploy_tasks&.any?
         @shutting_down = false
         @last_runs = {}
         @loop_tick_at = Concurrent::AtomicReference.new(nil)
+        @deploy_error = nil
       end
 
+      # The order is load-bearing: the heartbeat registers this scheduler's row
+      # before it arms deploy tasks, so an old-revision scheduler in the
+      # overlap window sees it as lagging. A failed registration is logged and
+      # sync still runs; the new release's workers keep the old gate closed.
       def run
         setup_signals
         start_heartbeat
         sync_recurring_tasks
+        deploy_runner&.sync!
 
         Pgbus.logger.info do
           "[Pgbus] Scheduler started: #{schedule.tasks.size} recurring tasks, " \
-            "interval=#{config.recurring_schedule_interval}s"
+            "#{deploy_task_count} deploy tasks, interval=#{config.recurring_schedule_interval}s"
         end
 
         loop do
@@ -44,22 +53,12 @@ module Pgbus
       end
 
       def tick(now)
-        schedule.due_tasks(now).each do |task, run_at|
-          Pgbus::Instrumentation.instrument(
-            "pgbus.recurring.enqueue",
-            task: task.key,
-            class_name: task.class_name,
-            queue: task.queue_name,
-            run_at: run_at
-          ) do
-            schedule.enqueue_task(task, run_at: run_at)
-            @last_runs[task.key] = now
-          end
-        rescue StandardError => e
-          Pgbus.logger.error do
-            "[Pgbus] Error scheduling recurring task #{task.key}: #{e.class}: #{e.message}"
-          end
-        end
+        tick_recurring(now) if config.recurring_enabled
+        tick_deploy_tasks(now)
+      end
+
+      def deploy_task_count
+        deploy_runner&.task_count || 0
       end
 
       def last_run_at(key)
@@ -94,9 +93,43 @@ module Pgbus
 
       private
 
+      def tick_recurring(now)
+        schedule.due_tasks(now).each do |task, run_at|
+          Pgbus::Instrumentation.instrument(
+            "pgbus.recurring.enqueue",
+            task: task.key,
+            class_name: task.class_name,
+            queue: task.queue_name,
+            run_at: run_at
+          ) do
+            schedule.enqueue_task(task, run_at: run_at)
+            @last_runs[task.key] = now
+          end
+        rescue StandardError => e
+          Pgbus.logger.error do
+            "[Pgbus] Error scheduling recurring task #{task.key}: #{e.class}: #{e.message}"
+          end
+        end
+      end
+
+      # A persistent failure (the tables missing, the database down) is logged
+      # and reported once per distinct error, then at debug, not every tick.
+      def tick_deploy_tasks(now)
+        deploy_runner&.tick(now)
+        @deploy_error = nil
+      rescue StandardError => e
+        signature = "#{e.class}: #{e.message}"
+        if signature == @deploy_error
+          Pgbus.logger.debug { "[Pgbus] Error running deploy tasks (repeated): #{signature}" }
+        else
+          @deploy_error = signature
+          ErrorReporter.report(e, { action: "deploy_tasks_tick" }) # logs at error itself
+        end
+      end
+
       def sync_recurring_tasks
         tasks = config.recurring_tasks
-        return if tasks.nil?
+        return if tasks.nil? || !config.recurring_enabled
 
         RecurringTask.sync_from_config!(tasks)
         Pgbus.logger.info { "[Pgbus] Synced #{tasks.size} recurring task(s) from configuration" }
@@ -116,8 +149,9 @@ module Pgbus
       def start_heartbeat
         @heartbeat = Process::Heartbeat.new(
           kind: "scheduler",
+          config: @config,
           metadata: { pid: ::Process.pid, tasks: schedule.tasks.size, started_at: Time.now.to_f,
-                      supervisor_pid: ::Process.ppid },
+                      supervisor_pid: ::Process.ppid }.merge(deploy_runner ? { deploy_tasks: deploy_task_count } : {}),
           loop_tick_supplier: -> { @loop_tick_at.get }
         )
         @heartbeat.start

data/lib/pgbus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pgbus
-  VERSION = "0.19.0"
+  VERSION = "0.19.2"
 end

data/lib/pgbus/web/data_source/deploy_task_list.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Web
+    class DataSource
+      # The Deploy tasks page (issue #536): declared tasks with their last
+      # rollover and manual runs, one task's run history, the rollover the
+      # scheduler acts on, and the two actions (Run now, Enable/Disable).
+      module DeployTaskList
+        RUN_HISTORY = 25
+
+        # page/per_page nil returns every task (the MCP tool's default). An
+        # install without the tables (pgbus:add_deploy_tasks not run) gets the
+        # empty state, whose hint names the generator, not an error per refresh.
+        def deploy_tasks(page: nil, per_page: nil)
+          return [] unless DeployTask.table_exists?
+
+          scope = DeployTask.order(:key)
+          scope = scope.limit(per_page).offset(((page || 1) - 1) * per_page) if per_page
+          records = scope.to_a
+          runs = DeployTaskRun.latest_for(records.map(&:key)).group_by(&:task_key)
+          records.map { |record| deploy_task_row(record, runs.fetch(record.key, [])) }
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error fetching deploy tasks: #{e.class}: #{e.message}" }
+          []
+        end
+
+        def deploy_task(id)
+          return nil unless DeployTask.table_exists?
+
+          record = DeployTask.find_by(id: id)
+          return nil unless record
+
+          # The state reads the same unbounded latest-per-trigger runs as the
+          # list, so a run older than the 25 shown still counts.
+          runs = DeployTaskRun.for_task(record.key).recent(RUN_HISTORY).to_a
+          deploy_task_row(record, DeployTaskRun.latest_for([record.key]).to_a).merge(
+            arguments: record.parsed_arguments,
+            runs: runs.map { |run| deploy_run_hash(run).merge(queue_name: run.queue_name, msg_id: run.msg_id) }
+          )
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error fetching deploy task #{id}: #{e.class}: #{e.message}" }
+          nil
+        end
+
+        def toggle_deploy_task(id)
+          record = DeployTask.find_by(id: id)
+          return nil unless record
+
+          record.update!(enabled: !record.enabled)
+          record.enabled ? :enabled : :disabled
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error toggling deploy task #{id}: #{e.message}" }
+          nil
+        end
+
+        # Run now: the scheduler's enqueue path with no gate and no claim. It
+        # leaves a pending rollover arm alone and records a manual run.
+        # :enqueued or :failed, the real outcome.
+        def enqueue_deploy_task_now(id)
+          record = DeployTask.find_by(id: id)
+          return :failed unless record
+          # The hidden button is not the boundary: a disabled task is not run.
+          return disabled_enqueue(record) unless record.enabled
+
+          Deploy::Runner.new(config: Pgbus.configuration).enqueue(record.to_task, triggered_by: Deploy::Runner::MANUAL)
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error enqueuing deploy task #{id}: #{e.class}: #{e.message}" }
+          :failed
+        end
+
+        # The rollover judged against the newest live scheduler's revision,
+        # not this web process's; that one only when no scheduler is live
+        # (scheduler: false says so). nil when it cannot be read.
+        def deploy_rollover(now: Time.current)
+          scheduler, revision = Deploy::Rollover.scheduler_revision(now: now)
+          revision = Deploy::Revision.current unless scheduler
+          status = Deploy::Rollover.check(revision: revision, now: now)
+          { revision: revision, reason: status.reason, lagging: status.lagging, workers_live: status.workers_live,
+            live_by_revision: status.live_by_revision, scheduler: scheduler }
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error reading the deploy rollover: #{e.class}: #{e.message}" }
+          nil
+        end
+
+        private
+
+        def disabled_enqueue(record)
+          Pgbus.logger.warn { "[Pgbus::Web] Deploy task #{record.key} is disabled; Run now refused" }
+          :failed
+        end
+
+        def deploy_task_row(record, latest_runs)
+          by_trigger = latest_runs.index_by(&:triggered_by)
+          {
+            id: record.id, key: record.key, class_name: record.class_name, command: record.command,
+            version: record.version, every_deploy: record.every_deploy, queue_name: record.queue_name,
+            priority: record.priority, description: record.description, enabled: record.enabled,
+            static: record.static, armed_at: record.armed_at, armed_for: record.armed_for,
+            last_rollover_run: deploy_run_hash(by_trigger[Deploy::Runner::ROLLOVER]),
+            last_manual_run: deploy_run_hash(by_trigger[Deploy::Runner::MANUAL]),
+            created_at: record.created_at, updated_at: record.updated_at
+          }
+        end
+
+        def deploy_run_hash(run)
+          return nil unless run
+
+          { run_at: run.run_at, revision: run.revision, version: run.version, triggered_by: run.triggered_by }
+        end
+      end
+    end
+  end
+end

data/lib/pgbus/web/data_source/list_counts.rb

@@ -34,13 +34,14 @@ module Pgbus
         # names rather than lambdas, so the constant is plain frozen data.
         LIST_MODELS = {
           batches: :BatchEntry,
+          deploy_tasks: :DeployTask,
           job_locks: :UniquenessKey,
           outbox: :OutboxEntry,
           processed_events: :ProcessedEvent,
           recurring_tasks: :RecurringTask
         }.freeze
 
-        # list – :batches, :job_locks, :concurrency_keys, :outbox, :processed_events or :recurring_tasks.
+        # list – :batches, :deploy_tasks, :job_locks, :concurrency_keys, :outbox, :processed_events or :recurring_tasks.
         def list_count(list)
           raise ArgumentError, "unknown list: #{list.inspect}" unless list == :concurrency_keys || LIST_MODELS.key?(list)
 

data/lib/pgbus/web/data_source.rb

@@ -12,6 +12,7 @@ module Pgbus
       include EventList
       include ProcessList
       include DashboardSignals
+      include DeployTaskList
 
       # pgbus_failed_events rows outside the EventBus handler queues; binds
       # handler_queue_names_literal as $1.

data/lib/pgbus/web/deploy_task_state.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Web
+    # The Deploy tasks page's words for one task (issue #536), derived from
+    # its row and the rollover the scheduler acts on (DataSource#deploy_rollover),
+    # so the page prints the reason the scheduler waits for. Pure.
+    #
+    # States: disabled, waiting (armed, gate closed, with the gate's reason),
+    # due (armed, gate open), ran (not armed, has a rollover run), never. A
+    # manual run is appended to any state through manual_args.
+    module DeployTaskState
+      BADGE_TONES = { "disabled" => :gray, "waiting" => :yellow, "due" => :indigo, "ran" => :green,
+                      "never" => :gray }.freeze
+
+      Result = Data.define(:state, :reason_key, :reason_args, :badge_tone, :manual_args)
+
+      module_function
+
+      # row – a DataSource#deploy_tasks row. rollover – DataSource#deploy_rollover, or nil when unreadable.
+      def present(row, rollover)
+        state, key, args = derive(row, rollover)
+        manual = row[:last_manual_run]
+        Result.new(state: state, reason_key: key, reason_args: args, badge_tone: BADGE_TONES.fetch(state),
+                   manual_args: manual ? { ago: manual[:run_at] } : nil)
+      end
+
+      def derive(row, rollover)
+        return ["disabled", row[:armed_at] ? "disabled_armed" : "disabled", {}] unless row[:enabled]
+        return armed(rollover) if row[:armed_at]
+
+        run = row[:last_rollover_run]
+        return ["never", "never", {}] unless run
+
+        ["ran", "ran", { ago: run[:run_at], revision: run[:revision] }]
+      end
+
+      def armed(rollover)
+        return ["waiting", "waiting_unknown", {}] unless rollover
+        return ["waiting", "waiting_no_scheduler", {}] unless rollover[:scheduler]
+
+        case rollover[:reason]
+        when :ready then ["due", "due", {}]
+        when :lagging then ["waiting", "waiting_lagging", { count: rollover[:lagging].size, revision: rollover[:revision] }]
+        when :no_workers then ["waiting", "waiting_no_workers", { revision: rollover[:revision] }]
+        else ["waiting", "waiting_no_revision", {}]
+        end
+      end
+    end
+  end
+end

data/lib/pgbus.rb

@@ -298,6 +298,17 @@ module Pgbus
       Streams::Key.queue_name_budget
     end
 
+    # Open a batch, yield a Pgbus::Batch::Builder, and start the batch when
+    # the block returns — the top-level shortcut for Pgbus::Batch.start.
+    #
+    #   Pgbus.batch(description: "Import") do |b|
+    #     b.on_complete ImportDoneJob
+    #     b.add(*rows.map { |row| ImportRowJob.new(row.id) })
+    #   end
+    def batch(**, &)
+      Batch.start(**, &)
+    end
+
     # Publish an event to the bus — the top-level shortcut for
     # `Pgbus::EventBus::Publisher.publish`, symmetric with `Pgbus.stream`.
     #

data/sig/pgbus/configuration.rbs

@@ -7,6 +7,8 @@ module Pgbus
   class Configuration
     def allowed_global_id_models: () -> untyped
     def allowed_global_id_models=: (untyped) -> untyped
+    def app_revision: () -> untyped
+    def app_revision=: (untyped) -> untyped
     def apply_log_format!: () -> void
     def appsignal_enabled: () -> bool
     def appsignal_enabled=: (untyped) -> untyped
@@ -46,6 +48,14 @@ module Pgbus
     def default_priority=: (untyped) -> untyped
     def default_queue: () -> String
     def default_queue=: (untyped) -> untyped
+    def deploy_task_run_retention: () -> Numeric?
+    def deploy_task_run_retention=: (untyped value) -> untyped
+    def deploy_tasks: () -> untyped
+    def deploy_tasks=: (untyped) -> untyped
+    def deploy_tasks_enabled: () -> bool
+    def deploy_tasks_enabled=: (untyped) -> untyped
+    def deploy_tasks_files: () -> untyped
+    def deploy_tasks_files=: (untyped) -> untyped
     def dispatch_interval: () -> Float
     def dispatch_interval=: (untyped) -> untyped
     def doctor_on_boot: () -> untyped

data/sig/pgbus.rbs

@@ -49,6 +49,13 @@ module Pgbus
     end
   end
 
+  # Partial: only the types Pgbus.batch names. Batch's own methods are not
+  # covered by spec/pgbus/rbs_spec.rb yet.
+  class Batch
+    class Builder
+    end
+  end
+
   def self.configuration: () -> Configuration
   def self.configure: () { (Configuration) -> void } -> Configuration
   def self.finalize!: () -> Configuration
@@ -57,6 +64,8 @@ module Pgbus
   def self.stream_key: (*untyped parts, ?digest_bits: Integer) -> String
   def self.stream_key!: (String key) -> String
   def self.stream_name_budget: () -> Integer
+  # Keywords go to Pgbus::Batch.new (description:, properties:, on_complete:, uniqueness_key:, …).
+  def self.batch: (**untyped options) { (Batch::Builder) -> void } -> Batch
   # delay: seconds, as a Numeric or an ActiveSupport::Duration (1.hour).
   def self.publish: (String routing_key, untyped payload, ?headers: Hash[String, untyped]?, ?delay: Numeric | _ToI) -> untyped
   def self.publish_later: (String routing_key, untyped payload, delay: Numeric | _ToI, ?headers: Hash[String, untyped]?) -> untyped

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgbus
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.19.2
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -134,6 +134,7 @@ files:
 - app/controllers/pgbus/batches_controller.rb
 - app/controllers/pgbus/dashboard_controller.rb
 - app/controllers/pgbus/dead_letter_controller.rb
+- app/controllers/pgbus/deploy_tasks_controller.rb
 - app/controllers/pgbus/events_controller.rb
 - app/controllers/pgbus/frontends_controller.rb
 - app/controllers/pgbus/insights_controller.rb
@@ -159,6 +160,7 @@ files:
 - app/helpers/pgbus/application_helper.rb
 - app/helpers/pgbus/button_helper.rb
 - app/helpers/pgbus/dashboard_helper.rb
+- app/helpers/pgbus/deploy_tasks_helper.rb
 - app/helpers/pgbus/events_helper.rb
 - app/helpers/pgbus/insights_helper.rb
 - app/helpers/pgbus/processes_helper.rb
@@ -167,6 +169,8 @@ files:
 - app/models/pgbus/batch_entry.rb
 - app/models/pgbus/batch_execution.rb
 - app/models/pgbus/blocked_execution.rb
+- app/models/pgbus/deploy_task.rb
+- app/models/pgbus/deploy_task_run.rb
 - app/models/pgbus/job_stat.rb
 - app/models/pgbus/outbox_entry.rb
 - app/models/pgbus/process_entry.rb
@@ -194,6 +198,10 @@ files:
 - app/views/pgbus/dead_letter/_row.html.erb
 - app/views/pgbus/dead_letter/index.html.erb
 - app/views/pgbus/dead_letter/show.html.erb
+- app/views/pgbus/deploy_tasks/_rollover_banner.html.erb
+- app/views/pgbus/deploy_tasks/_tasks_table.html.erb
+- app/views/pgbus/deploy_tasks/index.html.erb
+- app/views/pgbus/deploy_tasks/show.html.erb
 - app/views/pgbus/events/_list.html.erb
 - app/views/pgbus/events/_processed_table.html.erb
 - app/views/pgbus/events/_replay.html.erb
@@ -246,6 +254,7 @@ files:
 - lib/active_job/queue_adapters/pgbus_adapter.rb
 - lib/generators/pgbus/add_batch_callback_jobs_generator.rb
 - lib/generators/pgbus/add_batch_executions_generator.rb
+- lib/generators/pgbus/add_deploy_tasks_generator.rb
 - lib/generators/pgbus/add_failed_events_index_generator.rb
 - lib/generators/pgbus/add_job_stats_generator.rb
 - lib/generators/pgbus/add_job_stats_latency_generator.rb
@@ -264,6 +273,7 @@ files:
 - lib/generators/pgbus/migration_path.rb
 - lib/generators/pgbus/templates/add_batch_callback_jobs.rb.erb
 - lib/generators/pgbus/templates/add_batch_executions.rb.erb
+- lib/generators/pgbus/templates/add_deploy_tasks_tables.rb.erb
 - lib/generators/pgbus/templates/add_failed_events_unique_index.rb.erb
 - lib/generators/pgbus/templates/add_job_stats.rb.erb
 - lib/generators/pgbus/templates/add_job_stats_latency.rb.erb
@@ -277,6 +287,7 @@ files:
 - lib/generators/pgbus/templates/add_stream_queues.rb.erb
 - lib/generators/pgbus/templates/add_stream_stats.rb.erb
 - lib/generators/pgbus/templates/add_uniqueness_keys.rb.erb
+- lib/generators/pgbus/templates/deploy_tasks.yml.erb
 - lib/generators/pgbus/templates/initializer.rb.erb
 - lib/generators/pgbus/templates/migrate_job_locks_to_uniqueness_keys.rb.erb
 - lib/generators/pgbus/templates/migration.rb.erb
@@ -296,6 +307,7 @@ files:
 - lib/pgbus/active_job/executor.rb
 - lib/pgbus/autovacuum_tuning.rb
 - lib/pgbus/batch.rb
+- lib/pgbus/batch/builder.rb
 - lib/pgbus/batch/sweep.rb
 - lib/pgbus/bus_record.rb
 - lib/pgbus/circuit_breaker.rb
@@ -315,6 +327,7 @@ files:
 - lib/pgbus/concurrency/semaphore.rb
 - lib/pgbus/configuration.rb
 - lib/pgbus/configuration/capsule_dsl.rb
+- lib/pgbus/configuration/deploy_settings.rb
 - lib/pgbus/configuration/presence_settings.rb
 - lib/pgbus/configuration/stream_authorization.rb
 - lib/pgbus/current_attributes.rb
@@ -322,6 +335,10 @@ files:
 - lib/pgbus/dead_letter_header.rb
 - lib/pgbus/dedicated_connection.rb
 - lib/pgbus/dedup_cache.rb
+- lib/pgbus/deploy/revision.rb
+- lib/pgbus/deploy/rollover.rb
+- lib/pgbus/deploy/runner.rb
+- lib/pgbus/deploy/task.rb
 - lib/pgbus/doctor.rb
 - lib/pgbus/engine.rb
 - lib/pgbus/error_reporter.rb
@@ -357,6 +374,7 @@ files:
 - lib/pgbus/mcp/runner.rb
 - lib/pgbus/mcp/server.rb
 - lib/pgbus/mcp/tools/concurrency_tool.rb
+- lib/pgbus/mcp/tools/deploy_tasks_tool.rb
 - lib/pgbus/mcp/tools/dlq_detail_tool.rb
 - lib/pgbus/mcp/tools/dlq_tool.rb
 - lib/pgbus/mcp/tools/health_tool.rb
@@ -447,12 +465,14 @@ files:
 - lib/pgbus/web/data_source.rb
 - lib/pgbus/web/data_source/dashboard_signals.rb
 - lib/pgbus/web/data_source/dead_letter.rb
+- lib/pgbus/web/data_source/deploy_task_list.rb
 - lib/pgbus/web/data_source/event_list.rb
 - lib/pgbus/web/data_source/job_list.rb
 - lib/pgbus/web/data_source/list_counts.rb
 - lib/pgbus/web/data_source/process_list.rb
 - lib/pgbus/web/data_source/queue_summary.rb
 - lib/pgbus/web/dead_letter_reason.rb
+- lib/pgbus/web/deploy_task_state.rb
 - lib/pgbus/web/event_state.rb
 - lib/pgbus/web/health_app.rb
 - lib/pgbus/web/health_server.rb