lepus 0.0.1.beta2 → 0.1.0

data/lib/lepus/web/management_api.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Lepus
+  module Web
+    # HTTP client for RabbitMQ Management API.
+    # Fetches queue and connection statistics.
+    class ManagementAPI
+      DEFAULT_PORT = 15672
+
+      attr_reader :base_url, :vhost
+
+      def initialize(base_url: nil, vhost: "/")
+        @base_url = base_url || derive_management_url
+        @vhost = vhost
+      end
+
+      # Fetch all queues for the configured vhost
+      # @return [Array<Hash>] array of queue data
+      def queues
+        data = get("/api/queues/#{encode_vhost}")
+        return [] unless data.is_a?(Array)
+
+        data.map { |q| normalize_queue(q) }
+      end
+
+      # Fetch all exchanges for the configured vhost
+      # @return [Array<Hash>] array of exchange data
+      def exchanges
+        data = get("/api/exchanges/#{encode_vhost}")
+        return [] unless data.is_a?(Array)
+
+        data
+          .reject { |e| e["name"].to_s.empty? || e["name"].to_s.start_with?("amq.") }
+          .map { |e| normalize_exchange(e) }
+      end
+
+      # Fetch all connections
+      # @return [Array<Hash>] array of connection data
+      def connections
+        data = get("/api/connections")
+        return [] unless data.is_a?(Array)
+
+        data.map { |c| normalize_connection(c) }
+      end
+
+      # Fetch a specific queue
+      # @param name [String] queue name
+      # @return [Hash, nil] queue data or nil if not found
+      def queue(name)
+        data = get("/api/queues/#{encode_vhost}/#{encode_name(name)}")
+        normalize_queue(data) if data
+      rescue NotFoundError
+        nil
+      end
+
+      class Error < StandardError; end
+
+      class ConnectionError < Error; end
+
+      class AuthenticationError < Error; end
+
+      class NotFoundError < Error; end
+
+      private
+
+      def parse_rabbitmq_uri
+        URI.parse(Lepus.config.rabbitmq_url)
+      rescue
+        nil
+      end
+
+      def derive_management_url
+        uri = parse_rabbitmq_uri
+        return "http://localhost:#{DEFAULT_PORT}" unless uri
+
+        "http://#{uri.host}:#{DEFAULT_PORT}"
+      end
+
+      def credentials
+        uri = parse_rabbitmq_uri
+        return unless uri&.user
+
+        [uri.user, uri.password]
+      end
+
+      def encode_vhost
+        URI.encode_www_form_component(@vhost)
+      end
+
+      def encode_name(name)
+        URI.encode_www_form_component(name)
+      end
+
+      def get(path)
+        uri = URI.parse("#{@base_url}#{path}")
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = 5
+        http.read_timeout = 10
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        if (creds = credentials)
+          request.basic_auth(*creds)
+        end
+        request["Accept"] = "application/json"
+
+        response = http.request(request)
+
+        case response.code.to_i
+        when 200
+          JSON.parse(response.body)
+        when 401
+          raise AuthenticationError, "Authentication failed for RabbitMQ Management API"
+        when 404
+          raise NotFoundError, "Resource not found: #{path}"
+        else
+          raise Error, "RabbitMQ Management API error: #{response.code} - #{response.body}"
+        end
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, Net::OpenTimeout, Net::ReadTimeout => e
+        raise ConnectionError, "Failed to connect to RabbitMQ Management API: #{e.message}"
+      end
+
+      def normalize_queue(q)
+        {
+          name: q["name"],
+          type: q["type"] || "classic",
+          messages: q["messages"] || 0,
+          messages_ready: q["messages_ready"] || 0,
+          messages_unacknowledged: q["messages_unacknowledged"] || 0,
+          consumers: q["consumers"] || 0,
+          memory: q["memory"] || 0,
+          message_stats: normalize_message_stats(q["message_stats"])
+        }
+      end
+
+      def normalize_message_stats(stats)
+        return {} unless stats
+
+        {
+          publish: stats["publish"] || 0,
+          publish_rate: stats.dig("publish_details", "rate") || 0.0,
+          deliver_get: stats["deliver_get"] || 0,
+          deliver_get_rate: stats.dig("deliver_get_details", "rate") || 0.0,
+          ack: stats["ack"] || 0,
+          ack_rate: stats.dig("ack_details", "rate") || 0.0,
+          redeliver: stats["redeliver"] || 0,
+          redeliver_rate: stats.dig("redeliver_details", "rate") || 0.0
+        }
+      end
+
+      def normalize_exchange(e)
+        {
+          name: e["name"],
+          type: e["type"],
+          durable: e["durable"],
+          auto_delete: e["auto_delete"],
+          message_stats: normalize_exchange_stats(e["message_stats"])
+        }
+      end
+
+      def normalize_exchange_stats(stats)
+        return {} unless stats
+
+        {
+          publish_in: stats["publish_in"] || 0,
+          publish_in_rate: stats.dig("publish_in_details", "rate") || 0.0,
+          publish_out: stats["publish_out"] || 0,
+          publish_out_rate: stats.dig("publish_out_details", "rate") || 0.0
+        }
+      end
+
+      def normalize_connection(c)
+        {
+          name: c["name"],
+          state: c["state"],
+          user: c["user"],
+          vhost: c["vhost"],
+          channels: c["channels"] || 0,
+          connected_at: c["connected_at"],
+          client_properties: {
+            connection_name: c.dig("client_properties", "connection_name")
+          }
+        }
+      end
+    end
+  end
+end

