solid_observer 0.1.0 → 0.3.0

data/lib/generators/solid_observer/templates/initializer.rb.tt

@@ -9,10 +9,9 @@ SolidObserver.configure do |config|
   # Recommended: false in production, true in development/staging
   config.ui_enabled = !Rails.env.production?
 
-  # Authentication for UI (when ui_enabled = true)
-  # config.http_basic_auth_enabled = true
-  # config.http_basic_auth_user = "admin"
-  # config.http_basic_auth_password = "secret"
+  # Authentication for web UI — set a username to enable HTTP Basic Auth
+  # config.ui_username = "admin"
+  # config.ui_password = "secret"
 
   # Base controller for UI (customize authorization)
   # config.ui_base_controller = "ApplicationController"
@@ -20,11 +19,11 @@ SolidObserver.configure do |config|
   # === Queue Observability (v0.1.0) ===
   config.observe_queue = true
 
-  # === Cache Observability (Coming in v0.2.0+) ===
+  # === Cache Observability (Coming in v0.4.0+) ===
   # config.observe_cache = true
   # config.cache_sampling_rate = 0.1  # Sample 10% of cache operations
 
-  # === Cable Observability (Coming in v0.2.0+) ===
+  # === Cable Observability (Coming in v0.5.0+) ===
   # config.observe_cable = true
 
   # Data Retention

data/lib/solid_observer/base_metric.rb

@@ -3,7 +3,7 @@
 module SolidObserver
   # BaseMetric provides the foundation for time-series metrics storage.
   #
-  # NOTE: Metrics functionality is planned for v0.2.0. The database connection
+  # NOTE: Metrics functionality is planned for a future release. The database connection
   # will be configured by the Engine (similar to BaseEvent) when metrics are
   # fully implemented.
   #

data/lib/solid_observer/chart_buffer.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class ChartBuffer
+    INSTANCE_MUTEX = Mutex.new
+
+    class << self
+      def append(value, at: Time.now)
+        instance.append(value, at: at)
+      end
+
+      def recent(window_seconds)
+        instance.recent(window_seconds)
+      end
+
+      def clear
+        instance.clear
+      end
+
+      private
+
+      def instance
+        INSTANCE_MUTEX.synchronize { @instance ||= new }
+      end
+    end
+
+    def initialize
+      @mutex = Mutex.new
+      @samples = []
+      @cap = nil
+    end
+
+    def append(value, at: Time.now)
+      sample = {t: at.to_i, v: value.to_i}
+
+      @mutex.synchronize { store_sample(sample) }
+
+      sample
+    end
+
+    def recent(window_seconds)
+      cutoff = Time.now.to_i - window_seconds.to_i
+
+      @mutex.synchronize do
+        @samples.select { |sample| sample[:t] >= cutoff }.map(&:dup)
+      end
+    end
+
+    def clear
+      @mutex.synchronize do
+        @samples.clear
+        @cap = nil
+      end
+    end
+
+    private
+
+    def store_sample(sample)
+      @cap ||= compute_cap
+      replace_or_append(sample)
+      trim_to_cap
+    end
+
+    def replace_or_append(sample)
+      latest_sample = @samples.last
+
+      if latest_sample && latest_sample[:t] == sample[:t]
+        @samples[-1] = sample
+      else
+        @samples << sample
+      end
+    end
+
+    def trim_to_cap
+      overflow = @samples.length - @cap
+      @samples.shift(overflow) if overflow.positive?
+    end
+
+    def compute_cap
+      (3600 / 5).to_i # 720 samples — 1h at the 5s cadence
+    end
+  end
+end

data/lib/solid_observer/cli/base.rb

@@ -39,8 +39,8 @@ module SolidObserver
 
         widths = calculate_column_widths(headers, rows)
 
-        output(format_table_row(headers, widths), color: :cyan)
-        output(separator_line(widths), color: :cyan)
+        output(format_table_row(headers, widths), color: :red)
+        output(separator_line(widths), color: :red)
 
         rows.each do |row|
           output(format_table_row(row, widths))

data/lib/solid_observer/cli/jobs.rb

@@ -186,8 +186,8 @@ module SolidObserver
       end
 
       def print_section_header(title)
