jmeter_perf 1.0.9

data/lib/jmeter_perf/plugins/response_times_over_time.rb

@@ -0,0 +1,53 @@
+module JmeterPerf
+  module Plugins
+    class ResponseTimesOverTime
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ResponseTimesOverTime" : (params[:name] || "ResponseTimesOverTime")
+        @doc = Nokogiri::XML(
+          JmeterPerf::Helpers::String.strip_heredoc(
+            <<-EOF
+              <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseTimesOverTimeGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{testname}" enabled="#{enabled(params)}">
+                <boolProp name="ResultCollector.error_logging">false</boolProp>
+                <objProp>
+                  <name>saveConfig</name>
+                  <value class="SampleSaveConfiguration">
+                    <time>true</time>
+                    <latency>true</latency>
+                    <timestamp>true</timestamp>
+                    <success>true</success>
+                    <label>true</label>
+                    <code>true</code>
+                    <message>true</message>
+                    <threadName>true</threadName>
+                    <dataType>true</dataType>
+                    <encoding>false</encoding>
+                    <assertions>true</assertions>
+                    <subresults>true</subresults>
+                    <responseData>false</responseData>
+                    <samplerData>false</samplerData>
+                    <xml>true</xml>
+                    <fieldNames>false</fieldNames>
+                    <responseHeaders>false</responseHeaders>
+                    <requestHeaders>false</requestHeaders>
+                    <responseDataOnError>false</responseDataOnError>
+                    <saveAssertionResultsFailureMessage>false</saveAssertionResultsFailureMessage>
+                    <assertionsResultsToSave>0</assertionsResultsToSave>
+                    <bytes>true</bytes>
+                  </value>
+                </objProp>
+                <stringProp name="filename"></stringProp>
+                <longProp name="interval_grouping">500</longProp>
+                <boolProp name="graph_aggregated">false</boolProp>
+                <stringProp name="include_sample_labels"></stringProp>
+                <stringProp name="exclude_sample_labels"></stringProp>
+              </kg.apc.jmeter.vizualizers.CorrectedResultCollector>
+            EOF
+          )
+        )
+        update params
+      end
+    end
+  end
+end

data/lib/jmeter_perf/plugins/response_times_percentiles.rb

@@ -0,0 +1,54 @@
+module JmeterPerf
+  module Plugins
+    class ResponseTimesPercentiles
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ResponseTimesPercentiles" : (params[:name] || "ResponseTimesPercentiles")
+        @doc = Nokogiri::XML(
+          JmeterPerf::Helpers::String.strip_heredoc(
+            <<-EOF
+              <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ResponseTimesPercentilesGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{testname}" enabled="#{enabled(params)}">
+                <boolProp name="ResultCollector.error_logging">false</boolProp>
+                <objProp>
+                  <name>saveConfig</name>
+                  <value class="SampleSaveConfiguration">
+                    <time>true</time>
+                    <latency>true</latency>
+                    <timestamp>true</timestamp>
+                    <success>true</success>
+                    <label>true</label>
+                    <code>true</code>
+                    <message>true</message>
+                    <threadName>true</threadName>
+                    <dataType>true</dataType>
+                    <encoding>false</encoding>
+                    <assertions>true</assertions>
+                    <subresults>true</subresults>
+                    <responseData>false</responseData>
+                    <samplerData>false</samplerData>
+                    <xml>true</xml>
+                    <fieldNames>false</fieldNames>
+                    <responseHeaders>false</responseHeaders>
+                    <requestHeaders>false</requestHeaders>
+                    <responseDataOnError>false</responseDataOnError>
+                    <saveAssertionResultsFailureMessage>false</saveAssertionResultsFailureMessage>
+                    <assertionsResultsToSave>0</assertionsResultsToSave>
+                    <bytes>true</bytes>
+                  </value>
+                </objProp>
+                <stringProp name="filename"></stringProp>
+                <longProp name="interval_grouping">500</longProp>
+                <boolProp name="graph_aggregated">false</boolProp>
+                <stringProp name="include_sample_labels"></stringProp>
+                <stringProp name="exclude_sample_labels"></stringProp>
+              </kg.apc.jmeter.vizualizers.CorrectedResultCollector>
+            EOF
+          )
+        )
+        update params
+        update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+      end
+    end
+  end
+end

