lepus 0.0.1.beta2 → 0.1.0

data/lib/lepus/process_registry/message_builder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lepus
+  class ProcessRegistry
+    # Builds heartbeat messages for RabbitMQ publishing.
+    class MessageBuilder
+      VERSION = "1.0"
+
+      def initialize(process, metrics: {})
+        @process = process
+        @metrics = metrics
+      end
+
+      def build_heartbeat
+        {
+          type: "heartbeat",
+          version: VERSION,
+          process: process_data,
+          metrics: metrics_data
+        }
+      end
+
+      def build_deregister
+        {
+          type: "deregister",
+          version: VERSION,
+          process_id: @process.id,
+          timestamp: Time.now.iso8601(6)
+        }
+      end
+
+      def to_json
+        JSON.generate(build_heartbeat)
+      end
+
+      private
+
+      def process_data
+        {
+          id: @process.id,
+          name: @process.name,
+          pid: @process.pid,
+          hostname: @process.hostname,
+          kind: @process.kind,
+          supervisor_id: @process.supervisor_id,
+          application: Lepus.config.application_name,
+          last_heartbeat_at: format_time(@process.last_heartbeat_at)
+        }
+      end
+
+      def metrics_data
+        {
+          rss_memory: @metrics[:rss_memory] || safe_rss_memory,
+          connections: @metrics[:connections] || 0,
+          consumers: @metrics[:consumers] || []
+        }
+      end
+
+      def safe_rss_memory
+        @process.rss_memory * 1024 # Convert kB to bytes (MEMORY_GRABBER returns kB)
+      rescue
+        0
+      end
+
+      def format_time(time)
+        time&.iso8601(6)
+      end
+    end
+  end
+end

data/lib/lepus/process_registry/rabbitmq_backend.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "json"
+require "timeout"
+
+module Lepus
+  class ProcessRegistry
+    # RabbitMQ-based backend for process registry.
+    # Publishes heartbeats to a fanout exchange for web dashboard aggregation.
+    # Also writes locally via FileBackend for local queries when aggregator is unavailable.
+    class RabbitmqBackend
+      include Backend
+
+      HEARTBEAT_EXCHANGE = "lepus.heartbeat"
+
+      attr_reader :fallback
+
+      def initialize(fallback: nil)
+        @fallback = fallback || FileBackend.new
+        @connection = nil
+        @channel = nil
+        @exchange = nil
+        @mutex = Mutex.new
+      end
+
+      def start
+        @fallback.start
+        setup_channel_and_exchange
+      end
+
+      def stop
+        @fallback.stop
+        close_channel
+      end
+
+      def add(process, metrics: {})
+        @fallback.add(process)
+        publish_heartbeat(process, metrics: metrics)
+      end
+
+      def delete(process)
+        @fallback.delete(process)
+        publish_deregister(process)
+      end
+
+      def find(id)
+        @fallback.find(id)
+      end
+
+      def exists?(id)
+        @fallback.exists?(id)
+      end
+
+      def all
+        @fallback.all
+      end
+
+      def count
+        @fallback.count
+      end
+
+      def clear
+        @fallback.clear
+      end
+
+      def path
+        @fallback.path
+      end
+
+      private
+
+      def setup_channel_and_exchange
+        return unless rabbitmq_available?
+
+        @mutex.synchronize do
+          return if @channel&.open?
+
+          @connection = Lepus.config.create_connection(suffix: "(registry)")
+          @channel = @connection.create_channel
+          @exchange = @channel.fanout(
+            HEARTBEAT_EXCHANGE,
+            durable: false,
+            auto_delete: false
+          )
+        end
+      rescue => e
+        Lepus.logger.warn("[ProcessRegistry] Failed to setup RabbitMQ channel: #{e.message}")
+        @connection = nil
+        @channel = nil
+        @exchange = nil
+      end
+
+      # Tear down the dedicated registry connection on supervisor shutdown.
+      # Bunny's graceful close waits up to 15s per channel for a broker
+      # `close-ok` continuation; during forked supervisor shutdown the broker
+      # sometimes never replies and SIGTERM handling blows past its 10s budget,
+      # timing out the integration specs. We bound the graceful attempt at 2s
+      # and fall back to closing the socket directly so the process can exit.
+      CLOSE_TIMEOUT = 2
+
+      def close_channel
+        @mutex.synchronize do
+          force_close_connection if @connection
+        end
+      ensure
+        @connection = nil
+        @channel = nil
+        @exchange = nil
+      end
+
+      def force_close_connection
+        Timeout.timeout(CLOSE_TIMEOUT) { @connection.close(false) } if @connection.open?
+      rescue => e
+        Lepus.logger.warn("[ProcessRegistry] Failed to close RabbitMQ connection: #{e.message}")
+        begin
+          @connection.instance_variable_get(:@transport)&.close
+        rescue
+          nil
+        end
+      end
+
+      def publish_heartbeat(process, metrics: {})
+        return unless @exchange
+
+        message = MessageBuilder.new(process, metrics: metrics)
+        @exchange.publish(
+          message.to_json,
+          content_type: "application/json"
+        )
+      rescue => e
+        Lepus.logger.warn("[ProcessRegistry] Failed to publish heartbeat: #{e.message}")
+      end
+
+      def publish_deregister(process)
+        return unless @exchange
+
+        message = MessageBuilder.new(process).build_deregister
+        @exchange.publish(
+          JSON.generate(message),
+          content_type: "application/json"
+        )
+      rescue => e
+        Lepus.logger.warn("[ProcessRegistry] Failed to publish deregister: #{e.message}")
+      end
+
+      def rabbitmq_available?
+        Lepus.config.rabbitmq_url.present?
+      rescue
+        true
+      end
+    end
+  end
+end

