httplog 1.3.0 → 1.4.3

data/gemfiles/http3.gemfile

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gem 'http', '~> 3.0'
-
-gemspec path: '..'

data/gemfiles/http4.gemfile

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gem 'http', '~> 4.0'
-
-gemspec path: '..'

data/gemfiles/http5.gemfile

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gem 'http', '~> 5.0.0.pre'
-
-gemspec path: '..'

data/gemfiles/rack1.gemfile

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gem 'rack', '~> 1.0'
-
-gemspec path: '..'

data/gemfiles/rack2.gemfile

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gem 'rack', '~> 2.0'
-
-gemspec path: '..'

data/spec/adapters/ethon_adapter.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'ethon'
-class EthonAdapter < HTTPBaseAdapter
-  def send_get_request
-    easy = Ethon::Easy.new
-    easy.http_request(parse_uri(true).to_s, :get, headers: @headers)
-    easy.perform
-  end
-
-  def send_head_request
-    easy = Ethon::Easy.new
-    easy.http_request(parse_uri.to_s, :head, headers: @headers)
-    easy.perform
-  end
-
-  def send_post_request
-    easy = Ethon::Easy.new
-    easy.http_request(parse_uri.to_s, :post, headers: @headers, body: @data)
-    easy.perform
-  end
-
-  def self.is_libcurl?
-    true
-  end
-end

data/spec/adapters/excon_adapter.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'excon'
-class ExconAdapter < HTTPBaseAdapter
-  def send_get_request
-    Excon.get(parse_uri(true).to_s, headers: @headers)
-  end
-
-  def send_head_request
-    Excon.head(parse_uri.to_s, headers: @headers)
-  end
-
-  def send_post_request
-    Excon.post(parse_uri.to_s, body: @data, headers: @headers)
-  end
-end

data/spec/adapters/faraday_adapter.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-class FaradayAdapter < HTTPBaseAdapter
-  def send_get_request
-    connection.get do |req|
-      req.url parse_uri(true).to_s
-      req.headers = @headers
-    end
-  end
-
-  def send_head_request
-    connection.head do |req|
-      req.url parse_uri.to_s
-      req.headers = @headers
-    end
-  end
-
-  def send_post_request
-    connection.post do |req|
-      req.url parse_uri.to_s
-      req.headers = @headers
-      req.body = @data
-    end
-  end
-
-  def send_post_form_request
-    connection.post do |req|
-      req.url parse_uri.to_s
-      req.headers = @headers
-      req.body = @params
-    end
-  end
-
-  def send_multipart_post_request
-    file_upload = Faraday::UploadIO.new(@params['file'], 'text/plain')
-
-    connection.post do |req|
-      req.url parse_uri.to_s
-      req.headers = @headers
-      req.body = @params.merge('file' => file_upload)
-    end
-  end
-
-  def logs_form_data?
-    false
-  end
-
-  private
-
-  def connection
-    Faraday.new(url: "#{@protocol}://#{@host}:#{@port}") do |faraday|
-      faraday.request :multipart
-      faraday.request :url_encoded
-
-      faraday.adapter Faraday.default_adapter # make requests with Net::HTTP
-    end
-  end
-end

data/spec/adapters/http_adapter.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'http'
-class HTTPAdapter < HTTPBaseAdapter
-  def send_get_request
-    client.get(parse_uri(true).to_s)
-  end
-
-  def send_head_request
-    client.head(parse_uri.to_s)
-  end
-
-  def send_post_request
-    client.post(parse_uri.to_s, body: @data)
-  end
-
-  def send_post_form_request
-    client.post(parse_uri.to_s, form: @params)
-  end
-
-  private
-
-  def client
-    method_name = respond_to?(:with_headers) ? :with_headers : :headers
-    ::HTTP.send(method_name, @headers)
-  end
-end

data/spec/adapters/http_base_adapter.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-class HTTPBaseAdapter
-  def initialize(options = {})
-    @host     = options.fetch(:host, 'localhost')
-    @port     = options.fetch(:port, 80)
-    @path     = options.fetch(:path, '/')
-    @headers  = options.fetch(:headers, {})
-    @data     = options.fetch(:data, nil)
-    @params   = options.fetch(:params, {})
-    @protocol = options.fetch(:protocol, 'http')
-  end
-
-  def logs_data?
-    true
-  end
-
-  def logs_form_data?
-    true
-  end
-
-  def parse_uri(query=false)
-    uri = "#{@protocol}://#{@host}:#{@port}#{@path}"
-    uri = [uri, URI::encode(@data)].join('?') if query && @data
-    URI.parse(uri)
-  end
-
-  def expected_response_body
-    "\n<html>"
-  end
-
-  def self.is_libcurl?
-    false
-  end
-
-  def self.should_log_headers?
-    true
-  end
-end

