jmeter_perf 1.0.9

data/lib/jmeter_perf/helpers/dsl_generator.rb

@@ -0,0 +1,157 @@
+require "nokogiri"
+require "pathname"
+
+require_relative "string"
+
+module JmeterPerf
+  module Helpers
+    # The DSLGenerator class generates the DSL methods and files
+    # for use in JMeter performance testing scripts. It uses a JMeter TestPlan (idl.xml)
+    # to generate the methods and files.
+    # @see https://github.com/jlurena/jmeter_perf/wiki/3.-Generating-DSL-Methods
+    class DSLGenerator
+      # Initializes the DSLGenerator.
+      # @param dsl_dir [String] Path to the directory where DSL files will be generated.
+      # @param idl_xml_path [String] Path to the XML file used for generating methods.
+      def initialize(dsl_dir:, idl_xml_path:, document_dsl: true)
+        @document_dsl = document_dsl
+        @dsl_dir = dsl_dir
+        @idl_xml_path = idl_xml_path
+      end
+
+      # Main method to generate DSL files and methods.
+      # It parses the XML, generates methods, documents,
+      # updates RBS files, and creates individual DSL files.
+      # @return [void]
+      def generate
+        results = parse_xml
+        methods = generate_methods(results)
+
+        write_methods_to_dsl_md(methods) if @document_dsl
+        update_rbs(methods) if @document_dsl
+        create_dsl_files(results)
+      end
+
+      private
+
+      # Parses the XML file specified by the `idl_xml_path` parameter.
+      # @return [Array<Nokogiri::XML::Node>] Array of XML nodes representing valid elements.
+      def parse_xml
+        idl_xml = File.open(@idl_xml_path)
+        doc = Nokogiri::XML(idl_xml.read.gsub(/\n\s+/, ""))
+        results = []
+
+        doc.traverse do |node|
+          if valid_node?(node)
+            results << node
+          end
+        end
+
+        results
+      end
+
+      # Checks if a given Nokogiri XML node is valid based on specific criteria.
+      #
+      # A node is considered valid if:
+      # - It is not an instance of Nokogiri::XML::Document.
+      # - It has an attribute named "testclass".
+      # - Its name is not "elementProp".
+      #
+      # @param node [Nokogiri::XML::Node] The XML node to be validated.
+      # @return [Boolean] Returns true if the node is valid, false otherwise.
+      def valid_node?(node)
+        node.class != Nokogiri::XML::Document &&
+          node.attributes["testclass"] &&
+          node.name != "elementProp"
+      end
+
+      # Generates methods based on parsed XML results.
+      # @param results [Array<Nokogiri::XML::Node>] Parsed XML nodes.
+      # @return [Array<Array<String>>] Array of class and method name pairs.
+      def generate_methods(results)
+        results.map do |element|
+          klass = JmeterPerf::Helpers::String.classify(element.attributes["testname"].to_s)
+          method = JmeterPerf::Helpers::String.underscore(klass)
+          [klass, method]
+        end.sort_by(&:first)
+      end
+
+      # Creates individual DSL files based on parsed XML results.
+      # @param results [Array<Nokogiri::XML::Node>] Parsed XML nodes.
+      # @return [void]
+      def create_dsl_files(results)
+        FileUtils.rm_rf(@dsl_dir)
+        FileUtils.mkdir_p(@dsl_dir)
+
+        results.each do |element|
+          klass = JmeterPerf::Helpers::String.classify(element.attributes["testname"].to_s)
+          puts "\tfor Element #{klass}"
+          File.write("#{@dsl_dir}/#{JmeterPerf::Helpers::String.underscore(klass)}.rb", <<~EOC)
+            module JmeterPerf
+              class DSL
+                # DSL method synonymous with the JMeter Element #{klass}
+                # @param params [Hash] Parameters for the #{klass} element (default: `{}`).
+                # @yield block to attach to the #{klass} element
+                # @return [JmeterPerf::#{klass}], a subclass of JmeterPerf::DSL that can be chained with other DSL methods.
+                # @see https://github.com/jlurena/jmeter_perf/wiki/1.-DSL-Documentation##{klass.downcase}
+                def #{JmeterPerf::Helpers::String.underscore(klass)}(params = {}, &)
+                  node = #{klass}.new(params)
+                  attach_node(node, &)
+                end
+
+                class #{klass}
+                  attr_accessor :doc
+                  include JmeterPerf::Helpers::XmlDocumentUpdater
+
+                  def initialize(params = {})
+                    testname = params.is_a?(Array) ? "#{klass}" : (params[:name] || "#{klass}")
+                    @doc = Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+                      <<~EOS
+            #{element.to_xml.gsub(/testname=".+?"/, 'testname="#{testname}"').gsub(/^/, "            ")}
+                      EOS
+                    ))
+                    update params
+                    update_at_xpath params if params.is_a?(Hash) && params[:update_at_xpath]
+                  end
+                end
+              end
+            end
+          EOC
+        end
+      end
+
+      # Updates the RBS file with method signatures for the DSL methods.
+      # @param methods [Array<Array<String>>] Array of class and method name pairs.
+      # @return [void]
+      def update_rbs(methods)
+        file_path = "sig/jmeter_perf.rbs"
+        replace_regex = /\s*## AUTOGENERATED - DSL methods RBS(.*?)## AUTOGENERATED - DSL methods RBS/m
+        new_content = <<~NEW_CONTENT
+          #{methods.map { |klass, method| "    def #{method}: (Hash[Symbol, untyped], &block) -> void" }.join("\n")}
+        NEW_CONTENT
+
+        current_content = File.read(file_path)
+
+        new_file_content = current_content.gsub(replace_regex) do
+          "\n    ## AUTOGENERATED - DSL methods RBS\n\n#{new_content}\n    ## AUTOGENERATED - DSL methods RBS"
+        end
+
+        File.write(file_path, new_file_content)
+      end
+
+      # Writes the list of generated methods to a markdown file.
+      # @param methods [Array<Array<String>>] Array of class and method name pairs.
+      # @return [void]
+      def write_methods_to_dsl_md(methods)
+        output = []
+        output << "# JmeterPerf::DSL methods"
+
+        methods.each do |klass, method|
+          output << "- #{klass}\n  `#{method}`"
+        end
+
+        File.write("DSL.md", output.join("\n"))
+      end
+    end
+  end
+end

