rails_console_pro 0.1.2 → 0.1.3

data/lib/rails_console_pro/printers/queue_insights_printer.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Printers
+    class QueueInsightsPrinter < BasePrinter
+      def print
+        print_header
+        print_meta
+        print_warnings
+        print_section("📬 Enqueued Jobs", value.enqueued_jobs) { |job| format_job(job) }
+        print_section("🔁 Retry Set", value.retry_jobs) { |job| format_job(job, include_attempts: true) }
+        print_section("⚙️ Recent Executions", value.recent_executions) { |execution| format_execution(execution) }
+        print_footer
+      end
+
+      private
+
+      def print_header
+        header_color = config.get_color(:header)
+        output.puts bold_color(header_color, "═" * config.header_width)
+        output.puts bold_color(header_color, "🧵 QUEUE INSIGHTS: #{display_label}")
+        output.puts bold_color(header_color, "═" * config.header_width)
+      end
+
+      def print_meta
+        return if value.meta.empty?
+
+        output.puts color(config.get_color(:info), "\nℹ️  Adapter Stats:")
+        value.meta.each do |key, data|
+          formatted_key = key.to_s.tr('_', ' ').capitalize
+          line = "#{formatted_key.ljust(18)} #{color(config.get_color(:attribute_value_numeric), data.to_s)}"
+          output.puts "  #{line}"
+        end
+      end
+
+      def print_warnings
+        return unless value.warnings?
+
+        warning_color = config.get_color(:warning)
+        value.warnings.each do |warning|
+          output.puts bold_color(warning_color, "⚠️  #{warning}")
+        end
+      end
+
+      def print_section(title, collection)
+        output.puts bold_color(config.get_color(:warning), "\n#{title}:")
+        if collection.empty?
+          output.puts color(:dim, "  (none)")
+          return
+        end
+
+        collection.each_with_index do |entry, index|
+          output.puts color(:dim, "  #{index + 1}. ")
+          formatted = yield(entry)
+          formatted.each { |line| output.puts "     #{line}" }
+        end
+      end
+
+      def print_footer
+        footer_color = config.get_color(:footer)
+        output.puts bold_color(footer_color, "\n" + "═" * config.header_width)
+        output.puts color(:dim, "Captured at: #{format_time(value.captured_at)}")
+      end
+
+      def format_job(job, include_attempts: false)
+        lines = []
+        lines << "#{bold_color(config.get_color(:attribute_key), job.job_class || job.queue || 'Job')} (#{job.id || 'unknown'})"
+        lines << "Queue: #{color(config.get_color(:info), job.queue || 'default')}"
+        lines << "Enqueued: #{color(config.get_color(:attribute_value_time), format_time(job.enqueued_at) || 'n/a')}"
+        if job.scheduled_at
+          lines << "Scheduled: #{color(config.get_color(:attribute_value_time), format_time(job.scheduled_at))}"
+        end
+        if include_attempts && job.attempts
+          lines << "Attempts: #{color(config.get_color(:attribute_value_numeric), job.attempts.to_s)}"
+        end
+        if job.error
+          lines << "Error: #{color(config.get_color(:error), job.error)}"
+        end
+        if job.args && !job.args.empty?
+          serialized_args = safe_truncate(job.args.inspect)
+          lines << "Args: #{color(config.get_color(:attribute_value_string), serialized_args)}"
+        end
+        if present?(job.metadata)
+          job.metadata.each do |key, value|
+            lines << "#{key.to_s.tr('_', ' ').capitalize}: #{color(config.get_color(:attribute_value_string), value.to_s)}"
+          end
+        end
+        lines
+      end
+
+      def format_execution(execution)
+        lines = []
+        lines << "#{bold_color(config.get_color(:attribute_key), execution.job_class || 'Execution')} (#{execution.id || 'unknown'})"
+        lines << "Queue: #{color(config.get_color(:info), execution.queue || 'default')}"
+        lines << "Started: #{color(config.get_color(:attribute_value_time), format_time(execution.started_at) || 'n/a')}"
+        if execution.runtime_ms
+          lines << "Runtime: #{color(config.get_color(:attribute_value_numeric), "#{execution.runtime_ms.to_f.round(2)} ms")}"
+        end
+        if execution.worker || execution.hostname
+          lines << "Worker: #{color(config.get_color(:attribute_value_string), [execution.worker, execution.hostname].compact.join('@'))}"
+        end
+        if present?(execution.metadata)
+          execution.metadata.each do |key, value|
+            lines << "#{key.to_s.tr('_', ' ').capitalize}: #{color(config.get_color(:attribute_value_string), value.to_s)}"
+          end
+        end
+        lines
+      end
+
+      def format_time(time)
+        return unless time
+
+        case time
+        when Time
+          time.strftime("%Y-%m-%d %H:%M:%S")
+        when Integer, Float
+          Time.at(time).strftime("%Y-%m-%d %H:%M:%S")
+        else
+          time.to_s
+        end
+      rescue
+        time.to_s
+      end
+
+      def safe_truncate(text, max = 120)
+        return text if text.length <= max
+
+        "#{text[0, max]}…"
+      end
+
+      def display_label
+        label = value.adapter_label.to_s.strip
+        label.empty? ? "ActiveJob" : label
+      end
+
+      def present?(value)
+        case value
+        when nil
+          false
+        when String
+          !value.empty?
+        else
+          value.respond_to?(:empty?) ? !value.empty? : true
+        end
+      end
+    end
+  end
+end
+
+

data/lib/rails_console_pro/printers/snippet_collection_printer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Printers
+    # Printer for snippet collection results
+    class SnippetCollectionPrinter < BasePrinter
+      PREVIEW_WIDTH = 80
+
+      def print
+        collection = value
+        print_header(collection)
+
+        if collection.empty?
+          output.puts color(config.get_color(:warning), "No snippets yet. Capture one with snippets(:add, \"User.count\")")
+        else
+          collection.each_with_index do |snippet, index|
+            print_row(snippet, index: index)
+          end
+        end
+
+        print_footer(collection)
+        collection
+      end
+
+      private
+
+      def print_header(collection)
+        border
+        title = "📚 SNIPPETS"
+        filters = []
+        filters << "query: #{collection.query.inspect}" if collection.query
+        filters << "tags: #{collection.tags.join(', ')}" if collection.tags.any?
+        filters << "limit: #{collection.limit}" if collection.limit
+
+        header_text = filters.any? ? "#{title} (#{filters.join(' · ')})" : title
+        output.puts bold_color(config.get_color(:header), header_text)
+        border
+      end
+
+      def print_row(snippet, index:)
+        index_label = color(config.get_color(:info), (index + 1).to_s.rjust(2))
+        id_label = bold_color(config.get_color(:attribute_key), snippet.id)
+        tags_label = snippet.tags.any? ? color(config.get_color(:info), "[#{snippet.tags.join(', ')}]") : nil
+        favorite_marker = snippet.favorite? ? color(config.get_color(:success), "★") : " "
+        summary = truncate(snippet.summary)
+
+        output.puts "#{index_label} #{favorite_marker} #{id_label} #{summary}"
+        if tags_label
+          output.puts color(:dim, "   #{tags_label}")
+        end
+      end
+
+      def print_footer(collection)
+        border
+        output.puts color(:dim, "Showing #{collection.size} #{collection.size == 1 ? 'snippet' : 'snippets'}")
+        border
+      end
+
+      def truncate(text)
+        return '' unless text
+        return text if text.length <= PREVIEW_WIDTH
+
+        "#{text[0, PREVIEW_WIDTH - 1]}…"
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/printers/snippet_printer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Printers
+    # Printer for individual snippet results
+    class SnippetPrinter < BasePrinter
+      def print
+        result = value
+        snippet = result.snippet
+
+        border
+        header_text = header_title(result)
+        output.puts bold_color(config.get_color(:header), header_text)
+        border
+
+        output.puts format_metadata(snippet, result)
+        output.puts
+
+        snippet.body.each_line.with_index(1) do |line, number|
+          output.puts format_line(number, line)
+        end
+
+        border
+        output.puts result.message if result.message
+        border
+
+        snippet
+      end
+
+      private
+
+      def header_title(result)
+        case result.action
+        when :add
+          "✨ Captured snippet #{result.snippet.id}"
+        when :favorite
+          "⭐ Favorite snippet #{result.snippet.id}"
+        when :unfavorite
+          "☆ Snippet #{result.snippet.id}"
+        else
+          "📄 Snippet #{result.snippet.id}"
+        end
+      end
+
+      def format_metadata(snippet, result)
+        tags = snippet.tags.any? ? "tags: #{snippet.tags.join(', ')}" : nil
+        details = []
+        details << "description: #{snippet.description}" if snippet.description
+        details << tags if tags
+        details << "favorite: #{snippet.favorite?}"
+        details << "created: #{snippet.created_at.strftime('%Y-%m-%d %H:%M')}"
+        details << "updated: #{snippet.updated_at.strftime('%Y-%m-%d %H:%M')}"
+
+        color(config.get_color(:info), details.compact.join(' · '))
+      end
+
+      def format_line(number, line)
+        number_label = color(config.get_color(:attribute_key), number.to_s.rjust(3))
+        "#{number_label} │ #{line.rstrip}"
+      end
+    end
+  end
+end
+

