solid_observer 0.1.1 → 0.4.0

data/app/models/solid_observer/queue_event.rb

@@ -10,6 +10,7 @@ module SolidObserver
       job_failed
       job_discarded
     ].freeze
+    DISTINCT_FILTER_LIMIT = 500
 
     validates :event_type, presence: true, inclusion: {in: EVENT_TYPES}
     validates :recorded_at, presence: true
@@ -19,5 +20,138 @@ module SolidObserver
     scope :by_event_type, ->(event_type) { where(event_type: event_type) }
     scope :since, ->(time) { where("recorded_at >= ?", time) }
     scope :before, ->(time) { where("recorded_at < ?", time) }
+    scope :recent, ->(limit = 10) { order(recorded_at: :desc).limit(limit) }
+    scope :recent_failures, ->(limit = 5) { by_event_type("job_failed").order(recorded_at: :desc).limit(limit) }
+    scope :distinct_job_classes, -> {
+      where("recorded_at >= ?", SolidObserver.config.event_retention.ago)
+        .where.not(job_class: nil)
+        .distinct
+        .limit(DISTINCT_FILTER_LIMIT)
+        .pluck(:job_class)
+        .sort
+    }
+    scope :distinct_queue_names, -> {
+      where("recorded_at >= ?", SolidObserver.config.event_retention.ago)
+        .where.not(queue_name: nil)
+        .distinct
+        .limit(DISTINCT_FILTER_LIMIT)
+        .pluck(:queue_name)
+        .sort
+    }
+
+    def self.performed_count_last(duration)
+      by_event_type("job_completed").since(duration.ago).count
+    end
+
+    def self.failed_count_last(duration)
+      by_event_type("job_failed").since(duration.ago).count
+    end
+
+    def self.enqueue_rate_per_minute(window: 5.minutes)
+      count = by_event_type("job_enqueued").since(window.ago).count
+      return 0.0 if count.zero?
+
+      (count.to_f / (window.to_f / 60.0)).round(1)
+    end
+
+    def self.enqueued_count_last(duration)
+      by_event_type("job_enqueued").since(duration.ago).count
+    end
+
+    def self.avg_duration_last(duration)
+      by_event_type("job_completed").since(duration.ago).average(:duration).to_f
+    end
+
+    def self.count_by_queue_and_event_type(window:, event_type:)
+      since(window.ago)
+        .where(event_type: event_type)
+        .where.not(queue_name: nil)
+        .group(:queue_name)
+        .count
+    end
+
+    def self.count_by_time_bucket(event_type:, window:, bucket_seconds:)
+      context = build_bucket_context(window: window, bucket_seconds: bucket_seconds)
+      return [] unless context
+
+      counts_by_bucket = fetch_counts_by_bucket(event_type: event_type, context: context)
+      fill_missing_buckets(context: context, counts_by_bucket: counts_by_bucket)
+    end
+
+    class << self
+      private
+
+      def build_bucket_context(window:, bucket_seconds:)
+        bucket_size = bucket_seconds.to_i
+        return nil if bucket_size <= 0 || window.to_i <= 0
+
+        end_time = Time.current
+        start_time = end_time - window
+
+        {
+          bucket_size: bucket_size,
+          start_time: start_time,
+          end_time: end_time,
+          start_bucket: align_bucket(start_time.to_i, bucket_size),
+          end_bucket: align_bucket(end_time.to_i, bucket_size)
+        }
+      end
+
+      def fetch_counts_by_bucket(event_type:, context:)
+        rows = fetch_grouped_rows(event_type: event_type, context: context)
+        rows.to_h { |row| [row["bucket_time"].to_i, row["bucket_count"].to_i] }
+      end
+
+      def fetch_grouped_rows(event_type:, context:)
+        pool = BaseEvent.connection_pool
+        query_context = context.merge(
+          event_type: event_type,
+          adapter: pool.db_config.adapter.to_s.downcase
+        )
+
+        pool.with_connection do |connection|
+          connection.select_all(grouped_counts_sql(connection: connection, query_context: query_context)).to_a
+        end
+      end
+
+      def grouped_counts_sql(connection:, query_context:)
+        <<~SQL.squish
+          SELECT #{bucket_time_sql(adapter: query_context[:adapter], bucket_size: query_context[:bucket_size])} AS bucket_time, COUNT(*) AS bucket_count
+          FROM #{table_name}
+          WHERE event_type = #{connection.quote(query_context[:event_type])}
+            AND recorded_at >= #{connection.quote(query_context[:start_time])}
+            AND recorded_at <= #{connection.quote(query_context[:end_time])}
+          GROUP BY bucket_time
+          ORDER BY bucket_time ASC
+        SQL
+      end
+
+      def bucket_time_sql(adapter:, bucket_size:)
+        case adapter
+        when "sqlite3", "sqlite"
+          "(CAST(strftime('%s', recorded_at) AS INTEGER) / #{bucket_size}) * #{bucket_size}"
+        when "postgresql"
+          if bucket_size == 60
+            "EXTRACT(EPOCH FROM date_trunc('minute', recorded_at))::bigint"
+          else
+            "(EXTRACT(EPOCH FROM recorded_at)::bigint / #{bucket_size}) * #{bucket_size}"
+          end
+        when "mysql2", "trilogy", "mysql"
+          "(UNIX_TIMESTAMP(recorded_at) DIV #{bucket_size}) * #{bucket_size}"
+        else
+          raise ArgumentError, "Unsupported adapter for bucket aggregation: #{adapter.inspect}"
+        end
+      end
+
+      def fill_missing_buckets(context:, counts_by_bucket:)
+        context[:start_bucket].step(context[:end_bucket], context[:bucket_size]).map do |timestamp|
+          {t: timestamp, v: counts_by_bucket.fetch(timestamp, 0)}
+        end
+      end
+
+      def align_bucket(value, bucket_size)
+        (value / bucket_size) * bucket_size
+      end
+    end
   end
 end