data/lib/jmeter_perf/helpers/fallback_content_proxy.rb

@@ -0,0 +1,96 @@
+#
+# This module provides a proxy class that delegates method calls to a primary receiver object,
+# and falls back to a secondary object if the primary does not respond to the method.
+#
+# @example
+#   primary = PrimaryClass.new
+#   fallback = FallbackClass.new
+#   proxy = JmeterPerf::Helpers::FallbackContextProxy.new(primary, fallback)
+#   proxy.some_method # Will call `some_method` on primary, or fallback if primary does not respond
+#
+module JmeterPerf::Helpers
+  class FallbackContextProxy
+    # List of methods that should not be proxied.
+    NON_PROXIED_METHODS = [
+      :__id__,
+      :__send__,
+      :!,
+      :"!=",
+      :==,
+      :equal?,
+      :instance_eval,
+      :instance_variable_get,
+      :instance_variable_set,
+      :instance_variables,
+      :object_id,
+      :remove_instance_variable
+    ]
+
+    # List of instance variables that should not be proxied.
+    NON_PROXIED_INSTANCE_VARIABLES = [
+      :@__fallback__,
+      :@__receiver__
+    ]
+
+    # Initializes a new FallbackContextProxy.
+    #
+    # @param receiver [Object] the primary object to which method calls are delegated.
+    # @param fallback [Object] the secondary object to which method calls are delegated if the primary does not respond.
+    def initialize(receiver, fallback)
+      @__receiver__ = receiver
+      @__fallback__ = fallback
+    end
+
+    # Returns the ID of the primary receiver.
+    #
+    # @return [Object] the ID of the primary receiver.
+    def id
+      @__receiver__.__send__(:id)
+    end
+
+    # Proxies the `sub` method call to the primary receiver or fallback.
+    #
+    # @param args [Array] the arguments to pass to the `sub` method.
+    # @return [Object] the result of the `sub` method call.
+    def sub(...)
+      __proxy_method__(:sub, ...)
+    end
+
+    # Returns the instance variables of the proxy, excluding non-proxied instance variables.
+    #
+    # @return [Array<Symbol>] the instance variables of the proxy.
+    def instance_variables
+      super.map(&:to_sym) - NON_PROXIED_INSTANCE_VARIABLES
+    end
+
+    # Checks if the proxy responds to a given method.
+    #
+    # @param name [Symbol] the name of the method.
+    # @param include_private [Boolean] whether to include private methods.
+    # @return [Boolean] true if the proxy responds to the method, false otherwise.
+    def respond_to_missing?(name, include_private)
+      __proxy_method__(:respond_to?, name, include_private)
+    end
+
+    # Handles method calls that are not explicitly defined in the proxy.
+    #
+    # @param method [Symbol] the name of the method.
+    # @param args [Array] the arguments to pass to the method.
+    # @return [Object] the result of the method call.
+    def method_missing(method, ...)
+      __proxy_method__(method, ...)
+    end
+
+    # Proxies a method call to the primary receiver or fallback.
+    #
+    # @param method [Symbol] the name of the method.
+    # @param args [Array] the arguments to pass to the method.
+    # @return [Object] the result of the method call.
+    # @raise [NoMethodError] if neither the primary receiver nor the fallback respond to the method.
+    def __proxy_method__(method, ...)
+      @__receiver__.__send__(method.to_sym, ...)
+    rescue NoMethodError
+      @__fallback__.__send__(method.to_sym, ...)
+    end
+  end
+end

