mint_http 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5928a4bac42cf6e1c6039ddbff011d758d7f0835feab6def492b72b0a3efda14
-  data.tar.gz: 0d4aba076e15a19bca4e91dd96f5b6fe63ba52509ca4ad72cef9ac22fe5e0c03
+  metadata.gz: 77ff75e95387e2ccfde90a946d31a9b7550d45d337ebbedc8838003018296b70
+  data.tar.gz: 51f733220f11dae0439d0f30ecf80eab46925c5e5cfa019b42a62057c5bc7c3b
 SHA512:
-  metadata.gz: 6603a0dde40391ec153b797d1cd5725feef3773f36ea5eb1c45c576cdd1c6b14dffbe2748e089850531b87656c48487e59ef9268a3416166fe5b2a0b57c0b141
-  data.tar.gz: 2f7cf463b45f12da07b663b3679781041539b66d56b046be2df8e9d86e812dd610345d48ccd189d8a3918a35f6ba1c0187fd7b14480fb0142900ff7e5f51db4f
+  metadata.gz: 9790d2693d711a634d26f19243fcdca950845118c831174f6426183d77fd885807f6391e17fcf25c8106894acccbb3b0da1a007b74ce7eefab33de06437387b4
+  data.tar.gz: cdc34a5e635f37e98f8e2981b634675152eab7218ab82e6bae669a2fb1842479f1c8b3c1af0831435161b9128af241c640e925197c53a7e322682425ec84e576

data/lib/mint_http/config.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MintHttp
+  class Config
+    # @!attribute [rw] logger
+    #   @return [Logger] logger to be used for logging request details
+    attr_accessor :logger
+
+    # @!attribute [rw] filter_params_list
+    #   @return [Array[String|Symbol]] logger to be used for logging request details
+    attr_accessor :filter_params_list
+
+    # @!attribute [rw] filter_params
+    #   @return [Boolean] indicate if MintHttp should filter out params from request logs
+    attr_accessor :filter_params
+  end
+end

data/lib/mint_http/request.rb

@@ -23,6 +23,10 @@ module MintHttp
     attr_reader :ssl_verify_mode
     attr_reader :ssl_verify_hostname
 
+    # Attributes only available when request is made
+    attr_reader :method
+    attr_reader :request_url
+
     def initialize
       @pool = nil
       @base_url = nil
@@ -44,6 +48,10 @@ module MintHttp
       @ssl_verify_mode = nil
       @ssl_verify_hostname = nil
 
+      @logger = MintHttp.config.logger
+      @filter_params_list = MintHttp.config.filter_params_list
+      @filter_params = MintHttp.config.filter_params
+
       header('User-Agent' => 'Mint Http')
       as_json
     end
@@ -204,6 +212,28 @@ module MintHttp
       self
     end
 
+    # @param [Logger] logger
+    def use_logger(logger)
+      @logger = logger
+      self
+    end
+
+    def no_logger
+      @logger = Logger.new('/dev/null')
+      self
+    end
+
+    # @param [Array[String]] params
+    def filter_param(*params)
+      @filter_params_list.concat(params)
+      self
+    end
+
+    def should_filter_params(filter = true)
+      @filter_params = filter
+      self
+    end
+
     def get(url, params = {})
       query(params).send_request('get', url)
     end
@@ -233,20 +263,60 @@ module MintHttp
     end
 
     def send_request(method, url)
+      @method = method
+
+      logger = RequestLogger.new(@logger, @filter_params_list, @filter_params)
       url, net_request, options = build_request(method, url)
 
-      res = with_client(url.hostname, url.port, options) do |http|
-        http.request(net_request)
+      logger.log_request(self, net_request)
+      logger.log_start
+
+      begin
+        res = with_client(url.hostname, url.port, options) do |http|
+          logger.log_connected
+          logger.log_connection_info(http)
+          http.request(net_request)
+        end
+      rescue StandardError => error
+        logger.log_end
+        logger.log_error(error)
+        logger.write_log
+        raise error
       end
 