data/app/models/solid_observer/queue_metric.rb

@@ -3,7 +3,7 @@
 module SolidObserver
   # QueueMetric provides time-series metrics storage for queue statistics.
   #
-  # NOTE: Metrics functionality is planned for v0.2.0. This class currently
+  # NOTE: Metrics functionality is planned for a future release. This class currently
   # serves as a placeholder and inherits base functionality from BaseMetric.
   # The database connection will be configured by the Engine when metrics
   # are fully implemented.

data/app/models/solid_observer/storage_info.rb

@@ -6,16 +6,19 @@ module SolidObserver
 
     MB_TO_BYTES = 1_048_576
     GB_TO_BYTES = 1_073_741_824
+    COMPONENTS = %w[queue_observer cache_observer solid_cache].freeze
 
     validates :db_size_bytes, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
     validates :event_count, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
     validates :recorded_at, presence: true
+    validates :component, presence: true, inclusion: {in: COMPONENTS}
 
     scope :recent, ->(limit = 10) { order(recorded_at: :desc).limit(limit) }
     scope :since, ->(time) { where("recorded_at >= ?", time) }
 
-    def self.record_snapshot(db_size:, event_count:)
+    def self.record_snapshot(db_size:, event_count:, component: "queue_observer")
       create!(
+        component: component,
         db_size_bytes: db_size || 0,
         event_count: event_count,
         recorded_at: Time.current

data/app/presenters/solid_observer/execution_presenter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SolidObserver
+  class ExecutionPresenter
+    STATUS_MAP = {
+      "SolidQueue::ReadyExecution" => "ready",
+      "SolidQueue::ScheduledExecution" => "scheduled",
+      "SolidQueue::ClaimedExecution" => "claimed",
+      "SolidQueue::FailedExecution" => "failed"
+    }.freeze
+
+    def initialize(execution)
+      @execution = execution
+    end
+
+    def status
+      STATUS_MAP.fetch(@execution.class.name, "unknown")
+    end
+
+    def job
+      @execution.job
+    end
+
+    def queue_name
+      responded, value = value_from(@execution, :queue_name)
+      return value if responded
+
+      value_from(job, :queue_name).last
+    end
+
+    def priority
+      responded, value = value_from(@execution, :priority)
+      return value if responded
+
+      value_from(job, :priority).last
+    end
+
+    def to_model
+      @execution
+    end
+
+    private
+
+    def value_from(target, method_name)
+      return [false, nil] unless target&.respond_to?(method_name)
+
+      [true, target.method(method_name).call]
+    end
+  end
+end