lepus 0.0.1.beta2 → 0.1.0

data/lib/lepus/message/delivery_info.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Lepus
+  class Message
+    # Internal data class representing delivery information.
+    # Provides the same interface as Bunny::DeliveryInfo (duck typing).
+    class DeliveryInfo
+      KNOWN_ATTRIBUTES = %i[delivery_tag redelivered exchange routing_key consumer_tag].freeze
+
+      attr_reader(*KNOWN_ATTRIBUTES)
+
+      def self.from_bunny(bunny_delivery_info)
+        new(
+          delivery_tag: bunny_delivery_info.delivery_tag,
+          redelivered: bunny_delivery_info.redelivered,
+          exchange: bunny_delivery_info.exchange,
+          routing_key: bunny_delivery_info.routing_key,
+          consumer_tag: bunny_delivery_info.consumer_tag
+        )
+      end
+
+      def initialize(**attrs)
+        @delivery_tag = attrs[:delivery_tag]
+        @redelivered = attrs.fetch(:redelivered, false)
+        @exchange = attrs[:exchange]
+        @routing_key = attrs[:routing_key]
+        @consumer_tag = attrs[:consumer_tag]
+        @extra_attributes = attrs.reject { |k, _| KNOWN_ATTRIBUTES.include?(k) }
+      end
+
+      def to_h
+        {
+          delivery_tag: delivery_tag,
+          redelivered: redelivered,
+          exchange: exchange,
+          routing_key: routing_key,
+          consumer_tag: consumer_tag
+        }.merge(@extra_attributes)
+      end
+
+      # Hash-style access to properties (compatible with Bunny::DeliveryInfo)
+      # @param key [Symbol, String] The property name
+      # @return [Object, nil] The property value
+      def [](key)
+        to_h[key.to_sym]
+      end
+
+      # Support dynamic attribute access for compatibility
+      def method_missing(method_name, *args)
+        return super if method_name.to_s.end_with?("=")
+        return super if args.any?
+
+        self[method_name]
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        !method_name.to_s.end_with?("=") || super
+      end
+
+      def eql?(other)
+        return false unless other.is_a?(self.class)
+
+        delivery_tag == other.delivery_tag &&
+          redelivered == other.redelivered &&
+          exchange == other.exchange &&
+          routing_key == other.routing_key &&
+          consumer_tag == other.consumer_tag
+      end
+      alias_method :==, :eql?
+    end
+  end
+end

data/lib/lepus/message/metadata.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Lepus
+  class Message
+    # Internal data class representing message metadata/properties.
+    # Provides the same interface as Bunny::MessageProperties (duck typing).
+    class Metadata
+      KNOWN_ATTRIBUTES = %i[
+        content_type content_encoding headers delivery_mode priority
+        correlation_id reply_to expiration message_id timestamp
+        type user_id app_id cluster_id
+      ].freeze
+
+      attr_reader(*KNOWN_ATTRIBUTES)
+
+      def self.from_bunny(bunny_metadata)
+        new(
+          content_type: bunny_metadata.content_type,
+          content_encoding: bunny_metadata.content_encoding,
+          headers: bunny_metadata.headers,
+          delivery_mode: bunny_metadata.delivery_mode,
+          priority: bunny_metadata.priority,
+          correlation_id: bunny_metadata.correlation_id,
+          reply_to: bunny_metadata.reply_to,
+          expiration: bunny_metadata.expiration,
+          message_id: bunny_metadata.message_id,
+          timestamp: bunny_metadata.timestamp,
+          type: bunny_metadata.type,
+          user_id: bunny_metadata.user_id,
+          app_id: bunny_metadata.app_id,
+          cluster_id: bunny_metadata.cluster_id
+        )
+      end
+
+      def initialize(**attrs)
+        @content_type = attrs[:content_type]
+        @content_encoding = attrs[:content_encoding]
+        @headers = attrs[:headers]
+        @delivery_mode = attrs[:delivery_mode]
+        @priority = attrs[:priority]
+        @correlation_id = attrs[:correlation_id]
+        @reply_to = attrs[:reply_to]
+        @expiration = attrs[:expiration]
+        @message_id = attrs[:message_id]
+        @timestamp = attrs[:timestamp]
+        @type = attrs[:type]
+        @user_id = attrs[:user_id]
+        @app_id = attrs[:app_id]
+        @cluster_id = attrs[:cluster_id]
+        @extra_attributes = attrs.reject { |k, _| KNOWN_ATTRIBUTES.include?(k) }
+      end
+
+      def to_h
+        {
+          content_type: content_type,
+          content_encoding: content_encoding,
+          headers: headers,
+          delivery_mode: delivery_mode,
+          priority: priority,
+          correlation_id: correlation_id,
+          reply_to: reply_to,
+          expiration: expiration,
+          message_id: message_id,
+          timestamp: timestamp,
+          type: type,
+          user_id: user_id,
+          app_id: app_id,
+          cluster_id: cluster_id
+        }.merge(@extra_attributes)
+      end
+
+      # Hash-style access to properties (compatible with Bunny::MessageProperties)
+      # @param key [Symbol, String] The property name
+      # @return [Object, nil] The property value
+      def [](key)
+        to_h[key.to_sym]
+      end
+
+      # Support dynamic attribute access for compatibility
+      def method_missing(method_name, *args)
+        return super if method_name.to_s.end_with?("=")
+        return super if args.any?
+
+        self[method_name]
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        !method_name.to_s.end_with?("=") || super
+      end
+
+      def eql?(other)
+        return false unless other.is_a?(self.class)
+
+        to_h == other.to_h
+      end
+      alias_method :==, :eql?
+    end
+  end
+end

data/lib/lepus/message.rb

@@ -2,20 +2,64 @@
 
 module Lepus
   class Message
-    attr_reader :delivery_info, :metadata, :payload
+    attr_reader :delivery_info, :metadata, :payload, :publish_options
+    attr_accessor :consumer_class
 
-    def initialize(delivery_info, metadata, payload)
+    # Coerce raw Bunny objects into a Message with internal data classes.
+    # This decouples the Message from Bunny-specific objects.
+    # If the objects are already internal classes, they are used as-is.
+    #
+    # @param bunny_delivery_info [Bunny::DeliveryInfo, DeliveryInfo] The delivery info from Bunny or internal class
+    # @param bunny_metadata [Bunny::MessageProperties, Metadata] The metadata from Bunny or internal class
+    # @param payload [String] The raw message payload
+    # @return [Message]
+    def self.coerce(bunny_delivery_info, bunny_metadata, payload)
+      delivery_info = if bunny_delivery_info.is_a?(DeliveryInfo)
+        bunny_delivery_info
+      else
+        DeliveryInfo.from_bunny(bunny_delivery_info)
+      end
+
+      metadata = if bunny_metadata.is_a?(Metadata)
+        bunny_metadata
+      else
+        Metadata.from_bunny(bunny_metadata)
+      end
+
+      channel = bunny_delivery_info.respond_to?(:channel) ? bunny_delivery_info.channel : nil
+
+      new(delivery_info, metadata, payload, channel: channel)
+    end
+
+    def initialize(delivery_info, metadata, payload, channel: nil, publish_options: nil)
       @delivery_info = delivery_info
       @metadata = metadata
       @payload = payload
+      @channel = channel
+      @publish_options = publish_options || {}
+    end
+
+    # Returns the channel associated with this message.
+    # Falls back to checking out a new channel from the producer connection pool if none is set.
+    # Note: The fallback channel is not memoized; each call will checkout a new channel.
+    #
+    # @return [Bunny::Channel, nil] The channel or nil if unavailable
+    def channel
+      return @channel if @channel
+
+      checkout_channel
     end
 
-    def mutate(payload: nil, metadata: nil, delivery_info: nil)
+    def mutate(payload: nil, metadata: nil, delivery_info: nil, consumer_class: nil, channel: nil, publish_options: nil)
       self.class.new(
         delivery_info || @delivery_info,
         metadata || @metadata,
-        payload || @payload
-      )
+        payload || @payload,
+        channel: channel || @channel,
+        publish_options: publish_options || @publish_options
+      ).tap do |message|
+        message.consumer_class = consumer_class || @consumer_class
+      end
     end
 
     def to_h