data/lib/rails_console_pro/profile_result.rb

@@ -0,0 +1,109 @@
+ # frozen_string_literal: true
+ 
+ module RailsConsolePro
+   # Value object representing a profiling session summary
+   class ProfileResult
+     QuerySample = Struct.new(
+       :sql,
+       :duration_ms,
+       :cached,
+       :name,
+       :binds,
+       keyword_init: true
+     )
+
+     DuplicateQuery = Struct.new(
+       :fingerprint,
+       :sql,
+       :count,
+       :total_duration_ms,
+       keyword_init: true
+     )
+
+     attr_reader :label,
+                 :duration_ms,
+                 :result,
+                 :error,
+                 :query_count,
+                 :cached_query_count,
+                 :write_query_count,
+                 :total_sql_duration_ms,
+                 :slow_queries,
+                 :duplicate_queries,
+                 :query_samples,
+                 :instantiation_count,
+                 :cache_hits,
+                 :cache_misses,
+                 :cache_writes,
+                 :started_at,
+                 :finished_at
+
+     def initialize(label:, duration_ms:, result:, error:, query_count:, cached_query_count:,
+                    write_query_count:, total_sql_duration_ms:, slow_queries:, duplicate_queries:,
+                    query_samples:, instantiation_count:, cache_hits:, cache_misses:,
+                    cache_writes:, started_at:, finished_at:)
+       @label = label
+       @duration_ms = duration_ms
+       @result = result
+       @error = error
+       @query_count = query_count
+       @cached_query_count = cached_query_count
+       @write_query_count = write_query_count
+       @total_sql_duration_ms = total_sql_duration_ms
+       @slow_queries = Array(slow_queries)
+       @duplicate_queries = Array(duplicate_queries)
+       @query_samples = Array(query_samples)
+       @instantiation_count = instantiation_count
+       @cache_hits = cache_hits
+       @cache_misses = cache_misses
+       @cache_writes = cache_writes
+       @started_at = started_at
+       @finished_at = finished_at
+     end
+
+    def label?
+      !(label.nil? || (label.respond_to?(:empty?) && label.empty?))
+     end
+
+     def error?
+       !error.nil?
+     end
+
+     def cache_activity?
+       cache_hits.positive? || cache_misses.positive? || cache_writes.positive?
+     end
+
+     def slow_queries?
+       slow_queries.any?
+     end
+
+     def duplicate_queries?
+       duplicate_queries.any?
+     end
+
+     def query_samples?
+       query_samples.any?
+     end
+
+     def read_query_count
+       query_count - write_query_count
+     end
+
+     def to_json(pretty: true)
+       FormatExporter.to_json(self, pretty: pretty)
+     end
+
+     def to_yaml
+       FormatExporter.to_yaml(self)
+     end
+
+     def to_html(style: :default)
+       FormatExporter.to_html(self, title: "Profile: #{label || 'Session'}", style: style)
+     end
+
+     def export_to_file(file_path, format: nil)
+       FormatExporter.export_to_file(self, file_path, format: format)
+     end
+   end
+ end
+

data/lib/rails_console_pro/pry_commands.rb

@@ -32,6 +32,47 @@ if defined?(Pry)
     end
   end
 
