solid_observer 0.1.0 → 0.3.0

data/lib/solid_observer/services/cleanup_storage.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "database_size"
+
 module SolidObserver
   module Services
     class CleanupStorage
@@ -8,86 +10,102 @@ module SolidObserver
       end
 
       def call
-        deleted_count = 0
+        return 0 if SolidObserver.config.realtime_mode?
+
+        deleted_count = perform_cleanup_transaction
+        post_cleanup(deleted_count)
+      rescue => e
+        handle_cleanup_failure(e)
+      end
+
+      private
+
+      def handle_cleanup_failure(error)
+        Rails.logger.error "[SolidObserver] Cleanup failed: #{error.message}"
+        raise
+      end
 
+      def perform_cleanup_transaction
         QueueEvent.transaction do
           deleted_count = delete_old_events
           record_snapshot_after_cleanup
+          deleted_count
         end
+      end
 
+      def post_cleanup(deleted_count)
         vacuum_database
-
         check_storage_warnings
         log_results(deleted_count)
-
         deleted_count
-      rescue => e
-        Rails.logger.error "[SolidObserver] Cleanup failed: #{e.message}"
-        raise
       end
 
-      private
-
       def delete_old_events
         cutoff = SolidObserver.config.event_retention.ago
         QueueEvent.where("recorded_at < ?", cutoff).delete_all
       end
 
       def record_snapshot_after_cleanup
-        db_size = calculate_database_size
-        event_count = QueueEvent.count
-
+        # StorageInfo.db_size_bytes is NOT NULL; record_snapshot coerces nil to 0.
         StorageInfo.record_snapshot(
-          db_size: db_size,
-          event_count: event_count
+          db_size: current_database_size,
+          event_count: QueueEvent.count
         )
       end
 
       def vacuum_database
-        adapter = QueueEvent.connection.adapter_name.downcase
-        case adapter
-        when "sqlite"
-          QueueEvent.connection.execute("VACUUM")
-        when "postgresql"
-          QueueEvent.connection.execute("VACUUM ANALYZE solid_observer_queue_events")
-        when "mysql2", "trilogy"
-          QueueEvent.connection.execute("OPTIMIZE TABLE solid_observer_queue_events")
-        end
+        statement = maintenance_statement
+        return unless statement
+
+        QueueEvent.connection.execute(statement)
       rescue => e
         Rails.logger.warn "[SolidObserver] Database maintenance failed: #{e.message}"
       end
 
-      def calculate_database_size
-        db_path = QueueEvent.connection_db_config.database
-        File.size(db_path) if File.exist?(db_path)
-      rescue => e
-        Rails.logger.warn "[SolidObserver] Could not calculate DB size: #{e.message}"
-        0
+      def check_storage_warnings
+        current_size = current_database_size
+        return unless warning_needed?(current_size)
+
+        Rails.logger.warn(storage_warning_message(current_size))
       end
 
-      def check_storage_warnings
-        max_size = SolidObserver.config.max_db_size
-        threshold = SolidObserver.config.warning_threshold
-        current_size = calculate_database_size
+      def warning_needed?(current_size)
+        return false unless current_size
 
-        return unless current_size > (max_size * threshold)
+        config = SolidObserver.config
+        max_size = config.max_db_size
+        threshold = config.warning_threshold
+        current_size > (max_size * threshold)
+      end
 
+      def storage_warning_message(current_size)
+        max_size = SolidObserver.config.max_db_size
         percentage = ((current_size.to_f / max_size) * 100).round(1)
-        Rails.logger.warn "[SolidObserver] Queue DB approaching limit: #{format_bytes(current_size)} / #{format_bytes(max_size)} (#{percentage}%)"
+        current_size_human = human_size(current_size)
+        max_size_human = human_size(max_size)
+        "[SolidObserver] Queue DB approaching limit: #{current_size_human} / #{max_size_human} (#{percentage}%)"
       end
 
-      def log_results(deleted_count)
-        Rails.logger.info "[SolidObserver] Cleaned #{deleted_count} queue events"
+      def human_size(bytes)
+        ActiveSupport::NumberHelper.number_to_human_size(bytes, precision: 1, significant: false, strip_insignificant_zeros: false)
       end
 
-      def format_bytes(bytes)
-        return "0 B" if bytes.zero?
+      def current_database_size
+        return @current_database_size if defined?(@current_database_size)
+
+        @current_database_size = DatabaseSize.call(connection: QueueEvent.connection)
+      end
 
-        units = ["B", "KB", "MB", "GB"]
-        exp = (Math.log(bytes) / Math.log(1024)).to_i
-        exp = [exp, units.length - 1].min
+      def log_results(deleted_count)
+        Rails.logger.info "[SolidObserver] Cleaned #{deleted_count} queue events"
+      end
 