-        output("\n#{title}", color: :cyan)
-        output("=" * 80, color: :cyan)
+        output("\n#{title}", color: :red)
+        output("=" * 80, color: :red)
         output("")
       end
     end

data/lib/solid_observer/cli/status.rb

@@ -3,16 +3,34 @@
 module SolidObserver
   module CLI
     class Status < Base
+      BANNER_ICON_TOP = "         ┌─   ─┐"
+      BANNER_ICON_MID_LEFT = "            ◉"
+      BANNER_ICON_BOT = "         └─   ─┘"
+      BANNER_NAME = "solid_observer"
+      BANNER_NAME_GAP = "     "
+
       def call
+        print_banner
         print_header
         print_queue_stats
       end
 
       private
 
+      def print_banner
+        output(BANNER_ICON_TOP, color: :red)
+        output(banner_middle_line)
+        output(BANNER_ICON_BOT, color: :red)
+      end
+
+      def banner_middle_line
+        icon = color_enabled? ? colorize(BANNER_ICON_MID_LEFT, :red) : BANNER_ICON_MID_LEFT
+        "#{icon}#{BANNER_NAME_GAP}#{BANNER_NAME}"
+      end
+
       def print_header
-        output("\n📊 SolidObserver Status", color: :cyan)
-        output("=" * 50, color: :cyan)
+        output("\n📊 SolidObserver Status", color: :red)
+        output("=" * 50, color: :red)
         output("")
       end
 

data/lib/solid_observer/cli/storage.rb

@@ -5,23 +5,31 @@ module SolidObserver
     class Storage < Base
       def call
         print_section_header("💾 Storage Status")
+        return print_realtime_mode_message if SolidObserver.config.realtime_mode?
 
-        current_stats = gather_storage_stats
+        render_storage_status
+      end
 
-        if current_stats[:error]
-          error(current_stats[:error])
-          return
-        end
+      private
+
+      def print_realtime_mode_message
+        info("Storage monitoring is not available in real-time mode.")
+        info("Switch to persistence mode for event history and storage tracking.")
+        output("")
+      end
+
+      def render_storage_status
+        current_stats = gather_storage_stats
+        error_message = current_stats[:error]
+        return error(error_message) if error_message
 
         print_storage_table(current_stats)
         print_configuration
       end
 
-      private
-
       def gather_storage_stats
         {
-          db_size_bytes: calculate_database_size,
+          db_size_bytes: SolidObserver::Services::DatabaseSize.call(connection: QueueEvent.connection),
           event_count: QueueEvent.count,
           max_size_bytes: SolidObserver.config.max_db_size
         }
@@ -29,37 +37,38 @@ module SolidObserver
         {error: "Failed to gather storage stats: #{e.message}"}
       end
 
-      def calculate_database_size
-        db_config = QueueEvent.connection_db_config
-        db_path = db_config.database
-
-        return 0 unless File.exist?(db_path)
-
-        File.size(db_path)
-      rescue => e
-        warning("Could not calculate database size: #{e.message}")
-        0
-      end
-
       def print_storage_table(stats)
-        size_mb = bytes_to_mb(stats[:db_size_bytes])
-        percentage = calculate_percentage(stats[:db_size_bytes], stats[:max_size_bytes])
-        status = status_indicator(percentage)
+        event_count = stats[:event_count]
+        db_size_bytes = stats[:db_size_bytes]
+        max_size_bytes = stats[:max_size_bytes]
 
         table(
           headers: ["Component", "Size", "Events", "Usage", "Status"],
-          rows: [[
-            "Queue",
-            format_size(size_mb),
-            format_number(stats[:event_count]),
-            "#{percentage}%",
-            status
-          ]]
+          rows: [storage_row(event_count: event_count, db_size_bytes: db_size_bytes, max_size_bytes: max_size_bytes)]
         )
 
         output("")
       end
 
