httplog 0.1.1 → 0.2.0

data/README.rdoc

@@ -4,6 +4,18 @@ Log outgoing HTTP requests made from your application.
 See the {blog post}[http://trusche.github.com/blog/2011/09/29/logging-outgoing-http-requests/]
 for more details.
 
+So far this gem works with the following HTTP libraries:
+
+* Net::HTTP
+* OpenURI
+* HTTPClient
+
+In theory, it should also work with any library built on top of these. But since
+the difference between theory and practice is bigger in practice than in theory, YMMV.
+
+*PLEASE NOTE* that this is very much a development tool; it is *not recommended* to
+use this in a production environment.
+
 === Installation
 
   gem install httplog
@@ -27,7 +39,7 @@ You can override the following default options:
   HttpLog.options[:log_status]    = true
   HttpLog.options[:log_response]  = true
   HttpLog.options[:log_benchmark] = true
-  HttpLog.options[:compact_log]   = false = setting this to true will make all "log_*" options redundant
+  HttpLog.options[:compact_log]   = false # setting this to true will make all "log_*" options redundant
 
 So if you want to use this in a Rails app:
 
@@ -55,8 +67,8 @@ With the default configuration, the log output might look like this:
 
 === Known Issues
 
-When using open-uri, the reading of the HTTP response body is deferred,
-so it is not available for logging. This will be noted in the logging statement:
+*   When using open-uri, the reading of the HTTP response body is deferred,
+    so it is not available for logging. This will be noted in the logging statement:
 
   D, [2012-11-21T15:09:03.547005 #6857] DEBUG -- : [httplog] Connecting: localhost
   D, [2012-11-21T15:09:03.547938 #6857] DEBUG -- : [httplog] Sending: GET http://localhost:9292/index.html
@@ -64,11 +76,12 @@ so it is not available for logging. This will be noted in the logging statement:
   D, [2012-11-21T15:09:03.548662 #6857] DEBUG -- : [httplog] Benchmark: 0.000617 seconds
   D, [2012-11-21T15:09:03.548695 #6857] DEBUG -- : [httplog] Response: (not available yet)
 
+*    When using HTTPClient, the +:log_connect+ option has no effect.
 
 === Running the specs
 
-Make sure you have the necessary dependencies installed by running `bundle install`.
-Then simple run `bundle exec rspec spec`.
+Make sure you have the necessary dependencies installed by running +bundle install+.
+Then simply run +bundle exec rspec spec+.
 This will launch a simple rack server on port 9292 and run all tests locally against that server.
 
 === Contributing
@@ -77,4 +90,12 @@ If you have any issues with httplog,
 or feature requests,
 please {add 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.
+Please include passing specs with all pull requests.
+
+=== Contributors
+
+Thanks to these fine folks for contributing pull requests:
+
+* {Eric Cohen}[https://github.com/eirc]
+* {Nikos Dimitrakopoulos}[https://github.com/nikosd]
+* {Marcos Hack}[https://github.com/marcoshack]

data/lib/httplog/http_log.rb

@@ -1,80 +1,109 @@
 require "net/http"
 require "logger"
+require "benchmark"
 
 module HttpLog
+  DEFAULT_LOGGER  = Logger.new($stdout)
+  DEFAULT_OPTIONS = {
+    :logger        => DEFAULT_LOGGER,
+    :severity      => Logger::Severity::DEBUG,
+    :log_connect   => true,
+    :log_request   => true,
+    :log_headers   => false,
+    :log_data      => true,
+    :log_status    => true,
+    :log_response  => true,
+    :log_benchmark => true,
+    :compact_log   => false
+  }
+
+  class << self
+    def options
+      @@options ||= DEFAULT_OPTIONS.clone
+    end
 
-  def self.options
-    @@options ||= {
-      :logger        => Logger.new($stdout),
-      :severity      => Logger::Severity::DEBUG,
-      :log_connect   => true,
-      :log_request   => true,
-      :log_headers   => false,
-      :log_data      => true,
-      :log_status    => true,
-      :log_response  => true,
-      :log_benchmark => true,
-      :log_compact   => false
-    }
-  end
+    def reset_options!
+      @@options = DEFAULT_OPTIONS.clone
+    end
 
-  def self.log(msg)
-    @@options[:logger].add(@@options[:severity]) { "[httplog] #{msg}" }
-  end
+    def log(msg)
+      @@options[:logger].add(@@options[:severity]) { "[httplog] #{msg}" }
+    end
+
+    def log_request(method, uri)
+      return if options[:compact_log] || !options[:log_request]
+      log("Sending: #{method.to_s.upcase} #{uri}")
+    end
+
+    def log_headers(headers = {})
+      return if options[:compact_log] || !options[:log_headers]
+      headers.each do |key,value|
+        log("Header: #{key}: #{value}")
+      end
+    end
+
+    def log_status(status)
+      return if options[:compact_log] || !options[:log_status]
+      log("Status: #{status}")
+    end
+
+    def log_benchmark(seconds)
+      return if options[:compact_log] || !options[:log_benchmark]
+      log("Benchmark: #{seconds} seconds")
+    end
+
+    def log_body(body)
+      return if options[:compact_log] || !options[:log_response]
+      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.
+        log("Response: (not available yet)")
+      else
+        log("Response:\n#{body.to_s}")
+      end
+    end
 
+    def log_data(data)
+      return if options[:compact_log] || !options[:log_data]
+      log("Data: #{data}")
+    end
+
+    def log_compact(method, uri, status, seconds)
+      return unless options[:compact_log]
+      log("#{method} #{uri} completed with status code #{status} in #{seconds} seconds")
+    end
+  end
 end
 
 module Net
-
   class HTTP
     alias_method(:orig_request, :request) unless method_defined?(:orig_request)
     alias_method(:orig_connect, :connect) unless method_defined?(:orig_connect)
 
     def request(req, body = nil, &block)
 
+      url = "http://#{@address}:#{@port}#{req.path}"
+
       if started? && !HttpLog.options[:compact_log]
-        if HttpLog.options[:log_request]
-          HttpLog::log("Sending: #{req.method} http://#{@address}:#{@port}#{req.path}")
-        end
-
-        if HttpLog.options[:log_headers]
-          req.each_header do |key,value|
-            HttpLog::log("Header: #{key}: #{value}")
-          end
-        end
-
-        if req.method == "POST" && HttpLog.options[:log_data]
-          # A bit convoluted becase post_form uses form_data= to assign the data, so
-          # in that case req.body will be empty.
-          data = req.body.nil? || req.body.size == 0 ? body : req.body
-          HttpLog::log("Data: #{data}")
-        end
+        HttpLog.log_request(req.method, url)
+        HttpLog.log_headers(req.each_header.collect)
+        # A bit convoluted becase post_form uses form_data= to assign the data, so
+        # in that case req.body will be empty.
+        HttpLog::log_data(req.body.nil? || req.body.size == 0 ? body : req.body) if req.method == 'POST'
       end
 
-      ts_start  = Time.now
-      response  = orig_request(req, body, &block)
-      benchmark = Time.now - ts_start
+      bm = Benchmark.realtime do
+        @response = orig_request(req, body, &block)
+      end
 
       if started?
-        if HttpLog.options[:compact_log]
-          HttpLog::log("#{req.method} http://#{@address}:#{@port}#{req.path} completed with status code #{response.code} in #{benchmark} seconds")
-        else
-          HttpLog::log("Status: #{response.code}")        if HttpLog.options[:log_status]
-          HttpLog::log("Benchmark: #{benchmark} seconds") if HttpLog.options[:log_benchmark]
-
-          if HttpLog.options[:log_response]
-            if response.body.is_a?(Net::ReadAdapter)
-              # open-uri wraps the response in a Net::ReadAdapter that defers reading
-              # the contrent, so the reponse body is not available here.
-              HttpLog::log("Response: (not available yet)")
-            else
-              HttpLog::log("Response:\n#{response.body.to_s}")
-            end
-          end
-        end
+        HttpLog.log_compact(req.method, url, @response.code, bm)
+        HttpLog.log_status(@response.code)
+        HttpLog.log_benchmark(bm)
+        HttpLog.log_body(@response.body)
       end
 
-      response
+      @response
     end
 
     def connect
@@ -86,3 +115,27 @@ module Net
   end
 
 end
+
+if defined?(::HTTPClient)
+  class HTTPClient
+    private
+    alias_method :orig_do_request, :do_request
+
+    def do_request(method, uri, query, body, header, &block)
+      HttpLog.log_request(method, uri)
+      HttpLog.log_headers(header)
+      HttpLog.log_data(body) if method == :post
+
+      bm = Benchmark.realtime do
+        @response  = orig_do_request(method, uri, query, body, header, &block)
+      end
+
+      HttpLog.log_compact(method, uri, @response.status, bm)
+      HttpLog.log_status(@response.status)
+      HttpLog.log_benchmark(bm)
+      HttpLog.log_body(@response.body)
+
+      @response
+    end
+  end
+end

data/lib/httplog/version.rb

@@ -1,3 +1,4 @@
 module HttpLog
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: httplog
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors: