solid_observer 0.1.1 → 0.4.0

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

@@ -4,70 +4,74 @@ module SolidObserver
   module CLI
     class Storage < Base
       def call
-        if SolidObserver.config.realtime_mode?
-          print_section_header("💾 Storage Status")
-          info("Storage monitoring is not available in real-time mode.")
-          info("Switch to persistence mode for event history and storage tracking.")
-          output("")
-          return
-        end
-
         print_section_header("💾 Storage Status")
+        return print_realtime_mode_message if SolidObserver.config.realtime_mode?
 
-        current_stats = gather_storage_stats
-
-        if current_stats[:error]
-          error(current_stats[:error])
-          return
-        end
-
-        print_storage_table(current_stats)
-        print_configuration
+        render_storage_status
       end
 
       private
 
-      def gather_storage_stats
-        {
-          db_size_bytes: calculate_database_size,
-          event_count: QueueEvent.count,
-          max_size_bytes: SolidObserver.config.max_db_size
-        }
-      rescue => e
-        {error: "Failed to gather storage stats: #{e.message}"}
+      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 calculate_database_size
-        db_config = QueueEvent.connection_db_config
-        db_path = db_config.database
+      def render_storage_status
+        current_stats = gather_storage_stats
+        error_message = current_stats[:error]
+        return error(error_message) if error_message
 
-        return 0 unless File.exist?(db_path)
+        print_storage_table(current_stats)
+        print_configuration
+      end
 
-        File.size(db_path)
+      def gather_storage_stats
+        {components: SolidObserver::Services::StorageInfoSnapshot.call, max_size_bytes: SolidObserver.config.max_db_size}
       rescue => e
-        warning("Could not calculate database size: #{e.message}")
-        0
+        {error: "Failed to gather storage stats: #{e.message}"}
       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)
+        max_size_bytes = stats[:max_size_bytes]
+        components = stats[:components]
 
         table(
           headers: ["Component", "Size", "Events", "Usage", "Status"],
-          rows: [[
-            "Queue",
-            format_size(size_mb),
-            format_number(stats[:event_count]),
-            "#{percentage}%",
-            status
-          ]]
+          rows: components.map { |component| storage_row(component: component, max_size_bytes: max_size_bytes) }
         )
 
         output("")
       end
 
+      def storage_row(component:, max_size_bytes:)
+        event_count = component[:event_count]
+        size, usage, status = storage_displays(component: component, max_size_bytes: max_size_bytes)
+
+        [
+          component[:label],
+          size,
+          event_count ? format_number(event_count) : "—",
+          usage,
+          status
+        ]
+      end
+
+      def storage_displays(component:, max_size_bytes:)
+        return unavailable_displays unless component[:available]
+
+        db_size_bytes = component[:db_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 unavailable_displays
+        ["—", "—", "— Unavailable"]
+      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)
@@ -113,8 +117,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,23 +15,24 @@ 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,
-      :cache_sampling_rate
+      :cache_sampling_rate,
+      :cache_slow_threshold,
+      :cache_store_errors
 
     # 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
 
@@ -45,46 +46,31 @@ module SolidObserver
     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
-
-      # Storage mode
-      @storage_mode = :persistence
-
-      # 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, @cache_slow_threshold, @cache_store_errors,
+        @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, 0.1, true, 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
@@ -101,6 +87,22 @@ module SolidObserver
       @storage_mode == :realtime
     end
 
+    def solid_queue_available?
+      !!defined?(::SolidQueue)
+    end
+
+    def solid_cache_available?
+      !!defined?(::SolidCache)
+    end
+
+    def solid_queue_enabled?
+      observe_queue
+    end
+
+    def solid_cache_enabled?
+      observe_cache && solid_cache_available?
+    end
+
     def sampling_rate=(value)
       validate_rate!(:sampling_rate, value)
       @sampling_rate = value
@@ -113,6 +115,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
 
@@ -121,6 +127,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

@@ -1,26 +1,68 @@
 # frozen_string_literal: true
 
+require_relative "cache_event_buffer"
+require_relative "cache_subscriber"
+require_relative "services/record_cache_event"
+require_relative "services/record_cache_metric"
+require_relative "services/flush_cache_event_buffer"
+require_relative "services/cache_stats"
+require_relative "services/cache_operations"
+
 module SolidObserver
   class Engine < ::Rails::Engine
     isolate_namespace SolidObserver
 
+    SOLID_QUEUE_AVAILABLE = defined?(::SolidQueue)
+    SOLID_CACHE_AVAILABLE = defined?(::SolidCache)
+
+    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)
+        return if defined?(::SolidQueue)
 
         Rails.logger.warn "[SolidObserver] SolidQueue not detected. Queue observability features will be limited."
       end
 
