solid_observer 0.1.1 → 0.3.0

data/lib/solid_observer/queries/execution_finder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Queries
+    class ExecutionFinder
+      EXECUTION_TYPES = [
+        "SolidQueue::ReadyExecution",
+        "SolidQueue::ScheduledExecution",
+        "SolidQueue::ClaimedExecution",
+        "SolidQueue::FailedExecution"
+      ].freeze
+
+      STATUS_TO_EXECUTION_TYPE = {
+        "ready" => "SolidQueue::ReadyExecution",
+        "scheduled" => "SolidQueue::ScheduledExecution",
+        "claimed" => "SolidQueue::ClaimedExecution",
+        "failed" => "SolidQueue::FailedExecution"
+      }.freeze
+
+      def self.find_any(id)
+        EXECUTION_TYPES.each do |const_name|
+          execution = const_name.safe_constantize&.find_by(id: id)
+          return execution if execution
+        end
+        nil
+      end
+
+      def self.find_by_status(id, status)
+        const_name = STATUS_TO_EXECUTION_TYPE[status.to_s.downcase]
+        return nil unless const_name
+
+        const_name.safe_constantize&.find_by(id: id)
+      end
+
+      def self.find_failed(id)
+        return nil unless defined?(SolidQueue::FailedExecution)
+
+        SolidQueue::FailedExecution.find_by(id: id)
+      end
+    end
+  end
+end

data/lib/solid_observer/queries/job_executions_query.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  module Queries
+    class JobExecutionsQuery
+      ALL_ACTIVE_STATUSES = %w[ready scheduled claimed failed].freeze
+
+      STATUS_SCOPES = {
+        "ready" => -> { SolidQueue::ReadyExecution.all },
+        "scheduled" => -> { SolidQueue::ScheduledExecution.all },
+        "claimed" => -> { SolidQueue::ClaimedExecution.all },
+        "failed" => -> { SolidQueue::FailedExecution.all }
+      }.freeze
+
+      def initialize(filter)
+        @filter = filter
+      end
+
+      def call
+        status = @filter.status
+        return all_active_executions if status == "all_active"
+
+        filtered_scope(status).order(created_at: :desc)
+      end
+
+      private
+
+      def all_active_executions
+        records = all_active_records.sort_by(&:created_at).reverse
+        preload_jobs(records)
+      end
+
+      def all_active_records
+        ALL_ACTIVE_STATUSES.flat_map do |status|
+          filtered_scope(status).order(created_at: :desc).limit(50).to_a
+        end
+      end
+
+      def preload_jobs(records)
+        ActiveRecord::Associations::Preloader.new(records:, associations: :job).call
+        records
+      end
+
+      def filtered_scope(status)
+        scope = status_scope(status)
+        scope = apply_queue_filter(scope, status)
+        apply_job_class_filter(scope)
+      end
+
+      def status_scope(status)
+        STATUS_SCOPES.fetch(status, STATUS_SCOPES["ready"]).call
+      end
+
+      def apply_job_class_filter(scope)
+        job_class = @filter.job_class
+        return scope if job_class.blank?
+
+        scope.joins(:job).where(solid_queue_jobs: {class_name: job_class})
+      end
+
+      def apply_queue_filter(scope, status)
+        queue_name = @filter.queue_name
+        return scope if queue_name.blank?
+
+        if %w[failed claimed].include?(status)
+          scope.joins(:job).where(solid_queue_jobs: {queue_name: queue_name})
+        else
+          scope.where(queue_name: queue_name)
+        end
+      end
+    end
+  end
+end

data/lib/solid_observer/queue_event_buffer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "singleton"
+require "concurrent/timer_task"
 
 module SolidObserver
   # Thread-safe buffer for collecting queue events before batch insertion.
@@ -14,10 +15,20 @@ module SolidObserver
   class QueueEventBuffer
     include Singleton
 
+    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
       @mutex = Mutex.new
+      @metrics_mutex = Mutex.new
       @buffer = []
-      @flush_scheduled = false
+      @metrics = INITIAL_METRICS.dup
+      @timer_task = nil
     end
 
     # Adds an event to the buffer and triggers flush if threshold reached.
@@ -25,17 +36,11 @@ module SolidObserver
     # @param event_data [Hash] Event data to buffer
     # @return [void]
     def push(event_data)
-      config = SolidObserver.config
-      return unless config.persistence_mode?
-
-      should_flush = false
-
-      @mutex.synchronize do
-        @buffer << event_data
-        schedule_flush unless @flush_scheduled
-        should_flush = @buffer.size >= config.buffer_size
-      end
+      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
 
@@ -51,10 +56,16 @@ module SolidObserver
         @buffer.clear
       end
 
-      Services::FlushEventBuffer.call(events_to_flush)
-    rescue => e
-      @mutex.synchronize { @buffer.unshift(*events_to_flush) }
-      Rails.logger&.error "[SolidObserver] Buffer flush failed: #{e.message}" if defined?(Rails)
+      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
@@ -65,19 +76,146 @@ module SolidObserver
       @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 schedule_flush
-      @flush_scheduled = true
-      thread = Thread.new do
-        sleep SolidObserver.config.flush_interval
-        @mutex.synchronize { @flush_scheduled = false }
-        flush!
-      rescue => e
-        Rails.logger&.error "[SolidObserver] Scheduled flush failed: #{e.message}" if defined?(Rails)
+    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
-      thread.name = "SolidObserver::QueueEventBuffer#flush"
-      thread.report_on_exception = false
+    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

data/lib/solid_observer/queue_stats.rb

@@ -1,20 +1,167 @@
 # frozen_string_literal: true
 
+require_relative "chart_buffer"
+
 module SolidObserver
+  # :reek:TooManyMethods
   class QueueStats
+    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"
+    POLL_DEFAULT_RANGE = "15m"
+    POLL_EMPTY_SNAPSHOT = {
+      ready: 0,
+      scheduled: 0,
+      claimed: 0,
+      workers: 0,
+      failed: 0,
+      enqueue_rate_per_min: nil
+    }.freeze
+    TICK_EMPTY_SNAPSHOT = {
+      ready: 0,
+      scheduled: 0,
+      claimed: 0,
+      workers: 0,
+      failed: 0
+    }.freeze
+    BUCKET_RULES = [
+      [30.minutes.to_i, 30],
+      [2.hours.to_i, 60],
+      [1.day.to_i, 5.minutes.to_i]
+    ].freeze
+
     class << self
-      def snapshot
-        new.snapshot
+      def snapshot(range: DEFAULT_RANGE)
+        new.snapshot(range)
+      end
+
+      def snapshot_for_poll(range:)
+        new.snapshot_for_poll(parse_range(range, fallback: POLL_DEFAULT_RANGE))
+      end
+
+      def snapshot_for_tick
+        new.snapshot_for_tick
+      end
+
+      def chart_data(window: 15.minutes)
+        new.chart_data(window)
       end
 
       def solid_queue_available?
         !!(defined?(SolidQueue) && defined?(SolidQueue::Job))
       end
+
+      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
+    end
+
+    def snapshot(range = DEFAULT_RANGE)
+      klass = self.class
+      return snapshot_for_mode(range && klass.parse_range(range)) if klass.solid_queue_available?
+
+      error_response("SolidQueue not available")
+    rescue => e
+      error_response(e.message)
+    end
+
+    # :reek:TooManyStatements
+    def snapshot_for_poll(range)
+      empty_snapshot = POLL_EMPTY_SNAPSHOT.dup
+      klass = self.class
+      return empty_snapshot unless klass.solid_queue_available?
+
+      window = klass.range_duration(range, fallback: POLL_DEFAULT_RANGE)
+      persistence = SolidObserver.config.persistence_mode?
+      base = {
+        ready: ready_count,
+        scheduled: scheduled_count,
+        claimed: claimed_count,
+        workers: active_workers_count,
+        failed: failed_count,
+        enqueue_rate_per_min: persistence ? QueueEvent.enqueue_rate_per_minute(window: window) : nil
+      }
+
+      if persistence
+        base.merge!(throughput_stats(range))
+        base[:queues] = queue_depths
+        base[:performed_by_queue] = QueueEvent.count_by_queue_and_event_type(window: window, event_type: "job_completed")
+        base[:failed_by_queue] = QueueEvent.count_by_queue_and_event_type(window: window, event_type: "job_failed")
+      end
+
+      base
+    rescue
+      empty_snapshot
+    end
+
+    def snapshot_for_tick
+      return TICK_EMPTY_SNAPSHOT unless self.class.solid_queue_available?
+
+      {
+        ready: ready_count,
+        scheduled: scheduled_count,
+        claimed: claimed_count,
+        workers: active_workers_count,
+        failed: failed_count
+      }
+    rescue
+      TICK_EMPTY_SNAPSHOT
     end
 