-        "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
+      def maintenance_statement
+        case QueueEvent.connection.adapter_name.downcase
+        when "sqlite" then "VACUUM"
+        when "postgresql" then "VACUUM ANALYZE solid_observer_queue_events"
+        when "mysql2", "trilogy" then "OPTIMIZE TABLE solid_observer_queue_events"
+        end
       end
     end
   end

data/lib/solid_observer/services/database_size.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Services
+    # Returns bytes used by solid_observer_queue_events across supported adapters.
+    #
+    # SQLite uses whole-database page accounting; PostgreSQL and MySQL/Trilogy
+    # use table + index size from adapter-native system functions.
+    class DatabaseSize
+      TABLE_NAME = "solid_observer_queue_events"
+
+      def self.call(connection:)
+        new(connection).call
+      end
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def call
+        fetch_size
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished => e
+        log_query_failure(e.message)
+        nil
+      end
+
+      private
+
+      attr_reader :connection
+
+      def adapter_key
+        case connection.adapter_name.to_s.downcase
+        when /sqlite/ then :sqlite
+        when /postgres|postgis/ then :postgresql
+        when "mysql2", "trilogy" then :mysql
+        end
+      end
+
+      def fetch_size
+        case adapter_key
+        when :sqlite then sqlite_size
+        when :postgresql then postgresql_size
+        when :mysql then mysql_size
+        else
+          unknown_adapter_size
+        end
+      end
+
+      def unknown_adapter_size
+        log_unknown_adapter
+        nil
+      end
+
+      def sqlite_size
+        connection.query_value("SELECT pragma_page_count() * pragma_page_size()")&.to_i
+      end
+
+      def postgresql_size
+        quoted_table = connection.quote(TABLE_NAME)
+        connection.query_value("SELECT pg_total_relation_size(#{quoted_table})")&.to_i
+      end
+
+      def mysql_size
+        quoted_table = connection.quote(TABLE_NAME)
+
+        connection.query_value(<<~SQL)&.to_i
+          SELECT COALESCE(data_length + index_length, 0)
+          FROM information_schema.tables
+          WHERE table_schema = DATABASE()
+            AND table_name = #{quoted_table}
+        SQL
+      end
+
+      def log_unknown_adapter
+        Rails.logger&.warn(
+          "[SolidObserver] Unknown adapter for DatabaseSize: " \
+          "#{connection.adapter_name.inspect} — storage monitoring disabled"
+        )
+      end
+
+      def log_query_failure(message)
+        Rails.logger&.warn("[SolidObserver] DatabaseSize query failed: #{message}")
+      end
+    end
+  end
+end

data/lib/solid_observer/services/flush_event_buffer.rb

@@ -26,31 +26,47 @@ module SolidObserver
       def call
         return 0 if @events.empty?
 
+        bulk_insert
+        @events.size
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::StatementInvalid => e
+        handle_bulk_insert_failure(e)
+      end
+
+      private
+
+      def bulk_insert
         QueueEvent.transaction do
           QueueEvent.insert_all!(@events)
         end
+      end
 
-        @events.size
-      rescue ActiveRecord::RecordInvalid, ActiveRecord::StatementInvalid => e
-        log_error("Bulk insert failed, retrying in batches: #{e.message}")
+      def handle_bulk_insert_failure(error)
+        log_error("Bulk insert failed, retrying in batches: #{error.message}")
         retry_with_smaller_batches
       end
 
-      private
-
       def retry_with_smaller_batches
-        inserted = 0
+        inserted = @events.each_slice(BATCH_SIZE).sum { |batch| insert_batch(batch) }
+        log_failed_count if @failed_count.positive?
+        inserted
+      end
 
-        @events.each_slice(BATCH_SIZE) do |batch|
-          QueueEvent.insert_all(batch, returning: false)
-          inserted += batch.size
-        rescue ActiveRecord::StatementInvalid, ActiveRecord::RecordInvalid => e
-          @failed_count += batch.size
-          log_warning("Failed to insert batch of #{batch.size} events: #{e.message}")
-        end
+      def insert_batch(batch)
+        QueueEvent.insert_all(batch, returning: false)
+        batch.size
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::RecordInvalid => e
+        register_failed_batch(batch, e)
+        0
+      end
 
-        log_warning("#{@failed_count} events could not be saved") if @failed_count.positive?
-        inserted
+      def register_failed_batch(batch, error)
+        batch_size = batch.size
+        @failed_count += batch_size
+        log_warning("Failed to insert batch of #{batch_size} events: #{error.message}")
+      end
+
+      def log_failed_count
+        log_warning("#{@failed_count} events could not be saved")
       end
 
       def log_error(message)