data/lib/jmeter_perf/helpers/helper.rb

@@ -0,0 +1,63 @@
+module JmeterPerf::Helpers
+  module XmlDocumentUpdater
+    private
+
+    def update(params)
+      params.delete(:name)
+      enabled_disabled(params)
+      if params.instance_of?(Array)
+        update_collection params
+      else
+        params.each do |name, value|
+          node = @doc.children.xpath("//*[contains(@name,\"#{name}\")]")
+          if value.instance_of?(Nokogiri::XML::Builder)
+            node.first.children = value.doc.at_xpath("//builder").children
+          else
+            node.first.content = value unless node.empty?
+          end
+        end
+      end
+    end
+
+    def enabled_disabled(params)
+      return unless params.is_a?(Hash)
+      return unless @doc.children.first.attributes["enabled"]
+      @doc.children.first.attributes["enabled"].value = params[:enabled].to_s.empty? ? "true" : "false"
+    end
+
+    def update_at_xpath(params)
+      params[:update_at_xpath].each do |fragment|
+        if fragment[:xpath]
+          @doc.at_xpath(fragment[:xpath]) << fragment[:value]
+        else
+          fragment.each do |xpath, value|
+            @doc.at_xpath(xpath).content = value
+          end
+        end
+      end
+    end
+
+    def update_collection(params)
+      elements = @doc.at_xpath("//collectionProp/elementProp")
+      params.each_with_index do |param, index|
+        param.each do |name, value|
+          next unless elements&.element_children
+          element = elements.element_children.xpath("//*[contains(@name,\"#{name}\")]")
+          element.last.content = value
+        end
+        if index != params.size - 1 && elements
+          @doc.at_xpath("//collectionProp") << elements.dup
+        end
+      end
+    end
+
+    def enabled(params)
+      # default to true unless explicitly set to false
+      if params.has_key?(:enabled) && params[:enabled] == false
+        "false"
+      else
+        "true"
+      end
+    end
+  end
+end

data/lib/jmeter_perf/helpers/parser.rb