+  Pry::Commands.create_command "profile" do
+    description "Profile a block, callable, or relation and report query stats"
+
+    def process
+      pastel = RailsConsolePro::ColorHelper.pastel
+      unless RailsConsolePro.config.profile_command_enabled
+        output.puts pastel.yellow("Profile command is disabled. Enable it with: RailsConsolePro.configure { |c| c.profile_command_enabled = true }")
+        return
+      end
+
+      if args.empty?
+        show_usage
+        return
+      end
+
+      begin
+        expression = args.join(' ')
+        profile_target = eval(expression, target)
+        result = RailsConsolePro::Commands.profile(profile_target)
+        RailsConsolePro.call(output, result, pry_instance) if result
+      rescue SyntaxError => e
+        output.puts pastel.red("Syntax Error: #{e.message}")
+        show_usage
+      rescue => e
+        output.puts pastel.red("Error: #{e.message}")
+      end
+    end
+
+    private
+
+    def show_usage
+      pastel = RailsConsolePro::ColorHelper.pastel
+      output.puts pastel.red("Usage: profile expression")
+      output.puts pastel.yellow("Examples:")
+      output.puts pastel.cyan("  profile User.active.limit(10)")
+      output.puts pastel.cyan("  profile -> { User.includes(:posts).each { |u| u.posts.load } }")
+      output.puts pastel.yellow("")
+      output.puts pastel.yellow("Tip: For blocks, call the helper method directly: profile('Load') { User.limit(5).to_a }")
+    end
+  end
+
   Pry::Commands.create_command "explain" do
     description "Analyze SQL query execution plan"
     
@@ -186,6 +227,71 @@ if defined?(Pry)
     end
   end
 
+  Pry::Commands.create_command "jobs" do
+    description "Inspect ActiveJob queue insights (enqueued, retries, recent executions)"
+
+    def process
+      pastel = RailsConsolePro::ColorHelper.pastel
+      unless RailsConsolePro.config.queue_command_enabled
+        output.puts pastel.yellow("Jobs command is disabled. Enable it with: RailsConsolePro.configure { |c| c.queue_command_enabled = true }")
+        return
+      end
+
+      begin
+        options = parse_options
+        result = RailsConsolePro::Commands.jobs(options)
+        if result
+          RailsConsolePro.call(output, result, pry_instance)
+        else
+          output.puts pastel.yellow("No queue insights available.")
+        end
+      rescue => e
+        output.puts pastel.red("Error: #{e.message}")
+      end
+    end
+
+    private
+
+    def parse_options
+      return {} if args.empty?
+
+      options = {}
+
+      args.each do |token|
+        case token
+        when /\A(limit|queue)=(.+)\z/i
+          key = Regexp.last_match(1).downcase.to_sym
+          value = Regexp.last_match(2)
+          value = value.to_i if key == :limit
+          options[key] = value
+        when /\Astatus=(.+)\z/i, /\A--status=(.+)\z/i
+          statuses = Regexp.last_match(1).split(',').map(&:strip).reject(&:empty?)
+          options[:status] = Array(options[:status]) + statuses
+        when /\A(class|job_class)=(.+)\z/i, /\A--class=(.+)\z/i
+          options[:job_class] = Regexp.last_match(2)
+        when /\Aretry=(.+)\z/i, /\A--retry=(.+)\z/i
+          options[:retry] = Regexp.last_match(1)
+        when /\Adelete=(.+)\z/i, /\A--delete=(.+)\z/i
+          options[:delete] = Regexp.last_match(1)
+        when /\Adetails?=(.+)\z/i, /\A--details?=(.+)\z/i
+          options[:details] = Regexp.last_match(1)
+        when '--retry-only'
+          options[:status] = Array(options[:status]) + ['retry']
+        when '--enqueued-only'
+          options[:status] = Array(options[:status]) + ['enqueued']
+        when '--recent-only', '--executing-only', '--running-only'
+          options[:status] = Array(options[:status]) + ['recent']
+        when /\A\d+\z/
+          options[:limit] = token.to_i
+        else
+          options[:queue] ||= token
+        end
+      end
+
+      options
+    end
+  end
+
   Pry::Commands.create_command "diff" do
     description "Compare two objects and highlight differences"
     

