jmeter_perf 1.0.10 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08f52576a21a7846d4b8c9e9a64a515d41eca60573109bbc6e824e799d666ad2'
-  data.tar.gz: bf3ef28bf092d0ebde1dfd073349a8f43677b588b730f0e8d6303ce84975cdfc
+  metadata.gz: 600531edf66d0d72c64c6015327f9b63db03ab11357e28758a7250aead0d9106
+  data.tar.gz: f254970ad87fb7850e4989d25c3f6437cb037614a76cd5c145b6c3bb5db6b4a3
 SHA512:
-  metadata.gz: 906d3f98be9a3286557f094a6cb65a6cb0e154e65b8535439ca274435ca654248ac627a46caeb9439b6a336055334bbab62acb7d2c627b9949aeeb8a07929247
-  data.tar.gz: 10b89dc579ed6b9cbec7f8e413ce95d95b51cc4622cf779293949cf530b94e84d2580dbd30b126372e1ee01c2de364d6839e2d5feb19feaf5b5a9a958d5e665c
+  metadata.gz: 14c69cb7eac86ce588226a5c69a4b791e7d4f9015034c2314f9c13daab0a5dbeab5feeaaaaf6f58fe9be22c3216ac99e94f9d0e718cc1027ea4aa0d2e43e43a7
+  data.tar.gz: 2608a6d4db406a42a9bbaf2874e2cebfdb0768b62100e5515eb68a098683fc191410632aa9c314c0b17a8884405fc314499473d7335dc4d4177b3c56e8f3abfe

data/.rspec

@@ -1,3 +1,3 @@
---format documentation
+--profile
+--format progress
 --color
---require spec_helper

data/README.md

@@ -1,5 +1,6 @@
 # JmeterPerf
 Dynamically generate JMeter test plans, run performance tests, generate reports, compare reports and more using JMeter and Ruby.
+Inspired by the now archived/defunct [ruby-jmeter](https://github.com/flood-io/ruby-jmeter).
 
 ## Installation
 
@@ -17,7 +18,11 @@ Check out the Wiki! https://github.com/jlurena/jmeter_perf/wiki
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies.
+Run `rake` to run the linter and tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+Additionally, there is an `example` Rails Application you can play with.
 
 ## Contributing
 

data/example/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    jmeter_perf (1.0.6)
+    jmeter_perf (1.1.0)
       nokogiri (~> 1.16, >= 1.16.7)
       tdigest (~> 0.2.1)
 

data/lib/jmeter_perf/report/comparator.rb

@@ -25,8 +25,21 @@ module JmeterPerf
         huge: 2.0      # huge
       }
 
-      # Valid effect size directions
-      EFFECT_SIZE_DIRECTION = %i[positive negative both]
+      COMPARISON_REPORT_HEADER = [
+        "Label",
+        "Total Requests",
+        "Total Elapsed Time",
+        "RPM",
+        "Errors",
+        "Error %",
+        "Min",
+        "Max",
+        "Avg",
+        "SD",
+        "P10",
+        "P50",
+        "P95"
+      ]
 
       # Initializes a Comparator instance to compare two reports.
       #
@@ -40,51 +53,80 @@ module JmeterPerf
         compare_reports!
       end
 
-      # Checks if the comparison passes based on Cohen's D and effect size.
+      # Checks if the comparison passes based on Cohen's D and effect size threshold.
       # @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)
+      # @note Positive effect size indicates an increase in performance and is considered a pass.
+      # @param cohens_d_limit [Float, nil] optional negative limit for Cohen's D
       # @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
+      # @raise [ArgumentError] if the effect size is invalid
       # @return [Boolean] true if comparison meets the criteria
-      def pass?(cohens_d_limit: nil, effect_size: :vsmall, direction: :both)
+      def pass?(cohens_d_limit: nil, effect_size: :vsmall)
         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
+        cohens_d >= -limit.abs
       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)
+      # @param output_format [Symbol] the format for the report, e.g., :html, :csv, :stdout (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)
+          generate_html_report(File.join(output_dir, "#{@name}_comparison_report.html"))
+          generate_csv_report(File.join(output_dir, "#{@name}_comparison_report.csv"))
+          print_comparison
+        when :html
+          generate_html_report(File.join(output_dir, "#{@name}_comparison_report.html"))
+        when :csv
+          generate_csv_report(File.join(output_dir, "#{@name}_comparison_report.csv"))
+        when :stdout
+          print_comparison
         else
           raise ArgumentError, "Invalid output format: #{output_format}"
         end
       end
 
