solid_observer 0.3.0 → 0.5.0

data/lib/solid_observer/queue_event_buffer.rb

@@ -1,221 +1,29 @@
 # frozen_string_literal: true
 
 require "singleton"
-require "concurrent/timer_task"
+
+require_relative "event_buffer_core"
 
 module SolidObserver
   # Thread-safe buffer for collecting queue events before batch insertion.
-  #
-  # Events are buffered in memory and flushed either when:
-  # - Buffer size reaches the configured threshold
-  # - Flush interval timer expires
-  #
-  # @example Push an event to the buffer
-  #   QueueEventBuffer.instance.push(event_data)
   class QueueEventBuffer
     include Singleton
+    include EventBufferCore
 
-    INITIAL_METRICS = {
-      flush_failures_count: 0,
-      drops_count: 0,
-      last_flush_at: nil,
-      last_flush_duration_ms: nil,
-      last_flush_error: nil
-    }.freeze
+    INITIAL_METRICS = EventBufferCore::INITIAL_METRICS
 
     def initialize
-      @mutex = Mutex.new
-      @metrics_mutex = Mutex.new
-      @buffer = []
-      @metrics = INITIAL_METRICS.dup
-      @timer_task = nil
-    end
-
-    # Adds an event to the buffer and triggers flush if threshold reached.
-    #
-    # @param event_data [Hash] Event data to buffer
-    # @return [void]
-    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
-
-    # Flushes all buffered events to the database.
-    #
-    # @return [void]
-    def flush!
-      events_to_flush = nil
-
-      @mutex.synchronize do
-        return if @buffer.empty?
-        events_to_flush = @buffer.dup
-        @buffer.clear
-      end
-
-      started_at_ms = monotonic_ms
-      begin
-        Services::FlushEventBuffer.call(events_to_flush)
-      rescue => e
-        requeue_failed_events(events_to_flush)
-        record_flush_failure(e)
-        Rails.logger&.error "[SolidObserver] Buffer flush failed: #{e.message}" if defined?(Rails)
-        return
-      end
-      record_flush_success(monotonic_ms - started_at_ms)
-    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!
+      initialize_event_buffer
     end
 
     private
 
-    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
-        # No-op: drop incoming event, keep oldest buffered events.
-      else
-        raise ArgumentError, "Unsupported buffer_overflow_strategy: #{overflow_strategy.inspect}"
-      end
-
-      1
-    end
-
-    def requeue_failed_events(events_to_flush)
-      return unless 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! }
+    def flush_service
+      Services::FlushEventBuffer
     end
 
-    def monotonic_ms
-      Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+    def log_label
+      "Buffer"
     end
   end
 end

data/lib/solid_observer/services/cable_operations.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Services
+    class CableOperations
+      MESSAGES = {
+        trim: {
+          success: "Expired/trimmable Solid Cable messages trimmed.",
+          failure: "Cable trim failed. No raw Cable payloads or adapter details are shown. Use solid_observer:cable:trim if the problem continues."
+        }.freeze,
+        unavailable: "Cable controls are unavailable because Solid Cable support is disabled or not detected."
+      }.freeze
+
+      class << self
+        def available?
+          new.available?
+        end
+
+        def trim
+          new.trim
+        end
+
+        def message(operation, key = nil)
+          return MESSAGES.fetch(:unavailable) if operation == :unavailable
+
+          MESSAGES.fetch(operation).fetch(key)
+        end
+
+        def unavailable_message
+          message(:unavailable)
+        end
+      end
+
+      def available?
+        SolidObserver.config.solid_cable_enabled? && !!defined?(::SolidCable::Message)
+      end
+
+      def trim
+        messages = self.class
+        return {ok: false, message: messages.unavailable_message} unless available?
+
+        perform_operation(
+          :trim,
+          success_message: messages.message(:trim, :success),
+          failure_message: messages.message(:trim, :failure)
+        ) do
+          trim_cable_messages
+        end
+      end
+
+      private
+
+      def trim_cable_messages
+        if defined?(::SolidCable::TrimJob)
+          ::SolidCable::TrimJob.perform_now
+        else
+          ::SolidCable::Message.trimmable.delete_all
+        end
+      end
+
+      def perform_operation(name, success_message:, failure_message:)
+        yield
+        {ok: true, message: success_message}
+      rescue => error
+        log_failure(name, error)
+        {ok: false, message: failure_message}
+      end
+
+      def log_failure(name, error)
+        Rails.logger&.warn("[SolidObserver] Cable #{name} failed: #{error.class}")
+      end
+    end
+  end
+end

