solid_observer 0.3.0 → 0.5.0

data/lib/solid_observer/chart_buffer.rb

@@ -2,7 +2,40 @@
 
 module SolidObserver
   class ChartBuffer
+    CACHE_KEY = "solid_observer/chart_buffer/ready_samples"
     INSTANCE_MUTEX = Mutex.new
+    SAMPLE_CAP = 720
+    STORAGE_MUTEX = Mutex.new
+
+    class SampleWindow
+      def initialize(samples)
+        @samples = samples
+      end
+
+      def upsert(sample, cap:)
+        return replace_latest_sample(sample) if latest_sample_timestamp == sample[:t]
+
+        append_new_sample(sample, cap: cap)
+      end
+
+      private
+
+      def latest_sample_timestamp
+        @samples.last&.[](:t)
+      end
+
+      def replace_latest_sample(sample)
+        @samples[-1] = sample
+        @samples
+      end
+
+      def append_new_sample(sample, cap:)
+        @samples << sample
+        overflow = @samples.length - cap
+        @samples.shift(overflow) if overflow.positive?
+        @samples
+      end
+    end
 
     class << self
       def append(value, at: Time.now)
@@ -24,16 +57,12 @@ module SolidObserver
       end
     end
 
-    def initialize
-      @mutex = Mutex.new
-      @samples = []
-      @cap = nil
-    end
+    @fallback_samples = []
 
     def append(value, at: Time.now)
       sample = {t: at.to_i, v: value.to_i}
 
-      @mutex.synchronize { store_sample(sample) }
+      STORAGE_MUTEX.synchronize { persist_sample(sample) }
 
       sample
     end
@@ -41,43 +70,71 @@ module SolidObserver
     def recent(window_seconds)
       cutoff = Time.now.to_i - window_seconds.to_i
 
-      @mutex.synchronize do
-        @samples.select { |sample| sample[:t] >= cutoff }.map(&:dup)
+      STORAGE_MUTEX.synchronize do
+        load_samples.select { |sample| sample[:t] >= cutoff }.map(&:dup)
       end
     end
 
     def clear
-      @mutex.synchronize do
-        @samples.clear
-        @cap = nil
+      STORAGE_MUTEX.synchronize do
+        empty_samples = []
+        replace_fallback_samples(empty_samples)
+        cache_store&.delete(CACHE_KEY)
+      rescue
+        nil
       end
     end
 
     private
 
-    def store_sample(sample)
-      @cap ||= compute_cap
-      replace_or_append(sample)
-      trim_to_cap
+    def persist_sample(sample)
+      samples = SampleWindow.new(load_samples).upsert(sample, cap: SAMPLE_CAP)
+      write_samples(samples)
     end
 
-    def replace_or_append(sample)
-      latest_sample = @samples.last
+    def load_samples
+      normalize_samples(cache_store&.read(CACHE_KEY) || stored_fallback_samples)
+    rescue
+      stored_fallback_samples
+    end
 
-      if latest_sample && latest_sample[:t] == sample[:t]
-        @samples[-1] = sample
-      else
-        @samples << sample
-      end
+    def write_samples(samples)
+      normalized = normalize_samples(samples)
+
+      replace_fallback_samples(normalized.map(&:dup))
+      cache_store&.write(CACHE_KEY, normalized)
+    rescue
+      replace_fallback_samples(normalized)
     end
 
-    def trim_to_cap
-      overflow = @samples.length - @cap
-      @samples.shift(overflow) if overflow.positive?
+    def cache_store
+      return unless defined?(Rails)
+
+      Rails.cache
     end
 
