solid_observer 0.1.1 → 0.4.0

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_cache_event.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module SolidObserver
+  module Services
+    class RecordCacheEvent
+      def self.call(event:, buffer:)
+        new(event, buffer).call
+      end
+
+      def initialize(event, buffer)
+        @event = event
+        @buffer = buffer
+      end
+
+      def call
+        record_metric_and_event
+      rescue => error
+        raise error if error.is_a?(NameError)
+        Rails.logger&.warn("[SolidObserver] Cache event recording failed: #{error.message}") if defined?(Rails)
+      end
+
+      private
+
+      def record_metric_and_event
+        SolidObserver::Services::RecordCacheMetric.call(event: @event)
+        return unless should_store_event?
+
+        @buffer.push(build_event_data)
+      end
+
+      def should_store_event?
+        sampled? || slow? || errored?
+      end
+
+      def sampled?
+        rand <= SolidObserver.config.cache_sampling_rate
+      end
+
+      def slow?
+        duration_in_seconds && duration_in_seconds >= SolidObserver.config.cache_slow_threshold
+      end
+
+      def errored?
+        return false unless SolidObserver.config.cache_store_errors
+
+        !exception_data.compact.empty?
+      end
+
+      def build_event_data
+        {
+          event_type: cache_operation,
+          key_digest: key_digest,
+          hit: hit_value,
+          duration: duration_in_seconds,
+          error_class: exception_data[:error_class],
+          error_message: exception_data[:error_message],
+          metadata: metadata.to_json,
+          recorded_at: Time.current
+        }
+      end
+
+      def cache_operation
+        @event.name.delete_suffix(".active_support")
+      end
+
+      def duration_in_seconds
+        @event.duration&./(1000.0)
+      end
+
+      def key_digest
+        Digest::SHA256.hexdigest(normalized_key_string)
+      end
+
+      def normalized_key_string
+        key = payload[:key]
+
+        case key
+        when Hash
+          key.keys.map(&:to_s).sort.join(",")
+        when Array
+          key.map(&:to_s).sort.join(",")
+        else
+          key.to_s
+        end
+      end
+
+      def hit_value
+        hit = payload[:hit]
+        hits = payload[:hits]
+
+        return hit unless hit.nil?
+        return nil unless hits.is_a?(Array)
+
+        hits.any?
+      end
+
+      def metadata
+        {
+          super_operation: payload[:super_operation]&.to_s,
+          key_size: key_size,
+          hits_count: hits_count
+        }.compact.merge(exception_data).compact
+      end
+
+      def key_size
+        key = payload[:key]
+        return key.keys.size if key.is_a?(Hash)
+        return key.size if key.is_a?(Array)
+
+        key.to_s.bytesize
+      end
+
+      def hits_count
+        hits = payload[:hits]
+        return nil unless hits.is_a?(Array)
+
+        hits.size
+      end
+
+      def exception_data
+        @exception_data ||= begin
+          exception_obj = payload[:exception_object]
+          exception = payload[:exception]
+
+          if exception_obj
+            {error_class: exception_obj.class.name, error_message: exception_obj.message}
+          elsif exception.is_a?(Array)
+            {error_class: exception.first, error_message: exception.last}
+          else
+            {}
+          end
+        end
+      end
+
+      def payload
+        @event.payload || {}
+      end
+    end
+  end
+end

data/lib/solid_observer/services/record_cache_metric.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Services
+    class RecordCacheMetric
+      def self.call(event:)
+        new(event).call
+      end
+
+      def initialize(event)
+        @event = event
+      end
+
+      def call
+        metric = SolidObserver::CacheMetric.find_or_create_by!(
+          event_type: event_type,
+          period_start: period_start
+        )
+
+        SolidObserver::CacheMetric
+          .where(id: metric.id)
+          .update_all(update_values)
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      rescue => error
+        Rails.logger&.warn("[SolidObserver] Cache metric recording failed: #{error.message}") if defined?(Rails)
+      end
+
+      private
+
+      def period_start
+        Time.current.beginning_of_minute
+      end
+
+      def event_type
+        @event.name.delete_suffix(".active_support")
+      end
+
+      def update_values
+        {
+          operations_count: Arel.sql("operations_count + 1"),
+          hits_count: Arel.sql("hits_count + #{hit_increment}"),
+          misses_count: Arel.sql("misses_count + #{miss_increment}"),
+          errors_count: Arel.sql("errors_count + #{error_increment}"),
+          duration_total: Arel.sql("duration_total + #{duration_in_seconds}")
+        }
+      end
+
+      def hit_increment
+        (payload[:hit] == true) ? 1 : 0
+      end
+
+      def miss_increment
+        (payload[:hit] == false) ? 1 : 0
+      end
+
+      def error_increment
+        exception_present? ? 1 : 0
+      end
+
+      def exception_present?
+        payload[:exception_object].present? || payload[:exception].is_a?(Array)
+      end
+
+      def duration_in_seconds
+        (@event.duration || 0).to_f / 1000.0
+      end
+
+      def payload
+        @event.payload || {}
+      end
+    end
+  end
+end

data/lib/solid_observer/services/record_event.rb

@@ -54,32 +54,69 @@ 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?
 

data/lib/solid_observer/services/storage_info_snapshot.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "database_size"
+
+module SolidObserver
+  module Services
+    class StorageInfoSnapshot
+      Component = Struct.new(:key, :label, :record_label, :model, :enabled, keyword_init: true) do
+        def enabled?
+          enabled.call
+        end
+
+        def solid_cache?
+          key == "solid_cache"
+        end
+
+        def storage_model
+          model.call
+        end
+
+        def data_source_exists?(connection, table_name)
+          connection.data_source_exists?(table_name)
+        end
+
+        def database_size(connection, table_name)
+          DatabaseSize.call(connection: connection, table_name: table_name)
+        end
+
+        def snapshot
+          return unless enabled?
+          return unavailable_snapshot(reason: "SolidCache is unavailable") if unavailable_solid_cache?
+
+          existing_data_source_snapshot
+        rescue *StorageInfoSnapshot::CONNECTION_ERRORS, TypeError
+          unavailable_snapshot(reason: "Storage unavailable")
+        end
+
+        def available_snapshot(db_size_bytes:, event_count:)
+          {
+            component: key,
+            label: label,
+            available: true,
+            db_size_bytes: db_size_bytes,
+            event_count: event_count,
+            record_label: record_label,
+            recorded_at: Time.current,
+            unavailable_reason: nil
+          }
+        end
+
+        def unavailable_snapshot(reason:)
+          {
+            component: key,
+            label: label,
+            available: false,
+            db_size_bytes: nil,
+            event_count: nil,
+            record_label: record_label,
+            recorded_at: nil,
+            unavailable_reason: reason
+          }
+        end
+
+        private
+
+        def unavailable_solid_cache?
+          solid_cache? && !defined?(::SolidCache::Entry)
+        end
+
+        def existing_data_source_snapshot
+          record_model = storage_model
+          connection = record_model.connection
+          table_name = record_model.table_name.to_s
+          return table_unavailable_snapshot if table_name.empty? || !data_source_exists?(connection, table_name)
+
+          available_snapshot(
+            db_size_bytes: database_size(connection, table_name),
+            event_count: record_model.count
+          )
+        end
+
+        def table_unavailable_snapshot
+          unavailable_snapshot(reason: "Table unavailable")
+        end
+      end
+
+      COMPONENTS = [
+        Component.new(
+          key: "queue_observer",
+          label: "Queue observer",
+          record_label: "observer events",
+          model: -> { SolidObserver::QueueEvent },
+          enabled: -> { SolidObserver.config.solid_queue_enabled? }
+        ),
+        Component.new(
+          key: "cache_observer",
+          label: "Cache observer",
+          record_label: "observer events",
+          model: -> { SolidObserver::CacheEvent },
+          enabled: -> { SolidObserver.config.solid_cache_enabled? }
+        ),
+        Component.new(
+          key: "solid_cache",
+          label: "SolidCache",
+          record_label: "cache rows",
+          model: -> { ::SolidCache::Entry },
+          enabled: -> { SolidObserver.config.solid_cache_enabled? }
+        )
+      ].freeze
+
+      CONNECTION_ERRORS = [
+        ActiveRecord::ConnectionNotEstablished,
+        ActiveRecord::StatementInvalid,
+        *([PG::ConnectionBad] if defined?(PG::ConnectionBad)),
+        *([Mysql2::Error::ConnectionError] if defined?(Mysql2::Error::ConnectionError)),
+        *([SQLite3::CantOpenException] if defined?(SQLite3::CantOpenException))
+      ].freeze
+
+      def self.call
+        new.call
+      end
+
+      def call
+        COMPONENTS.filter_map(&:snapshot)
+      end
+    end
+  end
+end

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.1"
+  VERSION = "0.4.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
 
@@ -60,6 +68,35 @@ namespace :solid_observer do
     end
   end
 
+  namespace :cache do
+    desc "Clear all SolidCache entries after confirmation"
+    task clear: :environment do
+      if !SolidObserver::Services::CacheOperations.available?
+        puts SolidObserver::Services::CacheOperations.unavailable_message
+        next
+      end
+
+      print "#{SolidObserver::Services::CacheOperations.message(:clear, :confirmation)} (y/N) "
+      $stdout.flush
+
+      if $stdin.gets&.strip&.downcase == "y"
+        puts SolidObserver::Services::CacheOperations.clear[:message]
+      else
+        puts "Aborted"
+      end
+    end
+
+    desc "Prune expired SolidCache entries"
+    task prune: :environment do
+      if !SolidObserver::Services::CacheOperations.available?
+        puts SolidObserver::Services::CacheOperations.unavailable_message
+        next
+      end
+
+      puts SolidObserver::Services::CacheOperations.prune[:message]
+    end
+  end
+
   namespace :storage do
     desc "Run storage cleanup based on retention policy"
     task cleanup: :environment do