Fix Array message handling in parser methods (silva96#62)

Some log formats may have the 'message' field as an Array instead of a
String. The parser methods were calling String methods like match?() and
include?() directly on the message field, which caused 'undefined method
match? for an instance of Array' errors.

Changes:
- Add normalize_message() helper method to handle String, Array, nil, and
  other types
- Update all message detection methods (sql_message?, cache_message?,
  call_stack_message?, job_enqueue_message?) to use normalize_message()
- Update Entry class to normalize messages when setting content
- Update CallLineEntry to use normalized messages
- Update extract_job_id_from_enqueue() to handle Array messages
- Add comprehensive test coverage for Array message handling

Fixes issue where log_bench would crash when encountering log entries
with Array messages, particularly affecting job enqueue detection.

Author: hecvasro

lib/log_bench/log/call_line_entry.rb

@@ -23,7 +23,7 @@ def self.build(raw_line)
 
       def extract_from_json(data)
         super
-        message = data["message"] || ""
+        message = Parser.normalize_message(data["message"])
         return unless call_line_message?(data)
 
         self.content = message.strip
@@ -40,7 +40,7 @@ def extract_call_info
       end
 
       def call_line_message?(data)
-        message = data["message"] || ""
+        message = Parser.normalize_message(data["message"])
         message.include?("↳")
       end
     end

lib/log_bench/log/entry.rb

@@ -9,7 +9,7 @@ def initialize(json_data)
         self.json_data = json_data
         self.timestamp = parse_timestamp(json_data["timestamp"])
         self.request_id = json_data["request_id"]
-        self.content = json_data["message"] || ""
+        self.content = Parser.normalize_message(json_data["message"])
         self.type = :other
       end
 

lib/log_bench/log/parser.rb

@@ -83,28 +83,42 @@ def self.lograge_request?(data)
         data["method"] && data["path"] && data["status"]
       end
 
+      def self.normalize_message(message)
+        case message
+        when String
+          message
+        when Array
+          message.join(" ")
+        when NilClass
+          ""
+        else
+          message.to_s
+        end
+      end
+
       def self.sql_message?(data)
-        message = data["message"] || ""
+        message = normalize_message(data["message"])
         %w[SELECT INSERT UPDATE DELETE TRANSACTION BEGIN COMMIT ROLLBACK SAVEPOINT].any? { |op| message.include?(op) }
       end
 
       def self.cache_message?(data)
-        message = data["message"] || ""
+        message = normalize_message(data["message"])
         message.include?("CACHE")
       end
 
       def self.call_stack_message?(data)
-        message = data["message"] || ""
+        message = normalize_message(data["message"])
         message.include?("↳")
       end
 
       def self.job_enqueue_message?(data)
-        message = data["message"] || ""
+        message = normalize_message(data["message"])
         message.match?(/Enqueued .+ \(Job ID: .+\)/)
       end
 
       def self.extract_job_id_from_enqueue(message)
-        match = message.match(/Job ID: ([^\)]+)/)
+        normalized_message = normalize_message(message)
+        match = normalized_message.match(/Job ID: ([^\)]+)/)
         match[1] if match
       end
 

test/test_job_enqueue_tracking.rb

@@ -84,6 +84,42 @@ def test_job_enqueue_message_detection
     refute LogBench::Log::Parser.job_enqueue_message?(data3)
   end
 
