nice_http 1.8.2 → 1.8.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15cb5c2a1e8c6df4d82ead3b1185f981d556c94c1ec358fa868d83a7a2cfb643
-  data.tar.gz: 7893ef6a779be11d71f8c5c7f468fd063ea41af0f6d63fbe3451c164e0fc3573
+  metadata.gz: 8d4be3fb22aecfd4d84cb2c9384da399cf7a521742bba214f5e2746491120f4b
+  data.tar.gz: c2a143357e458385078c5e6709100d06ae473f7363282eb9c36c766618631dcf
 SHA512:
-  metadata.gz: ebdd1df7c1b70729affae816609537cf637f6e3ccf38f6533bba24f941e60bccccc21695f6f96bd0d14f1f96ae9579cddbfea7d552823af888d25906d994a4ba
-  data.tar.gz: aa3e345d27836d891183909917679dc98520e0f0f9d64ce6c0d7588f521415ac26e7e94a63c4a328e5100a5e0e968a79aae3532ecce6df2b755e1a796bcba47a
+  metadata.gz: 7e752817f9ca1b87b944904435c2a507b41cc8c76e0744ff10a4db1f21ea7009a75255d97b45d6a381cd7f1ed30d91ef1fc46371fb935e6cd18482df3867f693
+  data.tar.gz: 6269a98fa4e85bf2a9b13069d279bd58f184267b5b38342a1aa5c3cfbe855207bbacb94b91f5f22e2735426fc726326be381edaab27229f943455569ce157e3d

data/README.md