+      def check_solid_cache_availability
+        return if defined?(::SolidCache)
+        return unless SolidObserver.config.observe_cache
+
+        Rails.logger.warn "[SolidObserver] SolidCache not detected. Cache observability features will be disabled."
+      end
+
+      def check_ui_authentication
+        Services::UiAuthCheck.call(config: SolidObserver.config)
+      end
+
       def configure_database_connection
         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_for_enabled_components?
+
+        Rails.logger.info "[SolidObserver] Activating event subscribers"
+        Subscriber.subscribe! if should_activate_queue_subscriber?
+        CacheSubscriber.subscribe! if should_activate_cache_subscriber?
+      end
 
-        db_config = ActiveRecord::Base.configurations.configs_for(
+      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}
         }
@@ -29,37 +71,87 @@ 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! if should_activate_queue_subscriber?
+        CacheSubscriber.subscribe! if should_activate_cache_subscriber?
+      end
+
+      def activation_skipped_for_table_status_for_enabled_components?
+        enabled_tables = []
+        enabled_tables << "solid_observer_queue_events" if should_activate_queue_subscriber?
+        enabled_tables << "solid_observer_cache_events" if should_activate_cache_subscriber?
+
+        enabled_tables.any? { |table_name| skip_activation_for_missing_table?(table_name) }
+      end
 
-        if SolidObserver.config.realtime_mode?
-          logger.info "[SolidObserver] Starting in real-time mode (no persistence)"
-        elsif !table_exists?("solid_observer_queue_events")
-          logger.info "[SolidObserver] Tables not found. Run: rails solid_observer:install:migrations && rails db:migrate"
-          return
+      def skip_activation_for_missing_table?(table_name)
+        case table_status(table_name)
+        when :absent
+          log_activation_skip("Tables not found (missing: #{table_name}). 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
-          logger.info "[SolidObserver] Activating event subscribers"
+          false
         end
+      end
 
-        Subscriber.subscribe!
-      rescue ActiveRecord::NoDatabaseError
-        logger.info "[SolidObserver] Database not ready yet. Skipping subscriber activation."
+      def should_activate_queue_subscriber?
+        SolidObserver.config.solid_queue_enabled?
       end
 
-      private
+      def should_activate_cache_subscriber?
+        SolidObserver.config.solid_cache_enabled?
+      end
+
+      def log_activation_skip(message)
+        Rails.logger.info("[SolidObserver] #{message}")
+      end
+
+      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
 
     config.before_initialize do
       Engine.check_solid_queue_availability
+      Engine.check_solid_cache_availability
     end
 
     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

data/lib/solid_observer/queries/events_query.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Queries
+    class EventsQuery
+      def initialize(filter)
+        @filter = filter
+      end
+
+      def call
+        event_type = @filter.event_type
+        job_class = @filter.job_class
+        queue_name = @filter.queue_name
+        from = @filter.from
+        to = @filter.to
+
+        scope = QueueEvent.order(recorded_at: :desc)
+        scope = scope.by_event_type(event_type) if event_type.present?
+        scope = scope.by_job_class(job_class) if job_class.present?
+        scope = scope.by_queue(queue_name) if queue_name.present?
+        scope = scope.since(from.beginning_of_day) if from
+        scope = scope.before(to.end_of_day) if to
+        scope
+      end
+    end
+  end
+end

data/lib/solid_observer/queries/execution_finder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Queries
+    class ExecutionFinder
+      EXECUTION_TYPES = [
+        "SolidQueue::ReadyExecution",
+        "SolidQueue::ScheduledExecution",
+        "SolidQueue::ClaimedExecution",
+        "SolidQueue::FailedExecution"
+      ].freeze
+
+      STATUS_TO_EXECUTION_TYPE = {
+        "ready" => "SolidQueue::ReadyExecution",
+        "scheduled" => "SolidQueue::ScheduledExecution",
+        "claimed" => "SolidQueue::ClaimedExecution",
+        "failed" => "SolidQueue::FailedExecution"
+      }.freeze
+
+      def self.find_any(id)
+        EXECUTION_TYPES.each do |const_name|
+          execution = const_name.safe_constantize&.find_by(id: id)
+          return execution if execution
+        end
+        nil
+      end
+
+      def self.find_by_status(id, status)
+        const_name = STATUS_TO_EXECUTION_TYPE[status.to_s.downcase]
+        return nil unless const_name
+
+        const_name.safe_constantize&.find_by(id: id)
+      end
+
+      def self.find_failed(id)
+        return nil unless defined?(SolidQueue::FailedExecution)
+
+        SolidQueue::FailedExecution.find_by(id: id)
+      end
+    end
+  end
+end