groonga-query-log 1.4.4 → 1.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: faeaa6fd86742d02ee7dd26056139a4cc4d267d10e5d18ae70bfb343ab946439
-  data.tar.gz: 4288f0e864a772a278d01bfd0d818d8d7f342234c883e2945025e4a8c881935f
+  metadata.gz: 4bc397a48e26c377cab3315458cc8da30cb80cd7efd00bdea36595d7f6cb8bd7
+  data.tar.gz: 142b467fd6d1b809e4ca2c8b06c826084488dc6cf48aabc387e2dbe22edf0688
 SHA512:
-  metadata.gz: de6b0181aa230461a7cfc90aa611587d5458aef929c8c6b85dfacb176f9052ac3ae62525ae86797338f629e330998c60712b6e7f604765cfaddeb2a0c321c648
-  data.tar.gz: 6cdb79c3619951d64ede9dabbce9c136a19bc4b6e7bc23ecfe07c92696be633217478ee7e7dac2c3fc9fd99ab496f6001c085dc956921508fe49a98a63fc6ac3
+  metadata.gz: 49862f644474605b03c770c8bd88ca4469a1d234f6b13fc707147ea6ff3c1d82b3f8aa883b35e9fefc09e6c4f58b12c66e9f899a1daf96f4342cc03ffa4969fd
+  data.tar.gz: cd8283475cab0a4cfdd4f3d2ae6d8d5b42ecc9b09b8877185a07a660fd44819910a372cb472620e0e65444ac762ec729387c5d53dee299eba1f3dbade445b2d5

data/bin/groonga-query-log-check-performance-regression

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+#
+# Copyright (C) 2019 Kentaro hayashi <hayashi@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "groonga-query-log/command/check-performance-regression"
+
+checker = GroongaQueryLog::Command::CheckPerformanceRegression.new
+exit(checker.run(ARGV))

data/doc/text/news.md

@@ -1,5 +1,19 @@
 # News
 
+## 1.4.5: 2019-08-15
+
+### Improvements
+
+  * `groonga-query-log-check-performance-regression`:
+
+    * Added feature for checking deterioration of performance.
+
+### Fixes
+
+  * `groonga-query-log-run-regression-test`:
+
+    * Fixed a bug that `--rewrite-and-not-operator` option doesn't work.
+
 ## 1.4.4: 2019-08-05
 
 ### Improvements

data/lib/groonga-query-log/command/check-performance-regression.rb

