solid_observer 0.3.0 → 0.4.0

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/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/version.rb

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

data/lib/tasks/solid_observer.rake

@@ -68,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_observer
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - BartOz
@@ -50,10 +50,13 @@ files:
 - LICENSE.txt
 - README.md
 - app/assets/javascripts/solid_observer/live_poll.js
+- app/assets/stylesheets/solid_observer/application.css
 - app/controllers/concerns/solid_observer/paginatable.rb
 - app/controllers/concerns/solid_observer/require_persistence_mode.rb
 - app/controllers/concerns/solid_observer/require_solid_queue.rb
 - app/controllers/solid_observer/application_controller.rb
+- app/controllers/solid_observer/cache_dashboard_controller.rb
+- app/controllers/solid_observer/cache_operations_controller.rb
 - app/controllers/solid_observer/dashboard_controller.rb
 - app/controllers/solid_observer/events_controller.rb
 - app/controllers/solid_observer/jobs_controller.rb
@@ -61,11 +64,19 @@ files:
 - app/helpers/solid_observer/application_helper.rb
 - app/helpers/solid_observer/dashboard_helper.rb
 - app/jobs/solid_observer/cleanup_job.rb
+- app/models/solid_observer/cache_event.rb
+- app/models/solid_observer/cache_metric.rb
 - app/models/solid_observer/queue_event.rb
 - app/models/solid_observer/queue_metric.rb
 - app/models/solid_observer/storage_info.rb
 - app/presenters/solid_observer/execution_presenter.rb
 - app/views/layouts/solid_observer/application.html.erb
+- app/views/solid_observer/cache_dashboard/_charts.html.erb
+- app/views/solid_observer/cache_dashboard/_recent_events.html.erb
+- app/views/solid_observer/cache_dashboard/_summary.html.erb
+- app/views/solid_observer/cache_dashboard/index.html.erb
+- app/views/solid_observer/cache_operations/_confirm_clear.html.erb
+- app/views/solid_observer/cache_operations/index.html.erb
 - app/views/solid_observer/dashboard/_chart.html.erb
 - app/views/solid_observer/dashboard/_live_state.html.erb
 - app/views/solid_observer/dashboard/_queue_table.html.erb
@@ -89,11 +100,16 @@ files:
 - db/migrate/20260115000002_create_solid_observer_metrics.rb
 - db/migrate/20260115000003_create_solid_observer_storage_info.rb
 - db/migrate/20260424000001_add_composite_indexes_to_queue_events.rb
+- db/migrate/20260601000001_create_solid_observer_cache_events.rb
+- db/migrate/20260601000002_create_solid_observer_cache_metrics.rb
+- db/migrate/20260602000001_add_component_to_solid_observer_storage_infos.rb
 - lib/generators/solid_observer/install_generator.rb
 - lib/generators/solid_observer/templates/initializer.rb.tt
 - lib/solid_observer.rb
 - lib/solid_observer/base_event.rb
 - lib/solid_observer/base_metric.rb
+- lib/solid_observer/cache_event_buffer.rb
+- lib/solid_observer/cache_subscriber.rb
 - lib/solid_observer/chart_buffer.rb
 - lib/solid_observer/cli/base.rb
 - lib/solid_observer/cli/jobs.rb
@@ -109,11 +125,17 @@ files:
 - lib/solid_observer/queries/job_executions_query.rb
 - lib/solid_observer/queue_event_buffer.rb
 - lib/solid_observer/queue_stats.rb
+- lib/solid_observer/services/cache_operations.rb
+- lib/solid_observer/services/cache_stats.rb
 - lib/solid_observer/services/cleanup_storage.rb
 - lib/solid_observer/services/database_size.rb
+- lib/solid_observer/services/flush_cache_event_buffer.rb
 - lib/solid_observer/services/flush_event_buffer.rb
 - lib/solid_observer/services/install_migrations.rb
+- lib/solid_observer/services/record_cache_event.rb
+- lib/solid_observer/services/record_cache_metric.rb
 - lib/solid_observer/services/record_event.rb
+- lib/solid_observer/services/storage_info_snapshot.rb
 - lib/solid_observer/services/ui_auth_check.rb
 - lib/solid_observer/subscriber.rb
 - lib/solid_observer/version.rb