nice_http 1.8.10 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df4f8b1cf983332827d337db8371accf6d74e5ee33f0b9e226ba42c99ab8214c
-  data.tar.gz: 1c69869b4508a7b70972b010673c28f18301765da25b209e00024bcaab8c2f1d
+  metadata.gz: 05ea4d762f4ce03ab7f89c6ca4aafd323c549c73f686f349dac356e43918ffa5
+  data.tar.gz: a9f1c491dabcd6e559f9454a10a7caeeddea4aac915d10be0548d5465fe1a256
 SHA512:
-  metadata.gz: 46eb5827fee9728f51deb59a2fa5354427da8effb4cdc61e35e0ad71291bef5fa0ad002f2296ab1921b72c4d102384a7518754d35e7da44391c5df39818fa226
-  data.tar.gz: 80a9201476a08a6f0c7a5bc97032c468032a4751a3d768665eddf9dbcbc21fd270942813ad8a53240178036afbf29d9bbaeea4e78c752bfa420c85370921d6eb
+  metadata.gz: 5744a1f61ef6835e7dca5fffa15617e7ecd842b28f4cdb7019f1583e95483d841ccdee5d07506d2e7d9d6b8e5ba6dc986e5425f89b20b91abec9ebfab555917c
+  data.tar.gz: f33f3d76090238a2f9b483a2791b295a908355072586d418f185c8326c3096700f3f89f5e477eb3e0191d256fd824ced3974d5ec628b34aba3ce0bd99179fa63

data/README.md