data/lib/lepus/process_registry.rb

@@ -1,37 +1,70 @@
 # frozen_string_literal: true
 
-require "singleton"
-
 module Lepus
+  # Process registry that delegates to a configurable backend.
+  # Default backend is FileBackend for local file-based storage.
+  # Use RabbitmqBackend to share process data across apps via web dashboard.
   class ProcessRegistry
-    include Singleton
+    class << self
+      def backend
+        @backend ||= Lepus.config.build_process_registry_backend
+      end
 
-    def initialize
-      @processes = ::Concurrent::Hash.new
-    end
+      attr_writer :backend
 
-    def add(process)
-      @processes[process.id] = process
-    end
+      def reset_backend!
+        @backend = nil
+      end
 
-    def delete(process)
-      @processes.delete(process.id)
-    end
+      def start
+        backend.start
+      end
 
-    def find(id)
-      @processes[id] || raise(Lepus::Process::NotFoundError.new(id))
-    end
+      def stop
+        backend.stop
+      end
 
-    def exists?(id)
-      @processes.key?(id)
-    end
+      def reset!
+        stop
+        start
+      end
 
-    def all
-      @processes.values
-    end
+      def add(process)
+        backend.add(process)
+      end
+
+      def update(process, metrics: {})
+        backend.update(process, metrics: metrics)
+      end
+
+      def delete(process)
+        backend.delete(process)
+      end
+
+      def find(id)
+        backend.find(id)
+      end
+
+      def exists?(id)
+        backend.exists?(id)
+      end
+
+      def all
+        backend.all
+      end
+
+      def count
+        backend.count
+      end
+
+      def clear
+        backend.clear
+      end
 
-    def clear
-      @processes.clear
+      # For backward compatibility with tests that check @path
+      def path
+        backend.respond_to?(:path) ? backend.path : nil
+      end
     end
   end
 end

data/lib/lepus/processes/base.rb

@@ -12,7 +12,6 @@ module Lepus
       attr_reader :name
 
       def initialize(*)
-        @name = generate_name
         @stopped = false
       end
 
@@ -38,10 +37,6 @@ module Lepus
 
       private
 
-      def generate_name
-        [kind.downcase, SecureRandom.hex(10)].join("-")
-      end
-
       def stopped?
         @stopped
       end

data/lib/lepus/processes/callbacks.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Lepus::Processes
+  # Provides callback functionality for process lifecycle events.
   module Callbacks
     def self.included(base)
       base.extend(ClassMethods)
@@ -52,6 +53,8 @@ module Lepus::Processes
         @after_shutdown_callbacks.concat methods
       end
 
+      private
+
       def before_boot_callbacks
         @before_boot_callbacks || []
       end

data/lib/lepus/processes/interruptible.rb

@@ -2,14 +2,6 @@
 
 module Lepus::Processes
   module Interruptible
-    def wake_up
-      interrupt
-    end
-
-    private
-
-    SELF_PIPE_BLOCK_SIZE = 11
-
     def interrupt
       self_pipe[:writer].write_nonblock(".")
     rescue Errno::EAGAIN, Errno::EINTR
@@ -18,6 +10,10 @@ module Lepus::Processes
       retry
     end
 
