httplog 1.3.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4e1ea9c25d6b30a6857ecbf3358e18a5336039ae411b381b33260d9e9b2af01
-  data.tar.gz: b7d8d584ad7742092d982b299fcfa4b64bc8d8899be9e854e9df2e185d2a5fb4
+  metadata.gz: 97cbba2cdb0af09dcf6664e290981b074a40f9c91d81be74a737a746bfc1e612
+  data.tar.gz: 228590a39ab68d89d3261f219e2bac4945f4fde315219943cbbacdfc1aaa2922
 SHA512:
-  metadata.gz: 8af022be7a67f8686565e1b989ddfdb7711b5643a647b936731f5bf9e176f3c9b628146c35190f592e617840bdba97df00cd1a84e0017e494de1c70a7acf8cdc
-  data.tar.gz: 9d0471b0c8b86705176d96c3ee116ecc0ed7f7aae39d8660acfff51ffa1f0453b63a368dd934e2efac7e28990e94d2720f5c345fecf01458095cf7085bf0d7f3
+  metadata.gz: d857f2dc7142fb7243371afd4d3993b65ced6092ecb6ac361abbd2957bc1884e18131ca707b3e2c9dc694ad9996c09e12ddf7b31f978d8d55def35322159a861
+  data.tar.gz: eafbb1ef94500b468083f8073049749e6073d2ec423fadae8f6aca3221624bb914f28a489305f35cd5fb222b247eb81f5b2446f4694f919959267d83c0bfcbe7

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+## 1.5.0 - 2021-05-20
+
+* Support for Ruby 2.7 and frozen strings
+* Development dependency updates
+* Dropped support for net/http v3
+* Performance tweaks
+* Fix for RestClient body read issue (WARNING: this may be reverted, see [#105](https://github.com/trusche/httplog/issues/105))
+
+## 1.4.3 - 2020-06-10
+
+* Masking `password` parameter by default... doh.
+
+## 1.4.2 - 2020-02-09
+
+* Rollback of the previous two releases due to bugs introduced there.
+
+## 1.4.1 - 2020-02-08 - YANKED
+
+* [#91](https://github.com/trusche/httplog/pull/91) Fixed bug returning empty response with HTTP gem
+
+## 1.4.0 - 2020-01-19 - YANKED
+
+* [#85](https://github.com/trusche/httplog/pull/85) Parse JSON response and apply deep masking
+
+## 1.3.3 - 2019-11-14
+
+* [#83](https://github.com/trusche/httplog/pull/83) Support for graylog
+
+## 1.3.1 - 2019-06-07
+
+* [#76](https://github.com/trusche/httplog/pull/76) Added configurable logger method
+
 ## 1.3.0 - 2019-05-18
 
 * [#74](https://github.com/trusche/httplog/pull/74) Added ability to filter sensitive parameter values in the request (based on [#73](https://github.com/trusche/httplog/pull/73)). Default masking of `password` parameter

data/README.md

@@ -2,14 +2,15 @@
 
 [![Gem Version](https://badge.fury.io/rb/httplog.svg)](http://badge.fury.io/rb/httplog) [![Build Status](https://travis-ci.org/trusche/httplog.svg?branch=master)](https://travis-ci.org/trusche/httplog) [![Code Climate](https://codeclimate.com/github/trusche/httplog.svg)](https://codeclimate.com/github/trusche/httplog)
 [![Release Version](https://img.shields.io/github/release/trusche/httplog.svg)](https://img.shields.io/github/release/trusche/httplog.svg)
+<a href="https://www.bearer.sh?ref=httplog"><img src="/bearer-badge.png" height="20px"/></a>
 
 Log outgoing HTTP requests made from your application. Helps with debugging pesky API error responses, or just generally understanding what's going on under the hood.
 
-Requires ruby >= 2.4.
+Requires ruby >= 2.5
 
 This gem works with the following ruby modules and libraries:
 
-* [Net::HTTP](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/net/http/rdoc/index.html)
+* [Net::HTTP](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/net/http/rdoc/index.html) v4+
 * [Ethon](https://github.com/typhoeus/ethon)
 * [Excon](https://github.com/geemus/excon)
 * [OpenURI](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/open-uri/rdoc/index.html)
@@ -29,6 +30,10 @@ This is very much a development and debugging tool; it is **not recommended** to
 use this in a production environment as it is monkey-patching the respective HTTP implementations.
 You have been warned - use at your own risk.
 
+Httplog is kindly sponsored by <a href="https://www.bearer.sh?ref=httplog">Bearer.sh</a> - go check them out please!
+
+<a href="https://www.bearer.sh?ref=httplog"><img src="/bearer-sponsor.png" height="72px" /></a>
+
 ### Installation
 
     gem install httplog
@@ -83,8 +88,22 @@ HttpLog.configure do |config|
   config.url_whitelist_pattern = nil
   config.url_blacklist_pattern = nil
 
-  # Mask the values of sensitive requestparameters
+  # Mask sensitive information in request and response JSON data.
+  # Enable global JSON masking by setting the parameter to `/.*/`
+  config.url_masked_body_pattern = nil
+
+  # You can specify any custom JSON serializer that implements `load` and `dump` class methods
+  # to parse JSON responses
+  config.json_parser = JSON
+
+  # When using graylog, you can supply a formatter here - see below for details
+  config.graylog_formatter = nil
+
+  # Mask the values of sensitive request parameters
   config.filter_parameters = %w[password]
+  
+  # Customize the prefix with a proc or lambda
+  config.prefix = ->{ "[httplog] #{Time.now} " }
 end
 ```
 
@@ -120,6 +139,37 @@ end
 
 For more color options please refer to the [rainbow documentation](https://github.com/sickill/rainbow)
 
+### Graylog logging
+
+If you use Graylog and want to use its search features such as "benchmark:>1 AND method:PUT",
+you can use this configuration:
+
+```ruby
+FORMATTER = Lograge::Formatters::KeyValue.new
+
+HttpLog.configure do |config|
+  config.logger            = <your GELF::Logger>
+  config.logger_method     = :add
+  config.severity          = GELF::Levels::DEBUG
+  config.graylog_formatter = FORMATTER
+end
+```
+
+You also can use GELF Graylog format this way:
+
+```ruby
+class Lograge::Formatters::Graylog2HttpLog < Lograge::Formatters::Graylog2
+  def short_message data
+    data[:response_body] = data[:response_body].to_s.byteslice(0, 32_766) unless data[:response_body].blank?
+    "[httplog] [#{data[:response_code]}] #{data[:method]} #{data[:url]}"
+  end
+end
+
+FORMATTER = Lograge::Formatters::Graylog2HttpLog.new
+```
+
+Or define your own class that implements the `call` method
+
 ### Compact logging
 
 If the log is too noisy for you, but you don't want to completely disable it either, set the `compact_log` option to `true`. This will log each request in a single line with method, request URI, response status and time, but no data or headers. No need to disable any other options individually.
@@ -218,9 +268,6 @@ a suggestion for a fix, please open an issue or, even better, submit a pull requ
 
 * Benchmarking only covers the time between starting the HTTP request and receiving the response. It does *not* cover the time it takes to establish the TCP connection.
 
-* When using [REST Client](https://github.com/rest-client/rest-client), POST requests might be missing the requests
-  data. See #54 for details.
-
 ### Running the specs
 
 Make sure you have the necessary dependencies installed by running `bundle install`.
@@ -232,19 +279,3 @@ This will launch a simple rack server on port 9292 and run all tests locally aga
 If you have any issues with or feature requests for httplog,
 please [open an issue](https://github.com/trusche/httplog/issues) on GitHub
 or fork the project and send a pull request. **Please include passing specs with all pull requests.**
-
-### Contributors
-
-Thanks to these fine folks for contributing pull requests:
-
-* [Doug Johnston](https://github.com/dougjohnston)
-* [Eric Cohen](https://github.com/eirc)
-* [Nikos Dimitrakopoulos](https://github.com/nikosd)
-* [Marcos Hack](https://github.com/marcoshack)
-* [Andrew Hammond](https://github.com/andrhamm)
-* [Chris Keele](https://github.com/christhekeele)
-* [Ryan Souza](https://github.com/ryansouza)
-* [Ilya Bondarenko](https://github.com/sedx)
-* [Kostas Zacharakis](https://github.com/kzacharakis)
-* [Yuri Smirnov](https://github.com/tycooon)
-* [Manuel Bustillo Alonso](https://github.com/bustikiller)

data/httplog.gemspec

@@ -17,7 +17,8 @@ Gem::Specification.new do |gem|
   gem.description = "Log outgoing HTTP requests made from your application. Helpful for tracking API calls
                      of third party gems that don't provide their own log output."
 
-  gem.files         = `git ls-files`.split("\n")
+  gem.files         = Dir['lib/**/*.rb'] +
+                        %w(httplog.gemspec README.md CHANGELOG.md)
   gem.test_files    = `git ls-files -- test/*`.split("\n")
   gem.require_paths = ['lib']
 
@@ -25,17 +26,19 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency 'ethon', ['~> 0.11']
   gem.add_development_dependency 'excon', ['~> 0.60']
-  gem.add_development_dependency 'faraday', ['~> 0.14']
+  gem.add_development_dependency 'faraday', ['~> 1.3']
   gem.add_development_dependency 'guard-rspec', ['~> 4.7']
-  gem.add_development_dependency 'http', ['~> 3.0']
+  gem.add_development_dependency 'http', ['~> 4.0']
   gem.add_development_dependency 'httparty', ['~> 0.16']
   gem.add_development_dependency 'httpclient', ['~> 2.8']
+  gem.add_development_dependency 'rest-client', ['~> 2.0']
   gem.add_development_dependency 'listen', ['~> 3.0']
   gem.add_development_dependency 'patron', ['~> 0.12']
-  gem.add_development_dependency 'rake', ['~> 12.3']
+  gem.add_development_dependency 'rake', ['~> 13.0']
   gem.add_development_dependency 'rspec', ['~> 3.7']
   gem.add_development_dependency 'simplecov', ['~> 0.15']
   gem.add_development_dependency 'thin', ['~> 1.7']
+  gem.add_development_dependency 'oj', ['>= 3.9.2']
 
   gem.add_dependency 'rack', ['>= 1.0']
   gem.add_dependency 'rainbow', ['>= 2.0.0']

data/lib/httplog/adapters/ethon.rb

@@ -39,7 +39,8 @@ if defined?(Ethon)
             response_headers: headers.map { |header| header.split(/:\s/) }.to_h,
             benchmark: bm,
             encoding: encoding,
-            content_type: content_type
+            content_type: content_type,
+            mask_body: HttpLog.masked_body_url?(url)
           )
           return_code
         end

data/lib/httplog/adapters/excon.rb

@@ -45,7 +45,8 @@ if defined?(Excon)
           response_headers: headers,
           benchmark: bm,
           encoding: headers['Content-Encoding'],
-          content_type: headers['Content-Type']
+          content_type: headers['Content-Type'],
+          mask_body: HttpLog.masked_body_url?(url)
         )
         result
       end

data/lib/httplog/adapters/http.rb

@@ -12,7 +12,8 @@ if defined?(::HTTP::Client) && defined?(::HTTP::Connection)
           @response = send(orig_request_method, req, options)
         end
 
-        if HttpLog.url_approved?(req.uri)
+        uri = req.uri
+        if HttpLog.url_approved?(uri)
           body = if defined?(::HTTP::Request::Body)
                    req.body.respond_to?(:source) ? req.body.source : req.body.instance_variable_get(:@body)
                  else
@@ -21,7 +22,7 @@ if defined?(::HTTP::Client) && defined?(::HTTP::Connection)
 
           HttpLog.call(
             method: req.verb,
-            url: req.uri,
+            url: uri,
             request_body: body,
             request_headers: req.headers,
             response_code: @response.code,
@@ -29,7 +30,8 @@ if defined?(::HTTP::Client) && defined?(::HTTP::Connection)
             response_headers: @response.headers,
             benchmark: bm,
             encoding: @response.headers['Content-Encoding'],
-            content_type: @response.headers['Content-Type']
+            content_type: @response.headers['Content-Type'],
+            mask_body: HttpLog.masked_body_url?(uri)
           )
 
           body.rewind if body.respond_to?(:rewind)

data/lib/httplog/adapters/httpclient.rb

@@ -16,12 +16,13 @@ if defined?(::HTTPClient)
         end
       end
 
-      if HttpLog.url_approved?(req.header.request_uri)
+      request_uri = req.header.request_uri
+      if HttpLog.url_approved?(request_uri)
         res = conn.pop
 
         HttpLog.call(
           method: req.header.request_method,
-          url: req.header.request_uri,
+          url: request_uri,
           request_body: req.body,
           request_headers: req.headers,
           response_code: res.status_code,
@@ -29,7 +30,8 @@ if defined?(::HTTPClient)
           response_headers: res.headers,
           benchmark: bm,
           encoding: res.headers['Content-Encoding'],
-          content_type: res.headers['Content-Type']
+          content_type: res.headers['Content-Type'],
+          mask_body: HttpLog.masked_body_url?(request_uri)
         )
         conn.push(res)
       end
@@ -41,7 +43,7 @@ if defined?(::HTTPClient)
       alias orig_create_socket create_socket
 
       # up to version 2.6, the method signature is `create_socket(site)`; after that,
-      # it's `create_socket(hort, port)`
+      # it's `create_socket(host, port)`
       if instance_method(:create_socket).arity == 1
         def create_socket(site)
           if HttpLog.url_approved?("#{site.host}:#{site.port}")

data/lib/httplog/adapters/net_http.rb

@@ -11,19 +11,30 @@ module Net
       bm = Benchmark.realtime do
         @response = orig_request(req, body, &block)
       end
+      body_stream  = req.body_stream
+      request_body = if body_stream
+                       body_stream.to_s # read and rewind for RestClient::Payload::Base
+                       body_stream.rewind if body_stream.respond_to?(:rewind) # RestClient::Payload::Base has no method rewind
+                       body_stream.read
+                     elsif req.body.nil? || req.body.empty?
+                       body
+                     else
+                       req.body
+                     end
 
       if HttpLog.url_approved?(url) && started?
         HttpLog.call(
           method: req.method,
           url: url,
-          request_body: req.body.nil? || req.body.empty? ? body : req.body,
+          request_body: request_body,
           request_headers: req.each_header.collect,
           response_code: @response.code,
           response_body: @response.body,
           response_headers: @response.each_header.collect,
           benchmark: bm,
           encoding: @response['Content-Encoding'],
-          content_type: @response['Content-Type']
+          content_type: @response['Content-Type'],
+          mask_body: HttpLog.masked_body_url?(url)
         )
       end
 

data/lib/httplog/adapters/patron.rb

@@ -20,7 +20,8 @@ if defined?(Patron)
             response_headers: @response.headers,
             benchmark: bm,
             encoding: @response.headers['Content-Encoding'],
-            content_type: @response.headers['Content-Type']
+            content_type: @response.headers['Content-Type'],
+            mask_body: HttpLog.masked_body_url?(url)
           )
         end
 

data/lib/httplog/configuration.rb

@@ -5,6 +5,7 @@ module HttpLog
     attr_accessor :enabled,
                   :compact_log,
                   :json_log,
+                  :graylog_formatter,
                   :logger,
                   :logger_method,
                   :severity,
@@ -18,34 +19,39 @@ module HttpLog
                   :log_benchmark,
                   :url_whitelist_pattern,
                   :url_blacklist_pattern,
+                  :url_masked_body_pattern,
                   :color,
                   :prefix_data_lines,
                   :prefix_response_lines,
                   :prefix_line_numbers,
+                  :json_parser,
                   :filter_parameters
 
     def initialize
-      @enabled               = true
-      @compact_log           = false
-      @json_log              = false
-      @logger                = Logger.new($stdout)
-      @logger_method         = :log
-      @severity              = Logger::Severity::DEBUG
-      @prefix                = LOG_PREFIX
-      @log_connect           = true
-      @log_request           = true
-      @log_headers           = false
-      @log_data              = true
-      @log_status            = true
-      @log_response          = true
-      @log_benchmark         = true
-      @url_whitelist_pattern = nil
-      @url_blacklist_pattern = nil
-      @color                 = false
-      @prefix_data_lines     = false
-      @prefix_response_lines = false
-      @prefix_line_numbers   = false
-      @filter_parameters     = []
+      @enabled                 = true
+      @compact_log             = false
+      @json_log                = false
+      @graylog_formatter       = nil
+      @logger                  = Logger.new($stdout)
+      @logger_method           = :log
+      @severity                = Logger::Severity::DEBUG
+      @prefix                  = LOG_PREFIX
+      @log_connect             = true
+      @log_request             = true
+      @log_headers             = false
+      @log_data                = true
+      @log_status              = true
+      @log_response            = true
+      @log_benchmark           = true
+      @url_whitelist_pattern   = nil
+      @url_blacklist_pattern   = nil
+      @url_masked_body_pattern = nil
+      @color                   = false
+      @prefix_data_lines       = false
+      @prefix_response_lines   = false
+      @prefix_line_numbers     = false
+      @json_parser             = JSON
+      @filter_parameters       = %w[password]
     end
   end
 end

data/lib/httplog/http_log.rb

@@ -29,8 +29,11 @@ module HttpLog
     end
 
     def call(options = {})
+      parse_request(options)
       if config.json_log
         log_json(options)
+      elsif config.graylog_formatter
+        log_graylog(options)
       elsif config.compact_log
         log_compact(options[:method], options[:url], options[:response_code], options[:benchmark])
       else
@@ -40,7 +43,7 @@ module HttpLog
         HttpLog.log_status(options[:response_code])
         HttpLog.log_benchmark(options[:benchmark])
         HttpLog.log_headers(options[:response_headers])
-        HttpLog.log_body(options[:response_body], options[:encoding], options[:content_type])
+        HttpLog.log_body(options[:response_body], options[:mask_body], options[:encoding], options[:content_type])
       end
     end
 
@@ -50,10 +53,14 @@ module HttpLog
       !config.url_whitelist_pattern || url.to_s.match(config.url_whitelist_pattern)
     end
 
+    def masked_body_url?(url)
+      config.filter_parameters.any? && config.url_masked_body_pattern && url.to_s.match(config.url_masked_body_pattern)
+    end
+
     def log(msg)
       return unless config.enabled
 
-      config.logger.public_send(config.logger_method, config.severity, colorize(prefix + msg))
+      config.logger.public_send(config.logger_method, config.severity, colorize(prefix + msg.to_s))
     end
 
     def log_connection(host, port = nil)
@@ -89,10 +96,10 @@ module HttpLog
       log("Benchmark: #{seconds.to_f.round(6)} seconds")
     end
 
-    def log_body(body, encoding = nil, content_type = nil)
+    def log_body(body, mask_body, encoding = nil, content_type = nil)
       return unless config.log_response
 
-      data = parse_body(body, encoding, content_type)
+      data = parse_body(body, mask_body, encoding, content_type)
 
       if config.prefix_response_lines
         log('Response:')
@@ -104,35 +111,50 @@ module HttpLog
       log("Response: #{e.message}")
     end
 
-    def parse_body(body, encoding, content_type)
-      unless text_based?(content_type)
-        raise BodyParsingError, "(not showing binary data)"
-      end
+    def parse_body(body, mask_body, encoding, content_type)
+      raise BodyParsingError, "(not showing binary data)" unless text_based?(content_type)
+
 
       if body.is_a?(Net::ReadAdapter)
         # open-uri wraps the response in a Net::ReadAdapter that defers reading
-        # the content, so the reponse body is not available here.
+        # the content, so the response body is not available here.
         raise BodyParsingError, '(not available yet)'
       end
 
-      if encoding =~ /gzip/ && body && !body.empty?
+      body_copy = body.dup
+      body_copy = body.to_s if defined?(HTTP::Response::Body) && body.is_a?(HTTP::Response::Body)
+      return nil if body_copy.nil? || body_copy.empty?
+
+
+      if encoding =~ /gzip/
         begin
-          sio = StringIO.new(body.to_s)
+          sio = StringIO.new(body_copy.to_s)
           gz = Zlib::GzipReader.new(sio)
-          body = gz.read
+          body_copy = gz.read
         rescue Zlib::GzipFile::Error
           log("(gzip decompression failed)")
         end
       end
 
-      utf_encoded(body.to_s, content_type)
+      result = utf_encoded(body_copy.to_s, content_type)
+
+      if mask_body
+        if content_type =~ /json/
+          result = begin
+                     masked_data config.json_parser.load(result)
+                   rescue => e
+                     'Failed to mask response body: ' + e.message
+                   end
+        else
+          result = masked(result)
+        end
+      end
+      result
     end
 
     def log_data(data)
       return unless config.log_data
 
-      data = utf_encoded(masked(data.dup).to_s) unless data.nil?
-
       if config.prefix_data_lines
         log('Data:')
         log_data_lines(data)
@@ -147,38 +169,6 @@ module HttpLog
       log("#{method.to_s.upcase} #{masked(uri)} completed with status code #{status} in #{seconds.to_f.round(6)} seconds")
     end
 
-    def log_json(data = {})
-      return unless config.json_log
-
-      data[:response_code] = transform_response_code(data[:response_code]) if data[:response_code].is_a?(Symbol)
-
-      parsed_body = begin
-        parse_body(data[:response_body], data[:encoding], data[:content_type])
-      rescue BodyParsingError => e
-        e.message
-      end
-
-      if config.compact_log
-        log({
-          method: data[:method].to_s.upcase,
-          url: masked(data[:url]),
-          response_code: data[:response_code].to_i,
-          benchmark: data[:benchmark]
-        }.to_json)
-      else
-        log({
-          method: data[:method].to_s.upcase,
-          url: masked(data[:url]),
-          request_body: masked(data[:request_body]),
-          request_headers: masked(data[:request_headers].to_h),
-          response_code: data[:response_code].to_i,
-          response_body: parsed_body,
-          response_headers: data[:response_headers].to_h,
-          benchmark: data[:benchmark]
-        }.to_json)
-      end
-    end
-
     def transform_response_code(response_code_name)
       Rack::Utils::HTTP_STATUS_CODES.detect { |_k, v| v.to_s.casecmp(response_code_name.to_s).zero? }.first
     end
@@ -199,6 +189,70 @@ module HttpLog
 
     private
 
+    def log_json(data = {})
+      return unless config.json_log
+
+      log(
+        begin
+          dump_json(data)
+        rescue
+          data[:response_body] = "#{config.json_parser} dump failed"
+          data[:request_body]  = "#{config.json_parser} dump failed"
+          dump_json(data)
+        end
+      )
+    end
+
+    def dump_json(data)
+      config.json_parser.dump(json_payload(data))
+    end
+
+    def log_graylog(data)
+      result = json_payload(data)
+      begin
+        send_to_graylog result
+      rescue
+        result[:response_body] = 'Graylog JSON dump failed'
+        result[:request_body]  = 'Graylog JSON dump failed'
+        send_to_graylog result
+      end
+    end
+
+    def send_to_graylog data
+      data.compact!
+      config.logger.public_send(config.logger_method, config.severity, config.graylog_formatter.call(data))
+    end
+
+    def json_payload(data = {})
+      data[:response_code] = transform_response_code(data[:response_code]) if data[:response_code].is_a?(Symbol)
+
+      parsed_body = begin
+                      parse_body(data[:response_body], data[:mask_body], data[:encoding], data[:content_type])
+                    rescue BodyParsingError => e
+                      e.message
+                    end
+
+      if config.compact_log
+        {
+          method:        data[:method].to_s.upcase,
+          url:           masked(data[:url]),
+          response_code: data[:response_code].to_i,
+          benchmark:     data[:benchmark]
+        }
+      else
+        {
+          method:           data[:method].to_s.upcase,
+          url:              masked(data[:url]),
+          request_body:     data[:request_body],
+          request_headers:  masked(data[:request_headers].to_h),
+          response_code:    data[:response_code].to_i,
+          response_body:    parsed_body,
+          response_headers: data[:response_headers].to_h,
+          benchmark:        data[:benchmark]
+        }
+      end
+    end
+
     def masked(msg, key=nil)
       return msg if config.filter_parameters.empty?
       return msg if msg.nil?
@@ -207,11 +261,14 @@ module HttpLog
       # in its entirety.
       return (config.filter_parameters.include?(key.downcase) ? PARAM_MASK : msg) if key
 
-      # Otherwise, we'll parse Strings for key=valye pairs...
+      # Otherwise, we'll parse Strings for key=value pairs,
+      # for name="key"\n value...
       case msg
       when *string_classes
         config.filter_parameters.reduce(msg) do |m,key|
-          m.to_s.gsub(/(#{key})=[^&]+/i, "#{key}=#{PARAM_MASK}")
+          scrubbed = m.to_s.encode('UTF-8', invalid: :replace, undef: :replace)
+          scrubbed.to_s.gsub(/(#{key})=[^&]+/i, "#{key}=#{PARAM_MASK}")
+            .gsub(/name="#{key}"\s+\K[\s\w]+/, "#{PARAM_MASK}\r\n") # multi-part Faraday
         end
       # ...and recurse over hashes
       when *hash_classes
@@ -222,6 +279,38 @@ module HttpLog
       end
     end
 
+    def parse_request(options)
+      return if options[:request_body].nil?
+
+      # Downcase content-type and content-encoding because ::HTTP returns "Content-Type" and "Content-Encoding"
+      headers = options[:request_headers].find_all do |header, _|
+        %w[content-type Content-Type content-encoding Content-Encoding].include? header
+      end.to_h.each_with_object({}) { |(k, v), h| h[k.downcase] = v }
+
+      copy = options[:request_body].dup
+
+      options[:request_body] = if text_based?(headers['content-type']) && options[:mask_body]
+                                 begin
+                                   parse_body(copy, options[:mask_body], headers['content-encoding'], headers['content-type'])
+                                 rescue BodyParsingError => e
+                                   log(e.message)
+                                 end
+                               else
+                                 masked(copy).to_s
+                               end
+    end
+
+    def masked_data msg
+      case msg
+      when Hash
+        Hash[msg.map { |k, v| [k, config.filter_parameters.include?(k.downcase) ? PARAM_MASK : masked_data(v)] }]
+      when Array
+        msg.map { |element| masked_data(element) }
+      else
+        msg
+      end
+    end
+
     def string_classes
       @string_classes ||= begin
         string_classes = [String]