log_bench 0.1.0

data/lib/log_bench/log/cache_entry.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module LogBench
+  module Log
+    class CacheEntry < Entry
+      SQL_OPERATIONS = %w[SELECT INSERT UPDATE DELETE].freeze
+
+      attr_reader :content, :timing
+
+      def initialize(raw_line)
+        super
+        self.type = :cache
+      end
+
+      def self.build(raw_line)
+        return unless parseable?(raw_line)
+
+        entry = Entry.new(raw_line)
+        return unless entry.type == :cache
+
+        new(raw_line)
+      end
+
+      def duration_ms
+        return 0.0 unless timing
+
+        timing.gsub(/[()ms]/, "").to_f
+      end
+
+      def hit?
+        content.include?("CACHE")
+      end
+
+      def miss?
+        !hit?
+      end
+
+      def to_h
+        super.merge(
+          content: content,
+          timing: timing,
+          operation: operation,
+          duration_ms: duration_ms,
+          hit: hit?
+        )
+      end
+
+      private
+
+      attr_reader :operation
+      attr_writer :content, :timing, :operation
+
+      def extract_from_json(data)
+        super
+        message = data["message"] || ""
+        return unless cache_message?(data)
+
+        self.content = message.strip
+        extract_timing_and_operation
+      end
+
+      def extract_timing_and_operation
+        clean_content = remove_ansi_codes(content)
+        self.timing = extract_timing(clean_content)
+        self.operation = extract_operation(clean_content)
+      end
+
+      def extract_timing(text)
+        match = text.match(/\(([0-9.]+ms)\)/)
+        match ? match[1] : nil
+      end
+
+      def extract_operation(text)
+        SQL_OPERATIONS.find { |op| text.include?(op) }
+      end
+
+      def remove_ansi_codes(text)
+        text.gsub(/\e\[[0-9;]*m/, "")
+      end
+    end
+  end
+end

data/lib/log_bench/log/call_line_entry.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module LogBench
+  module Log
+    class CallLineEntry < Entry
+      attr_reader :content
+
+      def initialize(raw_line)
+        super
+        self.type = :sql_call_line
+      end
+
+      def self.build(raw_line)
+        return unless parseable?(raw_line)
+
+        entry = Entry.new(raw_line)
+        return unless entry.type == :sql_call_line
+
+        new(raw_line)
+      end
+
+      def to_h
+        super.merge(
+          content: content,
+          file_path: file_path,
+          line_number: line_number,
+          method_name: method_name
+        )
+      end
+
+      private
+
+      attr_writer :content
+      attr_accessor :file_path, :line_number, :method_name
+
+      def extract_from_json(data)
+        super
+        message = data["message"] || ""
+        return unless call_line_message?(data)
+
+        self.content = message.strip
+        extract_call_info
+      end
+
+      def extract_call_info
+        # Parse call line like "  ↳ app/controllers/users_controller.rb:10:in 'UsersController#show'"
+        if content =~ /↳\s+(.+):(\d+):in\s+'(.+)'/
+          self.file_path = $1
+          self.line_number = $2.to_i
+          self.method_name = $3
+        end
+      end
+
+      def call_line_message?(data)
+        message = data["message"] || ""
+        message.include?("↳")
+      end
+    end
+  end
+end

data/lib/log_bench/log/collection.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module LogBench
+  module Log
+    class Collection
+      include Enumerable
+
+      attr_accessor :entries
+
+      def initialize(input)
+        self.entries = parse_input(input)
+      end
+
+      def each(&block)
+        entries.each(&block)
+      end
+
+      def size
+        entries.size
+      end
+
+      def empty?
+        entries.empty?
+      end
+
+      def requests
+        entries.select { |entry| entry.is_a?(Request) }
+      end
+
+      def queries
+        entries.flat_map(&:queries)
+      end
+
+      def cache_operations
+        entries.flat_map(&:cache_operations)
+      end
+
+      def filter_by_method(method)
+        filtered_requests = requests.select { |req| req.method == method.upcase }
+        create_collection_from_requests(filtered_requests)
+      end
+
+      def filter_by_path(path_pattern)
+        filtered_requests = requests.select { |req| req.path.include?(path_pattern) }
+        create_collection_from_requests(filtered_requests)
+      end
+
+      def filter_by_status(status_range)
+        filtered_requests = requests.select { |req| status_range.include?(req.status) }
+        create_collection_from_requests(filtered_requests)
+      end
+
+      def slow_requests(threshold_ms = 1000)
+        filtered_requests = requests.select { |req| req.duration && req.duration > threshold_ms }
+        create_collection_from_requests(filtered_requests)
+      end
+
+      def sort_by_duration
+        sorted_requests = requests.sort_by { |req| -(req.duration || 0) }
+        create_collection_from_requests(sorted_requests)
+      end
+
+      def sort_by_timestamp
+        sorted_requests = requests.sort_by(&:timestamp)
+        create_collection_from_requests(sorted_requests)
+      end
+
+      def to_a
+        entries
+      end
+
+      private
+
+      def create_collection_from_requests(requests)
+        new_collection = self.class.new([])
+        new_collection.entries = requests
+        new_collection
+      end
+
+      def parse_input(input)
+        lines = normalize_input(input)
+        parsed_entries = Parser.parse_lines(lines)
+        Parser.group_by_request(parsed_entries)
+      end
+
+      def normalize_input(input)
+        case input
+        when String
+          [input]
+        when Array
+          input.flat_map { |item| normalize_input(item) }
+        else
+          Array(input)
+        end
+      end
+    end
+  end
+end

data/lib/log_bench/log/entry.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module LogBench
+  module Log
+    class Entry
+      attr_reader :type, :raw_line, :request_id, :timestamp
+
+      def initialize(raw_line)
+        self.raw_line = raw_line.strip
+        self.timestamp = Time.now
+        self.type = :unknown
+        parse!
+      end
+
+      def self.build(raw_line)
+        new(raw_line) if parseable?(raw_line)
+      end
+
+      def self.parseable?(line)
+        data = JSON.parse(line.strip)
+        data.is_a?(Hash)
+      rescue JSON::ParserError
+        false
+      end
+
+      def http_request?
+        type == :http_request
+      end
+
+      def related_log?
+        !http_request?
+      end
+
+      def to_h
+        {
+          raw: raw_line,
+          timestamp: timestamp,
+          request_id: request_id,
+          type: type
+        }
+      end
+
+      private
+
+      attr_writer :type, :raw_line, :timestamp, :request_id
+
+      def parse!
+        parse_json
+      end
+
+      def parse_json
+        data = JSON.parse(raw_line)
+        return false unless data.is_a?(Hash)
+
+        # extract_from_json returns false if log should be discarded
+        extract_from_json(data)
+      rescue JSON::ParserError
+        false
+      end
+
+      def extract_from_json(data)
+        # Discard logs without request_id - they can't be correlated
+        return false unless data["request_id"]
+
+        self.timestamp = parse_timestamp(data["timestamp"])
+        self.request_id = data["request_id"]
+        self.type = determine_json_type(data)
+        true
+      end
+
+      def determine_json_type(data)
+        return :http_request if lograge_request?(data)
+        return :cache if cache_message?(data)
+        return :sql if sql_message?(data)
+        return :sql_call_line if call_stack_message?(data)
+
+        :other
+      end
+
+      def lograge_request?(data)
+        data["method"] && data["path"] && data["status"]
+      end
+
+      def sql_message?(data)
+        message = data["message"] || ""
+        %w[SELECT INSERT UPDATE DELETE TRANSACTION BEGIN COMMIT ROLLBACK SAVEPOINT].any? { |op| message.include?(op) }
+      end
+
+      def cache_message?(data)
+        message = data["message"] || ""
+        message.include?("CACHE")
+      end
+
+      def call_stack_message?(data)
+        message = data["message"] || ""
+        message.include?("↳")
+      end
+
+      def parse_timestamp(timestamp_str)
+        return Time.now unless timestamp_str
+
+        Time.parse(timestamp_str)
+      rescue ArgumentError
+        Time.now
+      end
+    end
+  end
+end

data/lib/log_bench/log/file.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module LogBench
+  module Log
+    class File
+      attr_reader :path, :last_position
+
+      def initialize(path)
+        self.path = find_log_file(path)
+        self.last_position = 0
+        validate!
+      end
+
+      def requests
+        collection.requests
+      end
+
+      def entries
+        collection.entries
+      end
+
+      def collection
+        @collection ||= Collection.new(lines)
+      end
+
+      def lines
+        @lines ||= read_lines
+      end
+
+      def reload!
+        self.lines = nil
+        self.collection = nil
+        self.last_position = 0
+      end
+
+      def tail(max_lines = 1000)
+        all_lines = read_lines
+        recent_lines = all_lines.last(max_lines)
+        Collection.new(recent_lines)
+      end
+
+      def watch(&block)
+        return enum_for(:watch) unless block_given?
+
+        loop do
+          new_lines = read_new_lines
+          next if new_lines.empty?
+
+          new_collection = Collection.new(new_lines)
+          yield new_collection unless new_collection.empty?
+
+          sleep 0.5
+        end
+      end
+
+      def size
+        ::File.size(path)
+      end
+
+      def exist?
+        ::File.exist?(path)
+      end
+
+      def mtime
+        ::File.mtime(path)
+      end
+
+      private
+
+      attr_writer :path, :last_position
+
+      def read_lines
+        return [] unless exist?
+
+        ::File.readlines(path, chomp: true)
+      end
+
+      def read_new_lines
+        return [] unless exist?
+        return [] unless size > last_position
+
+        new_lines = []
+        ::File.open(path, "r") do |file|
+          file.seek(last_position)
+          new_lines = file.readlines(chomp: true)
+          self.last_position = file.tell
+        end
+
+        new_lines
+      end
+
+      def find_log_file(path)
+        candidates = [path, "log/development.log"]
+
+        candidates.find { |candidate| ::File.exist?(candidate) } || path
+      end
+
+      def validate!
+        raise Error, "File not found: #{path}" unless exist?
+      end
+    end
+  end
+end

data/lib/log_bench/log/parser.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module LogBench
+  module Log
+    class Parser
+      def self.parse_line(raw_line)
+        return unless Entry.parseable?(raw_line)
+
+        entry = Entry.new(raw_line)
+        build_specific_entry(entry)
+      end
+
+      def self.parse_lines(lines)
+        lines.map { |line| parse_line(line) }.compact
+      end
+
+      def self.group_by_request(entries)
+        grouped = entries.group_by(&:request_id)
+        build_requests_from_groups(grouped)
+      end
+
+      def self.build_specific_entry(entry)
+        case entry.type
+        when :http_request
+          Request.build(entry.raw_line)
+        when :sql
+          QueryEntry.build(entry.raw_line)
+        when :cache
+          CacheEntry.build(entry.raw_line)
+        when :sql_call_line
+          CallLineEntry.build(entry.raw_line)
+        else
+          entry
+        end
+      end
+
+      def self.build_requests_from_groups(grouped)
+        requests = []
+
+        grouped.each do |request_id, entries|
+          next unless request_id
+
+          request = find_request_entry(entries)
+          next unless request
+
+          related_logs = find_related_logs(entries)
+          related_logs.each { |log| request.add_related_log(log) }
+
+          requests << request
+        end
+
+        requests.sort_by(&:timestamp)
+      end
+
+      def self.find_request_entry(entries)
+        entries.find { |entry| entry.is_a?(Request) }
+      end
+
+      def self.find_related_logs(entries)
+        entries.reject { |entry| entry.is_a?(Request) }
+      end
+    end
+  end
+end

data/lib/log_bench/log/query_entry.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module LogBench
+  module Log
+    class QueryEntry < Entry
+      SELECT = "SELECT"
+      INSERT = "INSERT"
+      UPDATE = "UPDATE"
+      DELETE = "DELETE"
+      TRANSACTION = "TRANSACTION"
+      BEGIN_TRANSACTION = "BEGIN"
+      COMMIT = "COMMIT"
+      ROLLBACK = "ROLLBACK"
+      SAVEPOINT = "SAVEPOINT"
+      SQL_OPERATIONS = [SELECT, INSERT, UPDATE, DELETE, TRANSACTION, BEGIN_TRANSACTION, COMMIT, ROLLBACK, SAVEPOINT].freeze
+
+      attr_reader :content, :timing
+
+      def initialize(raw_line)
+        super
+        self.type = :sql
+      end
+
+      def self.build(raw_line)
+        return unless parseable?(raw_line)
+
+        entry = Entry.new(raw_line)
+        return unless entry.type == :sql
+
+        new(raw_line)
+      end
+
+      def duration_ms
+        return 0.0 unless timing
+
+        timing.gsub(/[()ms]/, "").to_f
+      end
+
+      def select?
+        operation == SELECT
+      end
+
+      def insert?
+        operation == INSERT
+      end
+
+      def update?
+        operation == UPDATE
+      end
+
+      def delete?
+        operation == DELETE
+      end
+
+      def transaction?
+        operation == TRANSACTION
+      end
+
+      def begin?
+        operation == BEGIN_TRANSACTION
+      end
+
+      def commit?
+        operation == COMMIT
+      end
+
+      def rollback?
+        operation == ROLLBACK
+      end
+
+      def savepoint?
+        operation == SAVEPOINT
+      end
+
+      def slow?(threshold_ms = 100)
+        duration_ms > threshold_ms
+      end
+
+      def to_h
+        super.merge(
+          content: content,
+          timing: timing,
+          operation: operation,
+          duration_ms: duration_ms,
+          has_ansi: has_ansi_codes?(content)
+        )
+      end
+
+      private
+
+      def extract_from_json(data)
+        # Call parent method which checks for request_id
+        return false unless super
+
+        message = data["message"] || ""
+        return false unless sql_message?(data)
+
+        self.content = message.strip
+        extract_timing_and_operation
+        true
+      end
+
+      def extract_timing_and_operation
+        clean_content = remove_ansi_codes(content)
+        self.timing = extract_timing(clean_content)
+        self.operation = extract_operation(clean_content)
+      end
+
+      def extract_timing(text)
+        match = text.match(/\(([0-9.]+ms)\)/)
+        match ? match[1] : nil
+      end
+
+      def extract_operation(text)
+        SQL_OPERATIONS.find { |op| text.include?(op) }
+      end
+
+      def remove_ansi_codes(text)
+        text.gsub(/\e\[[0-9;]*m/, "")
+      end
+
+      def has_ansi_codes?(text)
+        text.match?(/\e\[[0-9;]*m/)
+      end
+
+      private
+
+      attr_reader :operation
+      attr_writer :content, :timing, :operation
+    end
+  end
+end