@@ -26,6 +70,35 @@ module Lepus
       }
     end
 
+    # Converts metadata and delivery_info into a hash suitable for Publisher.publish.
+    # Used by producer middlewares to pass options to the publisher.
+    #
+    # @return [Hash] Options hash compatible with Publisher.publish
+    def to_publish_options
+      opts = @publish_options.dup
+
+      if delivery_info
+        opts[:routing_key] = delivery_info.routing_key if delivery_info.routing_key
+      end
+
+      if metadata
+        opts[:headers] = metadata.headers if metadata.headers
+        opts[:content_type] = metadata.content_type if metadata.content_type
+        opts[:content_encoding] = metadata.content_encoding if metadata.content_encoding
+        opts[:correlation_id] = metadata.correlation_id if metadata.correlation_id
+        opts[:reply_to] = metadata.reply_to if metadata.reply_to
+        opts[:expiration] = metadata.expiration if metadata.expiration
+        opts[:message_id] = metadata.message_id if metadata.message_id
+        opts[:timestamp] = metadata.timestamp if metadata.timestamp
+        opts[:type] = metadata.type if metadata.type
+        opts[:app_id] = metadata.app_id if metadata.app_id
+        opts[:priority] = metadata.priority if metadata.priority
+        opts[:delivery_mode] = metadata.delivery_mode if metadata.delivery_mode
+      end
+
+      opts
+    end
+
     def eql?(other)
       other.is_a?(self.class) &&
         delivery_info == other.delivery_info &&
@@ -33,5 +106,15 @@ module Lepus
         payload == other.payload
     end
     alias_method :==, :eql?
+
+    private
+
+    def checkout_channel
+      Lepus.config.producer_config.with_connection do |connection|
+        connection.create_channel
+      end
+    rescue
+      nil
+    end
   end
 end

data/lib/lepus/middleware_chain.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Lepus
+  # Manages middleware registration and execution for producers.
+  # Middlewares can modify the message (payload, headers, routing_key, etc.)
+  # before it is published to RabbitMQ.
+  class MiddlewareChain
+    attr_reader :middlewares
+
+    def initialize
+      @middlewares = []
+    end
+
+    # Registers a middleware to the chain.
+    #
+    # @param middleware [Symbol, String, Class<Lepus::Middleware>] The middleware to register.
+    #   Can be a symbol/string (auto-loaded from producers/middlewares/) or a class.
+    # @param opts [Hash] Options passed to the middleware constructor.
+    # @return [self]
+    def use(middleware, opts = {})
+      instance = resolve_middleware(middleware, opts)
+      @middlewares << instance
+      self
+    end
+
+    # Executes the middleware chain with the given message.
+    # The final action (publishing) is called after all middlewares have processed the message.
+    #
+    # @param message [Lepus::Message] The message to process.
+    # @yield [message] Block called as the final action with the processed message.
+    # @return [Object] The result of the final action.
+    def execute(message, &final_action)
+      chain = @middlewares.reduce(final_action) do |next_middleware, middleware|
+        ->(msg) { middleware.call(msg, next_middleware) }
+      end
+      chain.call(message)
+    end
+
+    # Creates a combined chain from multiple chains.
+    # Used to merge global and per-producer middleware chains.
+    #
+    # @param chains [Array<MiddlewareChain>] The chains to combine.
+    # @return [MiddlewareChain] A new chain containing all middlewares.
+    def self.combine(*chains)
+      combined = new
+      chains.each do |chain|
+        chain.middlewares.each { |m| combined.middlewares << m }
+      end
+      combined
+    end
+
+    # Returns true if the chain has no middlewares.
+    #
+    # @return [Boolean]
+    def empty?
+      @middlewares.empty?
+    end
+
+    # Returns the number of middlewares in the chain.
+    #
+    # @return [Integer]
+    def size
+      @middlewares.size
+    end
+
+    private
+
+    def resolve_middleware(middleware, opts)
+      case middleware
+      when Symbol, String
+        load_middleware(middleware, opts)
+      when Class
+        middleware.new(**opts)
+      else
+        raise ArgumentError, "Middleware must be a Symbol, String, or Class, got #{middleware.class}"
+      end
+    end
+
+    def load_middleware(name, opts)
+      raise NotImplementedError, "Subclass must implement #load_middleware"
+    end
+  end
+end

