anomonitor 0.6.1

data/lib/anomonitor/jobs/browsers/delayed_job.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module Jobs
+    module Browsers
+      class DelayedJob
+        PER_TENANT = 50
+
+        def source_key
+          "delayed_job"
+        end
+
+        def fetch(filters)
+          unless defined?(::Delayed::Job)
+            Anomonitor.logger.warn("[Anomonitor] Jobs browser skipped delayed_job: Delayed::Job not loaded")
+            return []
+          end
+
+          if Tenancy.multi_tenant?
+            fetch_per_tenant(filters)
+          else
+            fetch_scope(::Delayed::Job, filters, nil)
+          end
+        rescue StandardError => e
+          Anomonitor.logger.warn("[Anomonitor] Delayed Job browser error: #{e.message}")
+          []
+        end
+
+        private
+
+        def fetch_per_tenant(filters)
+          rows = []
+          tenants = Tenancy.tenant_names
+          tenants = tenants.select { |t| t == filters[:tenant] } if filters[:tenant]
+          tenants.each do |tenant|
+            Tenancy.switch(tenant) do
+              rows.concat(fetch_scope(::Delayed::Job, filters, tenant))
+            end
+          rescue StandardError => e
+            Anomonitor.logger.warn("[Anomonitor] Delayed Job browser (#{tenant}) error: #{e.message}")
+          end
+          rows
+        end
+
+        def fetch_scope(klass, filters, tenant)
+          scope = apply_status(klass.all, filters[:status])
+          if filters[:queue] && klass.column_names.include?("queue")
+            scope = scope.where(queue: filters[:queue])
+          end
+          scope = scope.order(Arel.sql("COALESCE(failed_at, run_at, created_at) DESC"))
+          scope.limit(PER_TENANT).map { |job| row_for(job, tenant) }
+        rescue StandardError
+          # SQLite / adapters without Arel.sql coalesce ordering
+          scope = apply_status(klass.all, filters[:status])
+          if filters[:queue] && klass.column_names.include?("queue")
+            scope = scope.where(queue: filters[:queue])
+          end
+          scope.limit(PER_TENANT).map { |job| row_for(job, tenant) }
+        end
+
+        def apply_status(scope, status)
+          case status
+          when "pending"
+            scope = scope.where(failed_at: nil).where(locked_at: nil)
+            if scope.klass.column_names.include?("run_at")
+              scope = scope.where("run_at <= ?", Time.current)
+            end
+            scope
+          when "failed"
+            scope.where.not(failed_at: nil)
+          when "locked"
+            scope.where.not(locked_at: nil).where(failed_at: nil)
+          else
+            scope
+          end
+        end
+
+        def row_for(job, tenant)
+          name =
+            if job.respond_to?(:name) && job.name.present?
+              job.name
+            elsif job.respond_to?(:handler)
+              handler_class(job.handler)
+            else
+              "Delayed::Job"
+            end
+
+          error = nil
+          full_error = nil
+          if job.respond_to?(:last_error) && job.last_error
+            full_error = job.last_error.to_s
+            error = full_error.lines.first&.strip
+          end
+          handler = job.respond_to?(:handler) ? job.handler.to_s : nil
+
+          Row.new(
+            source: source_key,
+            id: job.id,
+            name: name,
+            status: status_for(job),
+            queue: job.respond_to?(:queue) ? job.queue : nil,
+            tenant: tenant,
+            run_at: job.respond_to?(:run_at) ? job.run_at : nil,
+            failed_at: job.respond_to?(:failed_at) ? job.failed_at : nil,
+            error: truncate(error),
+            tags: tenant ? { tenant: tenant } : {},
+            detail: {
+              "handler" => truncate(handler, 800),
+              "error" => truncate(full_error, 1000),
+              "attempts" => (job.respond_to?(:attempts) ? job.attempts : nil)
+            }.compact
+          )
+        end
+
+        def status_for(job)
+          return "failed" if job.respond_to?(:failed_at) && job.failed_at
+          return "locked" if job.respond_to?(:locked_at) && job.locked_at
+
+          "pending"
+        end
+
+        def handler_class(handler)
+          return "Delayed::Job" if handler.blank?
+
+          if handler =~ /!ruby\/object:(\S+)/
+            Regexp.last_match(1)
+          elsif handler =~ /job_class:\s*(\S+)/
+            Regexp.last_match(1)
+          else
+            handler.to_s.lines.first.to_s.strip[0, 80]
+          end
+        end
+
+        def truncate(text, max = 200)
+          return nil if text.nil?
+
+          s = text.to_s
+          s.length > max ? "#{s[0, max]}…" : s
+        end
+      end
+    end
+  end
+end

data/lib/anomonitor/jobs/browsers/sidekiq.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module Jobs
+    module Browsers
+      class Sidekiq
+        PER_SET = 50
+
+        def source_key
+          "sidekiq"
+        end
+
+        def fetch(filters)
+          unless defined?(::Sidekiq)
+            Anomonitor.logger.warn("[Anomonitor] Jobs browser skipped sidekiq: Sidekiq not loaded")
+            return []
+          end
+
+          status = filters[:status]
+          rows = []
+          rows.concat(pending_rows(filters)) if status == "all" || status == "pending"
+          rows.concat(locked_rows(filters)) if status == "all" || status == "locked"
+          rows.concat(failed_rows(filters)) if status == "all" || status == "failed"
+          rows
+        rescue StandardError => e
+          Anomonitor.logger.warn("[Anomonitor] Sidekiq jobs browser error: #{e.message}")
+          []
+        end
+
+        private
+
+        def pending_rows(filters)
+          queues = ::Sidekiq::Queue.all
+          queues = queues.select { |q| q.name == filters[:queue] } if filters[:queue]
+          rows = []
+          queues.each do |queue|
+            queue.each do |job|
+              rows << row_from_job(job, status: "pending", queue: queue.name)
+              break if rows.size >= PER_SET
+            end
+            break if rows.size >= PER_SET
+          end
+          rows
+        end
+
+        def locked_rows(filters)
+          return [] unless defined?(::Sidekiq::Workers)
+
+          rows = []
+          ::Sidekiq::Workers.new.each do |_process_id, _thread_id, work|
+            payload = work.is_a?(Hash) ? work : {}
+            job = payload["payload"] || payload[:payload] || payload
+            queue = payload["queue"] || payload[:queue] || job["queue"]
+            next if filters[:queue] && queue.to_s != filters[:queue]
+
+            rows << Row.new(
+              source: source_key,
+              id: job["jid"] || job[:jid],
+              name: job["class"] || job[:class] || "Sidekiq::Job",
+              status: "locked",
+              queue: queue,
+              tenant: nil,
+              run_at: parse_time(payload["run_at"] || payload[:run_at] || job["enqueued_at"]),
+              failed_at: nil,
+              error: nil,
+              tags: {}
+            )
+            break if rows.size >= PER_SET
+          end
+          rows
+        rescue StandardError
+          []
+        end
+
+        def failed_rows(filters)
+          rows = []
+          if defined?(::Sidekiq::RetrySet)
+            ::Sidekiq::RetrySet.new.each do |job|
+              next if filters[:queue] && job.queue.to_s != filters[:queue]
+
+              rows << row_from_job(job, status: "failed", queue: job.queue, error: job["error_message"])
+              break if rows.size >= PER_SET
+            end
+          end
+          if defined?(::Sidekiq::DeadSet) && rows.size < PER_SET
+            ::Sidekiq::DeadSet.new.each do |job|
+              next if filters[:queue] && job.queue.to_s != filters[:queue]
+
+              rows << row_from_job(job, status: "failed", queue: job.queue, error: job["error_message"])
+              break if rows.size >= PER_SET
+            end
+          end
+          rows
+        end
+
+        def row_from_job(job, status:, queue:, error: nil)
+          klass =
+            if job.respond_to?(:display_class)
+              job.display_class
+            elsif job.respond_to?(:klass)
+              job.klass
+            else
+              job["class"]
+            end
+          jid = job.respond_to?(:jid) ? job.jid : job["jid"]
+          at =
+            if job.respond_to?(:enqueued_at) && job.enqueued_at
+              parse_time(job.enqueued_at)
+            elsif job["enqueued_at"]
+              parse_time(job["enqueued_at"])
+            elsif job.respond_to?(:created_at)
+              parse_time(job.created_at)
+            end
+
+          err = error
+          err ||= job["error_message"] if job.respond_to?(:[])
+
+          args =
+            if job.respond_to?(:args)
+              job.args
+            elsif job.respond_to?(:[]) && job["args"]
+              job["args"]
+            end
+
+          Row.new(
+            source: source_key,
+            id: jid,
+            name: klass.to_s,
+            status: status,
+            queue: queue,
+            tenant: nil,
+            run_at: at,
+            failed_at: status == "failed" ? at : nil,
+            error: truncate(err),
+            tags: {},
+            detail: {
+              "class" => klass.to_s,
+              "jid" => jid,
+              "args" => truncate(args.inspect, 500),
+              "error" => truncate(err, 1000)
+            }.compact
+          )
+        end
+
+        def parse_time(value)
+          return nil if value.nil?
+          return value if value.is_a?(Time) || value.is_a?(DateTime)
+          return Time.at(value) if value.is_a?(Numeric)
+
+          Time.parse(value.to_s)
+        rescue StandardError
+          nil
+        end
+
+        def truncate(text, max = 200)
+          return nil if text.nil?
+
+          s = text.to_s
+          s.length > max ? "#{s[0, max]}…" : s
+        end
+      end
+    end
+  end
+end