data/spec/adapters/httparty_adapter.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'httparty'
-class HTTPartyAdapter < HTTPBaseAdapter
-  def send_get_request
-    HTTParty.get(parse_uri(true).to_s, headers: @headers)
-  end
-
-  def send_head_request
-    HTTParty.head(parse_uri.to_s, headers: @headers)
-  end
-
-  def send_post_request
-    HTTParty.post(parse_uri.to_s, body: @data, headers: @headers)
-  end
-end

data/spec/adapters/httpclient_adapter.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class HTTPClientAdapter < HTTPBaseAdapter
-  def send_get_request
-    ::HTTPClient.get(parse_uri(true), header: @headers)
-  end
-
-  def send_head_request
-    ::HTTPClient.head(parse_uri, header: @headers)
-  end
-
-  def send_post_request
-    ::HTTPClient.post(parse_uri, body: @data, header: @headers)
-  end
-
-  def send_post_form_request
-    ::HTTPClient.post(parse_uri, body: @params, header: @headers)
-  end
-
-  def send_multipart_post_request
-    send_post_form_request
-  end
-
-  def self.response_should_be
-    HTTP::Message
-  end
-
-  def logs_form_data?
-    false
-  end
-end

data/spec/adapters/net_http_adapter.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-class NetHTTPAdapter < HTTPBaseAdapter
-  def send_get_request
-    path = @path
-    path = [@path, URI::encode(@data)].join('?') if @data
-    Net::HTTP.get_response(@host, path, @port)
-  end
-
-  def send_head_request
-    Net::HTTP.new(@host, @port).head(@path, @headers)
-  end
-
-  def send_post_request
-    Net::HTTP.new(@host, @port).post(@path, @data)
-  end
-
-  def send_post_form_request
-    Net::HTTP.post_form(parse_uri, @params)
-  end
-end

data/spec/adapters/open_uri_adapter.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-class OpenUriAdapter < HTTPBaseAdapter
-  def send_get_request
-    open(parse_uri(true)) # rubocop:disable Security/Open
-  end
-
-  def expected_response_body
-    ' (not available yet)'
-  end
-
-  def self.should_log_headers?
-    false
-  end
-
-  def logs_data?
-    false
-  end
-end

data/spec/adapters/patron_adapter.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'patron'
-class PatronAdapter < HTTPBaseAdapter
-  def send_get_request
-    session = Patron::Session.new
-    session.get(parse_uri(true).to_s, @headers)
-  end
-
-  def send_head_request
-    session = Patron::Session.new
-    session.head(parse_uri.to_s, @headers)
-  end
-
-  def send_post_request
-    session = Patron::Session.new
-    session.post(parse_uri.to_s, @data, @headers)
-  end
-
-  def send_post_form_request
-    session = Patron::Session.new
-    session.post(parse_uri.to_s, @params, @headers)
-  end
-
-  def send_multipart_post_request
-    data = @params.dup
-    file = @params.delete('file')
-
-    session = Patron::Session.new
-    session.post_multipart(parse_uri.to_s, data, { file: file.path }, @headers)
-  end
-
-  def self.is_libcurl?
-    true
-  end
-end

data/spec/adapters/typhoeus_adapter.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'excon'
-class TyphoeusAdapter < HTTPBaseAdapter
-  def send_get_request
-    Typhoeus.get(parse_uri(true).to_s, headers: @headers)
-  end
-
-  def send_head_request
-    Typhoeus.head(parse_uri.to_s, headers: @headers)
-  end
-
-  def send_post_request
-    Typhoeus.post(parse_uri.to_s, body: @data, headers: @headers)
-  end
-
-  def send_post_form_request
-    Typhoeus.post(parse_uri.to_s, body: @params, headers: @headers)
-  end
-
-  def send_multipart_post_request
-    send_post_form_request
-  end
-
-  def self.is_libcurl?
-    true
-  end
-end