data/lib/lepus/web/respond_with.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lepus
+  module Web
+    class RespondWith
+      TEMPLATES = {
+        not_found: {
+          status: 404,
+          body: {error: "not_found"}
+        },
+        health: {
+          status: 200,
+          body: {status: "ok"}
+        },
+        ok: {
+          status: 200
+        }
+      }.freeze
+
+      def self.json(template: nil, body: nil, status: nil, headers: {})
+        headers["content-type"] = "application/json"
+        body ||= TEMPLATES.dig(template, :body)
+        status ||= TEMPLATES.dig(template, :status) || 200
+        [status, headers, [MultiJson.dump(body)]]
+      end
+    end
+  end
+end

data/lib/lepus/web.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "rack"
+require "multi_json"
+require "pathname"
+
+module Lepus
+  module Web
+    # Web-specific configuration extensions.
+    # Only activated when lepus/web is explicitly required.
+    module ConfigExtensions
+      attr_accessor :web_show_all_exchanges
+
+      def initialize(*)
+        super
+        @web_show_all_exchanges = false
+        # The FileBackend writes to a local path, which breaks when workers
+        # and the dashboard run in separate containers/hosts. Requiring
+        # `lepus/web` implies you want cross-process visibility, so default
+        # to the shared RabbitMQ-backed registry. Users can still override
+        # with `config.process_registry_backend = :file` in their initializer.
+        @process_registry_backend = :rabbitmq
+      end
+    end
+
+    # Web-specific consumer extensions.
+    # Tracks whether the last delivery resulted in an error (exception),
+    # allowing stats to distinguish explicit rejections from error rejections.
+    module ConsumerExtensions
+      def process_delivery(delivery_info, metadata, payload)
+        @_last_delivery_errored = false
+        super
+      end
+
+      def last_delivery_errored?
+        @_last_delivery_errored == true
+      end
+
+      private
+
+      def on_delivery_error
+        @_last_delivery_errored = true
+        super
+      end
+    end
+
+    # Web-specific handler extensions.
+    # Adds per-consumer stats recording on message delivery outcomes.
+    module HandlerExtensions
+      attr_accessor :stats
+
+      def process_delivery(delivery_info, metadata, payload)
+        super.tap { |result| record_stats(result) }
+      end
+
+      private
+
+      def record_stats(result)
+        return unless stats
+
+        case result
+        when :ack
+          stats.record_processed
+        when :reject, :nack, :requeue
+          if consumer.last_delivery_errored?
+            stats.record_errored
+          else
+            stats.record_rejected
+          end
+        end
+      rescue # rubocop:disable Lint/SuppressedException
+        # Never let stats recording interfere with message processing
+      end
+    end
+
+    # Web-specific worker extensions.
+    # Creates per-worker stats registry, collects metrics, and
+    # overrides heartbeat to include metrics data in heartbeat messages.
+    module WorkerExtensions
+      private
+
+      def setup_consumers!
+        @stats_registry = Lepus::Consumers::StatsRegistry.new
+        super
+      end
+
+      def build_handler(consumer_class, channel, queue, tag)
+        super.tap do |handler|
+          handler.stats = @stats_registry.for(consumer_class)
+        end
+      end
+
+      def heartbeat
+        process.heartbeat(metrics: metrics_data)
+      rescue Process::NotFoundError
+        self.process = nil
+        interrupt
+      end
+
+      def metrics_data
+        {
+          rss_memory: safe_rss_memory,
+          connections: connection_pool_size,
+          consumers: @stats_registry&.all || []
+        }
+      end
+
+      def safe_rss_memory
+        Processes::MEMORY_GRABBER.call(pid) * 1024 # Convert kB to bytes
+      rescue
+        0
+      end
+
+      def connection_pool_size
+        @connection_pool&.size || 0
+      end
+    end
+
+    # Extend core classes with web-specific behavior when loaded
+    Lepus::Configuration.prepend(ConfigExtensions)
+    Lepus::Consumer.prepend(ConsumerExtensions)
+    Lepus::Consumers::Handler.prepend(HandlerExtensions)
+    Lepus::Consumers::Worker.prepend(WorkerExtensions)
+
+    # If `Lepus.config` was already memoized before `lepus/web` was required
+    # (the common case — initializers run before `routes.rb`), flip the flag
+    # now so the lazily-built `ProcessRegistry.backend` picks up the shared
+    # RabbitMQ-backed store. We only flip when it's still the out-of-the-box
+    # `:file` default to avoid stomping on an explicit choice.
+    #
+    # We deliberately do **not** reset an already-memoized backend: the
+    # supervisor boots the registry after `config/environment` loads, so no
+    # backend exists yet at this point during normal boot. Resetting would
+    # leave a fresh unstarted backend behind and the next `.add` would raise.
+    if Lepus.instance_variable_defined?(:@config)
+      existing = Lepus.instance_variable_get(:@config)
+      existing.process_registry_backend = :rabbitmq if existing && existing.process_registry_backend == :file
+    end
+
+    class << self
+      attr_accessor :aggregator
+      attr_accessor :management_api
+    end
+
+    def self.assets_path
+      @assets_path ||= Pathname.new(File.expand_path("../../", __dir__)).join("web")
+    end
+
+    def self.start_aggregator
+      return if aggregator&.running?
+
+      self.aggregator = Aggregator.new
+      aggregator.start
+    end
+
+    def self.stop_aggregator
+      aggregator&.stop
+      self.aggregator = nil
+    end
+
+    def self.start_management_api
+      self.management_api = Lepus.config.build_management_api
+    end
+
+    def self.stop_management_api
+      self.management_api = nil
+    end
+
+    # Start all web services (aggregator and management API)
+    def self.start
+      start_aggregator
+      start_management_api
+    end
+
+    # Stop all web services
+    def self.stop
+      stop_aggregator
+      stop_management_api
+    end
+
+    def self.render_index(env)
+      base = base_path(env)
+      html = File.read(assets_path.join("index.html"))
+      html.gsub("__BASE_PATH__", base)
+    end
+
+    def self.base_path(env)
+      script_name = env["SCRIPT_NAME"].to_s
+      script_name = script_name.chomp("/")
+      "#{script_name}/"
+    end
+
+    def self.mime_for(path)
+      case File.extname(path)
+      when ".html" then "text/html"
+      when ".css" then "text/css"
+      when ".js" then "application/javascript"
+      when ".png" then "image/png"
+      when ".jpg", ".jpeg" then "image/jpeg"
+      when ".svg" then "image/svg+xml"
+      when ".woff", ".woff2" then "font/woff"
+      when ".ttf" then "font/ttf"
+      when ".eot" then "application/vnd.ms-fontobject"
+      else "application/octet-stream"
+      end
+    end
+
+    # Make the Web module directly mountable as a Rack application.
+    #
+    # Mounting via `mount Lepus::Web => "/lepus"` in routes.rb does not call
+    # `Lepus::Web.start` — Rails just stashes a reference to this module and
+    # dispatches requests to `.call`. So we lazily start the aggregator and
+    # management API on first request and memoize the Rack app. This only
+    # runs in processes that actually serve HTTP for the dashboard; the
+    # supervisor loads `routes.rb` during boot but never dispatches requests,
+    # so it never pays this cost.
+    def self.call(env)
+      ensure_started
+      (@rack_app ||= App.build).call(env)
+    end
+
+    def self.ensure_started
+      return if @rack_app && aggregator&.running?
+
+      @boot_mutex ||= Mutex.new
+      @boot_mutex.synchronize do
+        start unless aggregator&.running?
+      end
+    end
+  end
+end
+
+# Require web sub-files (not managed by Zeitwerk)
+require_relative "web/respond_with"
+require_relative "web/management_api"
+require_relative "web/aggregator"
+require_relative "web/api"
+require_relative "web/app"