data/lib/jmeter_perf/plugins/stepping_thread_group.rb

@@ -0,0 +1,34 @@
+module JmeterPerf
+  module Plugins
+    class SteppingThreadGroup
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "SteppingThreadGroup" : (params[:name] || "SteppingThreadGroup")
+        @doc = Nokogiri::XML(
+          JmeterPerf::Helpers::String.strip_heredoc(
+            <<-EOF
+              <kg.apc.jmeter.threads.SteppingThreadGroup guiclass="kg.apc.jmeter.threads.SteppingThreadGroupGui" testclass="kg.apc.jmeter.threads.SteppingThreadGroup" testname="#{testname}" enabled="true">
+                <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
+                <stringProp name="ThreadGroup.num_threads">#{params[:total_threads]}</stringProp>
+                <stringProp name="Threads initial delay">#{params[:initial_delay]}</stringProp>
+                <stringProp name="Start users count">#{params[:start_threads]}</stringProp>
+                <stringProp name="Start users count burst">#{params[:add_threads]}</stringProp>
+                <stringProp name="Start users period">#{params[:start_every]}</stringProp>
+                <stringProp name="Stop users count">#{params[:stop_threads]}</stringProp>
+                <stringProp name="Stop users period">#{params[:stop_every]}</stringProp>
+                <stringProp name="flighttime">#{params[:flight_time]}</stringProp>
+                <stringProp name="rampUp">#{params[:rampup]}</stringProp>
+                <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
+                  <boolProp name="LoopController.continue_forever">false</boolProp>
+                  <intProp name="LoopController.loops">-1</intProp>
+                </elementProp>
+              </kg.apc.jmeter.threads.SteppingThreadGroup>
+            EOF
+          )
+        )
+        update params
+      end
+    end
+  end
+end

data/lib/jmeter_perf/plugins/transactions_per_second.rb

@@ -0,0 +1,53 @@
+module JmeterPerf
+  module Plugins
+    class TransactionsPerSecond
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "TransactionsPerSecond" : (params[:name] || "TransactionsPerSecond")
+        @doc = Nokogiri::XML(
+          JmeterPerf::Helpers::String.strip_heredoc(
+            <<-EOF
+              <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.TransactionsPerSecondGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{testname}" enabled="#{enabled(params)}">
+                <boolProp name="ResultCollector.error_logging">false</boolProp>
+                <objProp>
+                  <name>saveConfig</name>
+                  <value class="SampleSaveConfiguration">
+                    <time>true</time>
+                    <latency>true</latency>
+                    <timestamp>true</timestamp>
+                    <success>true</success>
+                    <label>true</label>
+                    <code>true</code>
+                    <message>true</message>
+                    <threadName>true</threadName>
+                    <dataType>true</dataType>
+                    <encoding>false</encoding>
+                    <assertions>true</assertions>
+                    <subresults>true</subresults>
+                    <responseData>false</responseData>
+                    <samplerData>false</samplerData>
+                    <xml>true</xml>
+                    <fieldNames>false</fieldNames>
+                    <responseHeaders>false</responseHeaders>
+                    <requestHeaders>false</requestHeaders>
+                    <responseDataOnError>false</responseDataOnError>
+                    <saveAssertionResultsFailureMessage>false</saveAssertionResultsFailureMessage>
+                    <assertionsResultsToSave>0</assertionsResultsToSave>
+                    <bytes>true</bytes>
+                  </value>
+                </objProp>
+                <stringProp name="filename"></stringProp>
+                <longProp name="interval_grouping">1000</longProp>
+                <boolProp name="graph_aggregated">false</boolProp>
+                <stringProp name="include_sample_labels"></stringProp>
+                <stringProp name="exclude_sample_labels"></stringProp>
+              </kg.apc.jmeter.vizualizers.CorrectedResultCollector>
+            EOF
+          )
+        )
+        update params
+      end
+    end
+  end
+end

data/lib/jmeter_perf/plugins/ultimate_thread_group.rb