@@ -0,0 +1,447 @@
+# Copyright (C) 2019 Kentaro Hayashi <hayashi@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "optparse"
+require "json"
+
+require "groonga-query-log"
+require "groonga-query-log/command-line"
+
+require "groonga-query-log/command/analyzer"
+require "groonga-query-log/command/analyzer/sized-statistics"
+
+module GroongaQueryLog
+  module Command
+    class CheckPerformanceRegression < CommandLine
+      NSEC_IN_SECONDS = (1000 * 1000 * 1000)
+      USEC_IN_SECONDS = (1000 * 1000)
+      MSEC_IN_SECONDS = 1000
+
+      def initialize(options={})
+        setup_options(options)
+      end
+
+      def run(arguments)
+        paths = []
+        begin
+          paths = @option_parser.parse!(arguments)
+        rescue OptionParser::InvalidOption => error
+          $stderr.puts(error)
+          return false
+        end
+
+        if paths.size != 2
+          $stderr.puts("old query log and new query log must be specified.")
+          return false
+        end
+
+        old_query_paths = resolve_path(paths[0])
+        return false if old_query_paths.nil?
+        new_query_paths = resolve_path(paths[1])
+        return false if new_query_paths.nil?
+
+        old_statistics = analyze(old_query_paths)
+        return false if old_statistics.nil?
+        new_statistics = analyze(new_query_paths)
+        return false if new_statistics.nil?
+
+        open_output do |output|
+          checker = Checker.new(old_statistics,
+                                new_statistics,
+                                output,
+                                @threshold,
+                                @target_queries)
+          checker.check
+        end
+      end
+
+      private
+      def resolve_path(path)
+        if File.directory?(path)
+          Dir.glob("#{path}/*.log")
+        elsif File.exist?(path)
+          [path]
+        else
+          $stderr.puts("query log path doesn't exist: <#{path}>")
+          nil
+        end
+      end
+
+      def open_output(&block)
+        case @output
+        when "-"
+          yield($stdout)
+        when String
+          File.open(@output, "w", &block)
+        else
+          yield(@output)
+        end
+      end
+
+      def setup_options(options)
+        @output = options[:output] || "-"
+        @n_entries = 1000
+        @threshold = Threshold.new
+        @target_queries = []
+
+        @option_parser = OptionParser.new do |parser|
+          parser.version = VERSION
+          parser.banner += " OLD_QUERY_LOG NEW_QUERY_LOG"
+
+          parser.on("-n", "--n-entries=N",
+                    Integer,
+                    "Analyze N query log entries",
+                    "(#{@n_entries})") do |n|
+            @n_entries = n
+          end
+
+          if @output == "-"
+            default_output = "stdout"
+          else
+            default_output = @output
+          end
+          parser.on("--output=PATH",
+                    "Output to PATH.",
+                    "(#{default_output})") do |output|
+            @output = output
+          end
+
+          parser.on("--target-query-file=TARGET_QUERY_FILE",
+                    "Analyze matched queries which are listed " +
+                    "in specified TARGET_QUERY_FILE.") do |path|
+            if File.exist?(path)
+              @target_queries = File.readlines(path, chomp: true)
+            else
+              message = "target query file doesn't exist: <#{path}>"
+              raise OptionParser::InvalidOption.new(message)
+            end
+          end
+
+          parser.on("--slow-query-ratio=RATIO",
+                    Float,
+                    "Use RATIO as threshold to detect slow queries.",
+                    "If MEAN_NEW_ELAPSED_TIME / MEAN_OLD_ELAPSED_TIME AVERAGE",
+                    "is larger than RATIO, the query is slow.",
+                    "(#{@threshold.query_ratio})") do |ratio|
+            @threshold.query_ratio = ratio
+          end
+
+          parser.on("--slow-query-second=SECOND",
+                    Float,
+                    "Use SECOND as threshold to detect slow queries.",
+                    "If MEAN_NEW_ELAPSED_TIME - MEAN_OLD_ELAPSED_TIME AVERAGE",
+                    "is larger than SECOND, the query is slow.",
+                    "(#{@threshold.query_second})") do |second|
+            @threshold.query_second = second
+          end
+
+          parser.on("--slow-operation-ratio=RATIO",
+                    Float,
+                    "Use RATIO as threshold to detect slow operations.",
+                    "If MEAN_NEW_ELAPSED_TIME / MEAN_OLD_ELAPSED_TIME AVERAGE",
+                    "is larger than RATIO, the operation is slow.",
+                    "(#{@threshold.operation_ratio})") do |ratio|
+            @threshold.operation_ratio = ratio
+          end
+
+          parser.on("--slow-operation-second=SECOND",
+                    Float,
+                    "Use SECOND as threshold to detect slow operations.",
+                    "If MEAN_NEW_ELAPSED_TIME - MEAN_OLD_ELAPSED_TIME AVERAGE",
+                    "is larger than SECOND, the operation is slow.",
+                    "(#{@threshold.operation_second})") do |second|
+            @threshold.operation_second = second
+          end
+        end
+      end
+
+
+      def analyze(log_paths)
+        full_statistics = []
+        begin
+          n = 1
+          parser = Parser.new
+          parse_log(parser, log_paths) do |statistic|
+            next if n > @n_entries
+            full_statistics << statistic
+            n += 1
+          end
+        rescue Error
+          $stderr.puts($!.message)
+          return nil
+        end
+        full_statistics
+      end
+
+      class Threshold
+        attr_accessor :query_ratio
+        attr_accessor :query_second
+        attr_accessor :operation_ratio
+        attr_accessor :operation_second
+        def initialize
+          @query_ratio = 0
+          @query_second = 0.2
+          @operation_ratio = 0.1
+          @operation_second = 0.1
+        end
+
+        def slow_query?(diff_sec, diff_ratio)
+          return false if diff_sec.zero?
+          (diff_sec >= @query_second) and
+            (diff_ratio >= @query_ratio)
+        end
+
+        def slow_operation?(diff_sec, diff_ratio)
+          return false if diff_sec.zero?
+          (diff_sec >= @operation_second) and
+            (diff_ratio >= @operation_ratio)
+        end
+      end
+
+      class Statistic
+        def initialize(old, new, threshold)
+          @old = old
+          @new = new
+          @threshold = threshold
+        end
+
+        def old_elapsed_time
+          @old_elapsed_time ||= compute_mean(@old)
+        end
+
+        def new_elapsed_time
+          @new_elapsed_time ||= compute_mean(@new)
+        end
+
+        def diff_elapsed_time
+          new_elapsed_time - old_elapsed_time
+        end
+
+        def ratio
+          @ratio ||= compute_ratio
+        end
+
+        private
+        def compute_ratio
+          if old_elapsed_time.zero?
+            if new_elapsed_time.zero?
+              0.0
+            else
+              Float::INIFINITY
+            end
+          else
+            new_elapsed_time / old_elapsed_time
+          end
+        end
+      end
+
+      class OperationStatistic < Statistic
+        attr_reader :index
+        def initialize(operation, index, old, new, threshold)
+          super(old, new, threshold)
+          @operation = operation
+          @index = index
+        end
+
+        def name
+          @operation[:name]
+        end
+
+        def context
+          @operation[:context]
+        end
+
+        def slow?
+          @threshold.slow_operation?(diff_elapsed_time, ratio)
+        end
+
+        private
+        def compute_mean(operations)
+          elapsed_times = operations.collect do |operation|
+            operation[:relative_elapsed] / 1000.0 / 1000.0 / 1000.0
+          end
+          elapsed_times.inject(:+) / elapsed_times.size
+        end
+      end
+
+      class QueryStatistic < Statistic
+        attr_reader :query
+        def initialize(query, old, new, threshold)
+          super(old, new, threshold)
+          @query = query
+        end
+
+        def slow?
+          @threshold.slow_query?(diff_elapsed_time, ratio)
+        end
+
+        def each_operation_statistic
+          @old.first.operations.each_with_index do |operation, i|
+            old_operations = @old.collect do |statistic|
+              statistic.operations[i]
+            end
+            # TODO: old and new may use different index
+            new_operations = @new.collect do |statistic|
+              statistic.operations[i]
+            end
+            operation_statistic = OperationStatistic.new(operation,
+                                                         i,
+                                                         old_operations,
+                                                         new_operations,
+                                                         @threshold)
+            yield(operation_statistic)
+          end
+        end
+
+        private
+        def compute_mean(statistics)
+          elapsed_times = statistics.collect do |statistic|
+            statistic.elapsed / 1000.0 / 1000.0 / 1000.0
+          end
+          elapsed_times.inject(:+) / elapsed_times.size
+        end
+      end
+
+      class Checker
+        def initialize(old_statistics,
+                       new_statistics,
+                       output,
+                       threshold,
+                       target_queries)
+          @old_statistics = old_statistics
+          @new_statistics = new_statistics
+          @output = output
+          @threshold = threshold
+          @target_queries = target_queries
+        end
+
+        def check
+          old_statistics = filter_statistics(@old_statistics)
+          new_statistics = filter_statistics(@new_statistics)
+          old_queries = old_statistics.group_by(&:raw_command)
+          new_queries = new_statistics.group_by(&:raw_command)
+
+          query_statistics = []
+          old_queries.each_key do |query|
+            query_statistic = QueryStatistic.new(query,
+                                                 old_queries[query],
+                                                 new_queries[query],
+                                                 @threshold)
+            next unless query_statistic.slow?
+            query_statistics << query_statistic
+          end
+
+          n_slow_queries = 0
+          n_target_operations = 0
+          n_slow_operations = 0
+          query_statistics.sort_by(&:ratio).each do |query_statistic|
+            n_slow_queries += 1
+            @output.puts(<<-REPORT)
+Query: #{query_statistic.query}
+  Mean (old): #{format_elapsed_time(query_statistic.old_elapsed_time)}
+  Mean (new): #{format_elapsed_time(query_statistic.new_elapsed_time)}
+  Diff:       #{format_diff(query_statistic)}
+  Operations:
+            REPORT
+            query_statistic.each_operation_statistic do |operation_statistic|
+              n_target_operations += 1
+              next unless operation_statistic.slow?
+
+              n_slow_operations += 1
+              index = operation_statistic.index
+              name = operation_statistic.name
+              context = operation_statistic.context
+              label = [name, context].compact.join(" ")
+              old_elapsed_time = operation_statistic.old_elapsed_time
+              new_elapsed_time = operation_statistic.new_elapsed_time
+              @output.puts(<<-REPORT)
+    Operation[#{index}]: #{label}
+      Mean (old): #{format_elapsed_time(old_elapsed_time)}
+      Mean (new): #{format_elapsed_time(new_elapsed_time)}
+      Diff:       #{format_diff(operation_statistic)}
+              REPORT
+            end
+          end
+
+          n_all_queries = @old_statistics.size
+          n_target_queries = old_queries.size
+          n_old_cached_queries = count_cached_queries(@old_statistics)
+          n_new_cached_queries = count_cached_queries(@new_statistics)
+          @output.puts(<<-REPORT)
+Summary:
+  Slow queries:    #{format_summary(n_slow_queries, n_target_queries)}
+  Slow operations: #{format_summary(n_slow_operations, n_target_operations)}
+  Caches (old):    #{format_summary(n_old_cached_queries, n_all_queries)}
+  Caches (new):    #{format_summary(n_new_cached_queries, n_all_queries)}
+          REPORT
+          true
+        end
+
+        private
+        def count_cached_queries(statistics)
+          n_cached_queries = 0
+          statistics.each do |statistic|
+            n_cached_queries += 1 if statistic.cache_used?
+          end
+          n_cached_queries
+        end
+
+        def filter_statistics(statistics)
+          statistics.find_all do |statistic|
+            target_statistic?(statistic)
+          end
+        end
+
+        def target_statistic?(statistic)
+          return false if statistic.cache_used?
+          return true if @target_queries.empty?
+          @target_queries.include?(statistic.raw_command)
+        end
+
+        def format_elapsed_time(elapsed_time)
+          if elapsed_time < (1 / 1000.0 / 1000.0)
+            "%.1fnsec" % (elapsed_time * 1000 * 1000)
+          elsif elapsed_time < (1 / 1000.0)
+            "%.1fusec" % (elapsed_time * 1000 * 1000)
+          elsif elapsed_time < 1
+            "%.1fmsec" % (elapsed_time * 1000)
+          elsif elapsed_time < 60
+            "%.1fsec" % elapsed_time
+          else
+            "%.1fmin" % (elapsed_time / 60)
+          end
+        end
+
+        def format_diff(statistic)
+          "%s%s/%+.2f" % [
+            statistic.diff_elapsed_time < 0 ? "-" : "+",
+            format_elapsed_time(statistic.diff_elapsed_time),
+            statistic.ratio,
+          ]
+        end
+
+        def format_summary(n_slows, total)
+          if total.zero?
+            percentage = 0.0
+          else
+            percentage = (n_slows / total.to_f) * 100
+          end
+          "%d/%d(%6.2f%%)" % [n_slows, total, percentage]
+        end
+      end
+    end
+  end
+end

data/lib/groonga-query-log/command/run-regression-test.rb

@@ -338,7 +338,7 @@ module GroongaQueryLog
             @nullable_reference_number_accessors,
           :rewrite_not_or_regular_expression =>
             @rewrite_not_or_regular_expression,
-          :rewite_and_not_operator =>
+          :rewrite_and_not_operator =>
             @rewrite_and_not_operator,
           :target_command_names => @target_command_names,
           :read_timeout => @read_timeout,

data/lib/groonga-query-log/statistic.rb

@@ -61,6 +61,12 @@ module GroongaQueryLog
       elapsed_in_seconds >= @slow_response_threshold
     end
 
+    def cache_used?
+      each_operation.any? do |operation|
+        operation[:name] == "cache"
+      end
+    end
+
     def each_operation
       return to_enum(__method__) unless block_given?
 

data/lib/groonga-query-log/version.rb

@@ -15,5 +15,5 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 module GroongaQueryLog
-  VERSION = "1.4.4"
+  VERSION = "1.4.5"
 end

data/test/command/test-check-performance-regression.rb

@@ -0,0 +1,311 @@
+# Copyright (C) 2019  Kentaro Hayashi <hayashi@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "groonga-query-log/command/check-performance-regression"
+
+class CheckPerformanceRegressionCommandTest < Test::Unit::TestCase
+  include Helper::Path
+
+  def setup
+    @command = GroongaQueryLog::Command::CheckPerformanceRegression.new
+  end
+
+  def fixture_path(*components)
+    super("check-performance-regression", *components)
+  end
+
+  def run_command(*arguments)
+    output = StringIO.new
+    options = {:output => output}
+    command = GroongaQueryLog::Command::CheckPerformanceRegression.new(options)
+    command.run(arguments)
+    output.string
+  end
+
+  sub_test_case("options") do
+    MISSING_QUERY_LOG_ERROR = <<-OUTPUT
+old query log and new query log must be specified.
+    OUTPUT
+
+    def run_command_with_stderr
+      begin
+        output = StringIO.new
+        $stderr = output
+        yield
+        output.string
+      ensure
+        $stderr = STDERR
+      end
+    end
+
+    def test_no_option
+      actual = run_command_with_stderr do
+        @command.run([])
+      end
+      assert_equal(MISSING_QUERY_LOG_ERROR, actual)
+    end
+
+    def test_too_few_query_logs
+      actual = run_command_with_stderr do
+        @command.run([
+          fixture_path("query1.log")
+        ])
+      end
+      assert_equal(MISSING_QUERY_LOG_ERROR, actual)
+    end
+
+    def test_too_many_query_logs
+      actual = run_command_with_stderr do
+        @command.run([
+          fixture_path("query1.log"),
+          fixture_path("query2.log"),
+          fixture_path("query1.log")
+        ])
+      end
+      assert_equal(MISSING_QUERY_LOG_ERROR, actual)
+    end
+
+    def test_nonexistent_input_old_query
+      actual = run_command_with_stderr do
+        @command.run([
+          fixture_path("nonexsistent.log"),
+          fixture_path("query2.log")
+        ])
+      end
+      assert_equal(<<-OUTPUT, actual)
+query log path doesn't exist: <#{fixture_path("nonexsistent.log")}>
+      OUTPUT
+    end
+
+    def test_nonexistent_input_new_query
+      actual = run_command_with_stderr do
+        @command.run([
+          fixture_path("query1.log"),
+          fixture_path("nonexsistent.log")
+        ])
+      end
+      assert_equal(<<-OUTPUT, actual)
+query log path doesn't exist: <#{fixture_path("nonexsistent.log")}>
+      OUTPUT
+    end
+
+    def test_output
+      Tempfile.open('test_output') do |output|
+        @command.run([
+                       "--slow-query-ratio=0",
+                       "--slow-query-second=0",
+                       "--slow-operation-ratio=0",
+                       "--slow-operation-second=0",
+                       "--output=#{output.path}",
+                       fixture_path("query1.log"),
+                       fixture_path("query2.log")
+                     ])
+        expected = <<-OUTPUT
+Query: select --table Site --limit 0
+  Mean (old): 12.0msec
+  Mean (new): 14.0msec
+  Diff:       +2.0msec/+1.17
+  Operations:
+    Operation[0]: select
+      Mean (old): 5.0msec
+      Mean (new): 6.0msec
+      Diff:       +1.0msec/+1.20
+Summary:
+  Slow queries:    1/1(100.00%)
+  Slow operations: 1/2( 50.00%)
+  Caches (old):    0/1(  0.00%)
+  Caches (new):    0/1(  0.00%)
+      OUTPUT
+        assert_equal(expected, output.read)
+      end
+    end
+
+    def test_n_query
+      actual = run_command("--n-entries=1",
+                           "--slow-query-ratio=0",
+                           "--slow-query-second=0",
+                           "--slow-operation-ratio=0",
+                           "--slow-operation-second=0",
+                           fixture_path("nquery.log"),
+                           fixture_path("nquery2.log"))
+      expected = <<-OUTPUT
+Query: select --table Site --filter "_id >= 4 && _id <= 6"
+  Mean (old): 70.0msec
+  Mean (new): 90.0msec
+  Diff:       +20.0msec/+1.29
+  Operations:
+    Operation[0]: filter #<accessor _id(Site)> greater_equal 4
+      Mean (old): 40.0msec
+      Mean (new): 80.0msec
+      Diff:       +40.0msec/+2.00
+    Operation[1]: filter #<accessor _id(Site)> less_equal 6
+      Mean (old): 10.0msec
+      Mean (new): 20.0msec
+      Diff:       +10.0msec/+2.00
+    Operation[2]: select
+      Mean (old): 10.0msec
+      Mean (new): 20.0msec
+      Diff:       +10.0msec/+2.00
+    Operation[3]: output
+      Mean (old): 10.0msec
+      Mean (new): 20.0msec
+      Diff:       +10.0msec/+2.00
+Summary:
+  Slow queries:    1/1(100.00%)
+  Slow operations: 4/4(100.00%)
+  Caches (old):    0/1(  0.00%)
+  Caches (new):    0/1(  0.00%)
+      OUTPUT
+      assert_equal(expected, actual)
+    end
+  end
+
+  sub_test_case(".new") do
+    def test_output
+      actual = run_command("--slow-query-ratio=0.0",
+                           "--slow-query-second=0.0",
+                           "--slow-operation-ratio=0.0",
+                           "--slow-operation-second=0.0",
+                           fixture_path("query1.log"),
+                           fixture_path("query2.log"))
+      expected = <<-OUTPUT
+Query: select --table Site --limit 0
+  Mean (old): 12.0msec
+  Mean (new): 14.0msec
+  Diff:       +2.0msec/+1.17
+  Operations:
+    Operation[0]: select
+      Mean (old): 5.0msec
+      Mean (new): 6.0msec
+      Diff:       +1.0msec/+1.20
+Summary:
+  Slow queries:    1/1(100.00%)
+  Slow operations: 1/2( 50.00%)
+  Caches (old):    0/1(  0.00%)
+  Caches (new):    0/1(  0.00%)
+      OUTPUT
+      assert_equal(expected, actual)
+    end
+  end
+
+  sub_test_case("query-ratio") do
+    def test_filtered
+      actual = run_command("--slow-query-ratio=2",
+                           "--slow-query-second=0",
+                           "--slow-operation-ratio=0",
+                           "--slow-operation-second=0",
+                           fixture_path("query1.log"),
+                           fixture_path("query2.log"))
+      expected = <<-OUTPUT
+Summary:
+  Slow queries:    0/1(  0.00%)
+  Slow operations: 0/0(  0.00%)
+  Caches (old):    0/1(  0.00%)
+  Caches (new):    0/1(  0.00%)
+      OUTPUT
+      assert_equal(expected, actual)
+    end
+  end
+
+  sub_test_case("operation-ratio") do
+    def test_filtered
+      actual = run_command("--slow-query-ratio=0",
+                           "--slow-query-second=0",
+                           "--slow-operation-ratio=2",
+                           "--slow-operation-second=0",
+                           fixture_path("query1.log"),
+                           fixture_path("query2.log"))
+      expected = <<-OUTPUT
+Query: select --table Site --limit 0
+  Mean (old): 12.0msec
+  Mean (new): 14.0msec
+  Diff:       +2.0msec/+1.17
+  Operations:
+Summary:
+  Slow queries:    1/1(100.00%)
+  Slow operations: 0/2(  0.00%)
+  Caches (old):    0/1(  0.00%)
+  Caches (new):    0/1(  0.00%)
+      OUTPUT
+      assert_equal(expected, actual)
+    end
+  end
+
+  sub_test_case("query-second") do
+    def test_filtered
+      actual = run_command("--slow-query-ratio=0",
+                           "--slow-query-second=0.02",
+                           "--slow-operation-ratio=0",
+                           "--slow-operation-second=0",
+                           fixture_path("query1.log"),
+                           fixture_path("query2.log"))
+      expected = <<-OUTPUT
+Summary:
+  Slow queries:    0/1(  0.00%)
+  Slow operations: 0/0(  0.00%)
+  Caches (old):    0/1(  0.00%)
+  Caches (new):    0/1(  0.00%)
+      OUTPUT
+      assert_equal(expected, actual)
+    end
+  end
+
+  sub_test_case("operation-second") do
+    def test_filtered
+      actual = run_command("--slow-query-ratio=0",
+                           "--slow-query-second=0",
+                           "--slow-operation-ratio=0",
+                           "--slow-operation-second=0.001",
+                           fixture_path("query1.log"),
+                           fixture_path("query2.log"))
+      expected = <<-OUTPUT
+Query: select --table Site --limit 0
+  Mean (old): 12.0msec
+  Mean (new): 14.0msec
+  Diff:       +2.0msec/+1.17
+  Operations:
+    Operation[0]: select
+      Mean (old): 5.0msec
+      Mean (new): 6.0msec
+      Diff:       +1.0msec/+1.20
+Summary:
+  Slow queries:    1/1(100.00%)
+  Slow operations: 1/2( 50.00%)
+  Caches (old):    0/1(  0.00%)
+  Caches (new):    0/1(  0.00%)
+      OUTPUT
+      assert_equal(expected, actual)
+    end
+  end
+
+  sub_test_case("cache") do
+    def test_ignored_cache
+      actual = run_command("--slow-query-ratio=0",
+                           "--slow-operation-ratio=0",
+                           "--slow-query-second=0",
+                           fixture_path("cache.log"),
+                           fixture_path("cache.log"))
+      expected = <<-OUTPUT
+Summary:
+  Slow queries:    0/0(  0.00%)
+  Slow operations: 0/0(  0.00%)
+  Caches (old):    1/1(100.00%)
+  Caches (new):    1/1(100.00%)
+      OUTPUT
+      assert_equal(expected, actual)
+    end
+  end
+end

data/test/fixtures/check-performance-regression/cache.log

@@ -0,0 +1,3 @@
+2019-01-22 16:00:00.000000|0x7ffc70f60080|>select --table Site --limit 0
+2019-01-22 16:00:01.500000|0x7ffc70f60080|:000000006000000 cache(1)
+2019-01-22 16:00:03.000000|0x7ffc70f60080|<000000014000000 rc=0

data/test/fixtures/check-performance-regression/nquery.log

@@ -0,0 +1,10 @@
+2019-01-24 08:18:33.921596|0x7ffd9e258a40|>select --table Site --filter "_id >= 4 && _id <= 6"
+2019-01-24 08:18:33.968258|0x7ffd9e258a40|:000000040000000 filter(6): #<accessor _id(Site)> greater_equal 4
+2019-01-24 08:18:33.968917|0x7ffd9e258a40|:000000050000000 filter(3): #<accessor _id(Site)> less_equal 6
+2019-01-24 08:18:33.968940|0x7ffd9e258a40|:000000060000000 select(3)
+2019-01-24 08:18:33.969085|0x7ffd9e258a40|:000000070000000 output(3)
+2019-01-24 08:18:33.969311|0x7ffd9e258a40|<000000070000000 rc=0
+2019-01-24 08:19:05.449799|0x7ffe40eafa50|>select --table Site
+2019-01-24 08:19:05.450416|0x7ffe40eafa50|:000000000600000 select(9)
+2019-01-24 08:19:05.450706|0x7ffe40eafa50|:000000000900000 output(9)
+2019-01-24 08:19:05.451271|0x7ffe40eafa50|<000000001400000 rc=0

data/test/fixtures/check-performance-regression/nquery2.log

@@ -0,0 +1,10 @@
+2019-01-24 08:18:33.921596|0x7ffd9e258a40|>select --table Site --filter "_id >= 4 && _id <= 6"
+2019-01-24 08:18:33.968258|0x7ffd9e258a40|:000000080000000 filter(6): #<accessor _id(Site)> greater_equal 4
+2019-01-24 08:18:33.968917|0x7ffd9e258a40|:000000100000000 filter(3): #<accessor _id(Site)> less_equal 6
+2019-01-24 08:18:33.968940|0x7ffd9e258a40|:000000120000000 select(3)
+2019-01-24 08:18:33.969085|0x7ffd9e258a40|:000000140000000 output(3)
+2019-01-24 08:18:33.969311|0x7ffd9e258a40|<000000090000000 rc=0
+2019-01-24 08:19:05.449799|0x7ffe40eafa50|>select --table Site
+2019-01-24 08:19:05.450416|0x7ffe40eafa50|:000000000600000 select(9)
+2019-01-24 08:19:05.450706|0x7ffe40eafa50|:000000000900000 output(9)
+2019-01-24 08:19:05.451271|0x7ffe40eafa50|<000000001400000 rc=0

data/test/fixtures/check-performance-regression/query1.log

@@ -0,0 +1,4 @@
+2019-01-22 15:00:57.466438|0x7ffc70f60080|>select --table Site --limit 0
+2019-01-22 15:00:57.472248|0x7ffc70f60080|:000000005000000 select(1)
+2019-01-22 15:00:57.475195|0x7ffc70f60080|:000000007000000 output(0)
+2019-01-22 15:00:57.475480|0x7ffc70f60080|<000000012000000 rc=0

data/test/fixtures/check-performance-regression/query2.log

@@ -0,0 +1,4 @@
+2019-01-22 16:00:00.000000|0x7ffc70f60080|>select --table Site --limit 0
+2019-01-22 16:00:01.500000|0x7ffc70f60080|:000000006000000 select(1)
+2019-01-22 16:00:02.000000|0x7ffc70f60080|:000000008000000 output(0)
+2019-01-22 16:00:03.000000|0x7ffc70f60080|<000000014000000 rc=0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: groonga-query-log
 version: !ruby/object:Gem::Version
-  version: 1.4.4
+  version: 1.4.5
 platform: ruby
 authors:
 - Kouhei Sutou
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-07 00:00:00.000000000 Z
+date: 2019-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: groonga-command-parser
@@ -154,17 +154,18 @@ description: ''
 email:
 - kou@clear-code.com
 executables:
-- groonga-query-log-format-regression-test-logs
-- groonga-query-log-run-regression-test
+- groonga-query-log-detect-memory-leak
+- groonga-query-log-analyze
 - groonga-query-log-check-crash
 - groonga-query-log-replay
+- groonga-query-log-extract
+- groonga-query-log-show-running-queries
 - groonga-query-log-check-command-version-compatibility
+- groonga-query-log-run-regression-test
 - groonga-query-log-verify-server
-- groonga-query-log-show-running-queries
-- groonga-query-log-analyze
-- groonga-query-log-extract
-- groonga-query-log-detect-memory-leak
 - groonga-query-log-analyze-load
+- groonga-query-log-format-regression-test-logs
+- groonga-query-log-check-performance-regression
 extensions: []
 extra_rdoc_files: []
 files:
@@ -176,6 +177,7 @@ files:
 - bin/groonga-query-log-analyze-load
 - bin/groonga-query-log-check-command-version-compatibility
 - bin/groonga-query-log-check-crash
+- bin/groonga-query-log-check-performance-regression
 - bin/groonga-query-log-detect-memory-leak
 - bin/groonga-query-log-extract
 - bin/groonga-query-log-format-regression-test-logs
@@ -203,6 +205,7 @@ files:
 - lib/groonga-query-log/command/analyzer/streamer.rb
 - lib/groonga-query-log/command/check-command-version-compatibility.rb
 - lib/groonga-query-log/command/check-crash.rb
+- lib/groonga-query-log/command/check-performance-regression.rb
 - lib/groonga-query-log/command/detect-memory-leak.rb
 - lib/groonga-query-log/command/extract.rb
 - lib/groonga-query-log/command/format-regression-test-logs.rb
@@ -230,9 +233,15 @@ files:
 - lib/groonga/query-log/command/show-running-queries.rb
 - lib/groonga/query-log/command/verify-server.rb
 - test/command/test-analyzer.rb
+- test/command/test-check-performance-regression.rb
 - test/command/test-extract.rb
 - test/command/test-format-regression-test-logs.rb
 - test/command/test-run-regression-test.rb
+- test/fixtures/check-performance-regression/cache.log
+- test/fixtures/check-performance-regression/nquery.log
+- test/fixtures/check-performance-regression/nquery2.log
+- test/fixtures/check-performance-regression/query1.log
+- test/fixtures/check-performance-regression/query2.log
 - test/fixtures/multi.expected
 - test/fixtures/n_entries.expected
 - test/fixtures/no-report-summary.expected
@@ -289,36 +298,42 @@ summary: Groonga-query-log is a collection of library and tools to process [Groo
   as a library. You can analyze your Groonga's queries and test with your Groonga's
   query log by using groonga-query-log as a tool.
 test_files:
-- test/fixtures/reporter/console.expected
-- test/fixtures/reporter/html.expected
-- test/fixtures/reporter/json-stream.expected
-- test/fixtures/reporter/json.expected
-- test/fixtures/order/start-time.expected
+- test/run-test.rb
+- test/fixtures/n_entries.expected
+- test/fixtures/check-performance-regression/query1.log
+- test/fixtures/check-performance-regression/cache.log
+- test/fixtures/check-performance-regression/nquery2.log
+- test/fixtures/check-performance-regression/nquery.log
+- test/fixtures/check-performance-regression/query2.log
+- test/fixtures/target-tables.expected
+- test/fixtures/no-report-summary.expected
 - test/fixtures/order/-start-time.expected
 - test/fixtures/order/-elapsed.expected
+- test/fixtures/order/start-time.expected
 - test/fixtures/order/elapsed.expected
-- test/fixtures/no-report-summary.expected
-- test/fixtures/target-commands.expected
-- test/fixtures/run-regression-test/data/data.grn
-- test/fixtures/run-regression-test/query-logs/query.log
-- test/fixtures/run-regression-test/indexes/indexes.grn
-- test/fixtures/run-regression-test/schema/schema.grn
-- test/fixtures/other-query.log
-- test/fixtures/query.log
-- test/fixtures/target-tables.expected
-- test/fixtures/n_entries.expected
-- test/fixtures/multi.expected
-- test/fixtures/regression-test-logs/command-format.log
 - test/fixtures/regression-test-logs/url-format.log
+- test/fixtures/regression-test-logs/command-format.log
 - test/fixtures/regression-test-logs/error.log
+- test/fixtures/multi.expected
+- test/fixtures/query.log
+- test/fixtures/other-query.log
+- test/fixtures/reporter/json-stream.expected
+- test/fixtures/reporter/console.expected
+- test/fixtures/reporter/json.expected
+- test/fixtures/reporter/html.expected
+- test/fixtures/run-regression-test/schema/schema.grn
+- test/fixtures/run-regression-test/data/data.grn
+- test/fixtures/run-regression-test/indexes/indexes.grn
+- test/fixtures/run-regression-test/query-logs/query.log
+- test/fixtures/target-commands.expected
+- test/test-parser.rb
+- test/helper.rb
+- test/test-replayer.rb
+- test/test-response-comparer.rb
 - test/command/test-run-regression-test.rb
+- test/command/test-check-performance-regression.rb
 - test/command/test-format-regression-test-logs.rb
 - test/command/test-analyzer.rb
 - test/command/test-extract.rb
-- test/test-response-comparer.rb
-- test/test-replayer.rb
 - test/test-incompatibility-detector.rb
 - test/test-filter-rewriter.rb
-- test/test-parser.rb
-- test/helper.rb
-- test/run-test.rb