data/spec/configuration_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module HttpLog
-  describe Configuration do
-    let(:config) { Configuration.new }
-
-    describe '#compact_log' do
-      it 'defaults to false' do
-        expect(config.compact_log).to eq(false)
-      end
-    end
-
-    describe '#compact_log=' do
-      it 'sets values' do
-        config.compact_log = true
-        expect(config.compact_log).to eq(true)
-      end
-    end
-  end
-end

data/spec/lib/http_client_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe HTTPClient do
-  let(:client) { HTTPClient.new }
-
-  it 'works with transparent_gzip_decompression' do
-    client.transparent_gzip_decompression = true
-    expect { client.get("http://localhost:9292/index.html.gz") }.to_not(raise_error)
-    expect(log).to include(HttpLog::LOG_PREFIX + 'Status: 200')
-    expect(log).to include(HttpLog::LOG_PREFIX + 'Data:')
-    expect(log).to include(HttpLog::LOG_PREFIX + "Response:\n<html>")
-  end
-end

data/spec/lib/http_log_spec.rb

@@ -1,320 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe HttpLog do
-  subject { log } # see spec_helper
-
-  let(:secret)  { 'my secret' }
-  let(:host)    { 'localhost' }
-  let(:port)    { 9292 }
-  let(:path)    { '/index.html' }
-  let(:headers) { { 'accept' => '*/*', 'foo' => secret } }
-  let(:data)    { "foo=#{secret}&bar=foo" }
-  let(:params)  { { 'foo' => secret, 'bar' => 'foo:form-data' } }
-  let(:html)    { File.read('./spec/support/index.html') }
-  let(:json)    { JSON.parse(log.match(/\[httplog\]\s(.*)/).captures.first) }
-
-  # Default configuration
-  let(:enabled)               { HttpLog.configuration.enabled }
-  let(:severity)              { HttpLog.configuration.severity }
-  let(:log_headers)           { HttpLog.configuration.log_headers }
-  let(:log_request)           { HttpLog.configuration.log_request }
-  let(:log_response)          { HttpLog.configuration.log_response }
-  let(:log_data)              { HttpLog.configuration.log_data }
-  let(:log_connect)           { HttpLog.configuration.log_connect }
-  let(:log_benchmark)         { HttpLog.configuration.log_benchmark }
-  let(:color)                 { HttpLog.configuration.color }
-  let(:prefix)                { HttpLog.configuration.prefix }
-  let(:prefix_response_lines) { HttpLog.configuration.prefix_response_lines }
-  let(:prefix_line_numbers)   { HttpLog.configuration.prefix_line_numbers }
-  let(:json_log)              { HttpLog.configuration.json_log }
-  let(:compact_log)           { HttpLog.configuration.compact_log }
-  let(:url_blacklist_pattern) { HttpLog.configuration.url_blacklist_pattern }
-  let(:url_whitelist_pattern) { HttpLog.configuration.url_whitelist_pattern }
-  let(:filter_parameters)     { HttpLog.configuration.filter_parameters }
-
-  def configure
-    HttpLog.configure do |c|
-      c.enabled               = enabled
-      c.severity              = severity
-      c.log_headers           = log_headers
-      c.log_request           = log_request
-      c.log_response          = log_response
-      c.log_data              = log_data
-      c.log_connect           = log_connect
-      c.log_benchmark         = log_benchmark
-      c.color                 = color
-      c.prefix                = prefix
-      c.prefix_response_lines = prefix_response_lines
-      c.prefix_line_numbers   = prefix_line_numbers
-      c.json_log              = json_log
-      c.compact_log           = compact_log
-      c.url_blacklist_pattern = url_blacklist_pattern
-      c.url_whitelist_pattern = url_whitelist_pattern
-      c.filter_parameters     = filter_parameters
-    end
-  end
-
-  ADAPTERS = [
-    NetHTTPAdapter,
-    OpenUriAdapter,
-    HTTPClientAdapter,
-    HTTPartyAdapter,
-    FaradayAdapter,
-    ExconAdapter,
-    EthonAdapter,
-    PatronAdapter,
-    HTTPAdapter
-  ].freeze
-
-  ADAPTERS.each do |adapter_class|
-    context adapter_class, adapter: adapter_class.to_s do
-      let(:adapter) { adapter_class.new(host: host, port: port, path: path, headers: headers, data: data, params: params) }
-      before { configure }
-
-      context 'with default configuration' do
-        describe 'GET requests' do
-          let!(:res) { adapter.send_get_request }
-
-          it_behaves_like 'logs request', 'GET'
-          it_behaves_like 'logs data'
-          it_behaves_like 'logs expected response'
-          it_behaves_like 'logs status', 200
-          it_behaves_like 'logs benchmark'
-
-          it { is_expected.to_not include('Header:') }
-          it { is_expected.to_not include("\e[0") }
-
-          unless adapter_class.is_libcurl?
-            it { is_expected.to include("Connecting: #{host}:#{port}") }
-          end
-
-          it { expect(res).to be_a adapter.response if adapter.respond_to? :response }
-
-          context 'with gzip encoding' do
-            let(:path) { '/index.html.gz' }
-            let(:data) { nil }
-
-            it_behaves_like 'logs expected response'
-
-            if adapter_class.method_defined? :send_head_request
-              it "doesn't try to decompress body for HEAD requests" do
-                expect(log).to include('Response:')
-              end
-            end
-          end
-
-          context 'with UTF-8 response body' do
-            let(:path) { '/utf8.html' }
-            let(:data) { nil }
-
-            it_behaves_like 'logs expected response'
-            it { is_expected.to include('    <title>Блог Яндекса</title>') if adapter.logs_data? }
-          end
-
-          context 'with binary response body' do
-            %w[/test.bin /test.pdf].each do |response_file_name|
-              let(:path) { response_file_name }
-              let(:data) { nil }
-
-              it { is_expected.to include('Response: (not showing binary data)') }
-
-              context 'and JSON logging' do
-                let(:json_log) { true }
-                it { expect(json['response_body']).to eq '(not showing binary data)' }
-              end
-            end
-          end
-        end
-
-        describe 'POST requests' do
-          if adapter_class.method_defined? :send_post_request
-            let!(:res) { adapter.send_post_request }
-
-            unless adapter_class.is_libcurl?
-              it { is_expected.to include("Connecting: #{host}:#{port}") }
-            end
-
-            it_behaves_like 'logs request', 'POST'
-            it_behaves_like 'logs expected response'
-            it_behaves_like 'logs data'
-            it_behaves_like 'logs status', 200
-            it_behaves_like 'logs benchmark'
-
-            it { is_expected.to_not include('Header:') }
-
-            it { expect(res).to be_a adapter.response if adapter.respond_to? :response }
-
-            context 'with non-UTF request data' do
-              let(:data) { "a UTF-8 striñg with an 8BIT-ASCII character: \xC3" }
-              it_behaves_like 'logs expected response' # == doesn't throw exception
-            end
-
-            context 'with URI encoded non-UTF data' do
-              let(:data) { 'a UTF-8 striñg with a URI encoded 8BIT-ASCII character: %c3' }
-              it_behaves_like 'logs expected response' # == doesn't throw exception
-            end
-          end
-        end
-      end
-
-      context 'with custom configuration' do
-        context 'GET requests' do
-          before { adapter.send_get_request }
-
-          context 'when disabled' do
-            let(:enabled) { false }
-            it_behaves_like 'logs nothing'
-          end
-
-          context 'with different log level' do
-            let(:severity) { Logger::Severity::INFO }
-            it { is_expected.to include('INFO') }
-          end
-
-          context 'with headers logging' do
-            let(:log_headers) { true }
-            it { is_expected.to match(%r{Header: accept: */*}i) } # request
-            it { is_expected.to match(/Header: Server: thin/i) } # response
-            it_behaves_like 'filtered parameters'
-          end
-
-          context 'with blacklist hit' do
-            let(:url_blacklist_pattern) { /#{host}:#{port}/ }
-            it_behaves_like 'logs nothing'
-          end
-
-          context 'with blacklist miss' do
-            let(:url_blacklist_pattern) { /example.com/ }
-            it_behaves_like 'logs request', 'GET'
-          end
-
-          context 'with whitelist hit' do
-            let(:url_whitelist_pattern) { /#{host}:#{port}/ }
-            it_behaves_like 'logs request', 'GET'
-
-            context 'and blacklist hit' do
-              let(:url_blacklist_pattern) { /#{host}:#{port}/ }
-              it_behaves_like 'logs nothing'
-            end
-          end
-
-          context 'with whitelist miss' do
-            let(:url_whitelist_pattern) { /example.com/ }
-            it_behaves_like 'logs nothing'
-          end
-
-          it_behaves_like 'with request logging disabled'
-          it_behaves_like 'with connection logging disabled'
-          it_behaves_like 'data logging disabled'
-          it_behaves_like 'response logging disabled'
-          it_behaves_like 'benchmark logging disabled'
-          it_behaves_like 'filtered parameters'
-
-          context 'with single color' do
-            let(:color) { :red }
-            it { is_expected.to include("\e[31m") }
-          end
-
-          context 'with color hash' do
-            let(:color) { { color: :black, background: :yellow } }
-            it { is_expected.to include("\e[30m\e[43m") }
-          end
-
-          context 'with custom prefix' do
-            let(:prefix) { '[my logger]' }
-            it { is_expected.to include('[my logger]') }
-            it { is_expected.to_not include(HttpLog::LOG_PREFIX) }
-          end
-
-          context 'with custom lambda prefix' do
-            let(:prefix) { -> { '[custom prefix]' } }
-            it { is_expected.to include('[custom prefix]') }
-            it { is_expected.to_not include(HttpLog::LOG_PREFIX) }
-          end
-
-          context 'with compact config' do
-            let(:compact_log) { true }
-            it { is_expected.to match(%r{\[httplog\] GET http://#{host}:#{port}#{path}(\?.*)? completed with status code \d{3} in \d+\.\d{1,6} }) }
-            it { is_expected.to_not include("Connecting: #{host}:#{port}") }
-            it { is_expected.to_not include('Response:') }
-            it { is_expected.to_not include('Data:') }
-            it { is_expected.to_not include('Benchmark: ') }
-          end
-        end
-
-        context 'POST requests' do
-          if adapter_class.method_defined? :send_post_request
-            before { adapter.send_post_request }
-
-            it_behaves_like 'data logging disabled'
-            it_behaves_like 'response logging disabled'
-            it_behaves_like 'benchmark logging disabled'
-            it_behaves_like 'with prefix response lines'
-            it_behaves_like 'with line numbers'
-            it_behaves_like 'filtered parameters'
-          end
-        end
-
-        context 'POST form data requests' do
-          if adapter_class.method_defined? :send_post_form_request
-            before { adapter.send_post_form_request }
-
-            it_behaves_like 'data logging disabled'
-            it_behaves_like 'response logging disabled'
-            it_behaves_like 'benchmark logging disabled'
-            it_behaves_like 'with prefix response lines'
-            it_behaves_like 'with line numbers'
-            it_behaves_like 'filtered parameters'
-          end
-        end
-
-        context 'POST multi-part requests (file upload)' do
-          let(:upload) { Tempfile.new('http-log') }
-          let(:params) { { 'foo' => secret, 'file' => upload } }
-
-          if adapter_class.method_defined? :send_multipart_post_request
-            before { adapter.send_multipart_post_request }
-
-            it_behaves_like 'data logging disabled'
-            it_behaves_like 'response logging disabled'
-            it_behaves_like 'benchmark logging disabled'
-            it_behaves_like 'with prefix response lines'
-            it_behaves_like 'with line numbers'
-            it_behaves_like 'filtered parameters'
-          end
-        end
-      end
-
-      context 'with JSON config' do
-        let(:json_log) { true }
-
-        if adapter_class.method_defined? :send_post_request
-          before { adapter.send_post_request }
-
-          it { expect(json['method']).to eq('POST') }
-          it { expect(json['request_body']).to eq(data) }
-          it { expect(json['request_headers']).to be_a(Hash) }
-          it { expect(json['response_headers']).to be_a(Hash) }
-          it { expect(json['response_code']).to eq(200) }
-          it { expect(json['response_body']).to eq(html) }
-          it { expect(json['benchmark']).to be_a(Numeric) }
-          it_behaves_like 'filtered parameters'
-
-          context 'and compact config' do
-            let(:compact_log) { true }
-
-            it { expect(json['method']).to eq('POST') }
-            it { expect(json['request_body']).to be_nil }
-            it { expect(json['request_headers']).to be_nil }
-            it { expect(json['response_headers']).to be_nil }
-            it { expect(json['response_code']).to eq(200) }
-            it { expect(json['response_body']).to be_nil }
-            it { expect(json['benchmark']).to be_a(Numeric) }
-          end
-        end
-      end
-    end
-  end
-end