select_rails_log 0.2.0

data/lib/select_rails_log/filter/logs_regexp_filter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SelectRailsLog
+  module Filter
+    class LogsRegexpFilter < BaseFilter
+      define_options :logs_regexp_filter do
+        option :regexp,
+               "--logs-regexp REGEXP", "-L", Regexp,
+               "Filter by log messages",
+               %q(  ex: '"^  Rendering .*\.json"')
+      end
+
+      def initialize(...)
+        super
+        @regexp = options[:regexp]
+      end
+
+      def runnable?
+        !!@regexp
+      end
+
+      def run(data)
+        data[LOGS].any? { |log| @regexp.match?(log[MESSAGE]) }
+      end
+    end
+  end
+end

data/lib/select_rails_log/filter/params_regexp_filter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SelectRailsLog
+  module Filter
+    class ParamsRegexpFilter < BaseFilter
+      define_options :params_regexp_filter do
+        option :regexp,
+               "--params-regexp REGEXP", "-P", Regexp,
+               "Filter by parameters",
+               %q(  ex: '"foo"=>"ba[rz]"')
+      end
+
+      def initialize(...)
+        super
+        @regexp = options[:regexp]
+      end
+
+      def runnable?
+        !!@regexp
+      end
+
+      def run(data)
+        @regexp.match?(data[PARAMETERS])
+      end
+    end
+  end
+end

data/lib/select_rails_log/filter/range_pattern.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SelectRailsLog
+  module Filter
+    module RangePattern
+      private
+
+      def parse_range_pattern(pattern)
+        if /\A(?<range_begin>.*?[^.])?\.\.(?<exclude_end>\.)?(?<range_end>[^.].*)?\z/ =~ pattern
+          range_begin = yield(range_begin) if range_begin
+          range_end = yield(range_end) if range_end
+          exclude_end = !exclude_end.nil?
+          range_by_begin_end(range_begin, range_end, exclude_end)
+        elsif /\A(?<base>.+),(?<delta>[^,]+)\z/ =~ pattern
+          delta = delta.to_f
+          base = yield(base)
+          range_by_base_delta(base, delta)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def range_by_begin_end(begin_time, end_time, exclude_end)
+        Range.new(begin_time, end_time, exclude_end)
+      end
+
+      def range_by_base_delta(base, delta)
+        range_by_begin_end(base - delta, base + delta, true)
+      end
+    end
+  end
+end

data/lib/select_rails_log/filter/request_id_filter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SelectRailsLog
+  module Filter
+    class RequestIdFilter < BaseFilter
+      filter_type :request
+
+      define_options :request_id_filter do
+        option :request_ids, "--request-ids IDs", "-I", Array, "Filter by request-id"
+      end
+
+      def initialize(...)
+        super
+        @request_ids = options[:request_ids].dup
+      end
+
+      def runnable?
+        !!@request_ids&.any?
+      end
+
+      def run(data)
+        raise StopIteration if @request_ids.empty?
+
+        !!@request_ids.delete(data[REQUEST_ID])
+      end
+    end
+  end
+end

data/lib/select_rails_log/filter/time_range_filter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "range_pattern"
+
+module SelectRailsLog
+  module Filter
+    class TimeRangeFilter < BaseFilter
+      include RangePattern
+
+      define_options :time_range_filter do
+        option :pattern,
+               "--time-range RANGE", "-T", String,
+               "Filter by time range",
+               "  range format is 'time1..time2', 'time1...time2', or 'time,seconds'.",
+               "  ex: '2018-01-02 12:00..2018-02-01 12:00', '1/2 12:00...2/2 12:00', '3/5 12:00,30'"
+      end
+
+      def initialize(...)
+        super
+
+        pattern = options[:pattern]
+        return unless pattern
+
+        begin
+          @range = parse_range_pattern(pattern) { |time_str| Time.parse(time_str) }
+        rescue ArgumentError
+          raise CommandLineOptionError, "invalid time range pattern `#{pattern}`"
+        end
+      end
+
+      def runnable?
+        !!@range
+      end
+
+      def run(data)
+        return true if @range.cover?(data[STARTED]) || @range.cover?(data[COMPLETED])
+
+        range = data[STARTED]..data[COMPLETED]
+        range.cover?(@range.begin) || range.cover?(@range.end)
+      end
+    end
+  end
+end