data/lib/solid_observer/services/cable_stats.rb

@@ -0,0 +1,385 @@
+# frozen_string_literal: true
+
+require_relative "storage_info_snapshot"
+
+module SolidObserver
+  module Services
+    # :reek:TooManyConstants
+    class CableStats
+      RANGES = {
+        "15m" => 15.minutes,
+        "30m" => 30.minutes,
+        "1h" => 1.hour,
+        "7h" => 7.hours,
+        "1d" => 1.day,
+        "7d" => 7.days,
+        "14d" => 14.days
+      }.freeze
+      DEFAULT_RANGE = "15m"
+      ACTIVITY_TREND_EMPTY = {
+        available: false,
+        broadcasts: [],
+        rejections: []
+      }.freeze
+      STABILITY_EMPTY = {
+        available: false,
+        state: :stable,
+        rejection_count: 0,
+        error_count: 0,
+        rejection_rate: 0.0,
+        backlog_ratio: nil,
+        backlog_available: false,
+        latest_recorded_at: nil
+      }.freeze
+      STABILITY_DEGRADED = {
+        available: true,
+        state: :degraded,
+        rejection_count: 0,
+        error_count: 0,
+        rejection_rate: 0.0,
+        backlog_ratio: nil,
+        backlog_available: false,
+        latest_recorded_at: nil
+      }.freeze
+      BUCKET_RULES = [
+        [2.hours.to_i, 1.minute.to_i],
+        [1.day.to_i, 15.minutes.to_i],
+        [7.days.to_i, 2.hours.to_i]
+      ].freeze
+
+      class TrendData
+        class BucketSnapshot
+          attr_reader :broadcasts_count, :rejections_count
+
+          def initialize
+            @broadcasts_count = 0
+            @rejections_count = 0
+          end
+
+          def add(row)
+            @broadcasts_count += row[1].to_i
+            @rejections_count += row[4].to_i
+          end
+
+          def value_for(key)
+            public_send(key)
+          end
+        end
+
+        def initialize(metric_rows:, window:, current_time:)
+          @metric_rows = metric_rows
+          @window = window
+          @current_time = current_time
+        end
+
+        def to_h
+          return CableStats::ACTIVITY_TREND_EMPTY.dup if metric_rows.empty?
+
+          buckets = blank_buckets
+          metric_rows.each do |row|
+            buckets[align_bucket(row[0].to_i)]&.add(row)
+          end
+
+          {
+            available: true,
+            broadcasts: count_series(buckets, :broadcasts_count),
+            rejections: count_series(buckets, :rejections_count)
+          }
+        end
+
+        private
+
+        attr_reader :metric_rows, :window, :current_time
+
+        def blank_buckets
+          start_bucket = align_bucket((current_time - window).to_i)
+          end_bucket = align_bucket(current_time.to_i)
+
+          start_bucket.step(end_bucket, bucket_seconds).each_with_object({}) do |timestamp, buckets|
+            buckets[timestamp] = BucketSnapshot.new
+          end
+        end
+
+        def count_series(buckets, key)
+          buckets.map do |timestamp, totals|
+            {t: timestamp, v: totals.value_for(key)}
+          end
+        end
+
+        def bucket_seconds
+          seconds = window.to_i
+          CableStats::BUCKET_RULES.find { |limit, _bucket| seconds <= limit }&.last || 4.hours.to_i
+        end
+
+        def align_bucket(value)
+          (value / bucket_seconds) * bucket_seconds
+        end
+      end
+
+      class BacklogSnapshot
+        def self.call
+          new.call
+        end
+
+        # :reek:TooManyStatements
+        def call
+          snapshot = fetch_snapshot
+          return unavailable unless snapshot && snapshot[:available]
+
+          count = snapshot[:trimmable_count].to_i
+          total = snapshot[:event_count].to_i
+
+          {
+            available: true,
+            count: count,
+            ratio: total.positive? ? count.to_f / total.to_f : 0.0
+          }
+        rescue *StorageInfoSnapshot::CONNECTION_ERRORS, TypeError, NoMethodError
+          unavailable
+        end
+
+        private
+
+        def fetch_snapshot
+          StorageInfoSnapshot.call.find { |component| component[:component] == "solid_cable" }
+        end
+
+        def unavailable
+          {available: false, count: nil, ratio: nil}
+        end
+      end
+
+      class StabilityData
+        def initialize(window:, current_time:, backlog_snapshot:)
+          @window = window
+          @current_time = current_time
+          @backlog_snapshot = backlog_snapshot
+        end
+
+        def to_h(metric_broadcasts_count:, metric_rejections_count:)
+          compute(
+            metric_broadcasts_count: metric_broadcasts_count,
+            metric_rejections_count: metric_rejections_count
+          ).to_h
+        rescue ActiveRecord::StatementInvalid
+          CableStats::STABILITY_DEGRADED.dup
+        end
+
+        private
+
+        attr_reader :window, :current_time, :backlog_snapshot
+
+        # :reek:TooManyStatements
+        def compute(metric_broadcasts_count:, metric_rejections_count:)
+          event_counts = query_event_counts
+          rejection_count = event_counts[:rejection_count]
+          error_count = event_counts[:error_count]
+          rejection_rate = CableStats.ratio(metric_rejections_count, metric_broadcasts_count)
+          rejection_present = rejection_count.to_i.positive? || metric_rejections_count.to_i.positive?
+          backlog_ratio = backlog_snapshot[:ratio]
+          backlog_available = backlog_snapshot[:available]
+
+          {
+            available: true,
+            state: stability_state(
+              error_count: error_count,
+              rejection_rate: rejection_rate,
+              rejection_present: rejection_present,
+              backlog_ratio: backlog_ratio,
+              backlog_available: backlog_available
+            ),
+            rejection_count: rejection_count,
+            error_count: error_count,
+            rejection_rate: rejection_rate,
+            backlog_ratio: backlog_ratio,
+            backlog_available: backlog_available,
+            latest_recorded_at: event_counts[:latest_recorded_at]
+          }
+        end
+
+        # :reek:ControlParameter
+        # :reek:LongParameterList
+        # :reek:TooManyStatements
+        def stability_state(error_count:, rejection_rate:, rejection_present:, backlog_ratio:, backlog_available:)
+          config = SolidObserver.config
+
+          return :critical if error_count.to_i > config.cable_error_threshold.to_i
+          return :critical if rejection_rate >= config.cable_rejection_threshold.to_f
+          return :critical if backlog_ratio && backlog_ratio >= 0.5
+          return :degraded if backlog_ratio && backlog_ratio >= config.cable_backlog_threshold.to_f
+          return :degraded if rejection_present
+          return :degraded unless backlog_available
+
+          :stable
+        end
+
+        def query_event_counts
+          rejection_count, error_count, latest_recorded_at = SolidObserver::CableEvent.where(recorded_at: window_range).pick(
+            Arel.sql("COUNT(CASE WHEN event_type = 'transmit_subscription_rejection' THEN 1 END)"),
+            Arel.sql("COUNT(CASE WHEN error_class IS NOT NULL AND TRIM(error_class) != '' THEN 1 END)"),
+            Arel.sql("MAX(CASE WHEN event_type = 'transmit_subscription_rejection' OR (error_class IS NOT NULL AND TRIM(error_class) != '') THEN recorded_at END)")
+          )
+
+          {
+            rejection_count: rejection_count.to_i,
+            error_count: error_count.to_i,
+            latest_recorded_at: parse_latest_recorded_at(latest_recorded_at)
+          }
+        end
+
+        def parse_latest_recorded_at(value)
+          return nil unless value.present?
+
+          value.is_a?(Time) ? value : Time.parse(value.to_s)
+        rescue ArgumentError
+          nil
+        end
+
+        def window_range
+          (current_time - window)..current_time
+        end
+      end
+
+      class << self
+        def parse_range(value, fallback: DEFAULT_RANGE)
+          range_key = value.to_s
+          RANGES.key?(range_key) ? range_key : fallback
+        end
+
+        def range_duration(value, fallback: DEFAULT_RANGE)
+          RANGES.fetch(parse_range(value, fallback: fallback))
+        end
+
+        def ratio(numerator, denominator)
+          return 0.0 if denominator.to_i.zero?
+
+          numerator.to_f / denominator.to_f
+        end
+      end
+
+      def self.call(window:)
+        new.call(window: window)
+      end
+
+      def call(window:)
+        current_time = Time.current
+        dashboard_response(window: window, current_time: current_time)
+      rescue => error
+        Rails.logger&.error("[SolidObserver] CableStats call failed: #{error.class} #{error.message}") if defined?(Rails)
+        error_response
+      end
+
+      private
+
+      def dashboard_response(window:, current_time:)
+        time_window = (current_time - window)..current_time
+        metric_rows = metric_rows(time_window: time_window)
+        totals = metric_totals(time_window: time_window)
+        backlog_snapshot = BacklogSnapshot.call
+
+        build_response(
+          totals: totals,
+          backlog_snapshot: backlog_snapshot,
+          dashboard_data: dashboard_data(
+            window: window,
+            current_time: current_time,
+            metric_rows: metric_rows,
+            totals: totals,
+            backlog_snapshot: backlog_snapshot
+          )
+        )
+      end
+
+      # :reek:FeatureEnvy
+      # :reek:LongParameterList
+      def build_response(totals:, backlog_snapshot:, dashboard_data:)
+        broadcasts_count = totals[:broadcasts_count]
+        rejections_count = totals[:rejections_count]
+
+        {
+          broadcasts_count: broadcasts_count,
+          transmissions_count: totals[:transmissions_count],
+          confirmations_count: totals[:confirmations_count],
+          rejections_count: rejections_count,
+          perform_actions_count: totals[:perform_actions_count],
+          errors_count: totals[:errors_count],
+          rejection_rate: self.class.ratio(rejections_count, broadcasts_count),
+          activity_trends: dashboard_data[:activity_trends],
+          stability: dashboard_data[:stability],
+          backlog_count: backlog_snapshot[:count],
+          backlog_available: backlog_snapshot[:available]
+        }
+      end
+
+      # :reek:LongParameterList
+      def dashboard_data(window:, current_time:, metric_rows:, totals:, backlog_snapshot:)
+        {
+          activity_trends: TrendData.new(
+            metric_rows: metric_rows,
+            window: window,
+            current_time: current_time
+          ).to_h,
+          stability: StabilityData.new(
+            window: window,
+            current_time: current_time,
+            backlog_snapshot: backlog_snapshot
+          ).to_h(
+            metric_broadcasts_count: totals[:broadcasts_count],
+            metric_rejections_count: totals[:rejections_count]
+          )
+        }
+      end
+
+      def metric_rows(time_window:)
+        SolidObserver::CableMetric.where(period_start: time_window).pluck(
+          :period_start,
+          :broadcasts_count,
+          :transmissions_count,
+          :confirmations_count,
+          :rejections_count,
+          :perform_actions_count,
+          :errors_count
+        )
+      end
+
+      def metric_totals(time_window:)
+        broadcasts_count, transmissions_count, confirmations_count, rejections_count, perform_actions_count, errors_count = SolidObserver::CableMetric.where(
+          period_start: time_window
+        ).pick(
+          Arel.sql("COALESCE(SUM(broadcasts_count), 0)"),
+          Arel.sql("COALESCE(SUM(transmissions_count), 0)"),
+          Arel.sql("COALESCE(SUM(confirmations_count), 0)"),
+          Arel.sql("COALESCE(SUM(rejections_count), 0)"),
+          Arel.sql("COALESCE(SUM(perform_actions_count), 0)"),
+          Arel.sql("COALESCE(SUM(errors_count), 0)")
+        )
+
+        {
+          broadcasts_count: broadcasts_count,
+          transmissions_count: transmissions_count,
+          confirmations_count: confirmations_count,
+          rejections_count: rejections_count,
+          perform_actions_count: perform_actions_count,
+          errors_count: errors_count
+        }
+      end
+
+      def error_response
+        {
+          broadcasts_count: 0,
+          transmissions_count: 0,
+          confirmations_count: 0,
+          rejections_count: 0,
+          perform_actions_count: 0,
+          errors_count: 0,
+          rejection_rate: 0.0,
+          activity_trends: ACTIVITY_TREND_EMPTY.dup,
+          stability: STABILITY_EMPTY.dup,
+          backlog_count: nil,
+          backlog_available: false,
+          error: "Service temporarily unavailable"
+        }
+      end
+    end
+  end
+end