+      def to_s
+        report_text = "Comparison Report\n"
+        report_text << "Cohen's D: #{@cohens_d}\n"
+        report_text << "Human Rating: #{@human_rating}\n"
+        report_text << "-" * 135 + "\n"
+
+        header_format = "%-15s %-17s %-18s %-8s %-8s %-9s %-7s %-7s %-8s %-8s %-8s %-8s %-8s\n"
+        row_format = "%-15s %-17d %-18d %-8.2f %-8d %-9.2f %-7d %-7d %-8.2f %-8.2f %-8.2f %-8.2f %-8.2f\n"
+
+        report_text << sprintf(header_format, *COMPARISON_REPORT_HEADER)
+        report_text << "-" * 135 + "\n"
+
+        [@base_report, @test_report].each_with_index do |report, index|
+          report_text << sprintf(row_format,
+            (index == 0) ? "Base Metric" : "Test Metric",
+            report.total_requests,
+            report.total_run_time,
+            report.rpm,
+            report.total_errors,
+            report.error_percentage,
+            report.min,
+            report.max,
+            report.avg,
+            report.std,
+            report.p10,
+            report.p50,
+            report.p95)
+        end
+
+        report_text << "-" * 135 + "\n"
+        report_text
+      end
+
+      def print_comparison
+        puts self
+      end
+
       private
 
       # Calculates Cohen's D and T-statistic between the two reports.
@@ -151,108 +193,43 @@ module JmeterPerf
         @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
+      # 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
 