@@ -0,0 +1,143 @@
+require "uri"
+
+module JmeterPerf::Helpers
+  module Parser
+    private
+
+    def parse_http_request(params)
+      if params[:raw_path]
+        params[:path] = params[:url]
+        parse_url(params)
+      else
+        parse_url(params)
+        params[:fill_in] ||= {}
+        params[:params]&.split("&")&.each do |param|
+          name, value = param.split("=")
+          params[:fill_in][name] ||= []
+          params[:fill_in][name] << value
+        end
+      end
+
+      fill_in(params) if params.has_key?(:fill_in)
+      raw_body(params) if params.has_key?(:raw_body)
+      files(params) if params.has_key?(:files)
+    end
+
+    def parse_url(params)
+      return if params[:url].empty?
+      if params[:url] =~ /https?:\/\/\$/ || params[:url][0] == "$"
+        params[:path] = params[:url] # special case for named expressions
+      else
+        uri = parse_uri(params[:url])
+        params[:port] ||= uri.port unless URI.parse(URI::DEFAULT_PARSER.escape(params[:url])).scheme.nil?
+        params[:protocol] ||= uri.scheme unless URI.parse(URI::DEFAULT_PARSER.escape(params[:url])).scheme.nil?
+        params[:domain] ||= uri.host
+        params[:path] ||= uri.path && URI.decode_www_form_component(uri.path)
+        params[:params] ||= uri.query && URI.decode_www_form_component(uri.query)
+      end
+      params.delete(:url)
+    end
+
+    def parse_uri(uri)
+      URI.parse(URI::DEFAULT_PARSER.escape(uri)).scheme.nil? ?
+        URI.parse(URI::DEFAULT_PARSER.escape("http://#{uri}")) :
+        URI.parse(URI::DEFAULT_PARSER.escape(uri))
+    end
+
+    def fill_in(params)
+      params[:update_at_xpath] ||= []
+      params[:update_at_xpath] = params[:fill_in]
+        .each_with_object(params[:update_at_xpath]) do |(name, values), memo|
+          Array(values).each do |value|
+            memo.push({
+              xpath: "//collectionProp",
+              value: Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+                <<-EOF
+                  <elementProp name="#{name}" elementType="HTTPArgument">
+                    <boolProp name="HTTPArgument.always_encode">#{params[:always_encode] ? "true" : false}</boolProp>
+                    <stringProp name="Argument.value">#{value}</stringProp>
+                    <stringProp name="Argument.metadata">=</stringProp>
+                    <boolProp name="HTTPArgument.use_equals">true</boolProp>
+                    <stringProp name="Argument.name">#{name}</stringProp>
+                  </elementProp>
+                EOF
+              )).children
+            })
+          end
+        end
+      params.delete(:fill_in)
+    end
+
+    def raw_body(params)
+      params[:update_at_xpath] ||= []
+      params[:update_at_xpath].push({
+        xpath: "//HTTPSamplerProxy",
+        value: Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<-EOF
+            <boolProp name="HTTPSampler.postBodyRaw">true</boolProp>
+          EOF
+        )).children
+      })
+
+      params[:update_at_xpath].push({
+        xpath: "//collectionProp",
+        value: Nokogiri::XML(JmeterPerf::Helpers::String.strip_heredoc(
+          <<-EOF
+            <elementProp name="" elementType="HTTPArgument">
+              <boolProp name="HTTPArgument.always_encode">false</boolProp>
+              <stringProp name="Argument.value">#{params[:raw_body].encode(xml: :text)}</stringProp>
+              <stringProp name="Argument.metadata">=</stringProp>
+            </elementProp>
+          EOF
+        )).children
+      })
+      params.delete(:raw_body)
+    end
+
+    def files(params)
+      files = params.delete(:files)
+      return if files.empty?
+      x = Nokogiri::XML::Builder.new do |b|
+        b.elementProp(name: "HTTPsampler.Files", elementType: "HTTPFileArgs") {
+          b.collectionProp(name: "HTTPFileArgs.files") {
+            files.each do |f|
+              b.elementProp(name: f[:path], elementType: "HTTPFileArg") {
+                b.stringProp f[:path] || "", name: "File.path"
+                b.stringProp f[:paramname] || "", name: "File.paramname"
+                b.stringProp f[:mimetype] || "", name: "File.mimetype"
+              }
+            end
+          }
+        }
+      end
+      params[:update_at_xpath] ||= []
+      params[:update_at_xpath] << {
+        xpath: "//HTTPSamplerProxy",
+        value: x.doc.root
+      }
+    end
+
+    def parse_test_type(params)
+      case params.keys.first.to_s
+      when "contains"
+        2
+      when "not-contains"
+        6
+      when "matches"
+        1
+      when "not-matches"
+        5
+      when "equals"
+        8
+      when "not-equals"
+        12
+      when "substring"
+        16
+      when "not-substring"
+        20
+      else
+        2
+      end
+    end
+  end
+end

data/lib/jmeter_perf/helpers/running_statistics.rb

@@ -0,0 +1,62 @@
+require "tdigest"
+
+module JmeterPerf::Helpers
+  # Provides running statistics for a series of numbers, including approximate percentiles and
+  # standard deviation.
+  #
+  # @note This class uses a TDigest data structure to keep statistics "close enough". Accuracy is not guaranteed.
+  class RunningStatistisc
+    # The marker for when to call the compression function on the TDigest structure.
+    COMPRESS_MARKER = 1000
+
+    # @return [Float] the running average of the numbers added
+    attr_reader :avg
+
+    # Initializes a new instance of RunningStatistisc to calculate running statistics.
+    #
+    # @return [RunningStatistisc]
+    def initialize
+      @tdigest = ::TDigest::TDigest.new
+      @count = 0
+      @avg = 0
+      @m2 = 0 # Sum of squares of differences from the avg
+    end
+
+    # Adds a number to the running statistics and updates the average and variance calculations.
+    #
+    # @param num [Float] the number to add to the running statistics
+    # @return [void]
+    def add_number(num)
+      @tdigest.push(num)
+
+      @count += 1
+      delta = num - @avg
+      @avg += delta / @count
+      delta2 = num - @avg
+      @m2 += delta * delta2
+
+      # Compress data every 1000 items to maintain memory efficiency
+      @tdigest.compress! if @count % COMPRESS_MARKER == 0
+    end
+
+    # Retrieves approximate percentiles for the data set based on the requested percentile values.
+    #
+    # @param percentiles [Array<Float>] the requested percentiles (e.g., 0.5 for the 50th percentile)
+    # @return [Array<Float>] an array of calculated percentiles corresponding to the requested values
+    # @example Requesting the 10th, 50th, and 95th percentiles
+    #   get_percentiles(0.1, 0.5, 0.95) #=> [some_value_for_10th, some_value_for_50th, some_value_for_95th]
+    def get_percentiles(*percentiles)
+      @tdigest.compress!
+      percentiles.map { |percentile| @tdigest.percentile(percentile) }
+    end
+
+    # Calculates the standard deviation of the numbers added so far.
+    #
+    # @return [Float] the standard deviation, or 0 if fewer than two values have been added
+    def standard_deviation
+      return 0 if @count < 2
+      Math.sqrt(@m2 / (@count - 1))
+    end
+    alias_method :std, :standard_deviation
+  end
+end

data/lib/jmeter_perf/helpers/string.rb

@@ -0,0 +1,60 @@
+module JmeterPerf::Helpers
+  class String
+    class << self
+      # Converts a string to CamelCase.
+      #
+      # @param string [String] the string to be converted.
+      # @return [String] the CamelCase version of the string.
+      def classify(string)
+        camelize(string.gsub(/\s/, "_"))
+      end
+
+      # Converts a string to snake_case.
+      #
+      # @param string [String] the string to be converted.
+      # @return [String] the snake_case version of the string.
+      def underscore(string)
+        string.gsub("::", "/")
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr("-", "_")
+          .downcase
+      end
+
+      # Converts a string to CamelCase or camelCase.
+      #
+      # @param str [String] the string to be converted.
+      # @param uppercase_first_letter [Boolean, Symbol] whether to capitalize the first letter or not.
+      #   If `:lower`, the first letter will be lowercase.
+      # @return [String] the CamelCase or camelCase version of the string.
+      def camelize(str, uppercase_first_letter = true)
+        string = str.dup
+        # String#camelize takes a symbol (:upper or :lower), so here we also support :lower to keep the methods consistent.
+        if !uppercase_first_letter || uppercase_first_letter == :lower
+          string = string.sub(/^(?:(?=a)b(?=\b|[A-Z_])|\w)/) { |match| match.downcase! || match }
+        elsif string.match?(/\A[a-z\d]*\z/)
+          return string.capitalize
+        else
+          string = string.sub(/^[a-z\d]*/) { |match| match.capitalize || match }
+        end
+
+        string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
+          word = $2
+          substituted = word.capitalize! || word
+          ($1) ? "_#{substituted}" : substituted
+        end
+
+        string.gsub!(/[^a-zA-Z0-9]/, "")
+        string
+      end
+
+      # Strips leading whitespace from each line that is the same as the amount of whitespace on the first line.
+      #
+      # @param string [String] the string to be stripped of leading whitespace.
+      # @return [String] the string with leading whitespace removed.
+      def strip_heredoc(string)
+        string.gsub(/^#{string[/\A\s*/]}/, "")
+      end
+    end
+  end
+end

data/lib/jmeter_perf/helpers/user-agents.rb

@@ -0,0 +1,42 @@
+# This module provides a collection of common user-agent strings for various devices and browsers.
+# It allows retrieval of user-agent strings based on device type.
+module JmeterPerf::Helpers
+  module UserAgent
+    # A hash containing user-agent strings for common devices and browsers.
+    # @return [Hash<Symbol, String>] the user-agent strings for various devices and browsers.
+    COMMON_DEVICES = {
+      # User-agent string for iPhone
+      iphone: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",
+      # User-agent string for iPod
+      ipod: "Mozilla/5.0 (iPod touch; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",
+      # User-agent string for iPad
+      ipad: "Mozilla/5.0 (iPad; CPU OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",
+      # User-agent string for Safari on macOS
+      safari_osx: "Mozilla/5.0 (Macintosh; Intel Mac OS X 13_0) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Safari/605.1.15",
+      # User-agent string for Safari on Windows
+      safari_win: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.188",
+      # User-agent string for Edge
+      edge: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.188",
+      # User-agent string for Chrome on macOS
+      chrome_osx: "Mozilla/5.0 (Macintosh; Intel Mac OS X 13_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36",
+      # User-agent string for Chrome on Windows
+      chrome_win: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36",
+      # User-agent string for Firefox on macOS
+      ff_osx: "Mozilla/5.0 (Macintosh; Intel Mac OS X 13.0; rv:115.0) Gecko/20100101 Firefox/115.0",
+      # User-agent string for Firefox on Windows
+      ff_win: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:115.0) Gecko/20100101 Firefox/115.0",
+      # User-agent string for Opera on macOS
+      opera_osx: "Mozilla/5.0 (Macintosh; Intel Mac OS X 13.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 OPR/102.0.0.0",
+      # User-agent string for Opera on Windows
+      opera_win: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 OPR/102.0.0.0"
+    }
+
+    # Retrieves the user-agent string for the specified device.
+    #
+    # @param device [Symbol] the device type for which to retrieve the user-agent string.
+    # @return [String] the user-agent string for the specified device, or the default Chrome on macOS user-agent string if the device is not found.
+    def self.string(device)
+      COMMON_DEVICES[device] || COMMON_DEVICES[:chrome_osx]
+    end
+  end
+end