+    private
+
+    SELF_PIPE_BLOCK_SIZE = 11
+
     def interruptible_sleep(time)
       if time > 0 && self_pipe[:reader].wait_readable(time)
         loop { self_pipe[:reader].read_nonblock(SELF_PIPE_BLOCK_SIZE) }

data/lib/lepus/processes/procline.rb

@@ -5,7 +5,7 @@ module Lepus::Processes
     # Sets the procline ($0)
     # [lepus-supervisor: <string>]
     def procline(string)
-      $0 = "[lepus-#{kind.downcase}: #{string}]"
+      $0 = "[lepus-#{string}]"
     end
   end
 end

data/lib/lepus/processes/registrable.rb

@@ -60,7 +60,7 @@ module Lepus::Processes
         process.heartbeat
       rescue Process::NotFoundError
         self.process = nil
-        wake_up
+        interrupt
       end
     end
   end

data/lib/lepus/processes/runnable.rb

@@ -27,7 +27,7 @@ module Lepus::Processes
     def stop
       super
 
-      wake_up
+      interrupt
       @thread&.join
     end
 

data/lib/lepus/processes.rb

@@ -2,5 +2,20 @@
 
 module Lepus
   module Processes
+    MEMORY_GRABBER = case RUBY_PLATFORM
+    when /linux/
+      ->(pid) {
+        IO.readlines("/proc/#{$$}/status").each do |line|
+          next unless line.start_with?("VmRSS:")
+          break line.split[1].to_i
+        end
+      }
+    when /darwin|bsd/
+      ->(pid) {
+        `ps -o pid,rss -p #{pid}`.lines.last.split.last.to_i
+      }
+    else
+      ->(pid) { 0 }
+    end
   end
 end

data/lib/lepus/producer.rb

@@ -1,42 +1,153 @@
 # frozen_string_literal: true
 
 module Lepus
+  # The abstract base class for producers publishing messages to exchanges.
+  # @abstract Subclass and override {#configure} to implement.
   class Producer
-    DEFAULT_EXCHANGE_OPTIONS = {
-      type: :topic,
-      durable: true,
-      auto_delete: false
-    }.freeze
-
-    DEFAULT_PUBLISH_OPTIONS = {
-      expiration: 7 * (60 * 60 * 24)
-    }.freeze
-
-    def initialize(exchange_name, **options)
-      @exchange_name = exchange_name
-      @exchange_options = DEFAULT_EXCHANGE_OPTIONS.merge(options)
-    end
+    class << self
+      def abstract_class?
+        return @abstract_class == true if defined?(@abstract_class)
 