+      def storage_row(event_count:, db_size_bytes:, max_size_bytes:)
+        size, usage, status = storage_displays(db_size_bytes, max_size_bytes)
+
+        [
+          "Queue",
+          size,
+          format_number(event_count),
+          usage,
+          status
+        ]
+      end
+
+      def storage_displays(db_size_bytes, max_size_bytes)
+        return ["N/A", "N/A", "— Unknown"] unless db_size_bytes
+
+        percentage = calculate_percentage(db_size_bytes, max_size_bytes)
+        [format_size(bytes_to_mb(db_size_bytes)), "#{percentage}%", status_indicator(percentage)]
+      end
+
       def print_configuration
         retention_days = (SolidObserver.config.event_retention / 1.day).to_i
         max_size_mb = bytes_to_mb(SolidObserver.config.max_db_size)
@@ -105,8 +114,8 @@ module SolidObserver
 
       def print_section_header(title)
         output("")
-        output(title, color: :cyan)
-        output("=" * 50, color: :cyan)
+        output(title, color: :red)
+        output("=" * 50, color: :red)
         output("")
       end
     end

data/lib/solid_observer/configuration.rb

@@ -15,14 +15,13 @@ module SolidObserver
     # UI Settings
     attr_accessor :ui_enabled,
       :ui_base_controller,
-      :http_basic_auth_enabled,
-      :http_basic_auth_user,
-      :http_basic_auth_password
+      :ui_username,
+      :ui_password
 
     # Observer Settings
     attr_accessor :observe_queue
 
-    # Observer Settings (planned for v0.2.0)
+    # Observer Settings (planned for a future release)
     # @note Cache and Cable observers are not yet implemented
     attr_accessor :observe_cache,
       :observe_cable,
@@ -31,51 +30,58 @@ module SolidObserver
     # Retention Settings
     attr_accessor :event_retention
 
-    # Retention Settings (planned for v0.2.0)
+    # Retention Settings (planned for a future release)
     # @note Metrics cleanup is not yet implemented
     attr_accessor :metrics_retention
 
     # Storage Settings
     attr_accessor :max_db_size
 
+    # Storage Mode
+    attr_reader :storage_mode
+
     # Performance Settings (with validation)
     attr_reader :sampling_rate,
       :warning_threshold,
       :buffer_size,
-      :flush_interval
+      :flush_interval,
+      :max_buffer_size,
+      :buffer_overflow_strategy,
+      :filter_cache_ttl
 
     # Correlation Settings
     attr_accessor :correlation_id_generator
 
     def initialize
-      # UI defaults
-      @ui_enabled = !production?
-      @ui_base_controller = "::ApplicationController"
-      @http_basic_auth_enabled = false
-      @http_basic_auth_user = nil
-      @http_basic_auth_password = nil
-
-      # Observer defaults
-      @observe_queue = true
-      @observe_cache = false
-      @observe_cable = false
-
-      # Retention defaults
-      @event_retention = 30.days
-      @metrics_retention = 90.days
-
-      # Storage defaults
-      @max_db_size = 1.gigabyte
-      @warning_threshold = 0.8
-
-      # Performance defaults
-      @sampling_rate = 1.0
-      @cache_sampling_rate = 0.1
-      @buffer_size = 1000
-      @flush_interval = 10.seconds
-
-      # Correlation defaults
-      @correlation_id_generator = nil
+      @ui_enabled, @ui_base_controller, @ui_username, @ui_password,
+        @storage_mode, @observe_queue, @observe_cache, @observe_cable,
+        @event_retention, @metrics_retention, @max_db_size, @warning_threshold,
+        @sampling_rate, @cache_sampling_rate, @buffer_size, @flush_interval,
+        @max_buffer_size, @buffer_overflow_strategy, @filter_cache_ttl,
+        @correlation_id_generator = !production?, "::ApplicationController", nil, nil,
+          :persistence, true, false, false,
+          30.days, 90.days, 1.gigabyte, 0.8,
+          1.0, 0.1, 1000, 10.seconds,
+          10_000, :drop_old, 1.minute,
+          nil
+    end
+
+    STORAGE_MODES = %i[persistence realtime].freeze
+    BUFFER_OVERFLOW_STRATEGIES = %i[drop_old drop_new].freeze
+
+    def storage_mode=(value)
+      value = value.to_sym
+      raise ArgumentError, "storage_mode must be :persistence or :realtime" unless STORAGE_MODES.include?(value)
+
+      @storage_mode = value
+    end
+
+    def persistence_mode?
+      @storage_mode == :persistence
+    end
+
+    def realtime_mode?
+      @storage_mode == :realtime
     end
 
     def sampling_rate=(value)
