log_bench 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 617bb4c585973c40149ffc5f58eba322446aa997a324515517269af591e88c02
-  data.tar.gz: 613d94f2d455abd75a523ebbf0f3c8aeafd5993657f5f4281c8d841c9e8af097
+  metadata.gz: e09eee0378110cca913cb1611c4b299a874dc025c7be07fcde2e89a48be8c010
+  data.tar.gz: 92bb7b5373652fb947534380d996ce052099e301968c28d3e44b878a1cdce180
 SHA512:
-  metadata.gz: 57aac276e8b98a7551b2f4dfa75df88c21723eb798aeedbd338d2323346902eaef3439a9a338dd4dfd6cd528361d3ebc950f404997a7a357f2643b7f0611a3cf
-  data.tar.gz: e1ee5e4e719aff224c76a3485212df6a91aa1565ad192e834a92d51040a3b10a3055222fec79129c73af96d3f5692c1b8c1b7547b0cfffed54f02bffe1bc308b
+  metadata.gz: f75eb599a35ef1717eda389dbd2919134374922d14b6c4ff1b1c8b98c6f13138feec808b458aea78be882e557cb5a058142dbdf2717386347e3d6ad57e70e208
+  data.tar.gz: 9564662777ca62c550ec723240a25e5ff97f968734cac13845810ed8a207d5dec296d8ef1bbf2f2c193b7d8dc603ea14ab7fa2f6a21de6072275f9917a958991

data/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.

data/lib/log_bench/app/main.rb

@@ -19,7 +19,7 @@ module LogBench
 
       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
 

data/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 @@ module LogBench
         self.update_available = false
         self.update_version = nil
         self.cleared_requests = nil
+        self.job_ids_map = {}
       end
 
       def running?
@@ -280,9 +289,17 @@ module LogBench
         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

data/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

data/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

data/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 @@ module LogBench
       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 @@ module LogBench
     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

data/lib/log_bench/log/collection.rb

@@ -8,6 +8,7 @@ module LogBench
       attr_accessor :entries
 
       def initialize(input)
+        self.parsed_entries = nil
         self.entries = parse_input(input)
       end
 
@@ -59,6 +60,8 @@ module LogBench
 
       private
 
+      attr_accessor :parsed_entries
+
       def create_collection_from_requests(requests)
         new_collection = self.class.new([])
         new_collection.entries = requests
@@ -67,7 +70,7 @@ module LogBench
 
       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
 

data/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 @@ module LogBench
 
       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

data/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

data/lib/log_bench/log/parser.rb

@@ -3,12 +3,17 @@
 module LogBench
   module Log
     class Parser
+      extend JobPrefixFormatter
+
       def self.parse_line(raw_line)
         clean_line = raw_line.encode("UTF-8", invalid: :replace, undef: :replace, replace: "").strip
         data = JSON.parse(clean_line)
         return unless data.is_a?(Hash)
 
-        build_specific_entry(data)
+        entry = build_specific_entry(data)
+        register_job_enqueue(entry)
+        enrich_job_entry(entry)
+        entry
       rescue JSON::ParserError
         nil
       end
@@ -32,6 +37,8 @@ module LogBench
           QueryEntry.new(data, cached: true)
         when :sql_call_line
           CallLineEntry.new(data)
+        when :job_enqueue
+          JobEnqueueEntry.new(data)
         else
           Entry.new(data)
         end
@@ -67,6 +74,7 @@ module LogBench
         return :cache if cache_message?(data)
         return :sql if sql_message?(data)
         return :sql_call_line if call_stack_message?(data)
+        return :job_enqueue if job_enqueue_message?(data)
 
         :other
       end
@@ -89,6 +97,54 @@ module LogBench
         message = data["message"] || ""
         message.include?("↳")
       end