@@ -29,6 +29,11 @@ Example that creates 1000 good random and unique requests to register an user an
 - [Responses](#Responses)
 - [Special settings](#Special-settings)
 - [Authentication requests](#Authentication-requests)
+    - [Basic Authentication](#Basic-Authentication)
+    - [OpenID](#OpenID)
+    - [OAuth2](#OAuth2)
+    - [JWT Token](#JWT-Token)
+    - [lambda on headers](#lambda-on-headers)
 - [Http logs](#Http-logs)
     - [Multithreading](#Multithreading)
 - [Http stats](#Http-stats)
@@ -117,6 +122,7 @@ NiceHttp.defaults = {
     host: 'reqres.in',
     ssl: true,
     port: 443,
+    timeout: 15, #seconds
     debug: false,
     log: "./my_logs.log",
     headers: {"api-key": "the api key"}
@@ -241,6 +247,19 @@ If the request hash contains a key :method with one of these possible values: :g
      resp = @http.send_request req
 ```
 
+You can always access to the last request as a Hash object by: `NiceHttp.request`
+
+If you want to change the value of all headers using the value of the request on runtime, use `lambda`, `NiceHttp.requests` and `NiceHttp.request`:
+
+```ruby
+NiceHttp.requests = {
+  headers: {
+    Referer: lambda { "http://myserver.com" + NiceHttp.request.path }
+  }
+}
+```
+
+You can use `NiceHttp.requests` to specify certain `headers` or `data` that will apply on all requests sent.
 
 ## Responses
 
@@ -271,10 +290,14 @@ Also interesting keys would be: *time_elapsed_total*, *time_elapsed* and many mo
 
 *auto_redirect*: (true or false) in case of true it will take care of the auto redirections.
 
+*timeout*: Integer that will set a time out for the time waiting to connect to a host or waiting for a response.
+
 ## Authentication requests
 
 All we need to do is to add to our request the correct authentication tokens, seeds, headers.
 
+### Basic Authentication
+
 For example for Basic Authentication we need to add to the authorization header a seed generated with the user and password we want ot authenticate
 
 ```ruby
@@ -305,6 +328,8 @@ Remember for other kind of authentication systems NiceHttp take care of the redi
 
 In case you want or need to control the redirections by yourself instead of allowing NiceHttp to do it, then set ```@http.auto_redirect = false```
 
+### OpenID
+
 An example using OpenID authentication:
 
 ```ruby
@@ -349,17 +374,65 @@ The output:
 
 ```
 
+### OAuth2
+
 You can see on the next link how to get the OAuth2 token for Microsoft Azure and add it to your Http connection header. 
 
 https://gist.github.com/MarioRuiz/d3525185024737885c0c9afa6dc8b9e5
 
+### JWT token
+
+An example for Google using JWT
+
+my_json_key_file.json:
+```json
+{
+  "type": "service_account",
+  "project_id": "example",
+  "private_key_id": "fjdslkafldkasfadsjflkjdsaklfjasdklfjlkdsjfl",
+  "private_key": "-----BEGIN PRIVATE KEY-----....==\n-----END PRIVATE KEY-----\n",
+  "client_email": "example@example.iam.gserviceaccount.com",
+  "client_id": "46545646",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/example%40example.iam.gserviceaccount.com"
+}
+```
+
+```ruby
+    require 'jwt'
+    require 'nice_hash'
+    def generate_jwt(audience, json_key_file)
+      json = File.open(json_key_file).read.json
+      now = Time.new
+      payload = {
+        iss: json.client_email,
+        sub: json.client_email,
+        aud: audience,
+        exp: (now + 3600).to_i,
+        iat: (now - 60).to_i,
+        kid: json.private_key_id
+      }
+      jwt_token = JWT.encode payload, OpenSSL::PKey::RSA.new(json.private_key), "RS256"
+      return jwt_token
+    end
+
+    NiceHttp.headers = {
+      Authorization: lambda { "Bearer " + generate_jwt('https:/myhost.com', './my_json_key_file.json') }
+    }
+
+```
+
+### lambda on headers
+
 If you need a new token every time a new http connection is created you can use `lambda`
 
 ```ruby
 NiceHttp.headers[:Authorization] = lambda {get_token()}
 ```
 
-NiceHttp will call the get_token method you created every time a new Http connection is created.
+NiceHttp will call the get_token method you created every time a new connection is created.
 
 ## Http logs
 
@@ -489,7 +562,7 @@ RESPONSE:
 
 ```
 
-If you want to get the last request sent or the last response use `NiceHttp.last_request` or `NiceHttp.last_response`
+If you want to get the last request sent or the last response as a message use `NiceHttp.last_request` or `NiceHttp.last_response`. If you want to access the last request as a Hash use `NiceHttp.request`
 
 Also you can collect all data sent and received by setting `NiceHttp.capture = true` and all data will be stored on `NiceHttp.captured` as an Array of Strings (Request+Response).
 
@@ -514,7 +587,7 @@ threads = []
     end
 end
 
-t.each(&:join)
+threads.each(&:join)
 
 # log files: nice_http_0.log, nice_http_1.log... nice_http_39.log
 ```

data/lib/nice_http.rb

@@ -7,13 +7,14 @@ require_relative "nice_http/http_methods"
 
 ######################################################
 # Attributes you can access using NiceHttp.the_attribute:  
-#   :host, :port, :ssl, :headers, :debug, :log, :log_headers, :proxy_host, :proxy_port,  
+#   :host, :port, :ssl, :timeout, :headers, :debug, :log, :log_headers, :proxy_host, :proxy_port,  
 #   :last_request, :last_response, :request_id, :use_mocks, :connections,  
-#   :active, :auto_redirect, :values_for, :create_stats, :stats, :capture, :captured
+#   :active, :auto_redirect, :values_for, :create_stats, :stats, :capture, :captured, :request, :requests
 #
 # @attr [String] host The host to be accessed
 # @attr [Integer] port The port number
 # @attr [Boolean] ssl If you use ssl or not
+# @attr [Integer] timeout Max time to wait until connected to the host or getting a response.
 # @attr [Hash] headers Contains the headers you will be using on your connection
 # @attr [Boolean] debug In case true shows all the details of the communication with the host
 # @attr [String] log_path The path where the logs will be stored. By default empty string.
@@ -29,6 +30,8 @@ require_relative "nice_http/http_methods"
 # @attr [Integer] proxy_port the proxy port to be used
 # @attr [String] last_request The last request with all the content sent
 # @attr [String] last_response Only in case :debug is true, the last response with all the content
+# @attr [Hash] request The last request with all the content sent
+# @attr [Hash] requests The defaults for all requests. keys: :headers and :data
 # @attr [String] request_id If the response includes a requestId, will be stored here
 # @attr [Boolean] use_mocks If true, in case the request hash includes a :mock_response key, it will be used as the response instead
 # @attr [Array] connections It will include all the active connections (NiceHttp instances)
@@ -69,9 +72,9 @@ class NiceHttp
   end
 
   class << self
-    attr_accessor :host, :port, :ssl, :headers, :debug, :log_path, :log, :proxy_host, :proxy_port, :log_headers,
-                  :last_request, :last_response, :request_id, :use_mocks, :connections,
-                  :active, :auto_redirect, :log_files, :values_for, :create_stats, :stats, :capture, :captured
+    attr_accessor :host, :port, :ssl, :timeout, :headers, :debug, :log_path, :log, :proxy_host, :proxy_port, :log_headers,
+                  :last_request, :last_response, :request, :request_id, :use_mocks, :connections,
+                  :active, :auto_redirect, :log_files, :values_for, :create_stats, :stats, :capture, :captured, :requests
   end
 
   at_exit do
@@ -87,6 +90,7 @@ class NiceHttp
     @host = nil
     @port = 80
     @ssl = false
+    @timeout = nil
     @headers = {}
     @values_for = {}
     @debug = false
@@ -96,6 +100,8 @@ class NiceHttp
     @proxy_host = nil
     @proxy_port = nil
     @last_request = nil
+    @request = nil
+    @requests = nil
     @last_response = nil
     @request_id = ""
     @use_mocks = false
@@ -133,18 +139,19 @@ class NiceHttp
     subclass.reset!
   end
 
-  attr_reader :host, :port, :ssl, :debug, :log, :log_path, :proxy_host, :proxy_port, :response, :num_redirects
+  attr_reader :host, :port, :ssl, :timeout, :debug, :log, :log_path, :proxy_host, :proxy_port, :response, :num_redirects
   attr_accessor :headers, :cookies, :use_mocks, :auto_redirect, :logger, :values_for, :log_headers
 
   ######################################################
   # Change the default values for NiceHttp supplying a Hash
   #
-  # @param par [Hash] keys: :host, :port, :ssl, :headers, :debug, :log, :log_path, :proxy_host, :proxy_port, :use_mocks, :auto_redirect, :values_for, :create_stats, :log_headers, :capture
+  # @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
   ######################################################
   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)
@@ -296,6 +303,7 @@ class NiceHttp
   #             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)  
@@ -323,6 +331,7 @@ class NiceHttp
     @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
@@ -353,6 +362,7 @@ class NiceHttp
       @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)
@@ -448,6 +458,7 @@ class NiceHttp
     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)
@@ -461,18 +472,26 @@ class NiceHttp
         @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}, mode:#{@mode}, proxy_host: #{@proxy_host.to_s()}, proxy_port: #{@proxy_port.to_s()} "
+      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: "
@@ -487,6 +506,7 @@ class NiceHttp
       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
@@ -494,6 +514,7 @@ class NiceHttp
     rescue Exception => stack
       puts stack
       @logger.fatal stack
+      raise stack
     end
   end
 

data/lib/nice_http/http_methods.rb

@@ -85,10 +85,18 @@ module NiceHttpHttpMethods
         else
           @start_time_net = Time.now if @start_time_net.nil?
           resp = @http.get(path, headers_t)
-          if resp.code == 401 and @prev_request[:contains_lambda]
-            @logger.warn "Not authorized. Trying to generate a new token."
-            path, data, headers_t = manage_request(arg)
-            resp = @http.get(path, headers_t)
+          if resp.code == 401 and @headers_orig.values.map(&:class).include?(Proc)
+            try = false
+            @headers_orig.each do |k,v| 
+              if v.is_a?(Proc) and headers_t.key?(k)
+                try = true
+                headers_t[k] = v.call 
+              end
+            end
+            if try
+              @logger.warn "Not authorized. Trying to generate a new token."
+              resp = @http.get(path, headers_t)
+            end
           end
           data = resp.body
           manage_response(resp, data)
@@ -99,7 +107,8 @@ module NiceHttpHttpMethods
         @http.finish()
         @http.start()
         @start_time_net = Time.now if @start_time_net.nil?
-        resp = @http.get(path)
+        @headers_orig.each {|k,v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k)}
+        resp = @http.get(path, headers_t)
         data = resp.body
         manage_response(resp, data)
       end
@@ -210,10 +219,18 @@ module NiceHttpHttpMethods
         else
           resp = @http.post(path, data, headers_t)
           #todo: do it also for forms and multipart
-          if resp.code == 401 and @prev_request[:contains_lambda]
-            @logger.warn "Not authorized. Trying to generate a new token."
-            path, data, headers_t = manage_request(*arguments)
-            resp = @http.post(path, data, headers_t)
+          if resp.code == 401 and @headers_orig.values.map(&:class).include?(Proc)
+            try = false
+            @headers_orig.each do |k,v| 
+              if v.is_a?(Proc) and headers_t.key?(k)
+                try = true
+                headers_t[k] = v.call 
+              end
+            end
+            if try
+              @logger.warn "Not authorized. Trying to generate a new token."
+              resp = @http.post(path, data, headers_t)
+            end
           end
           data = resp.body
         end
@@ -223,6 +240,7 @@ module NiceHttpHttpMethods
         @http.finish()
         @http.start()
         @start_time_net = Time.now if @start_time_net.nil?
+        @headers_orig.each {|k,v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k)}
         resp, data = @http.post(path, data, headers_t)
       end
       manage_response(resp, data)
@@ -297,10 +315,18 @@ module NiceHttpHttpMethods
       begin
         @start_time_net = Time.now if @start_time_net.nil?
         resp = @http.send_request("PUT", path, data, headers_t)
-        if resp.code == 401 and @prev_request[:contains_lambda]
-          @logger.warn "Not authorized. Trying to generate a new token."
-          path, data, headers_t = manage_request(*arguments)
-          resp = @http.send_request("PUT", path, data, headers_t)
+        if resp.code == 401 and @headers_orig.values.map(&:class).include?(Proc)
+          try = false
+          @headers_orig.each do |k,v| 
+            if v.is_a?(Proc) and headers_t.key?(k)
+              try = true
+              headers_t[k] = v.call 
+            end
+          end
+          if try
+            @logger.warn "Not authorized. Trying to generate a new token."
+            resp = @http.send_request("PUT", path, data, headers_t)
+          end
         end
         data = resp.body
       rescue Exception => stack
@@ -308,6 +334,7 @@ module NiceHttpHttpMethods
         @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
         @http.finish()
         @http.start()
+        @headers_orig.each {|k,v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k)}
         @start_time_net = Time.now if @start_time_net.nil?
         resp, data = @http.send_request("PUT", path, data, headers_t)
       end
@@ -369,10 +396,18 @@ module NiceHttpHttpMethods
       begin
         @start_time_net = Time.now if @start_time_net.nil?
         resp = @http.patch(path, data, headers_t)
-        if resp.code == 401 and @prev_request[:contains_lambda]
-          @logger.warn "Not authorized. Trying to generate a new token."
-          path, data, headers_t = manage_request(*arguments)
-          resp = @http.patch(path, data, headers_t)
+        if resp.code == 401 and @headers_orig.values.map(&:class).include?(Proc)
+          try = false
+          @headers_orig.each do |k,v| 
+            if v.is_a?(Proc) and headers_t.key?(k)
+              try = true
+              headers_t[k] = v.call 
+            end
+          end
+          if try
+            @logger.warn "Not authorized. Trying to generate a new token."
+            resp = @http.patch(path, data, headers_t)
+          end
         end
         data = resp.body
       rescue Exception => stack
@@ -380,6 +415,7 @@ module NiceHttpHttpMethods
         @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
         @http.finish()
         @http.start()
+        @headers_orig.each {|k,v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k)}        
         @start_time_net = Time.now if @start_time_net.nil?
         resp, data = @http.patch(path, data, headers_t)
       end
@@ -456,19 +492,37 @@ module NiceHttpHttpMethods
         @start_time_net = Time.now if @start_time_net.nil?
         if data.to_s == ""
           resp = @http.delete(path, headers_t)
-          if resp.code == 401 and @prev_request[:contains_lambda]
-            @logger.warn "Not authorized. Trying to generate a new token."
-            path, data, headers_t = manage_request(argument)
-            resp = @http.delete(path, headers_t)
+          if resp.code == 401 and @headers_orig.values.map(&:class).include?(Proc)
+            try = false
+            @headers_orig.each do |k,v| 
+              if v.is_a?(Proc) and headers_t.key?(k)
+                try = true
+                headers_t[k] = v.call 
+              end
+            end
+            if try
+              @logger.warn "Not authorized. Trying to generate a new token."
+              resp = @http.delete(path, headers_t)
+            end
           end
         else
           request = Net::HTTP::Delete.new(path, headers_t)
           request.body = data
           resp = @http.request(request)
-          if resp.code == 401 and @prev_request[:contains_lambda]
-            @logger.warn "Not authorized. Trying to generate a new token."
-            path, data, headers_t = manage_request(argument)
-            resp = @http.request(request)
+          if resp.code == 401 and @headers_orig.values.map(&:class).include?(Proc)
+            try = false
+            @headers_orig.each do |k,v| 
+              if v.is_a?(Proc) and headers_t.key?(k)
+                try = true
+                headers_t[k] = v.call 
+              end
+            end
+            if try
+              @logger.warn "Not authorized. Trying to generate a new token."
+              request = Net::HTTP::Delete.new(path, headers_t)
+              request.body = data
+              resp = @http.request(request)
+            end
           end
         end
         data = resp.body
@@ -477,8 +531,9 @@ module NiceHttpHttpMethods
         @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
         @http.finish()
         @http.start()
+        @headers_orig.each {|k,v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k)}        
         @start_time_net = Time.now if @start_time_net.nil?
-        resp, data = @http.delete(path)
+        resp, data = @http.delete(path, headers_t)
       end
       manage_response(resp, data)
 
@@ -523,10 +578,18 @@ module NiceHttpHttpMethods
       begin
         @start_time_net = Time.now if @start_time_net.nil?
         resp = @http.head(path, headers_t)
-        if resp.code == 401 and @prev_request[:contains_lambda]
-          @logger.warn "Not authorized. Trying to generate a new token."
-          path, data, headers_t = manage_request(argument)
-          resp = @http.head(path, headers_t)
+        if resp.code == 401 and @headers_orig.values.map(&:class).include?(Proc)
+          try = false
+          @headers_orig.each do |k,v| 
+            if v.is_a?(Proc) and headers_t.key?(k)
+              try = true
+              headers_t[k] = v.call 
+            end
+          end
+          if try
+            @logger.warn "Not authorized. Trying to generate a new token."
+            resp = @http.head(path, headers_t)
+          end
         end
         data = resp.body
       rescue Exception => stack
@@ -534,8 +597,9 @@ module NiceHttpHttpMethods
         @logger.warn "The connection seems to be closed in the host machine. Trying to reconnect"
         @http.finish()
         @http.start()
+        @headers_orig.each {|k,v| headers_t[k] = v.call if v.is_a?(Proc) and headers_t.key?(k)}        
         @start_time_net = Time.now if @start_time_net.nil?
-        resp, data = @http.head(path)
+        resp, data = @http.head(path, headers_t)
       end
       manage_response(resp, data)
       return @response

data/lib/nice_http/manage_request.rb

@@ -13,7 +13,10 @@ module NiceHttpManageRequest
     require "json"
 
     @prev_request = Hash.new() if @prev_request.nil?
-    @prev_request[:contains_lambda] = false
+    @defaults_request = self.class.requests if @defaults_request.nil? and self.class.requests.is_a?(Hash)
+    @request = Hash.new() if @request.nil?
+    @defaults_request = Hash.new() unless @defaults_request.is_a?(Hash)
+
     begin
       content_type_included = false
       path = ""
@@ -21,6 +24,8 @@ module NiceHttpManageRequest
 
       @response = Hash.new()
       headers_t = @headers.dup()
+      headers_t.merge!(@defaults_request[:headers]) if @defaults_request.key?(:headers)
+
       cookies_to_set_str = ""
       if arguments.size == 3
         path = arguments[0]
@@ -125,6 +130,13 @@ module NiceHttpManageRequest
               }
             end
           elsif data.kind_of?(Hash)
+            data.merge!(@defaults_request[:data]) if @defaults_request.key?(:data)
+            #lambdas on data only supports on root of the hash
+            data.each do |k, v|
+              if v.is_a?(Proc)
+                data[k] = v.call 
+              end
+            end
             if arguments[0].include?(:values_for)
               data = data.set_values(arguments[0][:values_for])
             end
@@ -192,6 +204,40 @@ module NiceHttpManageRequest
         headers_t["Accept-Encoding"].gsub!("gzip", "") #removed so the response is in plain text
       end
 
+      if data.to_s() != "" and encoding.to_s().upcase != "UTF-8" and encoding != ""
+        data = data.to_s().encode(encoding, "UTF-8")
+      end
+      @request[:path] = path
+      @request[:data] = data
+      @request[:headers] = headers_t
+      @request[:method] = method_s.upcase
+      if arguments.size == 1 and arguments[0].kind_of?(Hash) and arguments[0].key?(:name)
+        @request[:name] = arguments[0][:name]
+      end
+      self.class.request = @request
+      headers_t.each do |k, v|
+        # for lambdas
+        if v.is_a?(Proc)
+          headers_t[k] = v.call 
+        end
+      end
+      @request[:headers] = headers_t
+      self.class.request = @request
+
+      if @debug or @prev_request[:path] != path or @prev_request[:headers] != headers_t or @prev_request[:data] != data
+        show_headers_data = true
+      else
+        show_headers_data = false
+      end
+
+      @prev_request[:path] = path
+      @prev_request[:data] = data
+      @prev_request[:headers] = headers_t
+      @prev_request[:method] = method_s.upcase
+      if arguments.size == 1 and arguments[0].kind_of?(Hash) and arguments[0].key?(:name)
+        @prev_request[:name] = arguments[0][:name]
+      end
+
       headers_ts = ""
 
       if @log_headers == :none
@@ -217,7 +263,7 @@ module NiceHttpManageRequest
         message += "#{method_s.upcase} Request"
       end
       message += "\n path: " + path.to_s() + "\n"
-      if @debug or @prev_request[:path] != path or @prev_request[:headers] != headers_t or @prev_request[:data] != data
+      if show_headers_data
         message += " headers: {" + headers_ts.to_s() + "}\n"
         message += " data: " + data_s.to_s() + "\n"
         message = @message_server + "\n" + message
@@ -232,23 +278,6 @@ module NiceHttpManageRequest
         @logger.info(message)
       end
 
-      if data.to_s() != "" and encoding.to_s().upcase != "UTF-8" and encoding != ""
-        data = data.to_s().encode(encoding, "UTF-8")
-      end
-      headers_t.each do |k, v|
-        # for lambdas
-        if v.is_a?(Proc)
-          headers_t[k] = v.call 
-          @prev_request[:contains_lambda] = true
-        end
-      end
-      @prev_request[:path] = path
-      @prev_request[:data] = data
-      @prev_request[:headers] = headers_t
-      @prev_request[:method] = method_s.upcase
-      if arguments.size == 1 and arguments[0].kind_of?(Hash) and arguments[0].key?(:name)
-        @prev_request[:name] = arguments[0][:name]
-      end
       return path, data, headers_t
     rescue Exception => stack
       @logger.fatal(stack)

metadata

@@ -1,35 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: nice_http
 version: !ruby/object:Gem::Version
-  version: 1.8.2
+  version: 1.8.7
 platform: ruby
 authors:
 - Mario Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-04 00:00:00.000000000 Z
+date: 2020-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nice_hash
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.15.4
+        version: '1.17'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.15.4
+        version: '1.17'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement