RubyGems - httplog - Versions diffs - 1.0.0 → 1.0.1 - Mend

httplog 1.0.0 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

checksums.yaml +4 -4
data/.gitignore +7 -0
data/.rspec +2 -0
data/.ruby-version +1 -0
data/.travis.yml +14 -0
data/CHANGELOG.md +75 -0
data/Gemfile +2 -0
data/Gemfile.lock +124 -0
data/Guardfile +24 -0
data/README.md +5 -6
data/gemfiles/http2.gemfile +5 -0
data/gemfiles/http3.gemfile +5 -0
data/gemfiles/http4.gemfile +5 -0
data/httplog.gemspec +41 -0
data/lib/httplog/adapters/http.rb +9 -1
data/lib/httplog/version.rb +1 -1
data/spec/adapters/ethon_adapter.rb +24 -0
data/spec/adapters/excon_adapter.rb +14 -0
data/spec/adapters/faraday_adapter.rb +53 -0
data/spec/adapters/http_adapter.rb +25 -0
data/spec/adapters/http_base_adapter.rb +31 -0
data/spec/adapters/httparty_adapter.rb +14 -0
data/spec/adapters/httpclient_adapter.rb +25 -0
data/spec/adapters/net_http_adapter.rb +19 -0
data/spec/adapters/open_uri_adapter.rb +17 -0
data/spec/adapters/patron_adapter.rb +34 -0
data/spec/adapters/typhoeus_adapter.rb +27 -0
data/spec/configuration_spec.rb +23 -0
data/spec/http_log_spec.rb +358 -0
data/spec/log/.gitkeep +0 -0
data/spec/spec_helper.rb +45 -0
data/spec/support/index.html +8 -0
data/spec/support/index.html.gz +0 -0
data/spec/support/log4r.yml +17 -0
data/spec/support/test.bin +0 -0
data/spec/support/test_server.rb +31 -0
data/spec/support/utf8-invalid.html +0 -0
data/spec/support/utf8.html +8 -0
metadata +99 -64

data/spec/adapters/http_adapter.rb ADDED Viewed