+
+      def self.job_enqueue_message?(data)
+        message = data["message"] || ""
+        message.match?(/Enqueued .+ \(Job ID: .+\)/)
+      end
+
+      def self.extract_job_id_from_enqueue(message)
+        match = message.match(/Job ID: ([^\)]+)/)
+        match[1] if match
+      end
+
+      # Register job enqueue in State
+      def self.register_job_enqueue(entry)
+        return unless entry.is_a?(JobEnqueueEntry)
+        return unless defined?(App::State)
+
+        App::State.instance.register_job_enqueue(entry.job_id, entry.request_id)
+      end
+
+      # Enrich job execution logs with request_id and colored prefix
+      def self.enrich_job_entry(entry)
+        return unless entry.respond_to?(:json_data)
+
+        tags = entry.json_data["tags"]
+        job_id, job_class = extract_job_info_from_tags(tags)
+        return unless job_id
+
+        add_job_prefix_to_entry(entry, job_id, job_class)
+        add_request_id_to_entry(entry, job_id)
+      end
+
+      # Add colored job prefix to entry content
+      def self.add_job_prefix_to_entry(entry, job_id, job_class)
+        return if entry.content.match?(/\[[\w:]+#[^\]]+\]/)
+
+        job_prefix = build_colored_job_prefix(job_class, job_id)
+        new_content = "#{job_prefix} #{entry.content}"
+        entry.instance_variable_set(:@content, new_content)
+      end
+
+      # Add request_id to entry from State
+      def self.add_request_id_to_entry(entry, job_id)
+        return if entry.request_id
+        return unless defined?(App::State)
+
+        request_id = App::State.instance.request_id_for_job(job_id)
+        entry.instance_variable_set(:@request_id, request_id) if request_id
+      end
     end
   end
 end

data/lib/log_bench/railtie.rb

@@ -102,6 +102,13 @@ module LogBench
 
         require "sidekiq/middleware/current_attributes"
         Sidekiq::CurrentAttributes.persist("LogBench::Current")
+
+        # Add our custom middleware to capture job ID
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add LogBench::SidekiqMiddleware
+          end
+        end
       end
 
       # Validate that LogBench setup worked correctly

data/lib/log_bench/sidekiq_middleware.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module LogBench
+  # Sidekiq middleware to capture job ID (jid) and job class name and set them in Current attributes
+  # for inclusion in JSON logs
+  class SidekiqMiddleware
+    def call(worker, job, _queue)
+      if defined?(LogBench::Current)
+        # Only set Current attributes for direct Sidekiq jobs
+        # ActiveJob jobs will use tags instead
+        unless activejob_wrapper?(job["class"])
+          LogBench::Current.jid = job["jid"]
+          LogBench::Current.job_class = job["class"] || worker.class.name
+        end
+      end
+
+      yield
+    ensure
+      if defined?(LogBench::Current)
+        # Clean up the job attributes after the job completes
+        LogBench::Current.jid = nil
+        LogBench::Current.job_class = nil
+      end
+    end
+
+    private
+
+    def activejob_wrapper?(job_class)
+      job_class == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+    end
+  end
+end

data/lib/log_bench/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LogBench
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: log_bench
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Benjamín Silva
 bindir: exe
 cert_chain: []
-date: 2025-10-07 00:00:00.000000000 Z
+date: 2025-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -145,15 +145,18 @@ files:
 - lib/log_bench/configuration.rb
 - lib/log_bench/configuration_validator.rb
 - lib/log_bench/current.rb
+- lib/log_bench/job_prefix_formatter.rb
 - lib/log_bench/json_formatter.rb
 - lib/log_bench/log/call_line_entry.rb
 - lib/log_bench/log/collection.rb
 - lib/log_bench/log/entry.rb
 - lib/log_bench/log/file.rb
+- lib/log_bench/log/job_enqueue_entry.rb
 - lib/log_bench/log/parser.rb
 - lib/log_bench/log/query_entry.rb
 - lib/log_bench/log/request.rb
 - lib/log_bench/railtie.rb
+- lib/log_bench/sidekiq_middleware.rb
 - lib/log_bench/version.rb
 - lib/log_bench/version_checker.rb
 - lib/tasks/log_bench.rake