lepus 0.0.1.beta2 → 0.1.0

data/lib/lepus/testing.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require_relative "testing/exchange"
+require_relative "testing/rspec_matchers"
+require_relative "testing/message_builder"
+
+module Lepus
+  module Testing
+    class << self
+      # Enable fake publishing mode and consumer error re-raising
+      def enable!
+        fake_publisher!
+        consumer_raise_errors!
+      end
+
+      # Disable fake publishing mode and consumer error re-raising
+      def disable!
+        fake_publisher_disable!
+        consumer_capture_errors!
+      end
+
+      # Enable fake publishing mode for testing
+      # When enabled, messages are stored in fake exchanges instead of being sent to RabbitMQ
+      def fake_publisher!
+        @fake_publisher_enabled = true
+      end
+
+      # Check if fake publishing is enabled
+      def fake_publisher_enabled?
+        @fake_publisher_enabled == true
+      end
+
+      # Disable fake publishing mode for testing
+      def fake_publisher_disable!
+        @fake_publisher_enabled = false
+      end
+
+      # When enabled, consumer exceptions are re-raised instead of being converted to :reject
+      # This is useful in specs, so RSpec can capture failures instead of false positives
+      def consumer_raise_errors!
+        @consumer_raise_errors_enabled = true
+      end
+
+      # Disable consumer error re-raising (default behavior converts to :reject)
+      def consumer_capture_errors!
+        @consumer_raise_errors_enabled = false
+      end
+
+      # Returns true if consumer errors should be re-raised in tests
+      def consumer_raise_errors?
+        @consumer_raise_errors_enabled == true
+      end
+
+      # Clear all messages from all fake exchanges
+      def clear_all_messages!
+        Exchange.clear_all_messages!
+      end
+
+      # Get all fake exchanges
+      def exchanges
+        Exchange.all
+      end
+
+      # Get a specific fake exchange by name
+      def exchange(name)
+        Exchange[name]
+      end
+
+      # Get messages for a specific producer class
+      def producer_messages(producer_class)
+        return [] unless producer_class.respond_to?(:definition)
+
+        begin
+          exchange_name = producer_class.definition.exchange_name
+          Exchange[exchange_name].messages
+        rescue
+          # If there's an error getting the exchange name, return empty array
+          []
+        end
+      end
+
+      # Test a consumer with a message
+      # @param consumer_class [Class] The consumer class to test
+      # @param message_or_payload [Lepus::Message, Hash, String] The message to process
+      # @return [Symbol] The result of the consumer's perform method (:ack, :reject, :requeue, :nack)
+      def consumer_perform(consumer_class, message_or_payload)
+        message = build_message(message_or_payload)
+        consumer = consumer_class.new
+        consumer.process_delivery(message.delivery_info, message.metadata, message.payload)
+      end
+
+      # Create a message builder for custom scenarios
+      # @return [MessageBuilder] A new message builder instance
+      def message_builder
+        MessageBuilder.new
+      end
+
+      private
+
+      # Build a message from various input types
+      def build_message(message_or_payload)
+        case message_or_payload
+        when Lepus::Message
+          message_or_payload
+        when Hash
+          if message_or_payload.key?(:payload)
+            # Hash with payload and other options
+            payload = message_or_payload.delete(:payload)
+            MessageBuilder.new
+              .with_payload(payload)
+              .tap { |builder| apply_options(builder, message_or_payload) }
+              .build
+          else
+            # Hash as payload - create message with Hash payload
+            MessageBuilder.new
+              .with_payload(message_or_payload)
+              .with_content_type("application/json")
+              .build
+          end
+        when String
+          MessageBuilder.new
+            .with_payload(message_or_payload)
+            .with_content_type("text/plain")
+            .build
+        else
+          raise ArgumentError, "Invalid message type: #{message_or_payload.class}"
+        end
+      end
+
+      # Apply options to a message builder
+      def apply_options(builder, options)
+        options.each do |key, value|
+          method_name = "with_#{key}"
+          if builder.respond_to?(method_name)
+            builder.send(method_name, value)
+          end
+        end
+      end
+
+      # Override Publisher methods when testing module is loaded
+      def setup_publisher_overrides!
+        return if @overrides_setup
+
+        # Add messages method to Producer class
+        Lepus::Producer.class_eval do
+          # Get messages published by this producer (only available in testing mode)
+          # @return [Array<Hash>] Array of published messages
+          def self.messages
+            Lepus::Testing.producer_messages(self)
+          end
+        end
+
+        # Override Publisher#publish
+        Lepus::Publisher.class_eval do
+          alias_method :original_publish, :publish
+
+          def publish(message, **options)
+            return unless Lepus::Producers.exchange_enabled?(exchange_name)
+
+            if Lepus::Testing.fake_publisher_enabled?
+              return fake_publish(message, **options)
+            end
+
+            original_publish(message, **options)
+          end
+
+          # Override Publisher#channel_publish
+          alias_method :original_channel_publish, :channel_publish
+
+          def channel_publish(channel, message, **options)
+            raise ArgumentError, "channel is required" unless channel
+            return unless Lepus::Producers.exchange_enabled?(exchange_name)
+
+            if Lepus::Testing.fake_publisher_enabled?
+              return fake_publish(message, **options)
+            end
+
+            original_channel_publish(channel, message, **options)
+          end
+
+          # Add fake_publish method
+          private
+
+          def fake_publish(message, **options)
+            opts = Lepus::Publisher::DEFAULT_PUBLISH_OPTIONS.merge(options)
+
+            fake_message = {
+              exchange: exchange_name,
+              payload: message, # Store the original message, not the JSON string
+              routing_key: opts[:routing_key],
+              headers: opts[:headers],
+              persistent: opts[:persistent],
+              mandatory: opts[:mandatory],
+              immediate: opts[:immediate],
+              content_type: message.is_a?(String) ? "text/plain" : "application/json",
+              timestamp: Time.now
+            }
+
+            Lepus::Testing::Exchange[exchange_name].add_message(fake_message)
+          end
+        end
+
+        @overrides_setup = true
+      end
+    end
+  end
+end
+
+# Automatically setup overrides when the testing module is required
+Lepus::Testing.send(:setup_publisher_overrides!)

data/lib/lepus/unique.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+begin
+  require "de_dupe"
+rescue LoadError
+  raise LoadError,
+    "The 'de-dupe' gem is required for Lepus unique middleware. " \
+    "Add `gem 'de-dupe'` to your Gemfile."
+end
+
+unless DeDupe.config.redis
+  raise Lepus::Error,
+    "DeDupe is not configured with Redis. " \
+    "Call DeDupe.configure { |c| c.redis = Redis.new } before requiring 'lepus/unique'."
+end
+
+require_relative "producers/middlewares/unique"
+require_relative "consumers/middlewares/unique"

data/lib/lepus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lepus
-  VERSION = "0.0.1.beta2"
+  VERSION = "0.1.0"
 end

data/lib/lepus/web/aggregator.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "json"
+require "concurrent"
+
+module Lepus
+  module Web
+    # Aggregates process heartbeats from RabbitMQ into in-memory state.
+    # Subscribes to the lepus.heartbeat fanout exchange and maintains
+    # a thread-safe cache of all processes across connected Lepus apps.
+    class Aggregator
+      HEARTBEAT_EXCHANGE = ProcessRegistry::RabbitmqBackend::HEARTBEAT_EXCHANGE
+
+      attr_reader :stale_threshold
+
+      def initialize(stale_threshold: nil)
+        @stale_threshold = stale_threshold || Lepus.config.process_alive_threshold
+        @processes = Concurrent::Map.new
+        @connection = nil
+        @channel = nil
+        @consumer = nil
+        @running = Concurrent::AtomicBoolean.new(false)
+        @pruning_task = nil
+        @mutex = Mutex.new
+      end
+
+      def start
+        return if @running.true?
+
+        @mutex.synchronize do
+          return if @running.true?
+
+          @running.make_true
+          setup_subscription
+          start_pruning_task
+        end
+      rescue => e
+        Lepus.logger.error("[Web::Aggregator] Failed to start: #{e.message}")
+        @running.make_false
+      end
+
+      def stop
+        @mutex.synchronize do
+          @running.make_false
+          @pruning_task&.shutdown
+          @consumer&.cancel
+          @channel&.close if @channel&.open?
+          @connection&.close if @connection&.open?
+        end
+      rescue => e
+        Lepus.logger.warn("[Web::Aggregator] Error during shutdown: #{e.message}")
+      ensure
+        @pruning_task = nil
+        @consumer = nil
+        @channel = nil
+        @connection = nil
+      end
+
+      def running?
+        @running.true?
+      end
+
+      def all_processes
+        prune_stale_entries
+        @processes.values.map { |data| data[:process] }
+      end
+
+      def find(id)
+        @processes[id]&.dig(:process)
+      end
+
+      def count
+        @processes.size
+      end
+
+      def clear
+        @processes.clear
+      end
+
+      private
+
+      def setup_subscription
+        @connection = Lepus.config.create_connection(suffix: "(web-aggregator)")
+        @channel = @connection.create_channel
+
+        exchange = @channel.fanout(
+          HEARTBEAT_EXCHANGE,
+          durable: false,
+          auto_delete: false
+        )
+
+        queue = @channel.queue("", exclusive: true, auto_delete: true)
+        queue.bind(exchange)
+
+        @consumer = queue.subscribe do |_delivery_info, _metadata, payload|
+          handle_message(payload)
+        end
+      end
+
+      def handle_message(payload)
+        data = JSON.parse(payload, symbolize_names: true)
+
+        case data[:type]
+        when "heartbeat"
+          process_heartbeat(data)
+        when "deregister"
+          process_deregistration(data)
+        end
+      rescue => e
+        Lepus.logger.warn("[Web::Aggregator] Failed to handle message: #{e.message}")
+      end
+
+      def process_heartbeat(data)
+        process_data = data[:process]
+        return unless process_data && process_data[:id]
+
+        metrics = data[:metrics] || {}
+
+        flat_process = process_data.merge(
+          rss_memory: metrics[:rss_memory] || 0,
+          connections: metrics[:connections] || 0,
+          consumers: metrics[:consumers] || []
+        )
+
+        @processes[process_data[:id]] = {
+          process: flat_process,
+          received_at: Time.now
+        }
+      end
+
+      def process_deregistration(data)
+        process_id = data[:process_id]
+        @processes.delete(process_id) if process_id
+      end
+
+      def start_pruning_task
+        @pruning_task = Concurrent::TimerTask.new(
+          execution_interval: [@stale_threshold / 2, 30].min
+        ) do
+          prune_stale_entries
+        end
+
+        @pruning_task.execute
+      end
+
+      def prune_stale_entries
+        threshold = Time.now - @stale_threshold
+        @processes.each do |id, data|
+          @processes.delete(id) if data[:received_at] < threshold
+        end
+      end
+    end
+  end
+end

data/lib/lepus/web/api.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Lepus
+  module Web
+    class API
+      def initialize(aggregator: nil, management_api: nil)
+        @aggregator = aggregator
+        @management_api = management_api
+      end
+
+      def call(env)
+        req = Rack::Request.new(env)
+        case req.path_info
+        when "/health"
+          Web::RespondWith.json(template: :health)
+        when "/processes"
+          processes_data
+        when "/queues"
+          queues_data
+        when "/connections"
+          connections_data
+        when "/exchanges"
+          exchanges_data
+        else
+          Web::RespondWith.json(template: :not_found)
+        end
+      end
+
+      private
+
+      def aggregator
+        @aggregator || Web.aggregator
+      end
+
+      def management_api
+        @management_api || Web.management_api
+      end
+
+      def processes_data
+        if aggregator&.running?
+          payload = aggregator.all_processes
+          Web::RespondWith.json(template: :ok, body: payload)
+        else
+          Web::RespondWith.json(template: :ok, body: [])
+        end
+      end
+
+      def queues_data
+        if management_api
+          raw_queues = management_api.queues
+          payload = annotate_queues_with_apps(raw_queues)
+          Web::RespondWith.json(template: :ok, body: payload)
+        else
+          Web::RespondWith.json(template: :ok, body: [])
+        end
+      rescue => e
+        Lepus.logger.warn("[Web::API] Failed to fetch queues: #{e.message}")
+        Web::RespondWith.json(template: :ok, body: [])
+      end
+
+      def connections_data
+        if management_api
+          payload = management_api.connections
+          Web::RespondWith.json(template: :ok, body: payload)
+        else
+          Web::RespondWith.json(template: :ok, body: [])
+        end
+      rescue => e
+        Lepus.logger.warn("[Web::API] Failed to fetch connections: #{e.message}")
+        Web::RespondWith.json(template: :ok, body: [])
+      end
+
+      def exchanges_data
+        if management_api
+          raw_exchanges = management_api.exchanges
+          payload = filter_exchanges(raw_exchanges)
+          Web::RespondWith.json(template: :ok, body: payload)
+        else
+          Web::RespondWith.json(template: :ok, body: [])
+        end
+      rescue => e
+        Lepus.logger.warn("[Web::API] Failed to fetch exchanges: #{e.message}")
+        Web::RespondWith.json(template: :ok, body: [])
+      end
+
+      def annotate_queues_with_apps(queues)
+        return queues unless aggregator&.running?
+
+        queue_app_map = build_queue_app_map
+        return queues if queue_app_map.empty?
+
+        queues.map do |queue|
+          app = queue_app_map[queue[:name]]
+          app ? queue.merge(application: app) : queue
+        end
+      end
+
+      def filter_exchanges(exchanges)
+        return exchanges if Lepus.config.web_show_all_exchanges
+        return exchanges unless aggregator&.running?
+
+        known_exchanges = build_known_exchange_names
+        return exchanges if known_exchanges.empty?
+
+        exchanges.select { |e| known_exchanges.include?(e[:name]) }
+      end
+
+      def build_queue_app_map
+        map = {}
+        aggregator.all_processes.each do |process|
+          app_name = process[:application]
+          next unless app_name
+
+          (process[:consumers] || []).each do |consumer|
+            map[consumer[:queue]] = app_name if consumer[:queue]
+          end
+        end
+        map
+      end
+
+      def build_known_exchange_names
+        names = Set.new
+        aggregator.all_processes.each do |process|
+          (process[:consumers] || []).each do |consumer|
+            names << consumer[:exchange] if consumer[:exchange]
+          end
+        end
+        names
+      end
+    end
+  end
+end

data/lib/lepus/web/app.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Lepus
+  module Web
+    class App
+      def self.build
+        root = Web.assets_path
+
+        Rack::Builder.new do
+          use Rack::Static,
+            urls: ["/assets", "/sw.js"],
+            root: root.to_s
+
+          map "/api" do
+            run Lepus::Web::API.new
+          end
+
+          run lambda { |env|
+            req = Rack::Request.new(env)
+            path = req.path_info
+
+            if path == "/" || path == "/index.html"
+              [200, {"content-type" => "text/html"}, [Web.render_index(env)]]
+            else
+              file_path = root.join(path.sub(%r{^/}, ""))
+              if File.file?(file_path)
+                [200, {"content-type" => Web.mime_for(file_path)}, [File.binread(file_path)]]
+              else
+                [200, {"content-type" => "text/html"}, [Web.render_index(env)]]
+              end
+            end
+          }
+        end
+      end
+    end
+  end
+end