data/lib/select_rails_log/filter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "filter/base_filter"
+require_relative "filter/request_id_filter"
+require_relative "filter/controller_action_filter"
+require_relative "filter/http_method_filter"
+require_relative "filter/http_status_filter"
+require_relative "filter/time_range_filter"
+require_relative "filter/duration_range_filter"
+require_relative "filter/params_regexp_filter"
+require_relative "filter/logs_regexp_filter"
+
+module SelectRailsLog
+  module Filter
+  end
+end

data/lib/select_rails_log/options.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module SelectRailsLog
+  class Options
+    extend Forwardable
+
+    def_delegators :@options, :key?, :[]=
+
+    def initialize
+      @options = {}
+    end
+
+    def fetch(key)
+      @options.fetch(key)
+    end
+    alias [] fetch
+  end
+end

data/lib/select_rails_log/printer/base_printer.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module SelectRailsLog
+  module Printer
+    class BasePrinter < Extension
+      include Constants
+
+      define_options :base_printer do
+        separator ""
+        separator "printer options:"
+
+        option :default_output, "--default-output PATH", "-O", "Output to file or directory"
+        option :exclude_debug_logs, "--exclude-debug-logs", "-x", "Exclude debug logs"
+      end
+
+      OUTPUT_FILE_DATETIME_FORMAT = "%Y%m%d-%H%M%S.%6N"
+      private_constant :OUTPUT_FILE_DATETIME_FORMAT
+
+      def initialize(options, standard_output)
+        super(options)
+
+        @common_options = @whole_options[:base_printer]
+        @output_file = @standard_output = standard_output
+        @output_filename = @output_directory = nil
+        init_output_destination
+
+        @prepared = false
+      end
+
+      def close
+        @output_file&.close unless output_directory? || output_stdout?
+      end
+
+      def print(data)
+        unless @prepared
+          prepare
+          @prepared = true
+        end
+
+        with_output(data) do |io|
+          print_data(io, data)
+        end
+      end
+
+      def runnable?
+        !!output_option
+      end
+
+      def output_stdout?
+        !output_directory? && @output_file == @standard_output
+      end
+
+      def output_directory?
+        !!@output_directory
+      end
+
+      private
+
+      def init_output_destination
+        dest = output_option
+        dest = @common_options[:default_output] if dest == DEFAULT_OUTPUT
+        return if !dest || dest == "-"
+
+        if dest.end_with?("/")
+          @output_directory = dest.chomp("/")
+        elsif File.directory?(dest)
+          @output_directory = dest
+        else
+          @output_filename = dest
+        end
+      end
+
+      def output_option
+        options.key?(:output) && options[:output]
+      end
+
+      def prepare
+        return unless @output_filename
+
+        @output_file = File.open(@output_filename, "w")
+      end
+
+      def with_output(data, &)
+        return yield(@output_file) unless output_directory?
+
+        FileUtils.mkdir_p(@output_directory)
+        File.open("#{@output_directory}/#{output_filename(data)}",
+                  File::CREAT | File::TRUNC | File::WRONLY, &)
+      end
+
+      def output_filename(data)
+        timestr = data[STARTED].strftime(OUTPUT_FILE_DATETIME_FORMAT)
+        "#{timestr}_#{data[ID]}#{self.class::SUFFIX}"
+      end
+
+      def print_data(_output, _data)
+        raise NotImplementedError
+      end
+
+      def each_log_with_index(data)
+        data[LOGS].each_with_index do |log, i|
+          next if @common_options[:exclude_debug_logs] && log[SEVERITY] == DEBUG
+
+          yield(log, i)
+        end
+      end
+
+      def each_log(data)
+        each_log_with_index(data) do |log, _i|
+          yield(log)
+        end
+      end
+    end
+  end
+end

