pgbus 0.0.1 → 0.1.2

data/lib/pgbus/concurrency/semaphore.rb

@@ -8,57 +8,29 @@ module Pgbus
         # Returns :acquired if a slot was available, :blocked if the limit is reached.
         def acquire(key, max_value, duration)
           expires_at = Time.now.utc + duration
-
-          result = execute(<<~SQL, "Pgbus Semaphore Acquire", [key, max_value, expires_at])
-            INSERT INTO pgbus_semaphores (key, value, max_value, expires_at)
-            VALUES ($1, 1, $2, $3)
-            ON CONFLICT (key) DO UPDATE
-              SET value = pgbus_semaphores.value + 1,
-                  max_value = EXCLUDED.max_value,
-                  expires_at = GREATEST(pgbus_semaphores.expires_at, EXCLUDED.expires_at)
-              WHERE pgbus_semaphores.value < pgbus_semaphores.max_value
-            RETURNING value
-          SQL
-
-          result.any? ? :acquired : :blocked
+          Pgbus::Semaphore.acquire!(key, max_value, expires_at)
         end
 
         # Release one slot in the semaphore. Called after a job completes.
         def release(key)
-          execute(<<~SQL, "Pgbus Semaphore Release", [key])
-            UPDATE pgbus_semaphores
-            SET value = GREATEST(value - 1, 0)
-            WHERE key = $1
-          SQL
+          Pgbus::Semaphore.where(key: key).update_all("value = GREATEST(value - 1, 0)")
         end
 
         # Delete semaphores that have expired (safety net for crashed workers).
-        # Returns the number of deleted rows.
+        # Returns an array of hashes with expired keys.
+        # Uses DELETE ... RETURNING for atomicity (no race between pluck and delete).
         def expire_stale
-          result = execute(<<~SQL, "Pgbus Semaphore Expire", [Time.now.utc])
-            DELETE FROM pgbus_semaphores
-            WHERE expires_at < $1 OR value <= 0
-            RETURNING key
-          SQL
-
-          result.to_a
+          result = Pgbus::Semaphore.connection.exec_query(
+            "DELETE FROM pgbus_semaphores WHERE expires_at < $1 RETURNING key",
+            "Pgbus Semaphore Expire",
+            [Time.now.utc]
+          )
+          result.rows.map { |row| { "key" => row[0] } }
         end
 
         # Check current value for a key. Useful for testing/monitoring.
         def current_value(key)
-          result = execute(<<~SQL, "Pgbus Semaphore Value", [key])
-            SELECT value FROM pgbus_semaphores WHERE key = $1
-          SQL
-
-          result.first&.fetch("value", nil)&.to_i
-        end
-
-        private
-
-        def execute(sql, name, binds)
-          return [] unless defined?(ActiveRecord::Base)
-
-          ActiveRecord::Base.connection.exec_query(sql, name, binds)
+          Pgbus::Semaphore.where(key: key).pick(:value)
         end
       end
     end

data/lib/pgbus/concurrency.rb

@@ -22,13 +22,15 @@ module Pgbus
       def limits_concurrency(to:, key: nil, duration: 15 * 60, on_conflict: :block) # rubocop:disable Naming/MethodParameterName
         raise ArgumentError, "to: must be a positive integer" unless to.is_a?(Integer) && to.positive?
         raise ArgumentError, "on_conflict must be :block, :discard, or :raise" unless %i[block discard raise].include?(on_conflict)
+        raise ArgumentError, "duration must be a positive number" unless duration.is_a?(Numeric) && duration.positive?
+        raise ArgumentError, "key must be callable (Proc or lambda)" if key && !key.respond_to?(:call)
 
         @pgbus_concurrency = {
           limit: to,
           key: key || ->(*) { name },
           duration: duration,
           on_conflict: on_conflict
-        }
+        }.freeze
       end
 
       def pgbus_concurrency
@@ -45,7 +47,13 @@ module Pgbus
         config = active_job.class.pgbus_concurrency
         return nil unless config
 