data/lib/rails_console_pro/queue_insights_result.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  class QueueInsightsResult
+    JobSummary = Struct.new(
+      :id,
+      :job_class,
+      :queue,
+      :args,
+      :enqueued_at,
+      :scheduled_at,
+      :attempts,
+      :error,
+      :metadata,
+      keyword_init: true
+    )
+
+    ExecutionSummary = Struct.new(
+      :id,
+      :job_class,
+      :queue,
+      :started_at,
+      :runtime_ms,
+      :worker,
+      :hostname,
+      :metadata,
+      keyword_init: true
+    )
+
+    attr_reader :adapter_name,
+                :adapter_type,
+                :enqueued_jobs,
+                :retry_jobs,
+                :recent_executions,
+                :meta,
+                :warnings,
+                :captured_at
+
+    def initialize(adapter_name:, adapter_type:, enqueued_jobs:, retry_jobs:, recent_executions:, meta: {}, warnings: [], captured_at: Time.current)
+      @adapter_name = adapter_name
+      @adapter_type = adapter_type
+      @enqueued_jobs = Array(enqueued_jobs)
+      @retry_jobs = Array(retry_jobs)
+      @recent_executions = Array(recent_executions)
+      @meta = meta || {}
+      @warnings = Array(warnings).compact
+      @captured_at = captured_at || Time.current
+    end
+
+    def adapter_label
+      [adapter_name, adapter_type].compact.uniq.join(" ")
+    end
+
+    def has_enqueued?
+      enqueued_jobs.any?
+    end
+
+    def has_retry_jobs?
+      retry_jobs.any?
+    end
+
+    def has_recent_executions?
+      recent_executions.any?
+    end
+
+    def empty?
+      !has_enqueued? && !has_retry_jobs? && !has_recent_executions?
+    end
+
+    def warnings?
+      warnings.any?
+    end
+
+    def total_enqueued
+      enqueued_jobs.size
+    end
+
+    def total_retry
+      retry_jobs.size
+    end
+
+    def total_recent
+      recent_executions.size
+    end
+
+    def totals
+      {
+        enqueued: total_enqueued,
+        retry: total_retry,
+        recent: total_recent
+      }
+    end
+
+    def with_overrides(overrides = {})
+      self.class.new(
+        adapter_name: overrides.fetch(:adapter_name, adapter_name),
+        adapter_type: overrides.fetch(:adapter_type, adapter_type),
+        enqueued_jobs: overrides.fetch(:enqueued_jobs, enqueued_jobs),
+        retry_jobs: overrides.fetch(:retry_jobs, retry_jobs),
+        recent_executions: overrides.fetch(:recent_executions, recent_executions),
+        meta: overrides.fetch(:meta, meta),
+        warnings: overrides.fetch(:warnings, warnings),
+        captured_at: overrides.fetch(:captured_at, captured_at)
+      )
+    end
+  end
+end
+
+
+

data/lib/rails_console_pro/serializers/profile_serializer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Serializers
+    # Serializer for ProfileResult objects
+    class ProfileSerializer < BaseSerializer
+      def serialize(profile)
+        {
+          label: profile.label,
+          duration_ms: profile.duration_ms,
+          total_sql_duration_ms: profile.total_sql_duration_ms,
+          query_count: profile.query_count,
+          read_query_count: profile.read_query_count,
+          write_query_count: profile.write_query_count,
+          cached_query_count: profile.cached_query_count,
+          instantiation_count: profile.instantiation_count,
+          cache_stats: serialize_cache(profile),
+          slow_queries: serialize_queries(profile.slow_queries),
+          duplicate_queries: serialize_duplicates(profile.duplicate_queries),
+          query_samples: serialize_queries(profile.query_samples),
+          error: serialize_error(profile.error),
+          started_at: profile.started_at&.iso8601,
+          finished_at: profile.finished_at&.iso8601,
+          result: serialize_data(profile.result)
+        }
+      end
+
+      private
+
+      def serialize_cache(profile)
+        {
+          hits: profile.cache_hits,
+          misses: profile.cache_misses,
+          writes: profile.cache_writes
+        }
+      end
+
+      def serialize_queries(queries)
+        Array(queries).map do |query|
+          {
+            sql: query.sql,
+            duration_ms: query.duration_ms,
+            cached: query.cached,
+            name: query.name,
+            binds: query.binds
+          }
+        end
+      end
+
+      def serialize_duplicates(duplicates)
+        Array(duplicates).map do |duplicate|
+          {
+            fingerprint: duplicate.fingerprint,
+            sql: duplicate.sql,
+            count: duplicate.count,
+            total_duration_ms: duplicate.total_duration_ms
+          }
+        end
+      end
+
+      def serialize_error(error)
+        return nil unless error
+
+        {
+          class: error.class.name,
+          message: error.message,
+          backtrace: Array(error.backtrace).first(10)
+        }
+      end
+    end
+  end
+end
+