data/lib/select_rails_log/printer/boxplot_printer.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "unicode_plot"
+require "io/console"
+
+module SelectRailsLog
+  module Printer
+    class BoxplotPrinter < BasePrinter
+      PLOT_TOTAL_DURATION = "Total duration"
+
+      define_options :boxplot_printer do
+        option :output, "--boxplot [FILE]", "-B", "Output statistics boxplot", default: DEFAULT_OUTPUT
+        option :min, "--boxplot-min MIN", "  Minimum value for boxplot", Float
+        option :max, "--boxplot-max MAX", "  Maximum value for boxplot", Float
+        option :width, "--boxplot-width NUM", "  Width of boxplot column", Integer
+      end
+
+      def initialize(*)
+        super
+
+        @plot_data = Hash.new { |h, k| h[k] = [] }
+        @controller_actions = Hash.new { |h, k| h[k] = {} }
+      end
+
+      def close
+        print_plot
+        super
+      end
+
+      private
+
+      def init_output_destination
+        super
+        return unless output_directory?
+
+        raise CommandLineOptionError, "output to directory is not supported for plot"
+      end
+
+      def print_plot
+        return if @plot_data.empty?
+
+        boxplot.render(@output_file)
+      end
+
+      def boxplot
+        opts = {
+          title: PLOT_TOTAL_DURATION,
+          data: @plot_data.keys.sort.each_with_object({}) { |k, h| h[k] = @plot_data[k] },
+          width: boxplot_width,
+          xlim: boxplot_xlim
+        }.compact
+        UnicodePlot.boxplot(**opts)
+      end
+
+      def boxplot_width
+        return options[:width] if options[:width]
+
+        begin
+          _rows, cols = @output_file.winsize
+        rescue Errno::ENOTTY, Errno::ENODEV, NoMethodError
+          return nil
+        end
+
+        cols - @plot_data.keys.map(&:size).max - 8
+      end
+
+      def boxplot_xlim
+        return unless options[:min] || options[:max]
+
+        [
+          options[:min] || 0,
+          options[:max] || 0
+        ]
+      end
+
+      def print_data(_output, data)
+        controller, action = data.values_at(CONTROLLER, ACTION)
+        controller_action = @controller_actions[controller][action] ||= "#{controller}##{action}"
+        @plot_data[controller_action] << data[DURATION]
+      end
+    end
+  end
+end

data/lib/select_rails_log/printer/data_serializable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SelectRailsLog
+  module Printer
+    module DataSerializable
+      include Constants
+
+      DATETIME_FORMAT = "%FT%T.%6N%:z"
+
+      private
+
+      def serialize_data(data)
+        serialized = data.slice(
+          REQUEST_ID, CONTROLLER, ACTION,
+          HTTP_STATUS, HTTP_METHOD, PATH, PARAMETERS, CLIENT,
+          DURATION, PERFORMANCE
+        )
+
+        serialized[STARTED] = strftime(data[STARTED])
+        serialized[COMPLETED] = strftime(data[COMPLETED])
+        serialized[PID] = data[PID].to_i
+        serialized[LOGS] = collect_logs(data)
+        serialized
+      end
+
+      def collect_logs(data)
+        logs = []
+
+        each_log(data) do |log|
+          logs << log.merge(TIME => strftime(log[TIME]))
+        end
+
+        logs
+      end
+
+      def strftime(time)
+        time&.strftime(DATETIME_FORMAT)
+      end
+    end
+  end
+end

data/lib/select_rails_log/printer/histgram_printer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "unicode_plot"
+
+module SelectRailsLog
+  module Printer
+    class HistgramPrinter < BasePrinter
+      PLOT_TOTAL_DURATION = "Total duration"
+
+      define_options :histgram_printer do
+        option :output, "--histgram [FILE]", "-H", "Output statistics histgram", default: DEFAULT_OUTPUT
+        option :nbins, "--histgram-nbins NUM", "  Number of bins for histgram", Integer
+      end
+
+      def initialize(*)
+        super
+
+        @plot_data = []
+      end
+
+      def close
+        print_plot
+        super
+      end
+
+      private
+
+      def init_output_destination
+        super
+        return unless output_directory?
+
+        raise CommandLineOptionError, "output to directory is not supported for plot"
+      end
+
+      def print_plot
+        return if @plot_data.empty?
+
+        UnicodePlot
+          .histogram(@plot_data, title: PLOT_TOTAL_DURATION, nbins: options[:nbins])
+          .render(@output_file)
+      end
+
+      def print_data(_output, data)
+        @plot_data << data[DURATION]
+      end
+    end
+  end
+end

data/lib/select_rails_log/printer/json_printer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "data_serializable"
+
+module SelectRailsLog
+  module Printer
+    class JsonPrinter < BasePrinter
+      include DataSerializable
+
+      SUFFIX = ".json"
+
+      define_options :json_printer do
+        option :output, "--json [PATH]", "-j", "Output in JSON format", default: DEFAULT_OUTPUT
+      end
+
+      def initialize(...)
+        super
+        @no_output = true
+      end
+
+      def close
+        @output_file.puts "]" unless output_directory?
+        super
+      end
+
+      private
+
+      def print_data(output, data)
+        unless output_directory?
+          if @no_output
+            output.print "["
+            @no_output = false
+          else
+            output.print ","
+          end
+        end
+
+        output.print JSON.fast_generate(serialize_data(data))
+        output.puts if output_directory?
+      end
+    end
+  end
+end

data/lib/select_rails_log/printer/jsonl_printer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "data_serializable"
+
+module SelectRailsLog
+  module Printer
+    class JsonlPrinter < BasePrinter
+      include DataSerializable
+
+      SUFFIX = ".jsonl"
+
+      define_options :jsonl_printer do
+        option :output, "--jsonl [PATH]", "-J", "Output in JSON Lines format", default: DEFAULT_OUTPUT
+      end
+
+      def runnable?
+        !!@options[:output]
+      end
+
+      private
+
+      def print_data(output, data)
+        output.puts JSON.fast_generate(serialize_data(data))
+      end
+    end
+  end
+end

data/lib/select_rails_log/printer/null_printer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SelectRailsLog
+  module Printer
+    class NullPrinter < BasePrinter
+      define_options :null_printer do
+        option :enabled, "--no-output", "-n", "No output", TrueClass
+      end
+
+      def runnable?
+        !!options[:enabled]
+      end
+
+      private
+
+      def print_data(...); end
+    end
+  end
+end

data/lib/select_rails_log/printer/raw_printer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SelectRailsLog
+  module Printer
+    class RawPrinter < BasePrinter
+      SUFFIX = ".log"
+      DATETIME_FORMAT = "%FT%T.%6N"
+
+      define_options :raw_printer do
+        option :output, "--raw [PATH]", "-r", "Output in raw format", default: DEFAULT_OUTPUT
+      end
+
+      private
+
+      def print_data(output, data)
+        return print_logs(output, data) unless data.key?(RAW_LOGS)
+
+        each_log_with_index(data) do |_log, index|
+          output.puts data[RAW_LOGS][index]
+        end
+      end
+
+      def print_logs(output, data)
+        pid, request_id = data.values_at(PID, REQUEST_ID)
+        reqid = "[#{request_id}] " if request_id
+        each_log(data) do |log|
+          print_log_line(output, pid, reqid, log)
+        end
+      end
+
+      def print_log_line(output, pid, reqid, log)
+        severity = log[SEVERITY]
+        output.printf(
+          "%<sev>s, [%<time>s #%<pid>d] %<severity>5s -- : %<reqid>s%<message>s\n",
+          sev: severity[0],
+          severity:,
+          pid:,
+          reqid:,
+          time: log[TIME].strftime(DATETIME_FORMAT),
+          message: log[MESSAGE]
+        )
+      end
+    end
+  end
+end