+  def test_job_enqueue_message_detection_with_array_message
+    # Should handle Array messages
+    data1 = {"message" => ["Enqueued", "TestJob", "(Job ID: 123-456)", "to", "Async(default)"]}
+    assert LogBench::Log::Parser.job_enqueue_message?(data1), "Should detect job enqueue when message is an Array"
+
+    # Should not detect regular messages when Array
+    data2 = {"message" => ["Regular", "log", "message"]}
+    refute LogBench::Log::Parser.job_enqueue_message?(data2), "Should not detect job enqueue for regular Array message"
+
+    # Should extract job ID from Array message
+    job_id = LogBench::Log::Parser.extract_job_id_from_enqueue(data1["message"])
+    assert_equal "123-456", job_id, "Should extract job ID from Array message"
+  end
+
+  def test_parse_job_enqueue_with_array_message
+    # Test parsing a job enqueue log entry where message is an Array
+    request_log = '{"method":"GET","path":"/users","status":200,"duration":45.2,"controller":"UsersController","action":"index","request_id":"d72f06fa-71f1-4fb4-a27f-d9b36fe17593","timestamp":"2025-01-01T10:00:00Z"}'
+    enqueue_log = '{"message":["Enqueued","TestJob","(Job ID: 8afaa702-7b0d-4d20-91ad-65bbf78ee0c8)","to","Async(default)","at","2025-10-17","14:02:51","UTC"],"level":"INFO","timestamp":"2025-10-17T14:02:49.976Z","time":1760709769.9763,"request_id":"d72f06fa-71f1-4fb4-a27f-d9b36fe17593","tags":["ActiveJob"]}'
+
+    collection = LogBench::Log::Collection.new([request_log, enqueue_log])
+    requests = collection.requests
+
+    assert_equal 1, requests.size
+    request = requests.first
+
+    # Should have one job enqueue entry in related logs
+    job_enqueue_entries = request.related_logs.select { |log| log.is_a?(LogBench::Log::JobEnqueueEntry) }
+    assert_equal 1, job_enqueue_entries.size
+
+    job_enqueue = job_enqueue_entries.first
+    assert_equal "8afaa702-7b0d-4d20-91ad-65bbf78ee0c8", job_enqueue.job_id
+    assert_equal "d72f06fa-71f1-4fb4-a27f-d9b36fe17593", job_enqueue.request_id
+    # Content should be normalized (joined Array)
+    assert_match(/Enqueued.*TestJob.*Job ID: 8afaa702-7b0d-4d20-91ad-65bbf78ee0c8/, job_enqueue.content)
+  end
+
   def test_full_workflow_example
     # This test demonstrates the complete workflow:
     # 1. HTTP request comes in

test/test_log_bench.rb

@@ -497,4 +497,60 @@ def test_parse_entries_with_null_or_missing_message
     assert_equal :other, request.related_logs[0].type
     assert_equal :other, request.related_logs[1].type
   end
+
+  def test_normalize_message_handles_string
+    assert_equal "test message", LogBench::Log::Parser.normalize_message("test message")
+  end
+
+  def test_normalize_message_handles_array
+    assert_equal "test message", LogBench::Log::Parser.normalize_message(["test", "message"])
+  end
+
+  def test_normalize_message_handles_nil
+    assert_equal "", LogBench::Log::Parser.normalize_message(nil)
+  end
+
+  def test_normalize_message_handles_other_types
+    assert_equal "123", LogBench::Log::Parser.normalize_message(123)
+    assert_equal "true", LogBench::Log::Parser.normalize_message(true)
+  end
+
+  def test_sql_message_detection_with_array
+    # Should detect SQL messages when message is an Array
+    data1 = {"message" => ["SELECT", "*", "FROM", "users"]}
+    assert LogBench::Log::Parser.sql_message?(data1), "Should detect SQL when message is an Array"
+
+    data2 = {"message" => ["INSERT", "INTO", "posts"]}
+    assert LogBench::Log::Parser.sql_message?(data2), "Should detect INSERT when message is an Array"
+
+    data3 = {"message" => ["Regular", "log", "message"]}
+    refute LogBench::Log::Parser.sql_message?(data3), "Should not detect SQL for regular Array message"
+  end
+
+  def test_cache_message_detection_with_array
+    # Should detect cache messages when message is an Array
+    data1 = {"message" => ["CACHE", "hit", "for", "key"]}
+    assert LogBench::Log::Parser.cache_message?(data1), "Should detect CACHE when message is an Array"
+
+    data2 = {"message" => ["Regular", "log", "message"]}
+    refute LogBench::Log::Parser.cache_message?(data2), "Should not detect CACHE for regular Array message"
+  end
+
+  def test_call_stack_message_detection_with_array
+    # Should detect call stack messages when message is an Array
+    data1 = {"message" => ["↳", "app/controllers/users_controller.rb:10"]}
+    assert LogBench::Log::Parser.call_stack_message?(data1), "Should detect call stack when message is an Array"
+
+    data2 = {"message" => ["Regular", "log", "message"]}
+    refute LogBench::Log::Parser.call_stack_message?(data2), "Should not detect call stack for regular Array message"
+  end
+
+  def test_entry_content_with_array_message
+    # Entry should normalize Array messages to strings
+    json_data = {"message" => ["Test", "message", "with", "array"], "timestamp" => "2025-01-01T10:00:00Z"}
+    entry = LogBench::Log::Entry.new(json_data)
+
+    assert_equal "Test message with array", entry.content
+    assert_instance_of String, entry.content
+  end
 end