-    def snapshot
-      return unavailable_response unless self.class.solid_queue_available?
+    # :reek:TooManyStatements
+    def chart_data(window)
+      seconds = window.to_i
+      ready = ChartBuffer.recent(seconds)
+      return {performed: [], failed: [], ready: ready} unless SolidObserver.config.persistence_mode?
 
+      bucket_seconds = derive_bucket_seconds(window)
+      {
+        performed: QueueEvent.count_by_time_bucket(
+          event_type: "job_completed",
+          window: window,
+          bucket_seconds: bucket_seconds
+        ),
+        failed: QueueEvent.count_by_time_bucket(
+          event_type: "job_failed",
+          window: window,
+          bucket_seconds: bucket_seconds
+        ),
+        ready: ready
+      }
+    end
+
+    private
+
+    def derive_bucket_seconds(window)
+      seconds = window.to_i
+      BUCKET_RULES.find { |limit, _bucket| seconds <= limit }&.last || 30.minutes.to_i
+    end
+
+    def snapshot_for_mode(range_key)
+      base = snapshot_base
+      return base unless SolidObserver.config.persistence_mode? && range_key
+
+      duration = self.class.range_duration(range_key)
+      base.merge(throughput_stats(range_key)).merge(
+        range: range_key,
+        performed_by_queue: QueueEvent.count_by_queue_and_event_type(window: duration, event_type: "job_completed"),
+        failed_by_queue: QueueEvent.count_by_queue_and_event_type(window: duration, event_type: "job_failed")
+      )
+    end
+
+    def snapshot_base
       {
         ready: ready_count,
         scheduled: scheduled_count,
@@ -24,26 +171,24 @@ module SolidObserver
         queues: queue_depths,
         available: true
       }
-    rescue => e
-      error_response(e)
     end
 
-    private
-
-    def unavailable_response
+    def throughput_stats(range_key)
+      duration = self.class.range_duration(range_key)
       {
-        ready: 0,
-        scheduled: 0,
-        claimed: 0,
-        failed: 0,
-        workers: 0,
-        queues: {},
-        available: false,
-        error: "SolidQueue not available"
+        performed_in_range: QueueEvent.performed_count_last(duration),
+        failed_in_range: QueueEvent.failed_count_last(duration),
+        enqueued_in_range: QueueEvent.enqueued_count_last(duration),
+        avg_duration_in_range: QueueEvent.avg_duration_last(duration),
+        # Stability indicator still uses dedicated rolling windows independent of selected range.
+        failed_last_24h: QueueEvent.failed_count_last(24.hours),
+        failed_last_hour: QueueEvent.failed_count_last(1.hour),
+        latest_failure_at: QueueEvent.recent_failures(1).first&.recorded_at,
+        enqueue_rate_per_min: QueueEvent.enqueue_rate_per_minute(window: duration)
       }
     end
 
-    def error_response(exception)
+    def error_response(message)
       {
         ready: 0,
         scheduled: 0,
@@ -52,7 +197,8 @@ module SolidObserver
         workers: 0,
         queues: {},
         available: false,
-        error: exception.message
+        range: DEFAULT_RANGE,
+        error: message
       }
     end