@@ -27,6 +27,7 @@ Example that creates 1000 good random and unique requests to register an user an
 - [Create a connection](#Create-a-connection)
 - [Creating requests](#Creating-requests)
 - [Responses](#Responses)
+    - [Async Responses](#Async-Responses)
 - [Special settings](#Special-settings)
 - [Authentication requests](#Authentication-requests)
     - [Basic Authentication](#Basic-Authentication)
@@ -259,7 +260,18 @@ NiceHttp.requests = {
 }
 ```
 
-You can use `NiceHttp.requests` to specify certain `headers` or `data` that will apply on all requests sent.
+You can use `NiceHttp.requests` to specify certain `headers`, `path` parameters or `data` that will apply on all requests sent.
+```ruby
+NiceHttp.requests = {
+  path: 'api-version=2022-12-09&testing=true',
+  data: {
+    properties: {
+      language: 'eng-us'
+    }
+  }
+}
+```
+
 
 ## Responses
 
@@ -271,7 +283,45 @@ The response will include at least the keys:
 
 *data*: the data response structure. In case of json we can get it as a hash by using: `resp.data.json`. Also you can filter the json structure and get what you want: `resp.data.json(:loginname, :address)`
 
-Also interesting keys would be: *time_elapsed_total*, *time_elapsed* and many more available
+Also interesting keys would be: *time_elapsed_total*, *time_elapsed* and many more available  
+
+### Async responses
+
+In case a 202 response and set the async settings, it will wait until the operation finishes and will return the result:
+
+```ruby
+NiceHttp.async_wait_seconds = 10
+NiceHttp.async_header = 'location'
+NiceHttp.async_completed = 'percComplete'
+NiceHttp.async_resource = 'resourceName'
+NiceHttp.async_status = 'status'
+
+http = NiceHttp.new('https://exampleSinatra.tcblues.repl.co')
+
+response = http.get '/async'
+pp response # =>
+{ :code=>"202",
+  :message=>"Accepted",
+  :location=>"https://exampleSinatra.tcblues.repl.co/operation/667",
+  :data=>"{\"result\":\"this is an async operation id: 667\"}",
+  :async=>
+    { :seconds=>4,
+      :data=>
+        "{'percComplete':100,'resourceName':'/resource/766','status':'Done','operationId':'667'}",
+      :status=>"Done",
+      :resource=>{:data=>"{'resourceId':'766','lolo':'lala'}"}
+    }
+  # plus other keys
+}
+
+p response.code # 202
+p response.location # "https://exampleSinatra.tcblues.repl.co/operation/667"
+p response.data.json # {:result=>"this is an async operation id: 667"} 
+p response.async.data.json # {:percComplete=>100, :resourceName=>"/resource/766", :status=>"Done",:operationId=>667}
+p response.async.status # Done
+p response.async.seconds # 4
+p response.async.resource.data.json # {:resourceId=>"766", :lolo=>"lala"}
+```
 
 
 ## Special settings
@@ -734,7 +784,7 @@ Example posting a csv file:
 
 Bug reports are very welcome on GitHub at https://github.com/marioruiz/nice_http.
 
-If you want to contribute please follow [GitHub Flow](https://guides.github.com/introduction/flow/index.html)
+If you want to contribute please follow [GitHub Flow](https://docs.github.com/en/get-started/quickstart/github-flow)
 
 ## License
 

data/lib/nice_http/add_stats.rb

@@ -0,0 +1,85 @@
+class NiceHttp
+  ######################################################
+  # To add specific stats
+  # The stats will be added to NiceHttp.stats[:specific]
+  #
+  # @param name [Symbol] name to group your specific stats
+  # @param state [Symbol] state of the name supplied to group your specific stats
+  # @param started [Time] when the process you want the stats started
+  # @param finished [Time] when the process you want the stats finished
+  # @param item [Object] (Optional) The item to be added to :items key to store all items in an array
+  #
+  # @example
+  #   started = Time.now
+  #   @http.send_request Requests::Customer.add_customer
+  #   30.times do
+  #      resp = @http.get(Requests::Customer.get_customer)
+  #      break if resp.code == 200
+  #      sleep 0.5
+  #   end
+  #   NiceHttp.add_stats(:customer, :create, started, Time.now)
+  ######################################################
+  def self.add_stats(name, state, started, finished, item = nil)
+    self.stats[:specific] ||= {}
+    self.stats[:specific][name] ||= { num: 0, started: started, finished: started, real_time_elapsed: 0, time_elapsed: { total: 0, maximum: 0, minimum: 100000, average: 0 } }
+    self.stats[:specific][name][:num] += 1
+
+    if started < self.stats[:specific][name][:finished]
+      self.stats[:specific][name][:real_time_elapsed] += (finished - self.stats[:specific][name][:finished])
+    else
+      self.stats[:specific][name][:real_time_elapsed] += (finished - started)
+    end
+    self.stats[:specific][name][:finished] = finished
+
+    time_elapsed = self.stats[:specific][name][:time_elapsed]
+    time_elapsed[:total] += finished - started
+    if time_elapsed[:maximum] < (finished - started)
+      time_elapsed[:maximum] = (finished - started)
+      if !item.nil?
+        time_elapsed[:item_maximum] = item
+      elsif Thread.current.name.to_s != ""
+        time_elapsed[:item_maximum] = Thread.current.name
+      end
+    end
+    if time_elapsed[:minimum] > (finished - started)
+      time_elapsed[:minimum] = (finished - started)
+      if !item.nil?
+        time_elapsed[:item_minimum] = item
+      elsif Thread.current.name.to_s != ""
+        time_elapsed[:item_minimum] = Thread.current.name
+      end
+    end
+    time_elapsed[:average] = time_elapsed[:total] / self.stats[:specific][name][:num]
+
+    self.stats[:specific][name][state] ||= { num: 0, started: started, finished: started, real_time_elapsed: 0, time_elapsed: { total: 0, maximum: 0, minimum: 1000, average: 0 }, items: [] }
+    self.stats[:specific][name][state][:num] += 1
+    if started < self.stats[:specific][name][state][:finished]
+      self.stats[:specific][name][state][:real_time_elapsed] += (finished - self.stats[:specific][name][state][:finished])
+    else
+      self.stats[:specific][name][state][:real_time_elapsed] += (finished - started)
+    end
+
+    self.stats[:specific][name][state][:finished] = finished
+
+    self.stats[:specific][name][state][:items] << item unless item.nil? or self.stats[:specific][name][state][:items].include?(item)
+    time_elapsed = self.stats[:specific][name][state][:time_elapsed]
+    time_elapsed[:total] += finished - started
+    if time_elapsed[:maximum] < (finished - started)
+      time_elapsed[:maximum] = (finished - started)
+      if !item.nil?
+        time_elapsed[:item_maximum] = item
+      elsif Thread.current.name.to_s != ""
+        time_elapsed[:item_maximum] = Thread.current.name
+      end
+    end
+    if time_elapsed[:minimum] > (finished - started)
+      time_elapsed[:minimum] = (finished - started)
+      if !item.nil?
+        time_elapsed[:item_minimum] = item
+      elsif Thread.current.name.to_s != ""
+        time_elapsed[:item_minimum] = Thread.current.name
+      end
+    end
+    time_elapsed[:average] = time_elapsed[:total] / self.stats[:specific][name][state][:num]
+  end
+end

data/lib/nice_http/close.rb

@@ -0,0 +1,39 @@
+class NiceHttp
+  ######################################################
+  # Close HTTP connection
+  ######################################################
+  def close
+    begin
+      pos = 0
+      found = false
+      self.class.connections.each { |conn|
+        if conn.object_id == self.object_id
+          found = true
+          break
+        else
+          pos += 1
+        end
+      }
+      if found
+        self.class.connections.delete_at(pos)
+      end
+
+      unless @closed
+        if !@http.nil?
+          @http.finish()
+          @http = nil
+          @logger.info "the HTTP connection was closed: #{@message_server}"
+        else
+          @http = nil
+          @logger.fatal "It was not possible to close the HTTP connection: #{@message_server}"
+        end
+        @closed = true
+      else
+        @logger.warn "It was not possible to close the HTTP connection, already closed: #{@message_server}"
+      end
+    rescue Exception => stack
+      @logger.fatal stack
+    end
+    self.class.active -= 1
+  end
+end

data/lib/nice_http/defaults.rb

@@ -0,0 +1,30 @@
+class NiceHttp
+  ######################################################
+  # Change the default values for NiceHttp supplying a Hash
+  #
+  # @param par [Hash] keys: :host, :port, :ssl, :timeout, :headers, :debug, :log, :log_path, :proxy_host, :proxy_port, :use_mocks, :auto_redirect, :values_for, :create_stats, :log_headers, :capture, :async_wait_seconds, :async_header, :async_completed, :async_resource, :async_status
+  ######################################################
+  def self.defaults=(par = {})
+    @host = par[:host] if par.key?(:host)
+    @port = par[:port] if par.key?(:port)
+    @ssl = par[:ssl] if par.key?(:ssl)
+    @timeout = par[:timeout] if par.key?(:timeout)
+    @headers = par[:headers].dup if par.key?(:headers)
+    @values_for = par[:values_for].dup if par.key?(:values_for)
+    @debug = par[:debug] if par.key?(:debug)
+    @log_path = par[:log_path] if par.key?(:log_path)
+    @log = par[:log] if par.key?(:log)
+    @log_headers = par[:log_headers] if par.key?(:log_headers)
+    @proxy_host = par[:proxy_host] if par.key?(:proxy_host)
+    @proxy_port = par[:proxy_port] if par.key?(:proxy_port)
+    @use_mocks = par[:use_mocks] if par.key?(:use_mocks)
+    @auto_redirect = par[:auto_redirect] if par.key?(:auto_redirect)
+    @create_stats = par[:create_stats] if par.key?(:create_stats)
+    @capture = par[:capture] if par.key?(:capture)
+    @async_wait_seconds = par[:async_wait_seconds] if par.key?(:async_wait_seconds)
+    @async_header = par[:async_header] if par.key?(:async_header)
+    @async_completed = par[:async_completed] if par.key?(:async_completed)
+    @async_resource = par[:async_resource] if par.key?(:async_resource)
+    @async_status = par[:async_status] if par.key?(:async_status)    
+  end
+end

data/lib/nice_http/inherited.rb

@@ -0,0 +1,8 @@
+class NiceHttp
+  ######################################################
+  # If inheriting from NiceHttp class
+  ######################################################
+  def self.inherited(subclass)
+    subclass.reset!
+  end
+end

data/lib/nice_http/initialize.rb

@@ -0,0 +1,253 @@
+class NiceHttp
+  ######################################################
+  # Creates a new http connection.
+  #
+  # @param args [] If no parameter supplied, by default will access how is setup on defaults
+  # @example
+  #   http = NiceHttp.new()
+  # @param args [String]. The url to create the connection.
+  # @example
+  #   http = NiceHttp.new("https://www.example.com")
+  # @example
+  #   http = NiceHttp.new("example.com:8999")
+  # @example
+  #   http = NiceHttp.new("localhost:8322")
+  # @param args [Hash] containing these possible keys:
+  #             host -- example.com. (default blank screen)
+  #             port -- port for the connection. 80 (default)
+  #             ssl -- true, false (default)
+  #             timeout -- integer or nil (default)
+  #             headers -- hash with the headers
+  #             values_for -- hash with the values_for
+  #             debug -- true, false (default)
+  #             log_path -- string with path for the logs, empty string (default)
+  #             log -- :no, :screen, :file, :fix_file (default).
+  #             log_headers -- :all, :none, :partial (default).
+  #                 A string with a path can be supplied.
+  #                 If :fix_file: nice_http.log
+  #                 In case :file it will be generated a log file with name: nice_http_YY-mm-dd-HHMMSS.log
+  #             proxy_host
+  #             proxy_port
+  #             async_wait_seconds -- integer (default 0)
+  #             async_header -- string (default 'location')
+  #             async_completed -- string (default empty string)
+  #             async_resource -- string (default empty string)
+  #             async_status -- string (default empty string)
+  # @example
+  #   http2 = NiceHttp.new( host: "reqres.in", port: 443, ssl: true )
+  # @example
+  #   my_server = {host: "example.com",
+  #                port: 80,
+  #                headers: {"api-key": "zdDDdjkck"}
+  #               }
+  #   http3 = NiceHttp.new my_server
+  ######################################################
+  def initialize(args = {})
+    require "net/http"
+    require "net/https"
+    @host = self.class.host
+    @port = self.class.port
+    @prepath = ""
+    @ssl = self.class.ssl
+    @timeout = self.class.timeout
+    @headers = self.class.headers.dup
+    @values_for = self.class.values_for.dup
+    @debug = self.class.debug
+    @log = self.class.log
+    @log_path = self.class.log_path
+    @log_headers = self.class.log_headers
+    @proxy_host = self.class.proxy_host
+    @proxy_port = self.class.proxy_port
+    @use_mocks = self.class.use_mocks
+    @auto_redirect = false #set it up at the end of initialize
+    auto_redirect = self.class.auto_redirect
+    @num_redirects = 0
+    @create_stats = self.class.create_stats
+    @capture = self.class.capture
+    @async_wait_seconds = self.class.async_wait_seconds
+    @async_header = self.class.async_header
+    @async_completed = self.class.async_completed
+    @async_resource = self.class.async_resource
+    @async_status = self.class.async_status
+    
+    #todo: set only the cookies for the current domain
+    #key: path, value: hash with key is the name of the cookie and value the value
+    # we set the default value for non existing keys to empty Hash {} so in case of merge there is no problem
+    @cookies = Hash.new { |h, k| h[k] = {} }
+
+    if args.is_a?(String) # 'http://www.example.com'
+      uri = URI.parse(args)
+      @host = uri.host unless uri.host.nil?
+      @port = uri.port unless uri.port.nil?
+      @ssl = true if !uri.scheme.nil? && (uri.scheme == "https")
+      @prepath = uri.path unless uri.path == "/"
+    elsif args.is_a?(Hash) && !args.keys.empty?
+      @host = args[:host] if args.keys.include?(:host)
+      @port = args[:port] if args.keys.include?(:port)
+      @ssl = args[:ssl] if args.keys.include?(:ssl)
+      @timeout = args[:timeout] if args.keys.include?(:timeout)
+      @headers = args[:headers].dup if args.keys.include?(:headers)
+      @values_for = args[:values_for].dup if args.keys.include?(:values_for)
+      @debug = args[:debug] if args.keys.include?(:debug)
+      @log = args[:log] if args.keys.include?(:log)
+      @log_path = args[:log_path] if args.keys.include?(:log_path)
+      @log_headers = args[:log_headers] if args.keys.include?(:log_headers)
+      @proxy_host = args[:proxy_host] if args.keys.include?(:proxy_host)
+      @proxy_port = args[:proxy_port] if args.keys.include?(:proxy_port)
+      @use_mocks = args[:use_mocks] if args.keys.include?(:use_mocks)
+      auto_redirect = args[:auto_redirect] if args.keys.include?(:auto_redirect)
+      @async_wait_seconds = args[:async_wait_seconds] if args.keys.include?(:async_wait_seconds)
+      @async_header = args[:async_header] if args.keys.include?(:async_header)
+      @async_completed = args[:async_completed] if args.keys.include?(:async_completed)
+      @async_resource = args[:async_resource] if args.keys.include?(:async_resource)
+      @async_status = args[:async_status] if args.keys.include?(:async_status)      
+    end
+
+    log_filename = ""
+    if @log.kind_of?(String) or @log == :fix_file or @log == :file or @log == :file_run
+      if @log.kind_of?(String)
+        log_filename = @log.dup
+        unless log_filename.start_with?(".")
+          if caller.first.start_with?(Dir.pwd)
+            folder = File.dirname(caller.first.scan(/(.+):\d/).join)
+          else
+            folder = File.dirname("#{Dir.pwd}/#{caller.first.scan(/(.+):\d/).join}")
+          end
+          folder += "/" unless log_filename.start_with?("/") or log_filename.match?(/^\w+:/)
+          log_filename = folder + log_filename
+        end
+        require "fileutils"
+        FileUtils.mkdir_p File.dirname(log_filename)
+        unless Dir.exist?(File.dirname(log_filename))
+          @logger = Logger.new nil
+          raise InfoMissing, :log, "Wrong directory specified for logs.\n"
+        end
+      elsif @log == :fix_file
+        log_filename = "nice_http.log"
+      elsif @log == :file
+        log_filename = "nice_http_#{Time.now.strftime("%Y-%m-%d-%H%M%S")}.log"
+      elsif @log == :file_run
+        log_filename = "#{caller.first.scan(/(.+):\d/).join}.log"
+      end
+      if Thread.current.name.to_s != ""
+        log_filename.gsub!(/\.log$/, "_#{Thread.current.name}.log")
+      end
+      unless @log_path.to_s == ""
+        log_filename.gsub!(Dir.pwd, ".")
+        dpath = @log_path.split("/")
+        dfile = log_filename.split("/")
+        log_filenamepath = ""
+        dfile.each_with_index do |d, i|
+          if d == dpath[i]
+            log_filenamepath << "#{d}/"
+          else
+            log_filename = @log_path + "#{log_filename.gsub(/^#{log_filenamepath}/, "")}"
+            break
+          end
+        end
+        log_filename = "./#{log_filename}" unless log_filename[0..1] == "./"
+        log_filename = ".#{log_filename}" unless log_filename[0] == "."
+
+        unless File.exist?(log_filename)
+          require "fileutils"
+          FileUtils.mkdir_p(File.dirname(log_filename))
+        end
+      end
+
+      if self.class.log_files.key?(log_filename) and File.exist?(log_filename)
+        @logger = self.class.log_files[log_filename]
+      else
+        begin
+          f = File.new(log_filename, "w")
+          f.sync = true
+          @logger = Logger.new f
+        rescue Exception => stack
+          @logger = Logger.new nil
+          raise InfoMissing, :log
+        end
+        self.class.log_files[log_filename] = @logger
+      end
+    elsif @log == :screen
+      @logger = Logger.new STDOUT
+    elsif @log == :no
+      @logger = Logger.new nil
+    else
+      raise InfoMissing, :log
+    end
+    @logger.level = Logger::INFO
+
+    if @host.to_s != "" and (@host.start_with?("http:") or @host.start_with?("https:"))
+      uri = URI.parse(@host)
+      @host = uri.host unless uri.host.nil?
+      @port = uri.port unless uri.port.nil?
+      @ssl = true if !uri.scheme.nil? && (uri.scheme == "https")
+      @prepath = uri.path unless uri.path == "/"
+    end
+    raise InfoMissing, :port if @port.to_s == ""
+    raise InfoMissing, :host if @host.to_s == ""
+    raise InfoMissing, :ssl unless @ssl.is_a?(TrueClass) or @ssl.is_a?(FalseClass)
+    raise InfoMissing, :timeout unless @timeout.is_a?(Integer) or @timeout.nil?
+    raise InfoMissing, :debug unless @debug.is_a?(TrueClass) or @debug.is_a?(FalseClass)
+    raise InfoMissing, :auto_redirect unless auto_redirect.is_a?(TrueClass) or auto_redirect.is_a?(FalseClass)
+    raise InfoMissing, :use_mocks unless @use_mocks.is_a?(TrueClass) or @use_mocks.is_a?(FalseClass)
+    raise InfoMissing, :headers unless @headers.is_a?(Hash)
+    raise InfoMissing, :values_for unless @values_for.is_a?(Hash)
+    raise InfoMissing, :log_headers unless [:all, :none, :partial].include?(@log_headers)
+    raise InfoMissing, :async_wait_seconds unless @async_wait_seconds.is_a?(Integer) or @async_wait_seconds.nil?
+    raise InfoMissing, :async_header unless @async_header.is_a?(String) or @async_header.nil?
+    raise InfoMissing, :async_completed unless @async_completed.is_a?(String) or @async_completed.nil?
+    raise InfoMissing, :async_resource unless @async_resource.is_a?(String) or @async_resource.nil?
+    raise InfoMissing, :async_status unless @async_status.is_a?(String) or @async_status.nil?
+    
+    begin
+      if !@proxy_host.nil? && !@proxy_port.nil?
+        @http = Net::HTTP::Proxy(@proxy_host, @proxy_port).new(@host, @port)
+        @http.use_ssl = @ssl
+        @http.set_debug_output $stderr if @debug
+        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        unless @timeout.nil?
+          @http.open_timeout = @timeout
+          @http.read_timeout = @timeout
+        end
+        @http.start
+      else
+        @http = Net::HTTP.new(@host, @port)
+        @http.use_ssl = @ssl
+        @http.set_debug_output $stderr if @debug
+        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        unless @timeout.nil?
+          @http.open_timeout = @timeout
+          @http.read_timeout = @timeout
+        end
+        @http.start
+      end
+
+      @message_server = "(#{self.object_id}):"
+
+      log_message = "(#{self.object_id}): Http connection created. host:#{@host},  port:#{@port},  ssl:#{@ssl}, timeout:#{@timeout}, mode:#{@mode}, proxy_host: #{@proxy_host.to_s()}, proxy_port: #{@proxy_port.to_s()} "
+
+      @logger.info(log_message)
+      @message_server += " Http connection: "
+      if @ssl
+        @message_server += "https://"
+      else
+        @message_server += "http://"
+      end
+      @message_server += "#{@host}:#{@port}"
+      if @proxy_host.to_s != ""
+        @message_server += " proxy:#{@proxy_host}:#{@proxy_port}"
+      end
+      @auto_redirect = auto_redirect
+      # for the case we have headers following nice_hash implementation
+      @headers_orig = @headers.dup
+      @headers = @headers.generate
+
+      self.class.active += 1
+      self.class.connections.push(self)
+    rescue Exception => stack
+      puts stack
+      @logger.fatal stack
+      raise stack
+    end
+  end
+end

data/lib/nice_http/manage/create_stats.rb

@@ -0,0 +1,64 @@
+module NiceHttpManageResponse
+  private
+
+  def create_stats(resp)
+    # all
+    set_stats(self.class.stats[:all])
+    # all method
+    unless self.class.stats[:all][:method].key?(@prev_request[:method])
+      self.class.stats[:all][:method][@prev_request[:method]] = {
+        response: {},
+      }
+    end
+    set_stats(self.class.stats[:all][:method][@prev_request[:method]])
+    # all method response
+    unless self.class.stats[:all][:method][@prev_request[:method]][:response].key?(resp.code)
+      self.class.stats[:all][:method][@prev_request[:method]][:response][resp.code] = {}
+    end
+    set_stats(self.class.stats[:all][:method][@prev_request[:method]][:response][resp.code])
+
+    # server
+    server = "#{@host}:#{@port}"
+    unless self.class.stats[:path].key?(server)
+      self.class.stats[:path][server] = {}
+    end
+    set_stats(self.class.stats[:path][server])
+    # server path
+    unless self.class.stats[:path][server].key?(@prev_request[:path])
+      self.class.stats[:path][server][@prev_request[:path]] = { method: {} }
+    end
+    set_stats(self.class.stats[:path][server][@prev_request[:path]])
+    # server path method
+    unless self.class.stats[:path][server][@prev_request[:path]][:method].key?(@prev_request[:method])
+      self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]] = {
+        response: {},
+      }
+    end
+    set_stats(self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]])
+    # server path method response
+    unless self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]][:response].key?(resp.code)
+      self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]][:response][resp.code] = {}
+    end
+    set_stats(self.class.stats[:path][server][@prev_request[:path]][:method][@prev_request[:method]][:response][resp.code])
+
+    if @prev_request.key?(:name)
+      # name
+      unless self.class.stats[:name].key?(@prev_request[:name])
+        self.class.stats[:name][@prev_request[:name]] = { method: {} }
+      end
+      set_stats(self.class.stats[:name][@prev_request[:name]])
+      # name method
+      unless self.class.stats[:name][@prev_request[:name]][:method].key?(@prev_request[:method])
+        self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]] = {
+          response: {},
+        }
+      end
+      set_stats(self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]])
+      # name method response
+      unless self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]][:response].key?(resp.code)
+        self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]][:response][resp.code] = {}
+      end
+      set_stats(self.class.stats[:name][@prev_request[:name]][:method][@prev_request[:method]][:response][resp.code])
+    end
+  end
+end

data/lib/nice_http/{manage_request.rb → manage/request.rb}

@@ -35,6 +35,13 @@ module NiceHttpManageRequest
         path = arguments[0].to_s()
       end
       path = (@prepath + path).gsub("//", "/") unless path.nil? or path.start_with?("http:") or path.start_with?("https:")
+
+      if @defaults_request.key?(:path) and @defaults_request[:path].is_a?(String) and !@defaults_request[:path].empty?
+        path += "?" if !path.include?("?") and !@defaults_request[:path].include?("?")
+        path += '&' if path.match?(/\?.+$/) and @defaults_request[:path][0]!='&'
+        path += @defaults_request[:path]
+      end
+
       @cookies.each { |cookie_path, cookies_hash|
         cookie_path = "" if cookie_path == "/"
         path_to_check = path
@@ -112,7 +119,7 @@ module NiceHttpManageRequest
                                       !headers_t["Content-Type"][/application\/jxml/].nil?)
           if arguments[0].include?(:values_for)
             arguments[0][:values_for].each { |key, value|
-              #todo: implement set_nested 
+              #todo: implement set_nested
               data = NiceHttpUtils.set_value_xml_tag(key.to_s(), data, value.to_s(), true)
             }
           end
@@ -121,7 +128,7 @@ module NiceHttpManageRequest
           if data.kind_of?(String)
             if arguments[0].include?(:values_for)
               arguments[0][:values_for].each { |key, value|
-              #todo: implement set_nested
+                #todo: implement set_nested
                 data.gsub!(/"(#{key})":\s*"([^"]*)"/, '"\1": "' + value + '"')  # "key":"value"
                 data.gsub!(/(#{key}):\s*"([^"]*)"/, '\1: "' + value + '"')  # key:"value"
                 data.gsub!(/(#{key}):\s*'([^']*)'/, '\1: \'' + value + "'")  # key:'value'
@@ -134,7 +141,7 @@ module NiceHttpManageRequest
             #lambdas on data only supports on root of the hash
             data.each do |k, v|
               if v.is_a?(Proc)
-                data[k] = v.call 
+                data[k] = v.call
               end
             end
             if arguments[0].include?(:values_for)
@@ -142,7 +149,7 @@ module NiceHttpManageRequest
             end
             data = data.to_json()
           elsif data.kind_of?(Array)
-            #todo: implement set_nested 
+            #todo: implement set_nested
             data_arr = Array.new()
             data.each_with_index { |row, indx|
               if arguments[0].include?(:values_for) and (row.is_a?(Array) or row.is_a?(Hash))
@@ -218,7 +225,7 @@ module NiceHttpManageRequest
       headers_t.each do |k, v|
         # for lambdas
         if v.is_a?(Proc)
-          headers_t[k] = v.call 
+          headers_t[k] = v.call
         end
       end
       @request[:headers] = headers_t
@@ -245,11 +252,11 @@ module NiceHttpManageRequest
         headers_t.each { |key, val| headers_ts += key.to_s + ":" + "''" + ", " }
       elsif @log_headers == :partial
         @logger.info "Just the last 10 characters on header values since option log_headers is set to :partial"
-        headers_t.each { |key, val| 
-          if val.to_s.size>10
-            headers_ts += key.to_s + ": ..." + (val.to_s[-10..-1] || val.to_s) + ", " 
+        headers_t.each { |key, val|
+          if val.to_s.size > 10
+            headers_ts += key.to_s + ": ..." + (val.to_s[-10..-1] || val.to_s) + ", "
           else
-            headers_ts += key.to_s + ":" + (val.to_s[-10..-1] || val.to_s) + ", " 
+            headers_ts += key.to_s + ":" + (val.to_s[-10..-1] || val.to_s) + ", "
           end
         }
       else