-    def compute_cap
-      (3600 / 5).to_i # 720 samples — 1h at the 5s cadence
+    def stored_fallback_samples
+      normalize_samples(self.class.instance_variable_get(:@fallback_samples))
+    end
+
+    def replace_fallback_samples(samples)
+      self.class.instance_variable_set(:@fallback_samples, samples)
+    end
+
+    def normalize_samples(samples)
+      Array(samples).filter_map do |sample|
+        normalize_sample(sample)
+      end.last(SAMPLE_CAP)
+    end
+
+    def normalize_sample(sample)
+      return unless sample.is_a?(Hash)
+
+      timestamp = sample[:t] || sample["t"]
+      value = sample[:v] || sample["v"]
+      return unless timestamp && value
+
+      {t: timestamp.to_i, v: value.to_i}
     end
   end
 end

data/lib/solid_observer/cli/storage.rb

@@ -28,47 +28,50 @@ module SolidObserver
       end
 
       def gather_storage_stats
-        {
-          db_size_bytes: SolidObserver::Services::DatabaseSize.call(connection: QueueEvent.connection),
-          event_count: QueueEvent.count,
-          max_size_bytes: SolidObserver.config.max_db_size
-        }
+        {components: SolidObserver::Services::StorageInfoSnapshot.call, max_size_bytes: SolidObserver.config.max_db_size}
       rescue => e
         {error: "Failed to gather storage stats: #{e.message}"}
       end
 
       def print_storage_table(stats)
-        event_count = stats[:event_count]
-        db_size_bytes = stats[:db_size_bytes]
         max_size_bytes = stats[:max_size_bytes]
+        components = stats[:components]
 
         table(
           headers: ["Component", "Size", "Events", "Usage", "Status"],
-          rows: [storage_row(event_count: event_count, db_size_bytes: db_size_bytes, max_size_bytes: max_size_bytes)]
+          rows: components.map { |component| storage_row(component: component, 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)
+      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)
 
         [
-          "Queue",
+          component[:label],
           size,
-          format_number(event_count),
+          event_count ? format_number(event_count) : "—",
           usage,
           status
         ]
       end
 
-      def storage_displays(db_size_bytes, max_size_bytes)
+      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)

data/lib/solid_observer/configuration.rb

@@ -22,10 +22,16 @@ module SolidObserver
     attr_accessor :observe_queue
 
     # Observer Settings (planned for a future release)
-    # @note Cache and Cable observers are not yet implemented
+    # @note Cable observer is not yet fully implemented
     attr_accessor :observe_cache,
       :observe_cable,
-      :cache_sampling_rate
+      :cache_sampling_rate,
+      :cache_slow_threshold,
+      :cache_store_errors
+
+    attr_reader :cable_rejection_threshold,
+      :cable_backlog_threshold,
+      :cable_error_threshold
 
     # Retention Settings
     attr_accessor :event_retention
@@ -47,7 +53,8 @@ module SolidObserver
       :flush_interval,
       :max_buffer_size,
       :buffer_overflow_strategy,
-      :filter_cache_ttl
+      :filter_cache_ttl,
+      :cable_sampling_rate
 
     # Correlation Settings
     attr_accessor :correlation_id_generator
@@ -56,12 +63,16 @@ module SolidObserver
       @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,
+        @sampling_rate, @cache_sampling_rate, @cable_sampling_rate, @cache_slow_threshold, @cache_store_errors,
+        @cable_rejection_threshold, @cable_backlog_threshold, @cable_error_threshold,
+        @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,
+          1.0, 0.1, 0.1, 0.1, true,
+          0.05, 0.10, 0.0,
+          1000, 10.seconds,
           10_000, :drop_old, 1.minute,
           nil
     end
@@ -84,11 +95,55 @@ module SolidObserver
       @storage_mode == :realtime
     end
 
+    def solid_queue_available?
+      !!defined?(::SolidQueue)
+    end
+
+    def solid_cache_available?
+      !!defined?(::SolidCache)
+    end
+
+    def solid_cable_available?
+      !!defined?(::SolidCable)
+    end
+
+    def solid_queue_enabled?
+      observe_queue
+    end
+
+    def solid_cache_enabled?
+      observe_cache && solid_cache_available?
+    end
+
+    def solid_cable_enabled?
+      observe_cable && solid_cable_available?
+    end
+
     def sampling_rate=(value)
       validate_rate!(:sampling_rate, value)
       @sampling_rate = value
     end
 
+    def cable_sampling_rate=(value)
+      validate_rate!(:cable_sampling_rate, value)
+      @cable_sampling_rate = value
+    end
+
+    def cable_rejection_threshold=(value)
+      validate_rate!(:cable_rejection_threshold, value)
+      @cable_rejection_threshold = value
+    end
+
+    def cable_backlog_threshold=(value)
+      validate_rate!(:cable_backlog_threshold, value)
+      @cable_backlog_threshold = value
+    end
+
+    def cable_error_threshold=(value)
+      validate_non_negative_numeric!(:cable_error_threshold, value)
+      @cable_error_threshold = value
+    end
+
     def warning_threshold=(value)
       validate_rate!(:warning_threshold, value)
       @warning_threshold = value
@@ -151,6 +206,13 @@ module SolidObserver
       end
     end
 
+    # :reek:FeatureEnvy
+    def validate_non_negative_numeric!(name, value)
+      unless value.is_a?(Numeric) && value >= 0
+        raise ArgumentError, "#{name} must be a non-negative number"
+      end
+    end
+
     def production?
       defined?(Rails) && Rails.env.production?
     end

data/lib/solid_observer/engine.rb

@@ -10,11 +10,25 @@ module SolidObserver
 
     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_solid_cable_availability
+        return if defined?(::SolidCable)
+        return unless SolidObserver.config.observe_cable
+
+        Rails.logger.warn "[SolidObserver] SolidCable not detected. Cable observability features will be disabled."
+      end
+
       def check_ui_authentication
         Services::UiAuthCheck.call(config: SolidObserver.config)
       end
@@ -28,15 +42,18 @@ module SolidObserver
 
       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!
+        activate_queue_subscriber
+        activate_cache_subscriber
+        activate_cable_subscriber
       end
 
       private
 
       def queue_db_config
+        return unless active_record_available?
+
         ActiveRecord::Base.configurations.configs_for(
           env_name: Rails.env,
           name: "solid_observer_queue"
@@ -48,40 +65,73 @@ module SolidObserver
           database: {writing: :solid_observer_queue, reading: :solid_observer_queue}
         }
 
-        SolidObserver::BaseEvent.connects_to(**connection_config)
-        SolidObserver::BaseMetric.connects_to(**connection_config)
+        SolidObserver::BaseRecord.connects_to(**connection_config)
+      end
+
+      def active_record_available?
+        defined?(::ActiveRecord::Base)
       end
 
       def activate_subscribers_in_realtime
         Rails.logger.info "[SolidObserver] Starting in real-time mode (no persistence)"
-        Subscriber.subscribe!
+        Subscriber.subscribe! if should_activate_queue_subscriber?
+        CacheSubscriber.subscribe! if should_activate_cache_subscriber?
+        CableSubscriber.subscribe! if should_activate_cable_subscriber?
+      end
+
+      def activate_queue_subscriber
+        activate_subscriber_for_table("solid_observer_queue_events", Subscriber) if should_activate_queue_subscriber?
+      end
+
+      def activate_cache_subscriber
+        activate_subscriber_for_table("solid_observer_cache_events", CacheSubscriber) if should_activate_cache_subscriber?
+      end
+
+      def activate_cable_subscriber
+        activate_subscriber_for_table("solid_observer_cable_events", CableSubscriber) if should_activate_cable_subscriber?
       end
 
-      def activation_skipped_for_table_status?
-        case table_status("solid_observer_queue_events")
+      def activate_subscriber_for_table(table_name, subscriber)
+        case table_status(table_name)
         when :absent
-          log_activation_skip("Tables not found. Run: rails solid_observer:install:migrations && rails db:migrate")
-          true
+          log_activation_skip("Tables not found (missing: #{table_name}). Run: rails solid_observer:install:migrations && rails db:migrate")
         when :unknown
           log_activation_skip("Database not reachable at boot. Skipping subscriber activation.")