data/lib/jmeter_perf/plugins/active_threads_over_time.rb

@@ -0,0 +1,59 @@
+module JmeterPerf
+  module Plugins
+    class ActiveThreadsOverTime
+      attr_accessor :doc
+      include JmeterPerf::Helpers::XmlDocumentUpdater
+      def initialize(params = {})
+        testname = params.is_a?(Array) ? "ActiveThreadsOverTime" : (params[:name] || "ActiveThreadsOverTime")
+        @doc = Nokogiri::XML(
+          JmeterPerf::Helpers::String.strip_heredoc(
+            <<-XML
+              <kg.apc.jmeter.vizualizers.CorrectedResultCollector guiclass="kg.apc.jmeter.vizualizers.ThreadsStateOverTimeGui" testclass="kg.apc.jmeter.vizualizers.CorrectedResultCollector" testname="#{testname}" enabled="true">
+                <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>false</message>
+                    <threadName>true</threadName>
+                    <dataType>false</dataType>
+                    <encoding>false</encoding>
+                    <assertions>false</assertions>
+                    <subresults>false</subresults>
+                    <responseData>false</responseData>
+                    <samplerData>false</samplerData>
+                    <xml>false</xml>
+                    <fieldNames>false</fieldNames>
+                    <responseHeaders>false</responseHeaders>
+                    <requestHeaders>false</requestHeaders>
+                    <responseDataOnError>false</responseDataOnError>
+                    <saveAssertionResultsFailureMessage>false</saveAssertionResultsFailureMessage>
+                    <assertionsResultsToSave>0</assertionsResultsToSave>
+                    <bytes>true</bytes>
+                    <threadCounts>true</threadCounts>
+                    <sampleCount>true</sampleCount>
+                  </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>
+                <stringProp name="start_offset"></stringProp>
+                <stringProp name="end_offset"></stringProp>
+                <boolProp name="include_checkbox_state">false</boolProp>
+                <boolProp name="exclude_checkbox_state">false</boolProp>
+              </kg.apc.jmeter.vizualizers.CorrectedResultCollector>
+            XML
+          )
+        )
+        update params
+      end
+    end
+  end
+end