@@ -0,0 +1,28 @@
+module JmeterPerf
+  module Plugins
+    class UltimateThreadGroup
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "UltimateThreadGroup" : (params[:name] || "UltimateThreadGroup")
+        @doc = Nokogiri::XML(
+          JmeterPerf::Helpers::String.strip_heredoc(
+            <<-EOF
+              <kg.apc.jmeter.threads.UltimateThreadGroup guiclass="kg.apc.jmeter.threads.UltimateThreadGroupGui" testclass="kg.apc.jmeter.threads.UltimateThreadGroup" testname="#{testname}" enabled="true">
+              <collectionProp name="ultimatethreadgroupdata">
+              </collectionProp>
+              <elementProp name="ThreadGroup.main_controller" elementType="LoopController" guiclass="LoopControlPanel" testclass="LoopController" testname="Loop Controller" enabled="true">
+                <boolProp name="LoopController.continue_forever">false</boolProp>
+                <intProp name="LoopController.loops">-1</intProp>
+              </elementProp>
+              <stringProp name="ThreadGroup.on_sample_error">continue</stringProp>
+            </kg.apc.jmeter.threads.UltimateThreadGroup>
+            EOF
+          )
+        )
+
+        update params
+      end
+    end
+  end
+end

data/lib/jmeter_perf/plugins/variable_throughput_timer.rb

@@ -0,0 +1,35 @@
+module JmeterPerf
+  module Plugins
+    class ThroughputShapingTimer
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ThroughputShapingTimer" : (params[:name] || "ThroughputShapingTimer")
+        @doc = Nokogiri::XML(
+          JmeterPerf::Helpers::String.strip_heredoc(
+            <<-EOF
+              <kg.apc.jmeter.timers.VariableThroughputTimer guiclass="kg.apc.jmeter.timers.VariableThroughputTimerGui" testclass="kg.apc.jmeter.timers.VariableThroughputTimer" testname="#{testname}" enabled="true">
+                <collectionProp name="load_profile"/>
+              </kg.apc.jmeter.timers.VariableThroughputTimer>
+            EOF
+          )
+        )
+
+        (params.is_a?(Array) ? params : params[:steps]).each_with_index do |step, index|
+          @doc.at_xpath("//collectionProp") << Nokogiri::XML(
+            JmeterPerf::Helpers::String.strip_heredoc(
+              <<-EOF
+                  <collectionProp name="step_#{index}">
+                    <stringProp name="start_rps_#{index}">#{step[:start_rps]}</stringProp>
+                    <stringProp name="end_rps_#{index}">#{step[:end_rps]}</stringProp>
+                    <stringProp name="duration_sec_#{index}">#{step[:duration]}</stringProp>
+                  </collectionProp>
+              EOF
+            )
+          ).children
+        end
+        update params
+      end
+    end
+  end
+end

data/lib/jmeter_perf/report/comparator.rb