data/lib/anomonitor/jobs/browsers/solid_queue.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module Jobs
+    module Browsers
+      class SolidQueue
+        LIMIT = 50
+
+        def source_key
+          "solid_queue"
+        end
+
+        def fetch(filters)
+          unless solid_queue_available?
+            Anomonitor.logger.warn("[Anomonitor] Jobs browser skipped solid_queue: tables not available")
+            return []
+          end
+
+          status = filters[:status]
+          rows = []
+          rows.concat(ready_rows(filters)) if status == "all" || status == "pending"
+          rows.concat(scheduled_rows(filters)) if status == "all" || status == "pending"
+          rows.concat(claimed_rows(filters)) if status == "all" || status == "locked"
+          rows.concat(failed_rows(filters)) if status == "all" || status == "failed"
+          rows.first(LIMIT)
+        rescue StandardError => e
+          Anomonitor.logger.warn("[Anomonitor] Solid Queue jobs browser error: #{e.message}")
+          []
+        end
+
+        private
+
+        def solid_queue_available?
+          return false unless defined?(ActiveRecord::Base)
+
+          table_exists?("solid_queue_jobs")
+        end
+
+        def table_exists?(name)
+          connection.data_source_exists?(name)
+        rescue StandardError
+          false
+        end
+
+        def connection
+          ActiveRecord::Base.connection
+        end
+
+        def ready_rows(filters)
+          return [] unless table_exists?("solid_queue_ready_executions")
+
+          map_jobs(select_joined("solid_queue_ready_executions", filters), "pending")
+        end
+
+        def scheduled_rows(filters)
+          return [] unless table_exists?("solid_queue_scheduled_executions")
+
+          sql = <<~SQL.squish
+            SELECT j.id, j.class_name, j.queue_name, j.created_at, j.scheduled_at,
+                   e.scheduled_at AS exec_at
+            FROM solid_queue_jobs j
+            INNER JOIN solid_queue_scheduled_executions e ON e.job_id = j.id
+            #{queue_clause(filters)}
+            ORDER BY j.id DESC
+            LIMIT #{LIMIT}
+          SQL
+          map_jobs(connection.select_all(sql), "pending")
+        end
+
+        def claimed_rows(filters)
+          return [] unless table_exists?("solid_queue_claimed_executions")
+
+          map_jobs(select_joined("solid_queue_claimed_executions", filters), "locked")
+        end
+
+        def failed_rows(filters)
+          return [] unless table_exists?("solid_queue_failed_executions")
+
+          sql = <<~SQL.squish
+            SELECT j.id, j.class_name, j.queue_name, j.created_at, j.scheduled_at,
+                   e.error, e.created_at AS failed_at
+            FROM solid_queue_jobs j
+            INNER JOIN solid_queue_failed_executions e ON e.job_id = j.id
+            #{queue_clause(filters)}
+            ORDER BY e.created_at DESC
+            LIMIT #{LIMIT}
+          SQL
+          map_jobs(connection.select_all(sql), "failed")
+        end
+
+        def select_joined(exec_table, filters)
+          sql = <<~SQL.squish
+            SELECT j.id, j.class_name, j.queue_name, j.created_at, j.scheduled_at
+            FROM solid_queue_jobs j
+            INNER JOIN #{exec_table} e ON e.job_id = j.id
+            #{queue_clause(filters)}
+            ORDER BY j.id DESC
+            LIMIT #{LIMIT}
+          SQL
+          connection.select_all(sql)
+        end
+
+        def queue_clause(filters)
+          return "" unless filters[:queue]
+
+          "WHERE j.queue_name = #{connection.quote(filters[:queue])}"
+        end
+
+        def map_jobs(result, status)
+          result.map do |row|
+            error = row["error"]
+            error = error.to_s.lines.first&.strip if error
+            run_at = parse_time(row["exec_at"] || row["scheduled_at"] || row["created_at"])
+            failed_at = status == "failed" ? parse_time(row["failed_at"] || row["created_at"]) : nil
+
+            Row.new(
+              source: source_key,
+              id: row["id"],
+              name: row["class_name"].presence || "SolidQueue::Job",
+              status: status,
+              queue: row["queue_name"],
+              tenant: nil,
+              run_at: run_at,
+              failed_at: failed_at,
+              error: truncate(error),
+              tags: {}
+            )
+          end
+        end
+
+        def parse_time(value)
+          return nil if value.nil?
+          return value if value.is_a?(Time) || value.is_a?(DateTime)
+
+          Time.parse(value.to_s)
+        rescue StandardError
+          nil
+        end
+
+        def truncate(text, max = 200)
+          return nil if text.nil?
+
+          s = text.to_s
+          s.length > max ? "#{s[0, max]}…" : s
+        end
+      end
+    end
+  end
+end