@@ -0,0 +1,25 @@
+require 'http'
+class HTTPAdapter < HTTPBaseAdapter
+  def send_get_request
+    client.get(parse_uri.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 ADDED Viewed

@@ -0,0 +1,31 @@
+class HTTPBaseAdapter
+  def initialize(host, port, path, headers, data, params, protocol = 'http')
+    @host = host
+    @port = port
+    @path = path
+    @headers = headers
+    @data = data
+    @params = params
+    @protocol = protocol
+  end
+  def logs_data?
+    true
+  end
+  def parse_uri
+    URI.parse("#{@protocol}://#{@host}:#{@port}#{@path}")
+  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 ADDED Viewed

@@ -0,0 +1,14 @@
+require 'httparty'
+class HTTPartyAdapter < HTTPBaseAdapter
+  def send_get_request
+    HTTParty.get(parse_uri.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 ADDED Viewed

@@ -0,0 +1,25 @@
+class HTTPClientAdapter < HTTPBaseAdapter
+  def send_get_request
+    ::HTTPClient.get(parse_uri, 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
+end

data/spec/adapters/net_http_adapter.rb ADDED Viewed

@@ -0,0 +1,19 @@
+class NetHTTPAdapter < HTTPBaseAdapter
+  def send_get_request
+    Net::HTTP.get_response(@host, [@path, @data].compact.join('?'), @port)
+  end
+  def send_head_request
+    http = Net::HTTP.new(@host, @port)
+    http.head(@path, @headers)
+  end
+  def send_post_request
+    http = Net::HTTP.new(@host, @port)
+    resp = http.post(@path, @data)
+  end
+  def send_post_form_request
+    res = Net::HTTP.post_form(parse_uri, @params)
+  end
+end

data/spec/adapters/open_uri_adapter.rb ADDED Viewed

@@ -0,0 +1,17 @@
+class OpenUriAdapter < HTTPBaseAdapter
+  def send_get_request
+    open(parse_uri)
+  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 ADDED Viewed

@@ -0,0 +1,34 @@
+require "patron"
+class PatronAdapter < HTTPBaseAdapter
+  def send_get_request
+    session = Patron::Session.new
+    session.get(parse_uri.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 ADDED Viewed

@@ -0,0 +1,27 @@
+require 'excon'
+class TyphoeusAdapter < HTTPBaseAdapter
+  def send_get_request
+    Typhoeus.get(parse_uri.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 ADDED Viewed

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+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/http_log_spec.rb ADDED Viewed

@@ -0,0 +1,358 @@
+# encoding: UTF-8
+require 'spec_helper'
+describe HttpLog do
+  let(:host) { 'localhost' }
+  let(:port) { 9292 }
+  let(:path) { "/index.html" }
+  let(:headers) { { "accept" => "*/*", "foo" => "bar" } }
+  let(:data) { "foo=bar&bar=foo" }
+  let(:params) { {'foo' => 'bar:form-data', 'bar' => 'foo'} }
+  ADAPTERS = [
+    NetHTTPAdapter,
+    OpenUriAdapter,
+    HTTPClientAdapter,
+    HTTPartyAdapter,
+    FaradayAdapter,
+    ExconAdapter,
+    EthonAdapter,
+    # FIXME: typheous does weird things to reponse headers using ethon as the default adapter,
+    # even though ethon stand-alone works just fine. Not worth supporting since Typhoeus has its
+    # own logging facility.
+    #
+    # TyphoeusAdapter,
+    PatronAdapter,
+    HTTPAdapter
+  ]
+  ADAPTERS.each do |adapter_class|
+    context adapter_class, :adapter => adapter_class.to_s do
+      let(:adapter) { adapter_class.new(host, port, path, headers, data, params) }
+      context "with default configuration" do
+        connection_test_method = adapter_class.is_libcurl? ? :to_not : :to
+        if adapter_class.method_defined? :send_get_request
+          it "should log GET requests" do
+            res = adapter.send_get_request
+            expect(log).send(connection_test_method, include(HttpLog::LOG_PREFIX + "Connecting: #{host}:#{port}"))
+            expect(log).to include(HttpLog::LOG_PREFIX + "Sending: GET http://#{host}:#{port}#{path}")
+            expect(log).to include(HttpLog::LOG_PREFIX + "Data:")
+            expect(log).to_not include(HttpLog::LOG_PREFIX + "Header:")
+            expect(log).to include(HttpLog::LOG_PREFIX + "Status: 200")
+            expect(log).to include(HttpLog::LOG_PREFIX + "Benchmark: ")
+            expect(log).to include(HttpLog::LOG_PREFIX + "Response:#{adapter.expected_response_body}")
+            expect(log.colorized?).to be_falsey
+            expect(res).to be_a adapter.response if adapter.respond_to? :response
+          end
+          context "with gzipped response body" do
+            let(:path) { '/index.html.gz' }
+            let(:data) { nil }
+            it "decompresses gzipped response body" do
+              adapter.send_get_request
+              expect(log).to include(HttpLog::LOG_PREFIX + "Response:#{adapter.expected_response_body}")
+            end
+            if adapter_class.method_defined? :send_head_request
+              it "doesn't try to decompress body for HEAD requests" do
+                adapter.send_head_request
+                expect(log).to include(HttpLog::LOG_PREFIX + "Response:")
+              end
+            end
+          end
+          context "with UTF-8 response body" do
+            let(:path) { '/utf8.html' }
+            let(:data) { nil }
+            it "works" do
+              adapter.send_get_request
+              expect(log).to include(HttpLog::LOG_PREFIX + "Response:#{adapter.expected_response_body}")
+              if adapter.logs_data?
+                expect(log).to include("    <title>Блог Яндекса</title>")
+              end
+            end
+          end
+          context "with binary response body" do
+            let(:path) { '/test.bin' }
+            let(:data) { nil }
+            it "doesn't log response" do
+              adapter.send_get_request
+              expect(log).to include(HttpLog::LOG_PREFIX + "Response: (not showing binary data)")
+            end
+          end
+        end
+        if adapter_class.method_defined? :send_post_request
+          it "logs POST requests" do
+            res = adapter.send_post_request
+            expect(log).send(connection_test_method, include(HttpLog::LOG_PREFIX + "Connecting: #{host}:#{port}"))
+            expect(log).to include(HttpLog::LOG_PREFIX + "Sending: POST http://#{host}:#{port}#{path}")
+            expect(log).to include(HttpLog::LOG_PREFIX + "Data: foo=bar&bar=foo")
+            expect(log).to_not include(HttpLog::LOG_PREFIX + "Header:")
+            expect(log).to include(HttpLog::LOG_PREFIX + "Status: 200")
+            expect(log).to include(HttpLog::LOG_PREFIX + "Benchmark: ")
+            expect(log).to include(HttpLog::LOG_PREFIX + "Response:#{adapter.expected_response_body}")
+            expect(log.colorized?).to be_falsey
+            expect(res).to be_a adapter.response if adapter.respond_to? :response
+          end
+          context "with non-UTF request data" do
+            let(:data) { "a UTF-8 striñg with an 8BIT-ASCII character: \xC3".freeze }
+            it "does not raise and error" do
+              expect {adapter.send_post_request }.to_not raise_error
+              expect(log).to include(HttpLog::LOG_PREFIX + "Response:")
+            end
+          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 "does not raise and error" do
+              expect { adapter.send_post_request }.to_not raise_error
+              expect(log).to include(HttpLog::LOG_PREFIX + "Response:")
+            end
+          end
+        end
+      end
+      context "with custom configuration" do
+        context "GET requests" do
+          it "should not log anything unless enabled is set" do
+            HttpLog.configure { |c| c.enabled = false }
+            adapter.send_get_request
+            expect(log).to eq('')
+          end
+          it "should log at other levels" do
+            HttpLog.configure { |c| c.severity = Logger::Severity::INFO }
+            adapter.send_get_request
+            expect(log).to include("INFO")
+          end
+          it "should log headers if enabled" do
+            HttpLog.configure { |c| c.log_headers = true }
+            adapter.send_get_request
+            # request header
+            expect(log.downcase).to include(HttpLog::LOG_PREFIX + "Header: accept: */*".downcase)
+            # response header
+            expect(log.downcase).to include(HttpLog::LOG_PREFIX + "Header: server: thin".downcase)
+          end
+          it "should not log headers if disabled" do
+            HttpLog.configure { |c| c.log_headers = false }
+            adapter.send_get_request
+            expect(log).to_not include(HttpLog::LOG_PREFIX + "Header:")
+          end
+          it "should log the request if url does not match blacklist pattern" do
+            HttpLog.configure { |c| c.url_blacklist_pattern = /example.com/ }
+            adapter.send_get_request
+            expect(log).to include(HttpLog::LOG_PREFIX + "Sending: GET")
+          end
+          it "should log the request if url matches whitelist pattern and not the blacklist pattern" do
+            HttpLog.configure { |c| c.url_blacklist_pattern = /example.com/ }
+            HttpLog.configure { |c| c.url_whitelist_pattern = /#{host}:#{port}/ }
+            adapter.send_get_request
+            expect(log).to include(HttpLog::LOG_PREFIX + "Sending: GET")
+          end
+          it "should not log the request if url matches blacklist pattern" do
+            HttpLog.configure { |c| c.url_blacklist_pattern = /#{host}:#{port}/ }
+            adapter.send_get_request
+            expect(log).to_not include(HttpLog::LOG_PREFIX + "Sending: GET")
+          end
+          it "should not log the request if url does not match whitelist pattern" do
+            HttpLog.configure { |c| c.url_whitelist_pattern = /example.com/ }
+            adapter.send_get_request
+            expect(log).to_not include(HttpLog::LOG_PREFIX + "Sending: GET")
+          end
+          it "should not log the request if url matches blacklist pattern and the whitelist pattern" do
+            HttpLog.configure { |c| c.url_blacklist_pattern = /#{host}:#{port}/ }
+            HttpLog.configure { |c| c.url_whitelist_pattern = /#{host}:#{port}/ }
+            adapter.send_get_request
+            expect(log).to_not include(HttpLog::LOG_PREFIX + "Sending: GET")
+          end
+          it "should not log the request if disabled" do
+            HttpLog.configure { |c| c.log_request = false }
+            adapter.send_get_request
+            expect(log).to_not include(HttpLog::LOG_PREFIX + "Sending: GET")
+          end
+          it "should not log the connection if disabled" do
+            HttpLog.configure { |c| c.log_connect = false }
+            adapter.send_get_request
+            expect(log).to_not include(HttpLog::LOG_PREFIX + "Connecting: #{host}:#{port}")
+          end
+          it "should not log data if disabled" do
+            HttpLog.configure { |c| c.log_data = false }
+            adapter.send_get_request
+            expect(log).to_not include(HttpLog::LOG_PREFIX + "Data:")
+          end
+          it "should colorized output" do
+            HttpLog.configure { |c| c.color = :red }
+            adapter.send_get_request
+            expect(log.colorized?).to be_truthy
+          end
+          it "should log with custom string prefix" do
+            HttpLog.configure { |c| c.prefix = '[my logger]' }
+            adapter.send_get_request
+            expect(log).to include("[my logger]")
+            expect(log).to_not include(HttpLog::LOG_PREFIX)
+          end
+          it "should log with custom lambda prefix" do
+            HttpLog.configure { |c| c.prefix = -> { '[custom prefix]' } }
+            adapter.send_get_request
+            expect(log).to include("[custom prefix]")
+            expect(log).to_not include(HttpLog::LOG_PREFIX)
+          end
+        end
+        context "POST requests" do
+          if adapter_class.method_defined? :send_post_request
+            it "should not log data if disabled" do
+              HttpLog.configure { |c| c.log_data = false }
+              adapter.send_post_request
+              expect(log).to_not include(HttpLog::LOG_PREFIX + "Data:")
+            end
+            it "should not log the response if disabled" do
+              HttpLog.configure { |c| c.log_response = false }
+              adapter.send_post_request
+              expect(log).to_not include(HttpLog::LOG_PREFIX + "Reponse:")
+            end
+            it "should prefix all response lines" do
+              HttpLog.configure { |c| c.prefix_response_lines = true }
+              adapter.send_post_request
+              expect(log).to include(HttpLog::LOG_PREFIX + "Response:")
+              expect(log).to include(HttpLog::LOG_PREFIX + "<html>")
+            end
+            it "should prefix all response lines with line numbers" do
+              HttpLog.configure { |c| c.prefix_response_lines = true }
+              HttpLog.configure { |c| c.prefix_line_numbers = true }
+              adapter.send_post_request
+              expect(log).to include(HttpLog::LOG_PREFIX + "Response:")
+              expect(log).to include(HttpLog::LOG_PREFIX + "1: <html>")
+            end
+            it "should not log the benchmark if disabled" do
+              HttpLog.configure { |c| c.log_benchmark = false }
+              adapter.send_post_request
+              expect(log).to_not include(HttpLog::LOG_PREFIX + "Benchmark:")
+            end
+            it "should colorized output" do
+              HttpLog.configure { |c| c.color = :red }
+              adapter.send_post_request
+              expect(log.colorized?).to be_truthy
+            end
+          end
+        end
+        context "POST form data requests" do
+          if adapter_class.method_defined? :send_post_form_request
+            it "should not log data if disabled" do
+              HttpLog.configure { |c| c.log_data = false }
+              adapter.send_post_form_request
+              expect(log).to_not include(HttpLog::LOG_PREFIX + "Data:")
+            end
+            it "should not log the response if disabled" do
+              HttpLog.configure { |c| c.log_response = false }
+              adapter.send_post_form_request
+              expect(log).to_not include(HttpLog::LOG_PREFIX + "Reponse:")
+            end
+            it "should not log the benchmark if disabled" do
+              HttpLog.configure { |c| c.log_benchmark = false }
+              adapter.send_post_form_request
+              expect(log).to_not include(HttpLog::LOG_PREFIX + "Benchmark:")
+            end
+          end
+        end
+        context "POST multi-part requests (file upload)" do
+          let(:upload) { Tempfile.new('http-log') }
+          let(:params) { {'foo' => 'bar', 'file' => upload} }
+          if adapter_class.method_defined? :send_multipart_post_request
+            it "should not log data if disabled" do
+              HttpLog.configure { |c| c.log_data = false }
+              adapter.send_multipart_post_request
+              expect(log).to_not include(HttpLog::LOG_PREFIX + "Data:")
+            end
+            it "should not log the response if disabled" do
+              HttpLog.configure { |c| c.log_response = false }
+              adapter.send_multipart_post_request
+              expect(log).to_not include(HttpLog::LOG_PREFIX + "Reponse:")
+            end
+            it "should not log the benchmark if disabled" do
+              HttpLog.configure { |c| c.log_benchmark = false }
+              adapter.send_multipart_post_request
+              expect(log).to_not include(HttpLog::LOG_PREFIX + "Benchmark:")
+            end
+          end
+        end
+      end
+      context "with compact config" do
+        before(:each) { HttpLog.configure { |c| c.compact_log = true } }
+        it "should log a single line with status and benchmark" do
+          adapter.send_get_request
+          expect(log).to match /\[httplog\] GET http:\/\/#{host}:#{port}#{path}(\?.*)? completed with status code \d{3} in (\d|\.)+/
+          expect(log).to_not include(HttpLog::LOG_PREFIX + "Connecting: #{host}:#{port}")
+          expect(log).to_not include(HttpLog::LOG_PREFIX + "Response:")
+          expect(log).to_not include(HttpLog::LOG_PREFIX + "Data:")
+          expect(log).to_not include(HttpLog::LOG_PREFIX + "Benchmark: ")
+        end
+      end
+=begin # NOTE: dropping this in v0.99.0 to support ruby 2.4.0. log4r has been stale for years.
+      context "with log4r" do
+        before(:each) do
+          require 'log4r'
+          require 'log4r/yamlconfigurator'
+          require 'log4r/outputter/datefileoutputter'
+          log4r_config= YAML.load_file(File.join(File.dirname(__FILE__),"support/log4r.yml"))
+          Log4r::YamlConfigurator.decode_yaml( log4r_config['log4r_config'] )
+          HttpLog.configure{ |c| c.logger = Log4r::Logger['test'] }
+        end
+        it "works" do
+          expect { adapter.send_get_request }.to_not raise_error
+        end
+      end
+=end
+    end
+  end
+end