data/lib/lepus.rb

@@ -15,13 +15,23 @@ require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
 loader.inflector.inflect "json" => "JSON"
 loader.inflector.inflect "cli" => "CLI"
+loader.inflector.inflect "api" => "API"
+loader.inflector.inflect "management_api" => "ManagementAPI"
 loader.collapse("#{__dir__}/lepus/rails.rb")
 loader.collapse("#{__dir__}/lepus/rails/*")
 loader.ignore("#{__dir__}/puma")
+loader.ignore("#{__dir__}/lepus/testing.rb")
+loader.ignore("#{__dir__}/lepus/unique.rb")
+loader.ignore("#{__dir__}/lepus/testing/*")
 loader.ignore("#{__dir__}/lepus/rails")
 loader.ignore("#{__dir__}/lepus/rails.rb")
 loader.ignore("#{__dir__}/lepus/cli.rb")
-loader.ignore("#{__dir__}/lepus/middlewares")
+loader.ignore("#{__dir__}/lepus/consumers/middlewares")
+loader.ignore("#{__dir__}/lepus/producers/middlewares")
+loader.ignore("#{__dir__}/lepus/web.rb")
+loader.ignore("#{__dir__}/lepus/web")
+loader.ignore("#{__dir__}/lepus/prometheus.rb")
+loader.ignore("#{__dir__}/lepus/prometheus")
 loader.log! if ENV["DEBUG"]
 loader.setup
 
@@ -43,6 +53,9 @@ module Lepus
   class InvalidConsumerConfigError < Error
   end
 
+  class InvalidProducerConfigError < Error
+  end
+
   class ShutdownError < Error
   end
 
@@ -50,41 +63,39 @@ module Lepus
   class MaxRecoveryAttemptsExhaustedError < ShutdownError
   end
 
-  extend self
-
-  def logger
-    @logger ||= DEFAULT_LOGGER
-  end
+  class << self
+    attr_writer :logger
 
-  def logger=(logger)
-    @logger = logger
-  end
+    def logger
+      @logger ||= DEFAULT_LOGGER
+    end
 
-  def instrument(channel, **options, &block)
-    if defined?(ActiveSupport::Notifications)
-      ActiveSupport::Notifications.instrument("#{channel}.lepus", **options, &block)
-    else
-      yield(options.dup)
+    def instrument(channel, **options, &block)
+      if defined?(ActiveSupport::Notifications)
+        ActiveSupport::Notifications.instrument("#{channel}.lepus", **options, &block)
+      else
+        yield(options.dup)
+      end
     end
-  end
 
-  def eager_load_consumers!
-    return false unless Lepus.config.consumers_directory.exist?
+    def eager_load_consumers!
+      return false unless Lepus.config.consumers_directory.exist?
 
-    Dir[config.consumers_directory.join("**/*.rb")].map { |path| Pathname.new(path) }.each do |path|
-      next unless path.extname == ".rb"
+      Dir[config.consumers_directory.join("**/*.rb")].map { |path| Pathname.new(path) }.each do |path|
+        next unless path.extname == ".rb"
 
-      require(path.expand_path.to_s)
+        require(path.expand_path.to_s)
+      end
+      true
     end
-    true
-  end
 
-  def self.config
-    @config ||= Configuration.new
-  end
+    def config
+      @config ||= Configuration.new
+    end
 
-  def self.configure
-    yield config
+    def configure
+      yield config
+    end
   end
 end
 
@@ -92,4 +103,4 @@ if defined?(::Rails)
   require_relative "lepus/rails"
 end
 
-# loader.eager_load
+loader.eager_load