@@ -0,0 +1,258 @@
+module JmeterPerf
+  module Report
+    # Comparator performs statistical comparison between two performance reports.
+    # It calculates metrics like Cohen's D and T-statistic to measure the effect size
+    # and generates comparison reports in various formats.
+    class Comparator
+      # @return [Float] the calculated Cohen's D value
+      # @see https://en.wikipedia.org/wiki/Effect_size#Cohen's_d
+      attr_reader :cohens_d
+      # @return [Float] the calculated T-statistic value
+      # @see https://en.wikipedia.org/wiki/Student%27s_t-test
+      attr_reader :t_statistic
+      # @return [String] a human-readable rating of the comparison result
+      attr_reader :human_rating
+      # @return [String] the name of the comparison, if provided
+      attr_reader :name
+
+      # Effect size thresholds according to Sawilowsky's rule of thumb
+      EFFECT_SIZE_LIMITS = {
+        vsmall: 0.01,  # very small
+        small: 0.2,    # small
+        medium: 0.5,   # medium
+        large: 0.8,    # large
+        vlarge: 1.2,   # very large
+        huge: 2.0      # huge
+      }
+
+      # Valid effect size directions
+      EFFECT_SIZE_DIRECTION = %i[positive negative both]
+
+      # Initializes a Comparator instance to compare two reports.
+      #
+      # @param base_report [Summary] the base performance report
+      # @param test_report [Summary] the test performance report
+      # @param name [String, nil] an optional name for the comparison (default: nil)
+      def initialize(base_report, test_report, name = nil)
+        @base_report = base_report
+        @test_report = test_report
+        @name = name&.gsub(/\s+/, "_")
+        compare_reports!
+      end
+
+      # Checks if the comparison passes based on Cohen's D and effect size.
+      # @note If no Cohen's D limit is provided, the `effect_size` threshold is used.
+      # @param cohens_d_limit [Float, nil] optional limit for Cohen's D (default: nil)
+      # @param effect_size [Symbol] the desired effect size threshold (default: :vsmall).
+      #   See {JmeterPerf::Report::Comparator::EFFECT_SIZE_LIMITS} for options.
+      # @param direction [Symbol] the direction of comparison, e.g., :positive (default: :both)
+      #   See {JmeterPerf::Report::Comparator::EFFECT_SIZE_DIRECTION} for options.
+      # @raise [ArgumentError] if the effect size or direction is invalid
+      # @return [Boolean] true if comparison meets the criteria
+      def pass?(cohens_d_limit: nil, effect_size: :vsmall, direction: :both)
+        limit = cohens_d_limit || EFFECT_SIZE_LIMITS[effect_size]
+        raise ArgumentError, "Invalid effect size: #{effect_size}" unless limit
+
+        raise ArgumentError, "Invalid direction: #{direction}" unless EFFECT_SIZE_DIRECTION.include?(direction)
+
+        case direction
+        when :positive
+          cohens_d >= limit
+        when :negative
+          cohens_d <= -limit
+        when :both
+          cohens_d >= limit || !(cohens_d <= -limit)
+        end
+      end
+
+      # Generates comparison reports in specified formats.
+      #
+      # @param output_dir [String] the directory for output files (default: ".")
+      # @param output_format [Symbol] the format for the report, e.g., :html, :csv (default: :all)
+      # @raise [ArgumentError] if the output format is invalid
+      # @return [void]
+      def generate_reports(output_dir: ".", output_format: :all)
+        generator = Generator.new(self, [@base_report, @test_report])
+
+        case output_format
+        when :all
+          generator.generate_report(File.join(output_dir, "#{@name}_comparison_report.html"), :html)
+          generator.generate_report(File.join(output_dir, "#{@name}_comparison_report.csv"), :csv)
+        when :html, :csv
+          generator.generate_report(File.join(output_dir, "#{@name}_comparison_report.#{output_format}"), output_format)
+        else
+          raise ArgumentError, "Invalid output format: #{output_format}"
+        end
+      end
+
+      private
+
+      # Calculates Cohen's D and T-statistic between the two reports.
+      #
+      # @return [void]
+      def compare_reports!
+        @cohens_d = calc_cohens_d(@base_report.avg, @test_report.avg, @base_report.std, @test_report.std).round(2)
+        @t_statistic = calc_t_statistic(
+          @base_report.avg,
+          @test_report.avg,
+          @base_report.std,
+          @test_report.std,
+          @test_report.total_requests
+        ).round(2)
+
+        set_diff_rating
+      end
+
+      # Calculates Cohen's D between two means with given standard deviations.
+      #
+      # @param mean1 [Float] mean of the base report
+      # @param mean2 [Float] mean of the test report
+      # @param sd1 [Float] standard deviation of the base report
+      # @param sd2 [Float] standard deviation of the test report
+      # @return [Float] calculated Cohen's D
+      def calc_cohens_d(mean1, mean2, sd1, sd2)
+        mean_diff = mean1 - mean2
+        pooled_sd = Math.sqrt((sd1**2 + sd2**2) / 2.0)
+        mean_diff / pooled_sd
+      end
+
+      # Calculates T-statistic between two means with given standard deviations and sample size.
+      #
+      # @param mean1 [Float] mean of the base report
+      # @param mean2 [Float] mean of the test report
+      # @param sd1 [Float] standard deviation of the base report
+      # @param sd2 [Float] standard deviation of the test report
+      # @param n2 [Integer] sample size of the test report
+      # @return [Float] calculated T-statistic
+      def calc_t_statistic(mean1, mean2, sd1, sd2, n2)
+        numerator = mean1 - mean2
+        denominator = Math.sqrt((sd1**2 + sd2**2) / n2)
+        numerator / denominator
+      end
+
+      # Sets a human-readable rating for the difference between reports.
+      #
+      # @return [void]
+      def set_diff_rating
+        s_dir = if cohens_d.positive?
+          "increase"
+        else
+          cohens_d.negative? ? "decrease" : "change"
+        end
+        s_mag = case cohens_d.abs
+        when 1.20...2.0 then "Very large"
+        when 0.80...1.20 then "Large"
+        when 0.50...0.80 then "Medium"
+        when 0.02...0.50 then "Small"
+        when 0.01...0.02 then "Very small"
+        when 0.0...0.01 then "Negligible"
+        else "Huge"
+        end
+        @human_rating = "#{s_mag} #{s_dir}"
+      end
+
+      # Generator is responsible for generating comparison reports in HTML and CSV formats.
+      class Generator
+        # Initializes a Generator instance to handle report generation.
+        #
+        # @param comparator [Comparator] the comparator instance
+        # @param reports [Array<Summary>] an array of performance reports
+        def initialize(comparator, reports)
+          @comparator = comparator
+          @reports = reports
+        end
+
+        # Generates a report in the specified format at the given path.
+        #
+        # @param output_path [String] the path to save the generated report
+        # @param output_format [Symbol] the format for the report, e.g., :html or :csv
+        # @return [void]
+        def generate_report(output_path, output_format)
+          case output_format
+          when :html
+            generate_html_report(output_path)
+          when :csv
+            generate_csv_report(output_path)
+          else
+            print_report(output_path)
+          end
+        end
+
+        # Generates an HTML report.
+        #
+        # @param output_path [String] the path to save the HTML report
+        # @return [void]
+        def generate_html_report(output_path)
+          template_path = File.join(__dir__, "..", "views", "report_template.html.erb")
+          template = File.read(template_path)
+          result = ERB.new(template).result(binding)
+          File.write(output_path, result)
+        end
+
+        # Generates a CSV report.
+        #
+        # @param output_path [String] the path to save the CSV report
+        # @return [void]
+        def generate_csv_report(output_path)
+          CSV.open(output_path, "wb") do |csv|
+            csv << ["Label", "Total Requests", "Total Elapsed Time", "RPM", "Errors", "Error %", "Min", "Max", "Avg", "SD", "P10", "P50", "P95"]
+            @reports.each_with_index do |report, index|
+              csv << [
+                (index == 0) ? "Base Metric" : "Test Metric",
+                report.total_requests,
+                report.total_elapsed_time,
+                sprintf("%.2f", report.rpm),
+                report.total_errors,
+                sprintf("%.2f", report.error_percentage),
+                report.min,
+                report.max,
+                sprintf("%.2f", report.avg),
+                sprintf("%.2f", report.std),
+                sprintf("%.2f", report.p10),
+                sprintf("%.2f", report.p50),
+                sprintf("%.2f", report.p95)
+              ]
+            end
+          end
+        end
+
+        # Prints a plain text version of the report to standard output.
+        #
+        # @param output_path [String] the path for plain text output
+        # @return [void]
+        def print_report(output_path)
+          report_text = "Comparison Report\n\n"
+          report_text << format_line(["Label", "Requests", "Errors", "Error %", "Min", "Median", "Avg", "Max", "Std", "P10", "P50", "P95"])
+          report_text << "-" * 90 + "\n"
+          @reports.each_with_index do |report, index|
+            report_text << format_line([
+              (index == 0) ? "Base Metric" : "Test Metric",
+              report.total_requests,
+              report.total_errors,
+              sprintf("%.2f", report.error_percentage),
+              report.min,
+              report.median,
+              sprintf("%.2f", report.avg),
+              report.max,
+              sprintf("%.2f", report.std),
+              sprintf("%.2f", report.p10),
+              sprintf("%.2f", report.p50),
+              sprintf("%.2f", report.p95)
+            ])
+          end
+          puts report_text
+        end
+
+        # Formats a line for plain text output.
+        #
+        # @param values [Array<String, Numeric>] the values to format
+        # @return [String] the formatted line
+        def format_line(values)
+          values.map { |v| v.to_s.ljust(10) }.join(" ") + "\n"
+        end
+      end
+
+      private_constant :Generator
+    end
+  end
+end