-          true
         else
-          false
+          subscriber.subscribe!
         end
       end
 
+      def should_activate_queue_subscriber?
+        SolidObserver.config.solid_queue_enabled?
+      end
+
+      def should_activate_cache_subscriber?
+        SolidObserver.config.solid_cache_enabled?
+      end
+
+      def should_activate_cable_subscriber?
+        SolidObserver.config.solid_cable_enabled?
+      end
+
       def log_activation_skip(message)
         Rails.logger.info("[SolidObserver] #{message}")
       end
 
       def table_status(table_name)
-        pool = SolidObserver::BaseEvent.connection_pool
+        return :unknown unless active_record_available?
+
+        data_source_status(table_name)
+      rescue *boot_connection_errors
+        :unknown
+      end
+
+      def data_source_status(table_name)
+        pool = SolidObserver::BaseRecord.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)
@@ -96,12 +146,15 @@ module SolidObserver
       end
 
       def boot_connection_errors
+        return [] unless active_record_available?
+
         [
           ActiveRecord::NoDatabaseError,
           ActiveRecord::ConnectionNotEstablished,
           ActiveRecord::StatementInvalid,
           *([PG::ConnectionBad] if defined?(PG::ConnectionBad)),
           *([Mysql2::Error::ConnectionError] if defined?(Mysql2::Error::ConnectionError)),
+          *([Trilogy::Error] if defined?(Trilogy::Error)),
           *([SQLite3::CantOpenException] if defined?(SQLite3::CantOpenException))
         ]
       end
@@ -109,6 +162,8 @@ module SolidObserver
 
     config.before_initialize do
       Engine.check_solid_queue_availability
+      Engine.check_solid_cache_availability
+      Engine.check_solid_cable_availability
     end
 
     config.after_initialize do