data/lib/lepus/primitive/hash.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lepus::Primitive
+  class Hash < ::Hash
+    def initialize(*args)
+      args.each do |arg|
+        arg.each do |key, value|
+          self[key] = value
+        end
+      end
+    end
+
+    def deep_symbolize_keys
+      each_with_object(self.class.new) do |(key, value), result|
+        sym_key = key.is_a?(::String) ? key.to_sym : key
+        sym_value = if value.is_a?(::Hash)
+          self.class.new(value).deep_symbolize_keys
+        elsif value.is_a?(::Array)
+          value.map do |item|
+            item.is_a?(::Hash) ? self.class.new(item).deep_symbolize_keys : item
+          end
+        else
+          value
+        end
+        result[sym_key] = sym_value
+      end
+    end
+  end
+end

data/lib/lepus/process.rb

@@ -9,28 +9,13 @@ module Lepus
     end
 
     ATTRIBUTES = %i[id name pid hostname kind last_heartbeat_at supervisor_id].freeze
-    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
 
     class << self
       def register(**attributes)
         attributes[:id] ||= SecureRandom.uuid
         Lepus.instrument :register_process, **attributes do |payload|
           new(**attributes).tap do |process|
-            ProcessRegistry.instance.add(process)
+            ProcessRegistry.add(process)
             payload[:process_id] = process.id
           end
         rescue Exception => error # rubocop:disable Lint/RescueException
@@ -50,10 +35,16 @@ module Lepus
       end
 
       def prunable
-        ProcessRegistry.instance.all.select do |process|
+        ProcessRegistry.all.select do |process|
           process.last_heartbeat_at && process.last_heartbeat_at < Time.now - Lepus.config.process_alive_threshold
         end
       end
+
+      def coerce(raw)
+        attrs = raw.transform_keys(&:to_sym)
+        attrs[:last_heartbeat_at] = Time.iso8601(attrs[:last_heartbeat_at]) if attrs[:last_heartbeat_at]
+        new(**attrs)
+      end
     end
 
     attr_reader :attributes
@@ -63,6 +54,14 @@ module Lepus
       @attributes[:id] ||= SecureRandom.uuid
     end
 
+    def to_h
+      attributes.dup.tap do |hash|
+        if hash[:last_heartbeat_at]
+          hash[:last_heartbeat_at] = hash[:last_heartbeat_at].iso8601(6)
+        end
+      end
+    end
+
     ATTRIBUTES.each do |attribute|
       define_method(attribute) { attributes[attribute] }
     end
@@ -72,15 +71,15 @@ module Lepus
     end
 
     def rss_memory
-      MEMORY_GRABBER.call(pid)
+      Processes::MEMORY_GRABBER.call(pid)
     end
 
-    def heartbeat
+    def heartbeat(metrics: {})
       now = Time.now
       Lepus.instrument :heartbeat_process, process: self, rss_memory: 0, last_heartbeat_at: now do |payload|
-        ProcessRegistry.instance.find(id) # ensure process is still registered
+        ProcessRegistry.find(id) # ensure process is still registered
 
-        update_attributes(last_heartbeat_at: now)
+        update_attributes(last_heartbeat_at: now, metrics: metrics)
         payload[:rss_memory] = rss_memory
       rescue Exception => error # rubocop:disable Lint/RescueException
         payload[:error] = error
@@ -88,13 +87,14 @@ module Lepus
       end
     end
 
-    def update_attributes(new_attributes)
+    def update_attributes(metrics: {}, **new_attributes)
       @attributes = @attributes.merge(new_attributes)
+      ProcessRegistry.update(self, metrics: metrics)
     end
 
     def destroy!
       Lepus.instrument :destroy_process, process: self do |payload|