data/lib/solid_observer/services/install_migrations.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Services
+    class InstallMigrations
+      def self.call(rails_env: Rails.env)
+        new(rails_env).call
+      end
+
+      def initialize(rails_env)
+        @rails_env = rails_env
+      end
+
+      def call
+        destination = resolve_destination
+        copied = ActiveRecord::Migration.copy(
+          destination,
+          "solid_observer" => SolidObserver::Engine.paths["db/migrate"].existent.first
+        )
+
+        {
+          destination: destination,
+          copied: copied
+        }
+      end
+
+      private
+
+      def resolve_destination
+        path = configured_path
+        return path if path
+
+        ActiveRecord::Tasks::DatabaseTasks.migrations_paths.first || "db/migrate"
+      end
+
+      def configured_path
+        config = ActiveRecord::Base.configurations.configs_for(
+          env_name: @rails_env,
+          name: "solid_observer_queue"
+        )
+        path = Array(config&.migrations_paths).first
+        return if path.blank?
+
+        FileUtils.mkdir_p(path) unless Dir.exist?(path)
+        path
+      end
+    end
+  end
+end

data/lib/solid_observer/services/record_event.rb

@@ -54,33 +54,72 @@ module SolidObserver
           job_class: metadata[:job_class],
           queue_name: metadata[:queue_name],
           correlation_id: CorrelationIdResolver.resolve(@event),
-          duration: @event.duration,
+          duration: duration_in_seconds,
           metadata: metadata.except(:job_class, :queue_name).to_json,
           recorded_at: Time.current
         }
       end
 
+      def duration_in_seconds
+        @event.duration&./(1000.0)
+      end
+
       def extract_metadata
         payload = @event.payload || {}
-        exception_obj = payload[:exception_object]
-
-        {
-          job_id: payload.dig(:job, :job_id),
-          job_class: payload.dig(:job, :class_name) || payload.dig(:job, :job_class),
-          queue_name: payload.dig(:job, :queue_name),
-          arguments: payload.dig(:job, :arguments),
-          executions: payload.dig(:job, :executions),
-          exception_class: exception_obj&.class&.name || payload[:exception]&.first,
-          exception_message: exception_obj&.message || payload[:exception]&.last,
-          enqueued_at: payload.dig(:job, :enqueued_at),
-          priority: payload.dig(:job, :priority)
-        }.compact
+        metadata_from(payload, payload[:job]).compact
       rescue => e
         Rails.logger.warn "[SolidObserver] Failed to extract metadata: #{e.message}" if defined?(Rails)
         {}
       end
 
+      def metadata_from(payload, job)
+        {
+          job_id: read_job_attr(job, :job_id),
+          job_class: read_job_class(job),
+          queue_name: read_job_attr(job, :queue_name),
+          executions: read_job_attr(job, :executions),
+          exception_class: exception_class(payload),
+          exception_message: exception_message(payload),
+          enqueued_at: read_job_attr(job, :enqueued_at),
+          priority: read_job_attr(job, :priority)
+        }
+      end
+
+      def read_job_attr(job, attr)
+        return nil unless job
+
+        if job.is_a?(Hash)
+          job[attr]
+        else
+          job.public_send(attr)
+        end
+      rescue NoMethodError
+        nil
+      end
+
+      def read_job_class(job)
+        return nil unless job
+
+        if job.is_a?(Hash)
+          job[:class_name] || job[:job_class]
+        else
+          job.class.name
+        end
+      end
+
+      def exception_class(payload)
+        exception_obj = payload[:exception_object]
+        exception_obj&.class&.name || payload[:exception]&.first
+      end
+
+      def exception_message(payload)
+        exception_obj = payload[:exception_object]
+        exception_obj&.message || payload[:exception]&.last
+      end
+
       def increment_metric
+        return unless SolidObserver.config.persistence_mode?
+
         period = Time.current.beginning_of_hour
         QueueMetric.increment(metric: @metric_name, period: period)
       rescue => e

data/lib/solid_observer/services/ui_auth_check.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Services
+    # Logs a boot-time WARNING when the Web UI's HTTP Basic Auth is misconfigured.
+    #
+    # No-ops when the UI is disabled or both credentials are set. Otherwise logs
+    # one of two warnings: "no auth configured" (neither credential set) or
+    # "auth misconfigured" (exactly one set, naming the missing one).
+    #
+    # The UI ships fail-open on partial credentials — see
+    # SolidObserver::ApplicationController#authenticate.
+    class UiAuthCheck
+      def self.call(config:, logger: Rails.logger)
+        new(config, logger).call
+      end
+
+      def initialize(config, logger)
+        @config = config
+        @logger = logger
+      end
+
+      def call
+        return unless config.ui_enabled
+
+        warning = warning_message
+        logger.warn(warning) if warning
+      end
+
+      private
+
+      attr_reader :config, :logger
+
+      def warning_message
+        return nil if both_credentials_present?
+        return no_auth_warning if neither_credential_present?
+
+        partial_auth_warning
+      end
+
+      def both_credentials_present?
+        config.ui_username.present? && config.ui_password.present?
+      end
+
+      def neither_credential_present?
+        config.ui_username.blank? && config.ui_password.blank?
+      end
+
+      def no_auth_warning
+        "[SolidObserver] WARNING: UI is enabled with no authentication configured. " \
+          "Set config.ui_username and config.ui_password."
+      end
+
+      def partial_auth_warning
+        set, missing = partial_credential_names
+        "[SolidObserver] WARNING: UI authentication is misconfigured — #{set} is set but #{missing} is missing/nil. " \
+          "The UI will ship UNAUTHENTICATED until both are configured. Set both credentials, or unset both to silence this warning."
+      end
+
+      def partial_credential_names
+        config.ui_username.present? ? %w[ui_username ui_password] : %w[ui_password ui_username]
+      end
+    end
+  end
+end