@@ -90,6 +96,10 @@ module SolidObserver
 
     def buffer_size=(value)
       validate_positive_integer!(:buffer_size, value)
+      if defined?(@max_buffer_size) && value > @max_buffer_size
+        raise ArgumentError, "buffer_size must be <= max_buffer_size"
+      end
+
       @buffer_size = value
     end
 
@@ -98,6 +108,29 @@ module SolidObserver
       @flush_interval = value
     end
 
+    def max_buffer_size=(value)
+      validate_positive_integer!(:max_buffer_size, value)
+      if defined?(@buffer_size) && value < @buffer_size
+        raise ArgumentError, "max_buffer_size must be >= buffer_size"
+      end
+
+      @max_buffer_size = value
+    end
+
+    def buffer_overflow_strategy=(value)
+      value = value.to_sym
+      unless BUFFER_OVERFLOW_STRATEGIES.include?(value)
+        raise ArgumentError, "buffer_overflow_strategy must be :drop_old or :drop_new"
+      end
+
+      @buffer_overflow_strategy = value
+    end
+
+    def filter_cache_ttl=(value)
+      validate_positive_numeric!(:filter_cache_ttl, value)
+      @filter_cache_ttl = value
+    end
+
     private
 
     def validate_rate!(name, value)

data/lib/solid_observer/correlation_id_resolver.rb

@@ -38,12 +38,7 @@ module SolidObserver
     end
 
     def call_custom_generator
-      result = SolidObserver.config.correlation_id_generator.call
-      return nil if result.blank?
-      result
-    rescue => e
-      log_generator_error(e)
-      nil
+      custom_generator_value.presence
     end
 
     def log_generator_error(exception)
@@ -58,5 +53,12 @@ module SolidObserver
     def extract_job_id
       @event.payload[:job].job_id
     end
+
+    def custom_generator_value
+      SolidObserver.config.correlation_id_generator.call
+    rescue => e
+      log_generator_error(e)
+      nil
+    end
   end
 end

data/lib/solid_observer/engine.rb

@@ -4,6 +4,10 @@ module SolidObserver
   class Engine < ::Rails::Engine
     isolate_namespace SolidObserver
 
+    middleware.use ActionDispatch::Cookies
+    middleware.use ActionDispatch::Session::CookieStore, key: "_solid_observer_session"
+    middleware.use ActionDispatch::Flash
+
     class << self
       def check_solid_queue_availability
         return if defined?(SolidQueue)
@@ -11,14 +15,35 @@ module SolidObserver
         Rails.logger.warn "[SolidObserver] SolidQueue not detected. Queue observability features will be limited."
       end
 
+      def check_ui_authentication
+        Services::UiAuthCheck.call(config: SolidObserver.config)
+      end
+
       def configure_database_connection
-        db_config = ActiveRecord::Base.configurations.configs_for(
+        return if SolidObserver.config.realtime_mode?
+        return unless queue_db_config
+
+        connect_observer_models
+      end
+
+      def activate_subscribers
+        return activate_subscribers_in_realtime if SolidObserver.config.realtime_mode?
+        return if activation_skipped_for_table_status?
+
+        Rails.logger.info "[SolidObserver] Activating event subscribers"
+        Subscriber.subscribe!
+      end
+
+      private
+
+      def queue_db_config
+        ActiveRecord::Base.configurations.configs_for(
           env_name: Rails.env,
           name: "solid_observer_queue"
         )
+      end
 
-        return unless db_config
-
+      def connect_observer_models
         connection_config = {
           database: {writing: :solid_observer_queue, reading: :solid_observer_queue}
         }
@@ -27,24 +52,58 @@ module SolidObserver
         SolidObserver::BaseMetric.connects_to(**connection_config)
       end
 
-      def activate_subscribers
-        logger = Rails.logger
+      def activate_subscribers_in_realtime
+        Rails.logger.info "[SolidObserver] Starting in real-time mode (no persistence)"
+        Subscriber.subscribe!
+      end
 
-        unless table_exists?("solid_observer_queue_events")
-          logger.info "[SolidObserver] Tables not found. Run: rails solid_observer:install:migrations && rails db:migrate"
-          return
+      def activation_skipped_for_table_status?
+        case table_status("solid_observer_queue_events")
+        when :absent
+          log_activation_skip("Tables not found. Run: rails solid_observer:install:migrations && rails db:migrate")
+          true
+        when :unknown
+          log_activation_skip("Database not reachable at boot. Skipping subscriber activation.")
+          true
+        else
+          false
         end
+      end
 
-        logger.info "[SolidObserver] Activating event subscribers"
-        Subscriber.subscribe!
-      rescue ActiveRecord::NoDatabaseError
-        logger.info "[SolidObserver] Database not ready yet. Skipping subscriber activation."
+      def log_activation_skip(message)
+        Rails.logger.info("[SolidObserver] #{message}")
       end
 
-      private
+      def table_status(table_name)
+        pool = SolidObserver::BaseEvent.connection_pool
+
+        return :present if cached_data_source_exists?(pool, table_name)
+
+        data_source_exists_in_db?(pool, table_name) ? :present : :absent
+      rescue *boot_connection_errors
+        :unknown
+      end
+
+      def cached_data_source_exists?(pool, table_name)
+        cache = pool.schema_cache
+        cache.data_source_exists?(pool, table_name)
+      rescue ArgumentError
+        cache.data_source_exists?(table_name)
+      end
+
+      def data_source_exists_in_db?(pool, table_name)
+        pool.with_connection { |connection| connection.data_source_exists?(table_name) }
+      end
 
-      def table_exists?(table_name)
-        ActiveRecord::Base.connection.table_exists?(table_name)
+      def boot_connection_errors
+        [
+          ActiveRecord::NoDatabaseError,
+          ActiveRecord::ConnectionNotEstablished,
+          ActiveRecord::StatementInvalid,
+          *([PG::ConnectionBad] if defined?(PG::ConnectionBad)),
+          *([Mysql2::Error::ConnectionError] if defined?(Mysql2::Error::ConnectionError)),
+          *([SQLite3::CantOpenException] if defined?(SQLite3::CantOpenException))
+        ]
       end
     end
 
@@ -55,6 +114,7 @@ module SolidObserver
     config.after_initialize do
       Engine.configure_database_connection
       Engine.activate_subscribers
+      Engine.check_ui_authentication
     end
   end
 end

data/lib/solid_observer/params/events_filter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Params
+    class EventsFilter
+      def self.from_params(params)
+        new(
+          event_type: params[:event_type].presence,
+          job_class: params[:job_class].presence,
+          queue_name: params[:queue_name].presence,
+          from: parse_date(params[:from]),
+          to: parse_date(params[:to]),
+          page: (params[:page].presence || 1).to_i
+        )
+      end
+
+      class << self
+        private
+
+        def parse_date(date_string)
+          return nil if date_string.blank?
+
+          Date.parse(date_string)
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      attr_reader :event_type, :job_class, :queue_name, :from, :to, :page
+
+      def initialize(event_type:, job_class:, queue_name:, from:, to:, page:)
+        @event_type, @job_class, @queue_name = event_type, job_class, queue_name
+        @from, @to, @page = from, to, page
+      end
+    end
+  end
+end

data/lib/solid_observer/params/jobs_filter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Params
+    class JobsFilter
+      ALLOWED_STATUSES = %w[ready scheduled claimed failed].freeze
+      PSEUDO_STATUSES = %w[all_active].freeze
+
+      def self.from_params(params)
+        new(
+          status: params[:status].presence || "all_active",
+          queue_name: params[:queue_name].presence,
+          job_class: params[:job_class].presence,
+          page: (params[:page].presence || 1).to_i
+        )
+      end
+
+      attr_reader :status, :queue_name, :job_class, :page
+
+      def initialize(status:, queue_name:, job_class:, page:)
+        @status = normalize_status(status)
+        @queue_name = queue_name
+        @job_class = job_class
+        @page = page
+      end
+
+      private
+
+      def normalize_status(status)
+        normalized = status.to_s.downcase
+        (ALLOWED_STATUSES + PSEUDO_STATUSES).include?(normalized) ? normalized : "all_active"
+      end
+    end
+  end
+end