-    def publish(message, **options)
-      payload = if message.is_a?(String)
-        options[:content_type] ||= "text/plain"
-        message
-      else
-        options[:content_type] ||= "application/json"
-        MultiJson.dump(message)
-      end
-
-      bunny.with_channel do |channel|
-        exchange = channel.exchange(@exchange_name, @exchange_options)
-        exchange.publish(
-          payload,
-          DEFAULT_PUBLISH_OPTIONS.merge(options)
+        instance_variable_get(:@definition).nil?
+      end
+
+      def abstract_class=(value)
+        @abstract_class = value
+        remove_instance_variable(:@definition) if instance_variable_defined?(:@definition)
+      end
+
+      def inherited(subclass)
+        super
+        subclass.abstract_class = false
+      end
+
+      def definition
+        return if abstract_class?
+        return @definition if defined?(@definition)
+
+        name = Primitive::String.new(to_s).underscore.split("/").last
+        @definition = Producers::Definition.new(exchange: name)
+      end
+
+      # Configures the producer, setting exchange and other options to be used by
+      # the publisher for sending messages.
+      #
+      # @param [Hash] opts The options to configure the producer with.
+      # @option opts [String, Hash] :exchange The name of the exchange to publish to.
+      # @option opts [Hash] :publish Default publish options (persistent, mandatory, immediate).
+      # @yield [definition] Optional block to further configure the producer.
+      # @yieldparam [Lepus::Producers::Definition] definition The definition object.
+      # @return [Lepus::Producers::Definition] The configured producer definition.
+      def configure(opts = {})
+        raise ArgumentError, "Cannot configure an abstract class" if abstract_class?
+
+        @definition = Producers::Definition.new(opts)
+        yield(@definition) if block_given?
+        @definition
+      end
+
+      def descendants # :nodoc:
+        descendants = []
+        ObjectSpace.each_object(singleton_class) do |k|
+          descendants.unshift k unless k == self
+        end
+        descendants.uniq
+      end
+
+      # Creates a publisher instance configured with this producer's settings.
+      # @return [Lepus::Publisher] A publisher instance ready to send messages.
+      def publisher
+        @publisher ||= Publisher.new(definition.exchange_name, **definition.exchange_options)
+      end
+
+      # Returns the middleware chain for this producer.
+      # @return [Lepus::Producers::MiddlewareChain]
+      def middleware_chain
+        @middleware_chain ||= Producers::MiddlewareChain.new
+      end
+
+      # Registers a middleware to this producer's chain.
+      #
+      # @param middleware [Symbol, String, Class<Lepus::Middleware>] The middleware to register.
+      # @param opts [Hash] Options passed to the middleware constructor.
+      # @return [Lepus::Producers::MiddlewareChain]
+      def use(middleware, opts = {})
+        middleware_chain.use(middleware, opts)
+      end
+
+      # Publishes a message using this producer's configuration.
+      # Executes the middleware chain (global + per-producer) before publishing.
+      #
+      # @param payload [String, Hash] The message payload to publish.
+      # @param options [Hash] Additional publish options (routing_key, headers, etc.).
+      # @return [void]
+      def publish(payload, **options)
+        if definition.nil?
+          raise InvalidProducerConfigError, <<~ERROR
+            The #{name} producer is not configured.
+            Please call #{name}.configure before using #{self.class.name}.publish.
+          ERROR
+        end
+
+        return unless Producers.enabled?(self)
+
+        publish_opts = definition.publish_options.merge(options)
+        message = build_message(payload, publish_opts)
+        combined_chain = MiddlewareChain.combine(
+          Lepus.config.producer_middleware_chain,
+          middleware_chain
         )
+
+        combined_chain.execute(message) do |msg|
+          publisher.publish(msg.payload, **msg.to_publish_options)
+        end
       end
+
+      private
+
+      def build_message(payload, options)
+        opts = options.dup
+        routing_key = opts.delete(:routing_key)
+        headers = opts.delete(:headers)
+
+        delivery_info = Message::DeliveryInfo.new(
+          exchange: definition.exchange_name,
+          routing_key: routing_key
+        )
+
+        metadata = Message::Metadata.new(
+          headers: headers,
+          content_type: opts.delete(:content_type),
+          content_encoding: opts.delete(:content_encoding),
+          correlation_id: opts.delete(:correlation_id),
+          reply_to: opts.delete(:reply_to),
+          expiration: opts.delete(:expiration),
+          message_id: opts.delete(:message_id),
+          timestamp: opts.delete(:timestamp),
+          type: opts.delete(:type),
+          app_id: opts.delete(:app_id),
+          priority: opts.delete(:priority),
+          delivery_mode: opts.delete(:delivery_mode)
+        )
+
+        # Remaining options (persistent, mandatory, etc.) are passed as publish_options
+        Message.new(delivery_info, metadata, payload, publish_options: opts)
+      end
+    end
+
+    # Instance methods for when you need to work with producer instances
+    def initialize
+      @definition = self.class.definition
     end
 
-    def bunny
-      Thread.current[:lepus_bunny] ||= Lepus.config.create_connection(suffix: "producer")
+    attr_reader :definition
+
+    def publisher
+      @publisher ||= Publisher.new(definition.exchange_name, **definition.exchange_options)
+    end
+
+    def publish(message, **options)
+      self.class.publish(message, **options)
     end
   end
 end

data/lib/lepus/producers/config.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Lepus
+  module Producers
+    # Configuration class for producer settings
+    class Config
+      extend Forwardable
+
+      DEFAULT_POOL_SIZE = 1
+      DEFAULT_POOL_TIMEOUT = 5.0
+
+      attr_accessor :pool_size, :pool_timeout
+
+      def_delegator :connection_pool, :with_connection
+
+      def initialize
+        @pool_size = DEFAULT_POOL_SIZE
+        @pool_timeout = DEFAULT_POOL_TIMEOUT
+      end
+
+      # Assign multiple attributes at once from a hash of options.
+      # @param options [Hash] hash of options to assign
+      # @return [void]
+      def assign(options = {})
+        options.each do |key, value|
+          raise ArgumentError, "Unknown attribute #{key}" unless respond_to?(:"#{key}=")
+
+          public_send(:"#{key}=", value)
+        end
+      end
+
+      private
+
+      # @return [Lepus::ConnectionPool] a connection pool instance configured for producers
+      def connection_pool
+        @connection_pool ||= Lepus::ConnectionPool.new(
+          size: pool_size,
+          timeout: pool_timeout,
+          suffix: "producer"
+        )
+      end
+    end
+  end
+end