Add active job support and colored job prefix (silva96#54)

* Add active job support and colored job prefix

* Add plain ActiveJob support

* Fix standard

* enrich existing log lines if they dont have the colored job id already

* Fix standard

* use job_id name instead of jid

* add job - request_id to map on the parsing process
Add job prefix if needed, on the parsing process
Add request id if needed, on the parsing process

Also, created a conviniece access method to the state so we don't need to pass it around everywhere.

Author: silva96

README.md

@@ -187,6 +187,82 @@ LogBench works with JSON-formatted logs. Each log entry should include:
 - `message`: SQL query with timing information
 - `request_id`: Links query to HTTP request
 
+## Job Logging
+
+LogBench provides enhanced logging for background jobs with colored job prefixes in the TUI. Job logs are automatically prefixed with `[JobClass#job-id]` in orange/yellow color for easy identification.
+
+### ActiveJob
+
+For **ActiveJob** classes, use the job's `logger` method (not `Rails.logger`) to ensure logs get proper job context:
+
+```ruby
+class EmailDeliveryJob < ApplicationJob
+  def perform(user_id)
+    logger.info "Starting email delivery for user #{user_id}"  # ✅ Will have job prefix
+
+    user = User.find(user_id)
+    logger.info "Found user: #{user.email}"                    # ✅ Will have job prefix
+
+    # SQL queries are automatically tagged
+    user.update!(last_email_sent_at: Time.current)            # ✅ Will have job prefix
+
+    logger.info "Email delivery completed"                     # ✅ Will have job prefix
+  end
+end
+```
+
+**❌ Don't use `Rails.logger` in ActiveJob:**
+```ruby
+class EmailDeliveryJob < ApplicationJob
+  def perform(user_id)
+    Rails.logger.info "This won't have job prefix"  # ❌ No job context
+  end
+end
+```
+
+### Plain Sidekiq Jobs
+
+For **plain Sidekiq** jobs (not using ActiveJob), LogBench automatically captures job context:
+
+```ruby
+class DataProcessingJob
+  include Sidekiq::Job
+
+  def perform(data_id)
+    Rails.logger.info "Processing data #{data_id}"  # ✅ Will have job prefix
+
+    # SQL queries are automatically tagged
+    data = Data.find(data_id)                       # ✅ Will have job prefix
+    data.process!
+
+    Rails.logger.info "Data processing completed"   # ✅ Will have job prefix
+  end
+end
+```
+
+### Job Log Output
+
+In the TUI, job-related logs appear with colored prefixes:
+
+```
+🟡[EmailDeliveryJob#email-job-123] Starting email delivery for user 456
+🟡[EmailDeliveryJob#email-job-123] Found user: user@example.com
+🟡[EmailDeliveryJob#email-job-123]   User Load (1.2ms)  SELECT "users".* FROM "users" WHERE "users"."id" = $1
+🟡[EmailDeliveryJob#email-job-123] Email delivery completed
+```
+
+*(🟡 represents yellow bold colored job name, consistent with Rails SQL query coloring)*
+
+### Job Context Detection
+
+LogBench automatically detects job context through:
+
+- **ActiveJob**: Uses Rails' tagged logging system with job class and job ID
+- **Plain Sidekiq**: Uses LogBench::Current attributes set by Sidekiq middleware
+- **SQL Queries**: Inherit job context from the current request/job execution
+
+No additional configuration is required - job logging works automatically once LogBench is installed.
+
 ## Testing
 
 LogBench includes a comprehensive test suite to ensure reliability and correctness.

lib/log_bench/app/main.rb

@@ -19,7 +19,7 @@ class Main
 
       def initialize(log_file_path = "log/development.log")
         self.log_file_path = find_log_file(log_file_path)
-        self.state = State.new
+        self.state = State.instance
         validate_log_file!
       end
 

lib/log_bench/app/state.rb

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
 
+require "singleton"
+
 module LogBench
   module App
     class State
+      include Singleton
+
       attr_reader :main_filter, :sort, :detail_filter, :cleared_requests
       attr_accessor :requests, :orphan_requests, :auto_scroll, :scroll_offset, :selected, :detail_scroll_offset, :detail_selected_entry, :text_selection_mode, :update_available, :update_version
 
       def initialize
+        reset!
+      end
+
+      def reset!
         self.requests = []
         self.orphan_requests = []
         self.selected = 0
@@ -23,6 +31,7 @@ def initialize
         self.update_available = false
         self.update_version = nil
         self.cleared_requests = nil
+        self.job_ids_map = {}
       end
 
       def running?
@@ -280,9 +289,17 @@ def adjust_detail_scroll_for_entry_selection(visible_height, lines)
         end
       end
 
+      def register_job_enqueue(job_id, request_id)
+        job_ids_map[job_id] = request_id
+      end
+
+      def request_id_for_job(job_id)
+        job_ids_map[job_id]
+      end
+
       private
 
-      attr_accessor :focused_pane, :running
+      attr_accessor :focused_pane, :running, :job_ids_map
       attr_writer :main_filter, :detail_filter, :sort, :cleared_requests
     end
   end

lib/log_bench/current.rb

@@ -3,7 +3,7 @@
 if defined?(ActiveSupport::CurrentAttributes)
   module LogBench
     class Current < ActiveSupport::CurrentAttributes
-      attribute :request_id
+      attribute :request_id, :jid, :job_class
     end
   end
 end

lib/log_bench/job_prefix_formatter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module LogBench
+  # Shared module for formatting job prefixes with ANSI colors
+  # Used by both JsonFormatter (when writing logs) and Parser (when reading old logs)
+  module JobPrefixFormatter
+    # Job color palette - using standard colors only (no bright colors)
+    JOB_COLORS = [
+      31, # Red
+      32, # Green
+      33, # Yellow
+      34, # Blue
+      35, # Magenta
+      36  # Cyan
+    ].freeze
+
+    # Extract job info from ActiveJob tags
+    # Returns [job_id, job_class] or nil if not a valid ActiveJob tag
+    def extract_job_info_from_tags(tags)
+      return nil unless tags.is_a?(Array) && tags.size >= 3
+      return nil unless tags[0] == "ActiveJob"
+
+      # ActiveJob tags format: ["ActiveJob", "JobClassName", "job-id"]
+      job_class = tags[1]
+      job_id = tags[2]
+      return nil unless job_class && job_id
+
+      [job_id, job_class]
+    end
+
+    # Build colored job prefix using ANSI color codes
+    def build_colored_job_prefix(job_class, job_id)
+      # Pick a color based on the job ID for visual differentiation
+      color_code = pick_job_color(job_id)
+      "\u001b[1m\u001b[#{color_code}m[#{job_class}##{job_id}]\u001b[0m"
+    end
+
+    # Pick a consistent color for a job based on its ID
+    def pick_job_color(job_id)
+      # Use a simple hash of the job ID to pick a consistent color
+      # This ensures the same job ID always gets the same color
+      hash = job_id.to_s.bytes.sum
+      JOB_COLORS[hash % JOB_COLORS.length]
+    end
+  end
+end

lib/log_bench/json_formatter.rb

@@ -8,6 +8,7 @@ module LogBench
   # JSON logs. Extends TaggedLogging::Formatter for full Rails compatibility.
   class JsonFormatter < ::Logger::Formatter
     include ActiveSupport::TaggedLogging::Formatter
+    include JobPrefixFormatter
 
     def call(severity, timestamp, progname, message)
       log_entry = build_log_entry(severity, timestamp, progname, message)
@@ -25,6 +26,15 @@ def build_log_entry(severity, timestamp, progname, message)
       entry = parse_lograge_message(entry[:message]) if lograge_message?(entry)
       request_id = current_request_id
 
+      # Get job info from Current attributes (direct Sidekiq jobs) or tags (ActiveJob)
+      job_id, job_class = get_job_info(tags)
+
+      # Add colored job prefix to message if we're in a job context
+      if job_id && job_class && entry[:message]
+        job_prefix = build_colored_job_prefix(job_class, job_id)
+        entry[:message] = "#{job_prefix} #{entry[:message]}"
+      end
+
       base_entry = {
         level: severity,
         timestamp: timestamp.utc.iso8601(3),
@@ -74,19 +84,50 @@ def parse_lograge_message(message_string)
     end
 
     def current_request_id
-      request_id = nil
-
-      if defined?(LogBench::Current) && LogBench::Current.respond_to?(:request_id)
-        request_id = LogBench::Current.request_id
-      elsif defined?(Current) && Current.respond_to?(:request_id)
-        request_id = Current.request_id
-      elsif defined?(RequestStore) && RequestStore.exist?(:request_id)
-        request_id = RequestStore.read(:request_id)
-      elsif Thread.current[:request_id]
-        request_id = Thread.current[:request_id]
+      get_current_attribute(:request_id)
+    end
+
+    def current_jid
+      get_current_attribute(:jid)
+    end
+
+    def current_job_class
+      get_current_attribute(:job_class)
+    end
+
+    # Generic method to get current attributes from various storage mechanisms
+    def get_current_attribute(attribute_name)
+      # Try LogBench::Current first (preferred)
+      if defined?(LogBench::Current) && LogBench::Current.respond_to?(attribute_name)
+        return LogBench::Current.public_send(attribute_name)
+      end
+
+      # Try Current (fallback for apps that define their own Current)
+      if defined?(Current) && Current.respond_to?(attribute_name)
+        return Current.public_send(attribute_name)
+      end
+
+      # Try RequestStore (for apps using request_store gem)
+      if defined?(RequestStore) && RequestStore.exist?(attribute_name)
+        return RequestStore.read(attribute_name)
+      end
+
+      # Try Thread local storage (last resort)
+      Thread.current[attribute_name]
+    end
+
+    # Get job info from Current attributes (direct Sidekiq jobs) or tags (ActiveJob)
+    def get_job_info(tags)
+      # First try Current attributes (for direct Sidekiq jobs)
+      current_jid = get_current_attribute(:jid)
+      current_job_class = get_current_attribute(:job_class)
+
+      if current_jid && current_job_class
+        return [current_jid, current_job_class]
       end
 
-      request_id
+      # Fallback to tags (for ActiveJob)
+      extract_job_info_from_tags(tags)
     end
   end
 end

lib/log_bench/log/collection.rb

@@ -8,6 +8,7 @@ class Collection
       attr_accessor :entries
 
       def initialize(input)
+        self.parsed_entries = nil
         self.entries = parse_input(input)
       end
 
@@ -59,6 +60,8 @@ def sort_by_timestamp
 
       private
 
+      attr_accessor :parsed_entries
+
       def create_collection_from_requests(requests)
         new_collection = self.class.new([])
         new_collection.entries = requests
@@ -67,7 +70,7 @@ def create_collection_from_requests(requests)
 
       def parse_input(input)
         lines = normalize_input(input)
-        parsed_entries = Parser.parse_lines(lines)
+        self.parsed_entries = Parser.parse_lines(lines)
         Parser.group_by_request(parsed_entries)
       end
 

lib/log_bench/log/entry.rb

@@ -3,7 +3,7 @@
 module LogBench
   module Log
     class Entry
-      attr_reader :type, :raw_line, :request_id, :timestamp, :content, :timing
+      attr_reader :type, :raw_line, :request_id, :timestamp, :content, :timing, :json_data
 
       def initialize(json_data)
         self.json_data = json_data
@@ -23,8 +23,7 @@ def related_log?
 
       private
 
-      attr_writer :type, :timestamp, :request_id, :content, :timing
-      attr_accessor :json_data
+      attr_writer :type, :timestamp, :request_id, :content, :timing, :json_data
 
       def parse_timestamp(timestamp_str)
         return Time.now unless timestamp_str

lib/log_bench/log/job_enqueue_entry.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LogBench
+  module Log
+    class JobEnqueueEntry < Entry
+      attr_reader :job_id
+
+      def initialize(json_data)
+        super
+        self.type = :job_enqueue
+        self.job_id = extract_job_id
+      end
+
+      private
+
+      attr_writer :job_id
+
+      def extract_job_id
+        Parser.extract_job_id_from_enqueue(content)
+      end
+    end
+  end
+end