data/lib/solid_observer/event_buffer_core.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "concurrent/timer_task"
+
+module SolidObserver
+  module EventBufferCore
+    INITIAL_METRICS = {
+      flush_failures_count: 0,
+      drops_count: 0,
+      last_flush_at: nil,
+      last_flush_duration_ms: nil,
+      last_flush_error: nil
+    }.freeze
+
+    def initialize_event_buffer
+      @mutex = Mutex.new
+      @metrics_mutex = Mutex.new
+      @buffer = []
+      @metrics = INITIAL_METRICS.dup
+      @timer_task = nil
+    end
+    private :initialize_event_buffer
+
+    def push(event_data)
+      return unless (config = SolidObserver.config).persistence_mode?
+
+      drops_count, should_flush = sync_push_and_check(event_data, config)
+      record_drop(drops_count) if drops_count.positive?
+      ensure_timer_running
+      flush! if should_flush
+    end
+
+    def flush!
+      events_to_flush = drain_buffer
+      return if events_to_flush.empty?
+
+      flush_events(events_to_flush, monotonic_ms)
+    end
+
+    def flush
+      flush!
+    end
+
+    def size
+      @mutex.synchronize { @buffer.size }
+    end
+
+    def clear
+      @mutex.synchronize { @buffer.clear }
+    end
+
+    def metrics
+      current_size = @mutex.synchronize { @buffer.size }
+      snapshot = @metrics_mutex.synchronize { @metrics.dup }
+      {
+        size: current_size,
+        max_buffer_size: SolidObserver.config.max_buffer_size
+      }.merge(snapshot)
+    end
+
+    def shutdown
+      stop_timer
+      flush!
+    end
+
+    private
+
+    def drain_buffer
+      @mutex.synchronize do
+        events_to_flush = @buffer.dup
+        @buffer.clear
+        events_to_flush
+      end
+    end
+
+    def flush_events(events_to_flush, started_at_ms)
+      flush_service.call(events_to_flush)
+      record_flush_success(monotonic_ms - started_at_ms)
+    rescue => error
+      handle_flush_error(error, events_to_flush)
+    end
+
+    def handle_flush_error(error, events_to_flush)
+      requeue_failed_events(events_to_flush)
+      record_flush_failure(error)
+      log_flush_failure(error)
+      nil
+    end
+
+    def log_flush_failure(error)
+      Rails.logger&.error("[SolidObserver] #{log_label} flush failed: #{error.message}") if defined?(Rails)
+    end
+
+    def apply_overflow_policy(event_data, config)
+      if @buffer.size < config.max_buffer_size
+        @buffer << event_data
+        return 0
+      end
+
+      handle_overflow(event_data, config.buffer_overflow_strategy)
+    end
+
+    def handle_overflow(event_data, overflow_strategy)
+      case overflow_strategy
+      when :drop_old
+        @buffer.shift
+        @buffer << event_data
+      when :drop_new
+        nil
+      else
+        raise ArgumentError, "Unsupported buffer_overflow_strategy: #{overflow_strategy.inspect}"
+      end
+
+      1
+    end
+
+    def requeue_failed_events(events_to_flush)
+      dropped_count = sync_requeue_events(events_to_flush, SolidObserver.config.max_buffer_size)
+      record_drop(dropped_count) if dropped_count.positive?
+    end
+
+    def trim_events_for_capacity(events, max_buffer_size)
+      dropped_count = events.size - max_buffer_size
+      return [events, 0] if dropped_count <= 0
+
+      [events_to_keep(events, max_buffer_size), dropped_count]
+    end
+
+    def ensure_timer_running
+      timer_to_start, timer_to_stop = replace_timer_if_stopped
+      return unless timer_to_start
+
+      timer_to_stop&.shutdown
+      timer_to_start.execute
+    end
+
+    def replace_timer_if_stopped
+      @mutex.synchronize do
+        current_timer_task = @timer_task
+        return [nil, nil] if timer_running?(current_timer_task)
+
+        [build_timer_task, current_timer_task]
+      end
+    end
+
+    def stop_timer
+      timer_to_stop = @mutex.synchronize do
+        current_timer = @timer_task
+        @timer_task = nil
+        current_timer
+      end
+
+      timer_to_stop&.shutdown
+    end
+
+    def record_flush_success(duration_ms)
+      @metrics_mutex.synchronize do
+        @metrics.merge!(
+          last_flush_at: Time.current,
+          last_flush_duration_ms: duration_ms,
+          last_flush_error: nil
+        )
+      end
+    end
+
+    def record_flush_failure(error)
+      @metrics_mutex.synchronize do
+        @metrics[:flush_failures_count] += 1
+        @metrics[:last_flush_error] = error.message
+      end
+    end
+
+    def record_drop(count = 1)
+      @metrics_mutex.synchronize do
+        @metrics[:drops_count] += count
+      end
+    end
+
+    def sync_push_and_check(event_data, config)
+      @mutex.synchronize do
+        drops_count = apply_overflow_policy(event_data, config)
+        [drops_count, @buffer.size >= config.buffer_size]
+      end
+    end
+
+    def sync_requeue_events(events_to_flush, max_buffer_size)
+      @mutex.synchronize do
+        combined_events = events_to_flush + @buffer
+        kept_events, dropped_count = trim_events_for_capacity(combined_events, max_buffer_size)
+        @buffer.replace(kept_events)
+        dropped_count
+      end
+    end
+
+    def events_to_keep(events, max_buffer_size)
+      if SolidObserver.config.buffer_overflow_strategy == :drop_old
+        events.last(max_buffer_size)
+      else
+        events.first(max_buffer_size)
+      end
+    end
+
+    def timer_running?(timer_task)
+      timer_task && !timer_task.shuttingdown?
+    end
+
+    def build_timer_task
+      @timer_task = Concurrent::TimerTask.new(
+        execution_interval: SolidObserver.config.flush_interval,
+        run_now: false
+      ) { flush! }
+    end
+
+    def monotonic_ms
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+    end
+  end
+end