-        ProcessRegistry.instance.delete(self)
+        ProcessRegistry.delete(self)
       rescue Exception => error # rubocop:disable Lint/RescueException
         payload[:error] = error
         raise
@@ -130,7 +130,7 @@ module Lepus
     private
 
     def supervisees
-      ProcessRegistry.instance.all.select { |process| process.supervisor_id == id }
+      ProcessRegistry.all.select { |process| process.supervisor_id == id }
     end
   end
 end

data/lib/lepus/process_registry/backend.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Lepus
+  class ProcessRegistry
+    # Abstract backend interface for process registry storage.
+    # Implementations must provide all methods defined here.
+    module Backend
+      def start
+        raise NotImplementedError, "#{self.class}#start must be implemented"
+      end
+
+      def stop
+        raise NotImplementedError, "#{self.class}#stop must be implemented"
+      end
+
+      def add(process)
+        raise NotImplementedError, "#{self.class}#add must be implemented"
+      end
+
+      def update(process, metrics: {})
+        add(process, metrics: metrics)
+      end
+
+      def delete(process)
+        raise NotImplementedError, "#{self.class}#delete must be implemented"
+      end
+
+      def find(id)
+        raise NotImplementedError, "#{self.class}#find must be implemented"
+      end
+
+      def exists?(id)
+        raise NotImplementedError, "#{self.class}#exists? must be implemented"
+      end
+
+      def all
+        raise NotImplementedError, "#{self.class}#all must be implemented"
+      end
+
+      def count
+        raise NotImplementedError, "#{self.class}#count must be implemented"
+      end
+
+      def clear
+        raise NotImplementedError, "#{self.class}#clear must be implemented"
+      end
+    end
+  end
+end

data/lib/lepus/process_registry/file_backend.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "tmpdir"
+require "base64"
+
+module Lepus
+  class ProcessRegistry
+    # File-based backend for process registry storage.
+    # Stores process data in a file using Marshal serialization.
+    # This is the default backend for apps not using the web dashboard.
+    class FileBackend
+      include Backend
+
+      attr_reader :path
+
+      def initialize(path: nil)
+        @path = path
+      end
+
+      def start
+        @path ||= Pathname.new(Dir.tmpdir).join("lepus_process_registry.store")
+      end
+
+      def stop
+        path.delete if path&.exist?
+      end
+
+      def add(process, metrics: {})
+        transaction do |data|
+          data[process.id] = process.to_h
+        end
+      end
+
+      def delete(process)
+        transaction do |data|
+          data.delete(process.id)
+        end
+      end
+
+      def find(id)
+        raw = read.fetch(id) { raise(Lepus::Process::NotFoundError.new(id)) }
+        Lepus::Process.coerce(raw)
+      end
+
+      def exists?(id)
+        read.key?(id)
+      end
+
+      def all
+        read.keys.map { |id| find(id) }
+      end
+
+      def count
+        return 0 unless path
+
+        read.size
+      end
+
+      def clear
+        return unless path
+
+        write({})
+      end
+
+      private
+
+      def transaction
+        data = read
+        yield data
+        write(data)
+      end
+
+      def read
+        with_lock(File::LOCK_SH) do |f|
+          if f.size.zero?
+            {}
+          else
+            encoded = f.read
+            Marshal.load(Base64.strict_decode64(encoded))
+          end
+        end
+      end
+
+      def write(data)
+        with_lock(File::LOCK_EX) do |f|
+          f.rewind
+          f.truncate(0)
+          encoded = Base64.strict_encode64(Marshal.dump(data))
+          f.write(encoded)
+          f.flush
+        end
+      end
+
+      def with_lock(lock_type)
+        unless path
+          raise "ProcessRegistry not started. Call Lepus::ProcessRegistry.start first."
+        end
+        File.open(path, File::RDWR | File::CREAT | File::BINARY, 0o644) do |f|
+          f.flock(lock_type)
+          result = yield f
+          f.flock(File::LOCK_UN)
+          result
+        end
+      end
+    end
+  end
+end