data/lib/anomonitor/jobs/browsers/table.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module Jobs
+    module Browsers
+      class Table
+        LIMIT = 100
+
+        def initialize(source)
+          @source = source
+        end
+
+        def source_key
+          "table:#{@source.name}"
+        end
+
+        def fetch(filters)
+          klass = @source.model_class
+          scope = klass.all
+          scope = scope.where(@source.tenant => filters[:tenant]) if filters[:tenant] && tenant_column?(klass)
+
+          if @source.delayed_job_style?
+            delayed_job_rows(scope, filters)
+          else
+            status_rows(scope, filters)
+          end
+        rescue NameError => e
+          Anomonitor.logger.warn("[Anomonitor] Jobs browser skipped #{source_key}: #{e.message}")
+          []
+        rescue StandardError => e
+          Anomonitor.logger.warn("[Anomonitor] Table jobs browser (#{@source.name}) error: #{e.message}")
+          []
+        end
+
+        private
+
+        def tenant_column?(klass)
+          col = @source.tenant
+          col && klass.column_names.include?(col.to_s)
+        end
+
+        def delayed_job_rows(scope, filters)
+          cols = scope.klass.column_names
+          scope = apply_delayed_status(scope, filters[:status], cols)
+          if filters[:queue] && cols.include?("queue")
+            scope = scope.where(queue: filters[:queue])
+          end
+          order_col = %w[failed_at run_at created_at updated_at].find { |c| cols.include?(c) }
+          scope = scope.order(order_col => :desc) if order_col
+          scope.limit(LIMIT).map { |record| delayed_row(record, cols) }
+        end
+
+        def apply_delayed_status(scope, status, cols)
+          case status
+          when "pending"
+            scope = scope.where(failed_at: nil) if cols.include?("failed_at")
+            if cols.include?("locked_by")
+              scope = scope.where(locked_by: nil)
+            elsif cols.include?("locked_at")
+              scope = scope.where(locked_at: nil)
+            end
+            scope = scope.where("run_at <= ?", Time.current) if cols.include?("run_at")
+            scope
+          when "failed"
+            cols.include?("failed_at") ? scope.where.not(failed_at: nil) : scope.none
+          when "locked"
+            return scope.none unless cols.include?("locked_at")
+
+            scope = scope.where.not(locked_at: nil)
+            scope = scope.where(failed_at: nil) if cols.include?("failed_at")
+            scope
+          else
+            scope
+          end
+        end
+
+        def delayed_row(record, cols)
+          tenant = cols.include?(@source.tenant.to_s) ? record.public_send(@source.tenant) : nil
+          error = cols.include?("last_error") ? record.public_send(:last_error) : nil
+          error = error.to_s.lines.first&.strip if error
+
+          Row.new(
+            source: source_key,
+            id: record.id,
+            name: record_name(record),
+            status: delayed_status(record, cols),
+            queue: cols.include?("queue") ? record.queue : nil,
+            tenant: tenant,
+            run_at: cols.include?("run_at") ? record.run_at : nil,
+            failed_at: cols.include?("failed_at") ? record.failed_at : nil,
+            error: truncate(error),
+            tags: { table: @source.name.to_s }.tap { |t| t[:tenant] = tenant if tenant },
+            detail: {
+              "table" => @source.name.to_s,
+              "handler" => truncate(cols.include?("handler") ? record.handler.to_s : nil, 800),
+              "error" => truncate(cols.include?("last_error") ? record.last_error.to_s : nil, 1000)
+            }.compact
+          )
+        end
+
+        def delayed_status(record, cols)
+          return "failed" if cols.include?("failed_at") && record.failed_at
+          return "locked" if cols.include?("locked_at") && record.locked_at
+
+          "pending"
+        end
+
+        def status_rows(scope, filters)
+          cols = scope.klass.column_names
+          status_col = @source.status
+          if status_col && cols.include?(status_col.to_s)
+            scope = apply_status_filter(scope, filters[:status], status_col)
+          elsif filters[:status] != "all"
+            return []
+          end
+
+          if filters[:queue] && cols.include?("queue")
+            scope = scope.where(queue: filters[:queue])
+          end
+
+          order_col = %w[updated_at created_at].find { |c| cols.include?(c) }
+          scope = scope.order(order_col => :desc) if order_col
+          scope.limit(LIMIT).map { |record| status_row(record, cols, status_col) }
+        end
+
+        def apply_status_filter(scope, status, status_col)
+          active = Array(@source.active).map(&:to_s)
+          case status
+          when "pending", "locked"
+            # status-style tables: active statuses map to pending; no distinct locked
+            return scope.none if status == "locked"
+            return scope.where(status_col => active) if active.any?
+
+            scope
+          when "failed"
+            failed = infer_failed_statuses(scope.klass, status_col, active)
+            failed.any? ? scope.where(status_col => failed) : scope.none
+          else
+            scope
+          end
+        end
+
+        def infer_failed_statuses(klass, status_col, active)
+          known = %w[failed error dead]
+          values = klass.distinct.limit(50).pluck(status_col).compact.map(&:to_s)
+          values.select { |v| known.include?(v.downcase) || (active.any? && !active.include?(v)) }
+                .select { |v| %w[failed error dead].include?(v.downcase) }
+        end
+
+        def status_row(record, cols, status_col)
+          raw_status = status_col && cols.include?(status_col.to_s) ? record.public_send(status_col).to_s : "pending"
+          active = Array(@source.active).map(&:to_s)
+          mapped =
+            if %w[failed error dead].include?(raw_status.downcase)
+              "failed"
+            elsif active.include?(raw_status)
+              "pending"
+            else
+              raw_status.presence || "pending"
+            end
+
+          tenant = @source.tenant && cols.include?(@source.tenant.to_s) ? record.public_send(@source.tenant) : nil
+          run_at =
+            if @source.timestamp && cols.include?(@source.timestamp.to_s)
+              record.public_send(@source.timestamp)
+            elsif cols.include?("created_at")
+              record.created_at
+            end
+
+          Row.new(
+            source: source_key,
+            id: record.id,
+            name: record_name(record),
+            status: mapped,
+            queue: cols.include?("queue") ? record.queue : nil,
+            tenant: tenant,
+            run_at: run_at,
+            failed_at: mapped == "failed" ? run_at : nil,
+            error: nil,
+            tags: { table: @source.name.to_s, status: raw_status }.tap { |t| t[:tenant] = tenant if tenant },
+            detail: { "table" => @source.name.to_s, "status" => raw_status }
+          )
+        end
+
+        def record_name(record)
+          if record.respond_to?(:name) && record.name.present?
+            record.name.to_s
+          elsif record.respond_to?(:handler) && record.handler.present?
+            record.handler.to_s.lines.first.to_s.strip[0, 80]
+          elsif record.respond_to?(:job_class) && record.job_class.present?
+            record.job_class.to_s
+          else
+            @source.model.to_s
+          end
+        end
+
+        def truncate(text, max = 200)
+          return nil if text.nil?
+
+          s = text.to_s
+          s.length > max ? "#{s[0, max]}…" : s
+        end
+      end
+    end
+  end
+end

data/lib/anomonitor/jobs/row.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Anomonitor
+  module Jobs
+    Row = Struct.new(
+      :source,
+      :id,
+      :name,
+      :status,
+      :queue,
+      :tenant,
+      :run_at,
+      :failed_at,
+      :error,
+      :tags,
+      :detail,
+      keyword_init: true
+    ) do
+      def sort_at
+        failed_at || run_at || Time.at(0)
+      end
+
+      def detail_text
+        return nil if detail.nil? || detail.empty?
+
+        detail.map { |k, v| "#{k}: #{v}" }.join("\n")
+      end
+    end
+  end
+end