-        config[:key].call(*active_job.arguments)
+        args = active_job.arguments
+        last = args.last
+        if last.is_a?(Hash) && last.each_key.all?(Symbol)
+          config[:key].call(*args[...-1], **last)
+        else
+          config[:key].call(*args)
+        end
       end
 
       # Inject the resolved concurrency key into the job's serialized payload.

data/lib/pgbus/configuration.rb

@@ -31,9 +31,21 @@ module Pgbus
     # LISTEN/NOTIFY
     attr_accessor :listen_notify, :notify_throttle_ms
 
+    # PGMQ schema installation mode (:auto, :extension, :embedded)
+    attr_reader :pgmq_schema_mode
+
     # Event consumers
     attr_accessor :event_consumers
 
+    # Recurring jobs
+    attr_accessor :recurring_tasks, :recurring_schedule_interval, :recurring_tasks_file,
+                  :skip_recurring, :recurring_execution_retention
+
+    # Multi-database support (optional separate database for pgbus tables)
+    # Set to { database: { writing: :pgbus, reading: :pgbus } } to use a separate database.
+    # Requires a matching entry in config/database.yml under the "pgbus" key.
+    attr_accessor :connects_to
+
     # Web dashboard
     attr_accessor :web_auth, :web_refresh_interval, :web_per_page, :web_live_updates, :web_data_source
 
@@ -66,8 +78,18 @@ module Pgbus
       @listen_notify = true
       @notify_throttle_ms = 250
 
+      @pgmq_schema_mode = :auto
+
       @event_consumers = nil
 
+      @recurring_tasks = nil
+      @recurring_schedule_interval = 1.0
+      @recurring_tasks_file = nil
+      @skip_recurring = false
+      @recurring_execution_retention = 7 * 24 * 3600 # 7 days
+
+      @connects_to = nil
+
       @web_auth = nil
       @web_refresh_interval = 5000
       @web_per_page = 25
@@ -83,6 +105,32 @@ module Pgbus
       "#{queue_name(name)}#{dead_letter_queue_suffix}"
     end
 
+    VALID_PGMQ_SCHEMA_MODES = %i[auto extension embedded].freeze
+
+    def pgmq_schema_mode=(mode)
+      mode = mode.to_sym
+      unless VALID_PGMQ_SCHEMA_MODES.include?(mode)
+        raise ArgumentError, "Invalid pgmq_schema_mode: #{mode}. Must be one of: #{VALID_PGMQ_SCHEMA_MODES.join(", ")}"
+      end
+
+      @pgmq_schema_mode = mode
+    end
+
+    def validate!
+      raise ArgumentError, "pool_size must be > 0" unless pool_size.is_a?(Numeric) && pool_size.positive?
+      raise ArgumentError, "pool_timeout must be > 0" unless pool_timeout.is_a?(Numeric) && pool_timeout.positive?
+      raise ArgumentError, "polling_interval must be > 0" unless polling_interval.is_a?(Numeric) && polling_interval.positive?
+      raise ArgumentError, "visibility_timeout must be > 0" unless visibility_timeout.is_a?(Numeric) && visibility_timeout.positive?
+      raise ArgumentError, "max_retries must be >= 0" unless max_retries.is_a?(Integer) && max_retries >= 0
+
+      workers.each do |w|
+        threads = w[:threads] || w["threads"] || 5
+        raise ArgumentError, "worker threads must be > 0" unless threads.is_a?(Integer) && threads.positive?
+      end
+
+      self
+    end
+
     def connection_options
       if database_url
         database_url

data/lib/pgbus/engine.rb

@@ -11,9 +11,23 @@ module Pgbus
       Pgbus::ConfigLoader.load(config_path) if config_path.exist?
     end
 