-      Response.new(res)
+      logger.log_end
+
+      response = Response.new(res, net_request, self)
+
+      logger.log_response(response)
+      logger.put_timing(response)
+      logger.write_log
+
+      response
     end
 
     private
 
-    def build_request(method, url)
+    def build_url(url)
       url = URI.parse(url)
-      url = @base_url + url if @base_url
+
+      unless url.is_a?(URI::Generic)
+        return url
+      end
+
+      unless @base_url
+        return url
+      end
+
+      unless @base_url.path.match?(/\/$/)
+        @base_url.path += '/'
+      end
+
+      @base_url + url.path.gsub(/^\/+/, '')
+    end
+
+    def build_request(method, url)
+      @request_url = url = build_url(url)
 
       unless %w[http https].include?(url.scheme)
         raise ArgumentError, "Only HTTP and HTTPS URLs are allowed"
@@ -348,5 +418,9 @@ module MintHttp
     def net_factory
       @net_factory ||= NetHttpFactory.new
     end
+
+    def clock_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
   end
 end

data/lib/mint_http/request_logger.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module MintHttp
+  class RequestLogger
+    MAX_BODY_SIZE = 15 * 1024
+    BODY_ALLOWED_TYPES = [/application\/.+/, /text\/.+/]
+
+    attr_reader :logger
+    attr_reader :filter_list
+    attr_reader :time_started
+    attr_reader :time_ended
+    attr_reader :time_connected
+    attr_reader :time_total
+    attr_reader :time_connecting
+    attr_reader :tls_config
+
+    # @param [Logger] logger
+    # @param [Array[String|Symbol]] request
+    def initialize(logger, filter_list, filter = true)
+      @logger = logger
+      @filter_list = filter_list.map(&:downcase)
+      @filter = filter
+      @time_started = 0.0
+      @time_ended = 0.0
+      @time_connected = 0.0
+      @time_total = 0.0
+      @time_connecting = 0.0
+
+      @request = nil
+      @net_request = nil
+      @response = nil
+      @error = nil
+    end
+
+    def log_request(request, net_request)
+      @request = request
+      @net_request = net_request
+    end
+
+    def log_response(response)
+      @response = response
+    end
+
+    def log_error(error)
+      @error = error
+    end
+
+    def log_start
+      @time_started = clock_time
+    end
+
+    def log_end
+      @time_ended = clock_time
+      @time_total = @time_ended - @time_started
+    end
+
+    def log_connected
+      @time_connected = clock_time
+      @time_connecting = @time_connected - @time_started
+    end
+
+    # @param [MintHttp::Response] response
+    def put_timing(response)
+      response.time_started = @time_started
+      response.time_ended = @time_ended
+      response.time_connected = @time_connected
+      response.time_total = @time_total
+      response.time_connecting = @time_connecting
+    end
+
+    def write_log
+      path = build_path(@request.request_url)
+      version = @response&.version || '1.1'
+
+      tls = 'None'
+      if @tls_config
+        tls = "#{@tls_config[:version]} Cipher: #{@tls_config[:cipher]}"
+      end
+
+      buffer = String.new
+      buffer << <<~TXT
+        MintHttp Log (#{@request.request_url})
+        @@ Timeouts: #{@request.open_timeout}, #{@request.write_timeout}, #{@request.read_timeout}
+        @@ Time: #{@time_started.round(3)} -> #{@time_connected.round(3)} connecting: #{time_connecting.round(3)} total: #{@time_total.round(3)} seconds
+        @@ TLS: #{tls}
+        -> #{@request.method.upcase} #{path} HTTP/#{version}
+        #{masked_headers(@net_request.each_header.to_h, '-> ')}
+        -> #{masked_body(@net_request.body, @request.headers['content-type'])}
+        =======
+      TXT
+
+      if @response
+        buffer << <<~TXT
+          <- Response: HTTP/#{@response.version} #{@response.status_code} #{@response.status_text}
+          #{masked_headers(@response.headers, '<- ')}
+          <- Length: #{@response.body.bytesize} Body: #{masked_body(@response.body, @response.headers['content-type'])}
+        TXT
+      end
+
+      if @error
+        buffer << "!! Error: #{@error.class}, message: #{@error.message}"
+      end
+
+      unless buffer.valid_encoding?
+        raise 'Buffer has not valid encoding'
+      end
+
+      @logger.info(buffer.strip)
+    end
+
+    def log_connection_info(http)
+      @tls_config = http.instance_eval do
+        if use_ssl?
+          { version: @socket.io.ssl_version, cipher: @socket.io.cipher[0] }
+        else
+          nil
+        end
+      end
+    end
+
+    private
+
+    def clock_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def build_path(url)
+      full_path = url.path.dup
+
+      if url.query
+        full_path << "?#{url.query}"
+      end
+
+      if url.fragment
+        full_path << "##{url.fragment}"
+      end
+
+      full_path
+    end
+
+    def lower_case_filter_list
+      @_lower_case_filter_list ||= @filter_list.map(&:downcase)
+    end
+
+    def filter_query(query)
+      unless @filter
+        return query
+      end
+
+      filtered = CGI::parse(query || '')
+        .to_h { |k, v| [k, lower_case_filter_list.include?(v) ? '[FILTERED]' : v] }
+
+      URI.encode_www_form(filtered)
+    end
+
+    def masked_headers(headers, prefix = '')
+      headers
+        .map { |k, v| [k.split('-').map(&:capitalize).join('-'), v] }
+        .map { |k, v| "#{prefix}#{k}: #{@filter && lower_case_filter_list.include?(k.downcase) ? '[FILTERED]' : v}" }
+        .join("\n")
+    end
+
+    def masked_body(body, type)
+      type ||= 'application/octet-stream'
+
+      size = body&.bytesize || 0
+      if size == 0
+        return '[EMPTY]'
+      end
+
+      if size > MAX_BODY_SIZE
+        return '[LARGE]'
+      end
+
+      unless body_allowed?(type)
+        return '[COMPLEX]'
+      end
+
+      unless @filter
+        return body
+      end
+
+      if type.match?(/json/)
+        redact_json(body)
+      elsif type.match?(/xml/)
+        redact_xml(body)
+      else
+        body
+      end
+    end
+
+    def body_allowed?(content_type)
+      BODY_ALLOWED_TYPES.any? { |pattern| pattern.match?(content_type) }
+    end
+
+    def redact_json(json)
+      @json_patterns ||= @filter_list.map do |keyword|
+        keyword = Regexp.escape(keyword)
+        Regexp.compile("\"(#{keyword})\"(\\s*):(\\s*)(?>\".+?(?<!\\\\)\"|\\d+(?>\\.\\d+)?)", Regexp::IGNORECASE | Regexp::EXTENDED)
+      end
+
+      @json_patterns.inject(json) do |carry, pattern|
+        carry.gsub(pattern, '"\1"\2:\3"[FILTERED]"')
+      end
+    end
+
+    def redact_xml(raw)
+      @xml_patterns ||= @filter_list.map do |keyword|
+        keyword = Regexp.escape(keyword)
+        Regexp.compile("<#{keyword}(?>.|\\n)+?</(#{keyword})>", Regexp::IGNORECASE | Regexp::EXTENDED)
+      end
+
+      @xml_patterns.inject(raw) do |carry, pattern|
+        carry.gsub(pattern, '<\1>[FILTERED]</\1>')
+      end
+    end
+  end
+end

data/lib/mint_http/response.rb

@@ -2,14 +2,47 @@
 
 module MintHttp
   class Response
+    # @!attribute [r] net_request
+    #   @return [Net::HTTPRequest]
+    attr_reader :net_request
+
+    # @!attribute [r] net_response
+    #   @return [Net::HTTPResponse]
     attr_reader :net_response
+
+    # @!attribute [r] mint_request
+    #   @return [MintHttp::Request]
+    attr_reader :mint_request
+
+    # @!attribute [r] version
+    #   @return [String]
     attr_reader :version
+
+    # @!attribute [r] status_code
+    #   @return [Integer]
     attr_reader :status_code
+
+    # @!attribute [r] status_text
+    #   @return [String]
     attr_reader :status_text
+
+    # @!attribute [r] headers
+    #   @return [Hash<String,Array[String]>]
     attr_reader :headers
 
-    def initialize(net_response)
+    attr_accessor :time_started
+    attr_accessor :time_ended
+    attr_accessor :time_connected
+    attr_accessor :time_total
+    attr_accessor :time_connecting
+
+    # @param [Net::HTTPResponse] net_response
+    # @param [Net::HTTPRequest] net_request
+    # @param [MintHttp::Request] mint_request
+    def initialize(net_response, net_request, mint_request)
       @net_response = net_response
+      @net_request = net_request
+      @mint_request = mint_request
       @version = net_response.http_version
       @status_code = net_response.code.to_i
       @status_text = net_response.message
@@ -69,6 +102,18 @@ module MintHttp
       @json ||= JSON.parse(body)
     end
 
+    def json?
+      headers['content-type']&.include?('application/json')
+    end
+
+    def xml?
+      headers['content-type']&.match?(/\/xml/)
+    end
+
+    def https?
+      @net_request
+    end
+
     def inspect
       "#<#{self.class}/#{@version} #{@status_code} #{@status_text} #{@headers.inspect}>"
     end

data/lib/mint_http/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MintHttp
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 end

data/lib/mint_http.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require 'logger'
+
 require_relative 'mint_http/version'
+require_relative 'mint_http/config'
 require_relative 'mint_http/pool_entry'
 require_relative 'mint_http/pool'
 require_relative 'mint_http/headers'
@@ -11,11 +14,24 @@ require_relative 'mint_http/errors/authorization_error'
 require_relative 'mint_http/errors/authentication_error'
 require_relative 'mint_http/errors/not_found_error'
 require_relative 'mint_http/net_http_factory'
+require_relative 'mint_http/request_logger'
 require_relative 'mint_http/response'
 require_relative 'mint_http/request'
 
 module MintHttp
   class << self
+    def init_mint
+      config.logger = Logger.new('/dev/null')
+      config.filter_params_list = []
+      config.filter_params = false
+    end
+
+    # @return [MintHttp::Config]
+    # noinspection RbsMissingTypeSignature,RubyClassVariableUsageInspection
+    def config
+      @@config ||= MintHttp::Config.new
+    end
+
     # @return [::MintHttp::Request]
     def method_missing(method, *args)
       request = Request.new
@@ -23,3 +39,5 @@ module MintHttp
     end
   end
 end
+
+MintHttp.init_mint

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mint_http
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Ali Alhoshaiyan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-06 00:00:00.000000000 Z
+date: 2024-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-http
@@ -95,6 +95,7 @@ files:
 - README.md
 - Rakefile
 - lib/mint_http.rb
+- lib/mint_http/config.rb
 - lib/mint_http/errors/authentication_error.rb
 - lib/mint_http/errors/authorization_error.rb
 - lib/mint_http/errors/client_error.rb
@@ -106,6 +107,7 @@ files:
 - lib/mint_http/pool.rb
 - lib/mint_http/pool_entry.rb
 - lib/mint_http/request.rb
+- lib/mint_http/request_logger.rb
 - lib/mint_http/response.rb
 - lib/mint_http/version.rb
 - sig/mint_http.rbs
@@ -130,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: A small fluent HTTP client.