data/lib/solid_observer/subscriber.rb

@@ -18,15 +18,9 @@ module SolidObserver
 
     class << self
       def subscribe!
-        return unless SolidObserver.config.observe_queue
-        return if subscribed?
+        return unless subscription_allowed?
 
-        @subscriptions = []
-        @subscriptions << subscribe_to_enqueue
-        @subscriptions << subscribe_to_perform
-        @subscriptions << subscribe_to_retry_stopped
-        @subscriptions << subscribe_to_discard
-        @subscriptions.compact!
+        @subscriptions = subscriptions_for_events.compact
       end
 
       def unsubscribe!
@@ -44,6 +38,19 @@ module SolidObserver
 
       private
 
+      def subscription_allowed?
+        SolidObserver.config.observe_queue && !subscribed?
+      end
+
+      def subscriptions_for_events
+        [
+          subscribe_to_enqueue,
+          subscribe_to_perform,
+          subscribe_to_retry_stopped,
+          subscribe_to_discard
+        ]
+      end
+
       def subscribe_to_enqueue
         ActiveSupport::Notifications.subscribe("enqueue.active_job") do |*args|
           event = ActiveSupport::Notifications::Event.new(*args)

data/lib/solid_observer/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module SolidObserver
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
   RUBY_MINIMUM_VERSION = "3.2.0"
   RAILS_MINIMUM_VERSION = "8.0"
 end

data/lib/solid_observer.rb

@@ -5,9 +5,15 @@ require_relative "solid_observer/configuration"
 require_relative "solid_observer/correlation_id_resolver"
 require_relative "solid_observer/base_event" if defined?(ActiveRecord)
 require_relative "solid_observer/base_metric" if defined?(ActiveRecord)
+require_relative "solid_observer/params/jobs_filter"
+require_relative "solid_observer/params/events_filter"
+require_relative "solid_observer/queries/job_executions_query" if defined?(ActiveRecord)
+require_relative "solid_observer/queries/events_query" if defined?(ActiveRecord)
+require_relative "solid_observer/queries/execution_finder" if defined?(ActiveRecord)
 require_relative "solid_observer/services/record_event" if defined?(ActiveRecord)
 require_relative "solid_observer/services/flush_event_buffer" if defined?(ActiveRecord)
 require_relative "solid_observer/services/cleanup_storage" if defined?(ActiveRecord)
+require_relative "solid_observer/services/ui_auth_check"
 require_relative "solid_observer/queue_event_buffer" if defined?(ActiveRecord)
 require_relative "solid_observer/subscriber" if defined?(ActiveSupport)
 require_relative "solid_observer/cli/base"
@@ -15,6 +21,7 @@ require_relative "solid_observer/cli/status"
 require_relative "solid_observer/cli/storage"
 require_relative "solid_observer/cli/jobs"
 require_relative "solid_observer/queue_stats"
+require_relative "../app/presenters/solid_observer/execution_presenter"
 require_relative "solid_observer/engine" if defined?(Rails::Engine)
 
 module SolidObserver

data/lib/tasks/solid_observer.rake

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../solid_observer/services/install_migrations"
+
 namespace :solid_observer do
   desc "Display SolidObserver version"
   task :version do
@@ -11,8 +13,14 @@ namespace :solid_observer do
   namespace :install do
     desc "Copy SolidObserver migrations to your application"
     task migrations: :environment do
-      Rake::Task["railties:install:migrations"].reenable
-      Rake::Task["railties:install:migrations"].invoke
+      result = SolidObserver::Services::InstallMigrations.call
+
+      if result[:copied].any?
+        suffix = (result[:copied].size == 1) ? "" : "s"
+        puts "Copied #{result[:copied].size} SolidObserver migration#{suffix} to #{result[:destination]}/"
+      else
+        puts "No new SolidObserver migrations to copy (all already present in #{result[:destination]}/)"
+      end
     end
   end