+    initializer "pgbus.recurring" do |app|
+      recurring_path = app.root.join("config", "recurring.yml")
+      if recurring_path.exist? && !Pgbus.configuration.recurring_tasks
+        Pgbus.configuration.recurring_tasks = Pgbus::Recurring::ConfigLoader.load(recurring_path)
+        Pgbus.configuration.recurring_tasks_file ||= recurring_path.to_s
+      end
+    end
+
+    initializer "pgbus.db" do
+      ActiveSupport.on_load(:active_record) do
+        Pgbus::ApplicationRecord.connects_to(**Pgbus.configuration.connects_to) if Pgbus.configuration.connects_to
+      end
+    end
+
     initializer "pgbus.active_job" do
       ActiveSupport.on_load(:active_job) do
-        require "pgbus/active_job/adapter"
+        include Pgbus::Concurrency
       end
     end
 
@@ -23,6 +37,10 @@ module Pgbus
       end
     end
 
+    rake_tasks do
+      load File.expand_path("../tasks/pgbus_pgmq.rake", __dir__)
+    end
+
     initializer "pgbus.web" do
       require "pgbus/web/authentication"
       require "pgbus/web/data_source"

data/lib/pgbus/event_bus/handler.rb

@@ -17,11 +17,7 @@ module Pgbus
         raw = JSON.parse(message.message)
         event = build_event(raw)
 
-        if self.class.idempotent?
-          return :skipped if already_processed?(event.event_id)
-
-          mark_processed!(event.event_id)
-        end
+        return :skipped if self.class.idempotent? && !claim_idempotency?(event.event_id)
 
         handle(event)
         instrument("pgbus.event_processed", event_id: event.event_id, handler: self.class.name)
@@ -51,25 +47,16 @@ module Pgbus
         ActiveSupport::Notifications.instrument(event_name, payload)
       end
 
-      def already_processed?(event_id)
-        return false unless defined?(ActiveRecord::Base)
-
-        ActiveRecord::Base.connection.select_value(
-          "SELECT 1 FROM pgbus_processed_events WHERE event_id = $1 AND handler_class = $2",
-          "Pgbus Idempotency Check",
-          [event_id, self.class.name]
-        )
-      end
-
-      def mark_processed!(event_id)
-        return unless defined?(ActiveRecord::Base)
-
-        ActiveRecord::Base.connection.exec_insert(
-          "INSERT INTO pgbus_processed_events (event_id, handler_class, processed_at) " \
-          "VALUES ($1, $2, $3) ON CONFLICT (event_id, handler_class) DO NOTHING",
-          "Pgbus Idempotency Mark",
-          [event_id, self.class.name, Time.now.utc]
+      # Atomically claim idempotency: INSERT ... ON CONFLICT DO NOTHING.
+      # Returns true if this handler claimed the event (row was inserted),
+      # false if another handler already processed it (conflict, no insert).
+      def claim_idempotency?(event_id)
+        result = ProcessedEvent.insert(
+          { event_id: event_id, handler_class: self.class.name, processed_at: Time.now.utc },
+          unique_by: %i[event_id handler_class]
         )
+        # insert returns an InsertAll::Result; inserted row count > 0 means we claimed it
+        result.rows.any?
       end
     end
   end

data/lib/pgbus/instrumentation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pgbus
+  # Lightweight instrumentation via ActiveSupport::Notifications.
+  #
+  # All events are prefixed with "pgbus." and carry timing information
+  # automatically when used with the block form of AS::Notifications.instrument.
+  #
+  # Events emitted:
+  #   pgbus.client.send_message   — single message enqueue
+  #   pgbus.client.send_batch     — batch enqueue
+  #   pgbus.client.read_batch     — batch dequeue
+  #   pgbus.client.read_message   — single message dequeue
+  #   pgbus.executor.execute      — full job execution (deserialize + perform + archive)
+  #   pgbus.serializer.serialize  — job/event serialization
+  #   pgbus.serializer.deserialize — job/event deserialization
+  #
+  module Instrumentation
+    module_function
+
+    def instrument(event, payload = {}, &block)
+      if defined?(ActiveSupport::Notifications)
+        ActiveSupport::Notifications.instrument(event, payload, &block)
+      elsif block
+        yield payload
+      end
+    end
+  end
+end