-        # 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([
+      # 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 << COMPARISON_REPORT_HEADER
+          [@base_report, @test_report].each_with_index do |report, index|
+            csv << [
               (index == 0) ? "Base Metric" : "Test Metric",
               report.total_requests,
+              report.total_run_time,
+              sprintf("%.2f", report.rpm),
               report.total_errors,
               sprintf("%.2f", report.error_percentage),
               report.min,
-              report.median,
-              sprintf("%.2f", report.avg),
               report.max,
+              sprintf("%.2f", report.avg),
               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

data/lib/jmeter_perf/report/summary.rb

@@ -32,8 +32,6 @@ module JmeterPerf
     #   @return [Float] the standard deviation of response times
     # @!attribute [rw] total_bytes
     #   @return [Integer] the total number of bytes received
-    # @!attribute [rw] total_elapsed_time
-    #   @return [Integer] the total elapsed time in milliseconds
     # @!attribute [rw] total_errors
     #   @return [Integer] the total number of errors encountered
     # @!attribute [rw] total_latency
@@ -88,7 +86,6 @@ module JmeterPerf
         "Standard Deviation" => :standard_deviation,
         "Total Run Time" => :total_run_time,
         "Total Bytes" => :total_bytes,
-        "Total Elapsed Time" => :total_elapsed_time,
         "Total Errors" => :total_errors,
         "Total Latency" => :total_latency,
         "Total Requests" => :total_requests,
@@ -135,7 +132,7 @@ module JmeterPerf
       # @param file_path [String] the file path of the performance file to summarize. Either a JTL or CSV file.
       # @param name [String, nil] an optional name for the summary, derived from the file path if not provided (default: nil)
       # @param jtl_read_timeout [Integer] the maximum number of seconds to wait for a line read (default: 3)
-      def initialize(file_path:, name: nil, jtl_read_timeout: 3)
+      def initialize(file_path:, name: nil, jtl_read_timeout: 30)
         @name = name || file_path.to_s.tr("/", "_")
         @jtl_read_timeout = jtl_read_timeout
         @finished = false
@@ -145,7 +142,6 @@ module JmeterPerf
         @min = 1_000_000
         @response_codes = Hash.new { |h, k| h[k.to_s] = 0 }
         @total_bytes = 0
-        @total_elapsed_time = 0
         @total_errors = 0
         @total_latency = 0
         @total_requests = 0
@@ -158,12 +154,12 @@ module JmeterPerf
         @end_time = nil
       end
 
-      # Marks the summary as finished, allowing any pending asynchronous operations to complete.
+      # Marks the summary as finished and joins the processing thread.
       #
       # @return [void]
       def finish!
         @finished = true
-        @processing_jtl_thread.join if @processing_jtl_thread&.alive?
+        @processing_jtl_thread&.join
       end
 
       # Generates a CSV report with the given output file.
@@ -191,23 +187,28 @@ module JmeterPerf
       end
 
       # Starts streaming and processing JTL file content asynchronously.
-      #
-      # @return [Thread] a thread that handles the asynchronous file streaming and parsing
+      # @note Once streaming, in order to finish processing, call `finish!` otherwise it will continue indefinitely.
+      # @return [void]
       def stream_jtl_async
         @processing_jtl_thread = Thread.new do
-          sleep 0.1 until File.exist?(@file_path) # Wait for the file to be created
+          Timeout.timeout(@jtl_read_timeout, nil, "Timed out attempting to open JTL File #{@file_path}") do
+            sleep 0.1 until File.exist?(@file_path) # Wait for the file to be created
+          end
 
           File.open(@file_path, "r") do |file|
-            file.seek(0, IO::SEEK_END)
             until @finished && file.eof?
               line = file.gets
-              next unless line # Skip if no line was read
 
-              # Process only if the line is complete (ends with a newline)
+              # Skip if the line is nil. This can happen if not @finished, and we are at EOF
+              next if line.nil?
+              # Process only if the line is complete. JMeter always finishes with a newline
               read_until_complete_line(file, line)
             end
           end
         end
+
+        @processing_jtl_thread.abort_on_exception = true
+        nil
       end
 
       # Summarizes the collected data by calculating statistical metrics and error rates.
@@ -225,17 +226,19 @@ module JmeterPerf
       private
 
       def read_until_complete_line(file, line)
-        return if file.lineno == 1 # Skip the header row
-        Timeout.timeout(@jtl_read_timeout) do
-          until line.end_with?("\n")
+        lineno = file.lineno
+        return if lineno == 1 # Skip the header row
+        Timeout.timeout(@jtl_read_timeout, nil, "Timed out processing line #{lineno}") do
+          # If finished and eof but no newline: Means processing was interrupted
+          # JMeter always finishes with a new line in the JTL file
+          until line.end_with?("\n") || (file.eof? && @finished)
             sleep 0.1
             line += file.gets.to_s
           end
         end
         parse_csv_row(line)
       rescue Timeout::Error
-        puts "Timeout waiting for line to complete: #{line}"
-        raise
+        raise Timeout::Error, "Timed out reading JTL file at line #{lineno}"
       rescue CSV::MalformedCSVError
         @csv_error_lines << file.lineno
       end
@@ -253,7 +256,6 @@ module JmeterPerf
           # Continue with processing the row as before...
           @running_statistics_helper.add_number(elapsed)
           @total_requests += 1
-          @total_elapsed_time += elapsed
           @response_codes[line_item.fetch(:responseCode)] += 1
           @total_errors += (line_item.fetch(:success) == "true") ? 0 : 1
           @total_bytes += line_item.fetch(:bytes, 0).to_i

data/lib/jmeter_perf/rspec_matchers/pass_performance_test.rb

@@ -13,26 +13,20 @@ RSpec::Matchers.define :pass_performance_test do
     @effect_size = effect_size
   end
 
-  chain :with_direction do |direction|
-    @direction = direction
-  end
-
   chain :with_cohen_d_limit do |limit|
     @cohen_limit = limit
   end
 
   chain :with do |options|
-    @effect_size = options[:effect_size]
-    @direction = options[:direction]
     @cohen_limit = options[:cohen_limit]
+    @effect_size = options[:effect_size]
   end
 
   match do |comparator|
     if comparator.is_a?(JmeterPerf::Report::Comparator)
       comparator.pass?(
         cohens_d_limit: @cohen_limit || nil,
-        effect_size: @effect_size || :vsmall,
-        direction: @direction || :both
+        effect_size: @effect_size || :vsmall
       )
     else
       false
@@ -41,7 +35,7 @@ RSpec::Matchers.define :pass_performance_test do
 
   failure_message do |comparator|
     if comparator.is_a?(JmeterPerf::Report::Comparator)
-      "#{comparator.name} failed: #{comparator.cohens_d} | #{comparator.human_rating}"
+      "Performance Test Failed\n#{comparator}"
     else
       "#{comparator.class.name} is not a valid comparator"
     end
@@ -49,7 +43,7 @@ RSpec::Matchers.define :pass_performance_test do
 
   failure_message_when_negated do |comparator|
     if comparator.is_a?(JmeterPerf::Report::Comparator)
-      "#{comparator.name} passed: #{comparator.cohens_d} | #{comparator.human_rating}"
+      "Performance Test Passed\n#{comparator}"
     else
       "#{comparator.class.name} is not a valid comparator"
     end

data/lib/jmeter_perf/rspec_matchers.rb

@@ -1 +1 @@
-Dir.glob(File.join(__dir__, "rspec_matchers.rb")).each { |f| require_relative f }
+Dir.glob(File.join(__dir__, "rspec_matchers/*.rb")).each { |f| require_relative f }

data/lib/jmeter_perf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JmeterPerf
-  VERSION = "1.0.10"
+  VERSION = "1.1.1"
 end

data/lib/jmeter_perf/views/report_template.html.erb

@@ -57,28 +57,28 @@
   </style>
 </head>
 <body>
-  <% if @comparator.name %>
-    <h2>Comparison Report for <span style="text-decoration: underline;"><%= @comparator.name %></span></h2>
+  <% if @name %>
+    <h2>Comparison Report for <span style="text-decoration: underline;"><%= @name %></span></h2>
   <% end %>
   <div class="summary-box" id="summary-box">
     <b>Report Generated:</b> <%= Time.now.strftime("%Y-%m-%d %H:%M:%S") %><br>
-    <b>Cohen's D:</b> <%= @comparator.cohens_d %><br>
-    <b>T Statistics:</b> <%= @comparator.t_statistic %><br>
-    <b>Summary:</b> <%= @comparator.human_rating %> in performance
+    <b>Cohen's D:</b> <%= @cohens_d %><br>
+    <b>T Statistic:</b> <%= @t_statistic %><br>
+    <b>Summary:</b> <%= @human_rating %> in performance
   </div>
   <table>
     <tr class="header-row">
-      <% ['Label', 'Total Requests', 'Total Elapsed Time', 'RPM', 'Errors', 'Error %', 'Min', 'Max', 'Avg', 'SD', 'P10', 'P50', 'P95'].each do |header| %>
+      <% JmeterPerf::Report::Comparator::COMPARISON_REPORT_HEADER.each do |header| %>
         <td class="tooltip"><%= header %>
           <span class="tooltiptext"><%= "Description for #{header}" %></span>
         </td>
       <% end %>
     </tr>
-    <% @reports.each_with_index do |report, index| %>
+    <% [@base_report, @test_report].each_with_index do |report, index| %>
       <tr>
         <td><%= index == 0 ? "Base Metric" : "Test Metric" %></td>
         <td><%= report.total_requests %></td>
-        <td><%= report.total_elapsed_time %></td>
+        <td><%= report.total_run_time %></td>
         <td><%= sprintf('%.2f', report.rpm) %></td>
         <td class="<%= 'bad' if report.total_errors > 0 %>"><%= report.total_errors %></td>
         <td class="<%= 'bad' if report.error_percentage > 0.0 %>"><%= sprintf('%.2f', report.error_percentage) %></td>
@@ -96,7 +96,7 @@
     import ColorScale from "https://cdn.skypack.dev/color-scales";
     document.addEventListener('DOMContentLoaded', function () {
       const summaryBox = document.getElementById('summary-box');
-      const cohenValue = <%= @comparator.cohens_d %>;
+      const cohenValue = <%= @cohens_d %>;
       let color;
 
       if (cohenValue === 0) {

data/lib/jmeter_perf.rb

@@ -61,7 +61,7 @@ module JmeterPerf
       @root = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
         <<-EOF
           <?xml version="1.0" encoding="UTF-8"?>
-          <jmeterTestPlan version="1.2" properties="3.1" jmeter="3.1" ruby-jmeter="3.0">
+          <jmeterTestPlan version="1.2" properties="3.1" jmeter="3.1" jmeterperf="#{JmeterPerf::VERSION}">
           <hashTree>
           </hashTree>
           </jmeterTestPlan>
@@ -74,17 +74,17 @@ module JmeterPerf
 
     # Saves the test plan as a JMX file.
     #
-    # @param out_jmx [String] The path for the output JMX file (default: `"ruby-jmeter.jmx"`).
-    def jmx(out_jmx: "ruby-jmeter.jmx")
+    # @param out_jmx [String] The path for the output JMX file (default: `"jmeter_perf.jmx"`).
+    def jmx(out_jmx: "jmeter_perf.jmx")
       File.write(out_jmx, doc.to_xml(indent: 2))
       logger.info "JMX saved to: #{out_jmx}"
     end
 
     # Runs the test plan with the specified configuration.
     #
-    # @param name [String] The name of the test run (default: `"ruby-jmeter"`).
+    # @param name [String] The name of the test run (default: `"jmeter_perf"`).
     # @param jmeter_path [String] Path to the JMeter executable (default: `"jmeter"`).
-    # @param out_jmx [String] The filename for the output JMX file (default: `"ruby-jmeter.jmx"`).
+    # @param out_jmx [String] The filename for the output JMX file (default: `"jmeter_perf.jmx"`).
     # @param out_jtl [String] The filename for the output JTL file (default: `"jmeter.jtl"`).
     # @param out_jmeter_log [String] The filename for the JMeter log file (default: `"jmeter.log"`).
     # @param out_cmd_log [String] The filename for the command log file (default: `"jmeter-cmd.log"`).
@@ -92,14 +92,15 @@ module JmeterPerf
     # @return [JmeterPerf::Report::Summary] The summary report of the test run.
     # @raise [RuntimeError] If the test execution fails.
     def run(
-      name: "ruby-jmeter",
+      name: "jmeter_perf",
       jmeter_path: "jmeter",
-      out_jmx: "ruby-jmeter.jmx",
+      out_jmx: "jmeter_perf.jmx",
       out_jtl: "jmeter.jtl",
       out_jmeter_log: "jmeter.log",
       out_cmd_log: "jmeter-cmd.log",
       jtl_read_timeout: 3
     )
+      summary = nil
       jmx(out_jmx:)
       logger.warn "Executing #{out_jmx} test plan locally ..."
 
@@ -108,15 +109,14 @@ module JmeterPerf
       CMD
 
       summary = JmeterPerf::Report::Summary.new(file_path: out_jtl, name:, jtl_read_timeout:)
-      jtl_process_thread = summary.stream_jtl_async
+      summary.stream_jtl_async
 
       File.open(out_cmd_log, "w") do |f|
         pid = Process.spawn(cmd, out: f, err: [:child, :out])
         Process.waitpid(pid)
       end
 
-      summary.finish!         # Notify jtl collection that JTL cmd finished
-      jtl_process_thread.join # Join main thread and wait for it to finish
+      summary.finish!         # Notify jtl collection that JTL cmd finished and waits
 
       unless $?.exitstatus.zero?
         logger.error("Failed to run #{cmd}. See #{out_cmd_log} and #{out_jmeter_log} for details.")
@@ -126,9 +126,8 @@ module JmeterPerf
       summary.summarize_data!
       logger.info "[Test Plan Execution Completed Successfully] JTL saved to: #{out_jtl}\n"
       summary
-    rescue
-      summary.finish!
-      raise
+    ensure
+      summary&.finish!
     end
 
     private

data/sig/jmeter_perf.rbs

@@ -1,195 +1,68 @@
+# frozen_string_literal: true
+
 module JmeterPerf
-  def self.test: (Hash[Symbol, untyped] params = {}) { () -> void } -> ExtendedDSL
+  def self.test: (params: Hash[Symbol, untyped] ?, &block: untyped) -> ExtendedDSL
 
   class ExtendedDSL < DSL
-    include JmeterPerf::Helper::Parser
-    attr_accessor root: Nokogiri::XML::Document
+    include JmeterPerf::Helpers::Parser
 
-    def initialize: (Hash[Symbol, untyped]) -> void
+    attr_accessor root: ::Nokogiri::XML::Document
 
-    def jmx: (out_jmx: String) -> void
+    def initialize: (params: Hash[Symbol, untyped] ?) -> void
+    def jmx: (out_jmx: String = "jmeter_perf.jmx") -> void
     def run: (
-      name: String,
-      jmeter_path: String?,
-      out_jmx: String,
-      out_jtl: String,
-      out_jmeter_log: String,
-      out_cmd_log: String
-    ) -> Report::Summary
+      name: String = "jmeter_perf",
+      jmeter_path: String = "jmeter",
+      out_jmx: String = "jmeter_perf.jmx",
+      out_jtl: String = "jmeter.jtl",
+      out_jmeter_log: String = "jmeter.log",
+      out_cmd_log: String = "jmeter-cmd.log",
+      jtl_read_timeout: Integer = 3
+    ) -> JmeterPerf::Report::Summary
   end
 
   module Report
-    class Summary
-      attr_reader name: String
-      attr_reader avg: Float
-      attr_reader error_percentage: Float
-      attr_reader max: Integer
-      attr_reader min: Integer
-      attr_reader p10: Float
-      attr_reader p50: Float
-      attr_reader p95: Float
-      attr_reader requests_per_minute: Float
-      attr_reader response_codes: Hash[String, Integer]
-      attr_reader standard_deviation: Float
-      attr_reader total_bytes: Integer
-      attr_reader total_elapsed_time: Integer
-      attr_reader total_errors: Integer
-      attr_reader total_latency: Integer
-      attr_reader total_requests: Integer
-      attr_reader total_sent_bytes: Integer
-
-      alias rpm: requests_per_minute
-      alias std: standard_deviation
-      alias median: p50
-
-      def initialize: (String | Pathname, String?) -> void
-      def finish!: () -> void
-      def stream_jtl_async: () -> Thread
-      def summarize_data!: () -> void
-    end
-
     class Comparator
       attr_reader cohens_d: Float
       attr_reader t_statistic: Float
       attr_reader human_rating: String
       attr_reader name: String
 
-      def initialize: (Summary, Summary, String?) -> void
-      def pass?: (Float?, Symbol, Symbol) -> bool
-      def generate_reports: (output_dir: String, output_format: Symbol) -> void
+      def initialize: (base_report: Summary, test_report: Summary, name: String ?) -> void
+      def pass?: (cohens_d_limit: Float ?, effect_size: Symbol = :vsmall) -> bool
+      def generate_reports: (output_dir: String = ".", output_format: Symbol = :all) -> void
+      def to_s: () -> String
+      def print_comparison: () -> void
     end
   end
 
-  class DSLGenerator
-    def initialize: (lib_dir: String, gem_dir: String, dsl_dir: String, idl_xml_path: String) -> void
-    def generate: () -> void
-  end
-
-  class DSL
-    def method_missing: (Symbol, *untyped, **untyped) { () -> void } -> void
-    def respond_to_missing?: (Symbol, bool) -> bool
-
-    # DSL Methods
-    ## AUTOGENERATED - DSL methods RBS
-
-    def ajp13_sampler: (Hash[Symbol, untyped], &block) -> void
-    def access_log_sampler: (Hash[Symbol, untyped], &block) -> void
-    def aggregate_graph: (Hash[Symbol, untyped], &block) -> void
-    def aggregate_report: (Hash[Symbol, untyped], &block) -> void
-    def assertion_results: (Hash[Symbol, untyped], &block) -> void
-    def bsf_assertion: (Hash[Symbol, untyped], &block) -> void
-    def bsf_listener: (Hash[Symbol, untyped], &block) -> void
-    def bsf_postprocessor: (Hash[Symbol, untyped], &block) -> void
-    def bsf_preprocessor: (Hash[Symbol, untyped], &block) -> void
-    def bsf_sampler: (Hash[Symbol, untyped], &block) -> void
-    def bsf_timer: (Hash[Symbol, untyped], &block) -> void
-    def bean_shell_assertion: (Hash[Symbol, untyped], &block) -> void
-    def bean_shell_listener: (Hash[Symbol, untyped], &block) -> void
-    def bean_shell_postprocessor: (Hash[Symbol, untyped], &block) -> void
-    def bean_shell_preprocessor: (Hash[Symbol, untyped], &block) -> void
-    def bean_shell_sampler: (Hash[Symbol, untyped], &block) -> void
-    def bean_shell_timer: (Hash[Symbol, untyped], &block) -> void
-    def css_jquery_extractor: (Hash[Symbol, untyped], &block) -> void
-    def csv_data_set_config: (Hash[Symbol, untyped], &block) -> void
-    def compare_assertion: (Hash[Symbol, untyped], &block) -> void
-    def comparison_assertion_visualizer: (Hash[Symbol, untyped], &block) -> void
-    def constant_throughput_timer: (Hash[Symbol, untyped], &block) -> void
-    def constant_timer: (Hash[Symbol, untyped], &block) -> void
-    def counter: (Hash[Symbol, untyped], &block) -> void
-    def debug_postprocessor: (Hash[Symbol, untyped], &block) -> void
-    def debug_sampler: (Hash[Symbol, untyped], &block) -> void
-    def distribution_graphalpha: (Hash[Symbol, untyped], &block) -> void
-    def duration_assertion: (Hash[Symbol, untyped], &block) -> void
-    def ftp_request: (Hash[Symbol, untyped], &block) -> void
-    def ftp_request_defaults: (Hash[Symbol, untyped], &block) -> void
-    def for_each_controller: (Hash[Symbol, untyped], &block) -> void
-    def gaussian_random_timer: (Hash[Symbol, untyped], &block) -> void
-    def generate_summary_results: (Hash[Symbol, untyped], &block) -> void
-    def graph_results: (Hash[Symbol, untyped], &block) -> void
-    def html_assertion: (Hash[Symbol, untyped], &block) -> void
-    def html_link_parser: (Hash[Symbol, untyped], &block) -> void
-    def html_parameter_mask: (Hash[Symbol, untyped], &block) -> void
-    def http_authorization_manager: (Hash[Symbol, untyped], &block) -> void
-    def http_cache_manager: (Hash[Symbol, untyped], &block) -> void
-    def http_cookie_manager: (Hash[Symbol, untyped], &block) -> void
-    def http_header_manager: (Hash[Symbol, untyped], &block) -> void
-    def http_request: (Hash[Symbol, untyped], &block) -> void
-    def http_request_defaults: (Hash[Symbol, untyped], &block) -> void
-    def http_url_rewriting_modifier: (Hash[Symbol, untyped], &block) -> void
-    def if_controller: (Hash[Symbol, untyped], &block) -> void
-    def include_controller: (Hash[Symbol, untyped], &block) -> void
-    def jdbc_connection_configuration: (Hash[Symbol, untyped], &block) -> void
-    def jdbc_postprocessor: (Hash[Symbol, untyped], &block) -> void
-    def jdbc_preprocessor: (Hash[Symbol, untyped], &block) -> void
-    def jdbc_request: (Hash[Symbol, untyped], &block) -> void
-    def jms_pointto_point: (Hash[Symbol, untyped], &block) -> void
-    def jms_publisher: (Hash[Symbol, untyped], &block) -> void
-    def jms_subscriber: (Hash[Symbol, untyped], &block) -> void
-    def json_path_postprocessor: (Hash[Symbol, untyped], &block) -> void
-    def jsr223_assertion: (Hash[Symbol, untyped], &block) -> void
-    def jsr223_listener: (Hash[Symbol, untyped], &block) -> void
-    def jsr223_postprocessor: (Hash[Symbol, untyped], &block) -> void
-    def jsr223_preprocessor: (Hash[Symbol, untyped], &block) -> void
-    def jsr223_sampler: (Hash[Symbol, untyped], &block) -> void
-    def jsr223_timer: (Hash[Symbol, untyped], &block) -> void
-    def j_unit_request: (Hash[Symbol, untyped], &block) -> void
-    def java_request: (Hash[Symbol, untyped], &block) -> void
-    def java_request_defaults: (Hash[Symbol, untyped], &block) -> void
-    def keystore_configuration: (Hash[Symbol, untyped], &block) -> void
-    def ldap_extended_request: (Hash[Symbol, untyped], &block) -> void
-    def ldap_extended_request_defaults: (Hash[Symbol, untyped], &block) -> void
-    def ldap_request: (Hash[Symbol, untyped], &block) -> void
-    def ldap_request_defaults: (Hash[Symbol, untyped], &block) -> void
-    def login_config_element: (Hash[Symbol, untyped], &block) -> void
-    def loop_controller: (Hash[Symbol, untyped], &block) -> void
-    def md5_hex_assertion: (Hash[Symbol, untyped], &block) -> void
-    def mail_reader_sampler: (Hash[Symbol, untyped], &block) -> void
-    def mailer_visualizer: (Hash[Symbol, untyped], &block) -> void
-    def module_controller: (Hash[Symbol, untyped], &block) -> void
-    def monitor_results: (Hash[Symbol, untyped], &block) -> void
-    def os_process_sampler: (Hash[Symbol, untyped], &block) -> void
-    def once_only_controller: (Hash[Symbol, untyped], &block) -> void
-    def poisson_random_timer: (Hash[Symbol, untyped], &block) -> void
-    def random_controller: (Hash[Symbol, untyped], &block) -> void
-    def random_order_controller: (Hash[Symbol, untyped], &block) -> void
-    def random_variable: (Hash[Symbol, untyped], &block) -> void
-    def recording_controller: (Hash[Symbol, untyped], &block) -> void
-    def reg_ex_user_parameters: (Hash[Symbol, untyped], &block) -> void
-    def regular_expression_extractor: (Hash[Symbol, untyped], &block) -> void
-    def response_assertion: (Hash[Symbol, untyped], &block) -> void
-    def response_time_graph: (Hash[Symbol, untyped], &block) -> void
-    def result_status_action_handler: (Hash[Symbol, untyped], &block) -> void
-    def runtime_controller: (Hash[Symbol, untyped], &block) -> void
-    def smime_assertion: (Hash[Symbol, untyped], &block) -> void
-    def smtp_sampler: (Hash[Symbol, untyped], &block) -> void
-    def soap_xml_rpc_request: (Hash[Symbol, untyped], &block) -> void
-    def save_responses_to_a_file: (Hash[Symbol, untyped], &block) -> void
-    def simple_config_element: (Hash[Symbol, untyped], &block) -> void
-    def simple_controller: (Hash[Symbol, untyped], &block) -> void
-    def simple_data_writer: (Hash[Symbol, untyped], &block) -> void
-    def spline_visualizer: (Hash[Symbol, untyped], &block) -> void
-    def summary_report: (Hash[Symbol, untyped], &block) -> void
-    def switch_controller: (Hash[Symbol, untyped], &block) -> void
-    def synchronizing_timer: (Hash[Symbol, untyped], &block) -> void
-    def tcp_sampler: (Hash[Symbol, untyped], &block) -> void
-    def tcp_sampler_config: (Hash[Symbol, untyped], &block) -> void
-    def test_action: (Hash[Symbol, untyped], &block) -> void
-    def test_fragment: (Hash[Symbol, untyped], &block) -> void
-    def test_plan: (Hash[Symbol, untyped], &block) -> void
-    def thread_group: (Hash[Symbol, untyped], &block) -> void
-    def throughput_controller: (Hash[Symbol, untyped], &block) -> void
-    def transaction_controller: (Hash[Symbol, untyped], &block) -> void
-    def uniform_random_timer: (Hash[Symbol, untyped], &block) -> void
-    def user_defined_variables: (Hash[Symbol, untyped], &block) -> void
-    def user_parameters: (Hash[Symbol, untyped], &block) -> void
-    def view_results_in_table: (Hash[Symbol, untyped], &block) -> void
-    def view_results_tree: (Hash[Symbol, untyped], &block) -> void
-    def while_controller: (Hash[Symbol, untyped], &block) -> void
-    def xml_assertion: (Hash[Symbol, untyped], &block) -> void
-    def xml_schema_assertion: (Hash[Symbol, untyped], &block) -> void
-    def x_path_assertion: (Hash[Symbol, untyped], &block) -> void
-    def x_path_extractor: (Hash[Symbol, untyped], &block) -> void
+  module Report
+    class Summary
+      attr_accessor avg: Float
+      attr_accessor error_percentage: Float
+      attr_accessor max: Integer
+      attr_accessor min: Integer
+      attr_accessor p10: Float
+      attr_accessor p50: Float
+      attr_accessor p95: Float
+      attr_accessor requests_per_minute: Float
+      attr_accessor response_codes: Hash[String, Integer]
+      attr_accessor standard_deviation: Float
+      attr_accessor total_bytes: Integer
+      attr_accessor total_errors: Integer
+      attr_accessor total_latency: Integer
+      attr_accessor total_requests: Integer
+      attr_accessor total_sent_bytes: Integer
+      attr_accessor csv_error_lines: Array[Integer]
+      attr_accessor total_run_time: Integer
+      attr_accessor name: String
 
-    ## AUTOGENERATED - DSL methods RBS
+      def self.read: (csv_path: String) -> Summary
+      def initialize: (file_path: String, name: String ? = nil, jtl_read_timeout: Integer = 3) -> void
+      def finish!: () -> void
+      def write_csv: (output_file: String) -> void
+      def stream_jtl_async: () -> Thread
+      def summarize_data!: () -> void
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jmeter_perf
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.1.1
 platform: ruby
 authors:
 - Jean Luis Urena
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-11-01 00:00:00.000000000 Z
+date: 2024-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri