samuel 0.2.1 → 0.3.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2009 Chris Kampmeier
+Copyright 2009–2010 Chris Kampmeier
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,13 +1,16 @@
 = Samuel
 
-Samuel is a gem for automatic logging of your Net::HTTP requests. It's named for
+Samuel is a gem for automatic logging of your HTTP requests. It's named for
 the serial diarist Mr. Pepys, who was known to reliably record events both
 quotidian and remarkable.
 
 Should a Great Plague, Fire, or Whale befall an important external web service
 you use, you'll be sure to have a tidy record of it.
 
-== Usage:
+It supports both Net::HTTP and HTTPClient (formerly HTTPAccess2),
+automatically loading the correct logger for the HTTP client you're using.
+
+== Usage
 
 When Rails is loaded, Samuel configures a few things automatically. So all you
 need to do is this:
@@ -24,6 +27,14 @@ For non-Rails projects, you'll have to manually configure logging, like this:
 
 If you don't assign a logger, Samuel will configure a default logger on +STDOUT+.
 
+== HTTP Clients
+
+When you load Samuel, it automatically detects which HTTP clients you've
+loaded, then patches them to add logging. If no HTTP drivers are loaded when
+you load Samuel, it will automatically load Net::HTTP for you. (So, if you're
+using HTTPClient or a library based on it, make sure to require it before you
+require Samuel.)
+
 == Configuration
 
 There are two ways to specify configuration options for Samuel: global and
@@ -44,27 +55,30 @@ configuration for a set of HTTP requests:
 
 Right now, there are three configuration changes you can make in either style:
 
-* +:labels+ - This is a hash with domain substrings as keys and log labels as
-  values. If a request domain includes one of the domain substrings, the
-  corresponding label will be used for the first part of that log entry. By
-  default this is set to <tt>\{"" => "HTTP"}</tt>, so that all requests are
+* <tt>:labels</tt> -- This is a hash with domain substrings as keys and log
+  labels as values. If a request domain includes one of the domain substrings,
+  the corresponding label will be used for the first part of that log entry.
+  By default this is set to <tt>{"" => "HTTP"}</tt>, so that all requests are
   labeled with <tt>"HTTP Request"</tt>.
-* +:label+ - As an alternative to the +:labels+ hash, this is simply a string.
-  If set, it takes precedence over any +:labels+ (by default, it's not set). It
-  gets <tt>"Request"</tt> appended to it as well -- so if you want your log to
-  always say +Twitter API Request+ instead of the default +HTTP Request+, you
-  can set this to <tt>"Twitter API"</tt>. I'd recommend using this setting
-  globally if you're only making requests to one service, or inline if you just
-  need to temporarily override the global +:labels+.
-* +:filtered_params+ - This works just like Rails's +filter_parameter_logging+
-  method. Set it to a symbol, string, or array of them, and Samuel will filter
-  the value of query parameters that have any of these patterns as a substring
-  by replacing the value with <tt>[FILTERED]</tt> in your logs. By default, no
-  filtering is enabled.
+
+* <tt>:label</tt> -- As an alternative to the <tt>:labels</tt> hash, this is
+  simply a string. If set, it takes precedence over any <tt>:labels</tt> (by
+  default, it's not set). It gets <tt>"Request"</tt> appended to it as well --
+  so if you want your log to always say <tt>Twitter API Request</tt> instead
+  of the default <tt>HTTP Request</tt>, you can set this to <tt>"Twitter
+  API"</tt>. I'd recommend using this setting globally if you're only making
+  requests to one service, or inline if you just need to temporarily override
+  the global <tt>:labels</tt>.
+
+* <tt>:filtered_params</tt> -- This works just like Rails's
+  +filter_parameter_logging+ method. Set it to a symbol, string, or array of
+  them, and Samuel will filter the value of query parameters that have any of
+  these patterns as a substring by replacing the value with
+  <tt>[FILTERED]</tt> in your logs. By default, no filtering is enabled.
 
 Samuel logs successful HTTP requests at the +INFO+ level; Failed requests log at
 the +WARN+ level. This isn't currently configurable, but it's on the list.
 
 == License
 
-Copyright 2009 Chris Kampmeier. See +LICENSE+ for details.
+Copyright 2009–2010 Chris Kampmeier. See +LICENSE+ for details.

data/Rakefile

@@ -5,23 +5,20 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "samuel"
+    gem.version = "0.3.0"
     gem.summary = %Q{An automatic logger for HTTP requests in Ruby}
-    gem.description = %Q{An automatic logger for HTTP requests in Ruby. Adds Net::HTTP request logging to your Rails logs, and more.}
+    gem.description = %Q{An automatic logger for HTTP requests in Ruby, supporting the Net::HTTP and HTTPClient client libraries.}
     gem.email = "chris@kampers.net"
     gem.homepage = "http://github.com/chrisk/samuel"
     gem.authors = ["Chris Kampmeier"]
     gem.rubyforge_project = "samuel"
-    gem.add_development_dependency "thoughtbot-shoulda"
-    gem.add_development_dependency "yard"
+    gem.add_development_dependency "shoulda"
     gem.add_development_dependency "mocha"
+    gem.add_development_dependency "httpclient"
     gem.add_development_dependency "fakeweb"
   end
-  Jeweler::GemcutterTasks.new
-  Jeweler::RubyforgeTasks.new do |rubyforge|
-    rubyforge.doc_task = "yardoc"
-  end
 rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
 require 'rake/testtask'
@@ -44,7 +41,7 @@ begin
   end
 rescue LoadError
   task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+    abort "RCov is not available. In order to run rcov, you must: gem install rcov"
   end
 end
 
@@ -57,6 +54,6 @@ begin
   YARD::Rake::YardocTask.new
 rescue LoadError
   task :yardoc do
-    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+    abort "YARD is not available. In order to run yardoc, you must: gem install yard"
   end
 end

data/lib/samuel.rb

@@ -1,16 +1,21 @@
 require "logger"
-require "net/http"
-require "net/https"
-require "benchmark"
+require "forwardable"
 
-require "samuel/net_http"
-require "samuel/request"
+require "samuel/loader"
+require "samuel/diary"
+require "samuel/driver_patches/http_client"
+require "samuel/driver_patches/net_http"
+require "samuel/log_entries/base"
+require "samuel/log_entries/http_client"
+require "samuel/log_entries/net_http"
 
 
 module Samuel
   extend self
 
-  attr_writer :config, :logger
+  VERSION = "0.3.0"
+
+  attr_writer :logger, :config
 
   def logger
     @logger = nil if !defined?(@logger)
@@ -27,12 +32,6 @@ module Samuel
     Thread.current[:__samuel_config] ? Thread.current[:__samuel_config] : @config
   end
 
-  def log_request(http, request, &block)
-    request = Request.new(http, request, block)
-    request.perform_and_log!
-    request.response
-  end
-
   def with_config(options = {})
     original_config = config.dup
     nested = !Thread.current[:__samuel_config].nil?
@@ -46,7 +45,8 @@ module Samuel
     Thread.current[:__samuel_config] = nil
     @config = {:label => nil, :labels => {"" => "HTTP"}, :filtered_params => []}
   end
-
 end
 
+
 Samuel.reset_config
+Samuel::Loader.apply_driver_patches

data/lib/samuel/diary.rb

@@ -0,0 +1,29 @@
+module Samuel
+  module Diary
+    extend self
+
+    def record_request(http, request, time_requested)
+      @requests ||= []
+      @requests.push({:request => request, :time_requested => time_requested})
+    end
+
+    def record_response(http, request, response, time_responded)
+      time_requested = @requests.detect { |r| r[:request] == request }[:time_requested]
+      @requests.reject! { |r| r[:request] == request }
+      log_request_and_response(http, request, response, time_requested, time_responded)
+    end
+
+    private
+
+    def log_request_and_response(http, request, response, time_started, time_ended)
+      log_entry_class = case http.class.to_s
+        when "Net::HTTP"  then LogEntries::NetHttp
+        when "HTTPClient" then LogEntries::HttpClient
+        else raise NotImplementedError
+      end
+      log_entry = log_entry_class.new(http, request, response, time_started, time_ended)
+      log_entry.log!
+    end
+
+  end
+end

data/lib/samuel/driver_patches/http_client.rb

@@ -0,0 +1,54 @@
+module Samuel
+  module DriverPatches
+
+    module HTTPClient
+      def self.included(klass)
+        methods_to_wrap = %w(initialize do_get_block do_get_stream)
+        methods_to_wrap.each do |method|
+          klass.send(:alias_method, "#{method}_without_samuel", method)
+          klass.send(:alias_method, method, "#{method}_with_samuel")
+        end
+      end
+
+      def initialize_with_samuel(*args)
+        initialize_without_samuel(*args)
+        @request_filter << LoggingFilter.new(self)
+      end
+
+      def do_get_block_with_samuel(req, proxy, conn, &block)
+        begin
+          do_get_block_without_samuel(req, proxy, conn, &block)
+        rescue Exception => e
+          Samuel::Diary.record_response(self, req, e, Time.now)
+          raise
+        end
+      end
+
+      def do_get_stream_with_samuel(req, proxy, conn)
+        begin
+          do_get_stream_without_samuel(req, proxy, conn)
+        rescue Exception => e
+          Samuel::Diary.record_response(self, req, e, Time.now)
+          raise
+        end
+      end
+
+      class LoggingFilter
+        def initialize(http_client_instance)
+          @http_client_instance = http_client_instance
+        end
+
+        def filter_request(request)
+          Samuel::Diary.record_request(@http_client_instance, request, Time.now)
+        end
+
+        def filter_response(request, response)
+          Samuel::Diary.record_response(@http_client_instance, request, response, Time.now)
+          nil # this returns command symbols like :retry, etc.
+        end
+      end
+    end
+
+  end
+end
+

data/lib/samuel/driver_patches/net_http.rb

@@ -0,0 +1,42 @@
+module Samuel
+  module DriverPatches
+
+    module NetHTTP
+      def self.included(klass)
+        methods_to_wrap = %w(request connect)
+        methods_to_wrap.each do |method|
+          klass.send(:alias_method, "#{method}_without_samuel", method)
+          klass.send(:alias_method, method, "#{method}_with_samuel")
+        end
+      end
+
+      def request_with_samuel(request, body = nil, &block)
+        Samuel::Diary.record_request(self, request, Time.now)
+
+        response, exception_raised = nil, false
+        begin
+          response = request_without_samuel(request, body, &block)
+        rescue Exception => response
+          exception_raised = true
+        end
+
+        Samuel::Diary.record_response(self, request, response, Time.now)
+
+        raise response if exception_raised
+        response
+      end
+
+      def connect_with_samuel
+        connect_without_samuel
+      rescue Exception => response
+        fake_request = Object.new
+        def fake_request.path; ""; end
+        def fake_request.method; "CONNECT"; end
+        Samuel::Diary.record_request(self, fake_request, Time.now)
+        Samuel::Diary.record_response(self, fake_request, response, Time.now)
+        raise
+      end
+    end
+
+  end
+end

data/lib/samuel/loader.rb

@@ -0,0 +1,19 @@
+module Samuel
+  module Loader
+    extend self
+
+    def apply_driver_patches
+      loaded = { :net_http    => defined?(Net::HTTP),
+                 :http_client => defined?(HTTPClient) }
+
+      Net::HTTP.send(:include, DriverPatches::NetHTTP) if loaded[:net_http]
+      HTTPClient.send(:include, DriverPatches::HTTPClient) if loaded[:http_client]
+
+      if loaded.values.none?
+        require 'net/http'
+        apply_driver_patches
+      end
+    end
+
+  end
+end

data/lib/samuel/log_entries/base.rb

@@ -0,0 +1,76 @@
+module Samuel
+  module LogEntries
+
+    class Base
+      def initialize(http, request, response, time_requested, time_responded)
+        @http, @request, @response = http, request, response
+        @seconds = time_responded - time_requested
+      end
+
+      def log!
+        Samuel.logger.add(log_level, log_message)
+      end
+
+
+      protected
+
+      def log_message
+        bold      = "\e[1m"
+        blue      = "\e[34m"
+        underline = "\e[4m"
+        reset     = "\e[0m"
+        "  #{bold}#{blue}#{underline}#{label} request (#{milliseconds}ms) " +
+        "#{response_summary}#{reset}  #{method} #{uri}"
+      end
+
+      def milliseconds
+        (@seconds * 1000).round
+      end
+
+      def uri
+        "#{scheme}://#{host}#{port_if_not_default}#{path}#{'?' if query}#{filtered_query}"
+      end
+
+      def label
+        return Samuel.config[:label] if Samuel.config[:label]
+
+        pair = Samuel.config[:labels].detect { |domain, label| host.include?(domain) }
+        pair[1] if pair
+      end
+
+      def response_summary
+        if @response.is_a?(Exception)
+          @response.class
+        else
+          "[#{status_code} #{status_message}]"
+        end
+      end
+
+      def log_level
+        error? ? Logger::WARN : Logger::INFO
+      end
+
+      def ssl?
+        scheme == 'https'
+      end
+
+      def filtered_query
+        return "" if query.nil?
+        patterns = [Samuel.config[:filtered_params]].flatten
+        patterns.map { |pattern|
+          pattern_for_regex = Regexp.escape(pattern.to_s)
+          [/([^&]*#{pattern_for_regex}[^&=]*)=(?:[^&]+)/, '\1=[FILTERED]']
+        }.inject(query) { |filtered, filter| filtered.gsub(*filter) }
+      end
+
+      def port_if_not_default
+        if (!ssl? && port == 80) || (ssl? && port == 443)
+          ""
+        else
+          ":#{port}"
+        end
+      end
+    end
+
+  end
+end

data/lib/samuel/log_entries/http_client.rb

@@ -0,0 +1,28 @@
+module Samuel
+  module LogEntries
+
+    class HttpClient < Base
+      extend Forwardable
+
+      def_delegators :"@request.header.request_uri",
+                     :host, :path, :query, :scheme, :port
+
+      def method
+        @request.header.request_method
+      end
+
+      def status_code
+        @response.status
+      end
+
+      def status_message
+        @response.header.reason_phrase.strip
+      end
+
+      def error?
+        @response.is_a?(Exception) || @response.status.to_s =~ /^(4|5)/
+      end
+    end
+
+  end
+end

data/lib/samuel/log_entries/net_http.rb

@@ -0,0 +1,45 @@
+module Samuel
+  module LogEntries
+
+    class NetHttp < Base
+      def host
+        @http.address
+      end
+
+      def path
+        @request.path.split("?")[0]
+      end
+
+      def query
+        @request.path.split("?")[1]
+      end
+
+      def scheme
+        @http.use_ssl? ? "https" : "http"
+      end
+
+      def port
+        @http.port
+      end
+
+      def method
+        @request.method.to_s.upcase
+      end
+
+      def status_code
+        @response.code
+      end
+
+      def status_message
+        @response.message.strip
+      end
+
+      def error?
+        error_classes = %w(Exception Net::HTTPClientError Net::HTTPServerError)
+        response_ancestors = @response.class.ancestors.map { |a| a.to_s }
+        (error_classes & response_ancestors).any?
+      end
+    end
+  
+  end
+end

data/samuel.gemspec

@@ -1,16 +1,16 @@
 # Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{samuel}
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Chris Kampmeier"]
-  s.date = %q{2009-09-15}
-  s.description = %q{An automatic logger for HTTP requests in Ruby. Adds Net::HTTP request logging to your Rails logs, and more.}
+  s.date = %q{2010-01-01}
+  s.description = %q{An automatic logger for HTTP requests in Ruby, supporting the Net::HTTP and HTTPClient client libraries.}
   s.email = %q{chris@kampers.net}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -22,12 +22,18 @@ Gem::Specification.new do |s|
      "LICENSE",
      "README.rdoc",
      "Rakefile",
-     "VERSION",
      "lib/samuel.rb",
-     "lib/samuel/net_http.rb",
-     "lib/samuel/request.rb",
+     "lib/samuel/diary.rb",
+     "lib/samuel/driver_patches/http_client.rb",
+     "lib/samuel/driver_patches/net_http.rb",
+     "lib/samuel/loader.rb",
+     "lib/samuel/log_entries/base.rb",
+     "lib/samuel/log_entries/http_client.rb",
+     "lib/samuel/log_entries/net_http.rb",
      "samuel.gemspec",
-     "test/request_test.rb",
+     "test/http_client_test.rb",
+     "test/loader_test.rb",
+     "test/net_http_test.rb",
      "test/samuel_test.rb",
      "test/test_helper.rb",
      "test/thread_test.rb"
@@ -39,7 +45,9 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{An automatic logger for HTTP requests in Ruby}
   s.test_files = [
-    "test/request_test.rb",
+    "test/http_client_test.rb",
+     "test/loader_test.rb",
+     "test/net_http_test.rb",
      "test/samuel_test.rb",
      "test/test_helper.rb",
      "test/thread_test.rb"
@@ -50,20 +58,21 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<httpclient>, [">= 0"])
       s.add_development_dependency(%q<fakeweb>, [">= 0"])
     else
-      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<httpclient>, [">= 0"])
       s.add_dependency(%q<fakeweb>, [">= 0"])
     end
   else
-    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<httpclient>, [">= 0"])
     s.add_dependency(%q<fakeweb>, [">= 0"])
   end
 end
+

data/test/http_client_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class HttpClientTest < Test::Unit::TestCase
+  context "making an HTTPClient request" do
+    setup    { setup_test_logger
+               start_test_server
+               Samuel.reset_config }
+    teardown { teardown_test_logger }
+
+    context "to GET http://localhost:8000/, responding with a 200 in 53ms" do
+      setup do
+        now = Time.now
+        Time.stubs(:now).returns(now, now + 0.053)
+        HTTPClient.get("http://localhost:8000/")
+      end
+
+      should_log_lines     1
+      should_log_at_level  :info
+      should_log_including "HTTP request"
+      should_log_including "(53ms)"
+      should_log_including "[200 OK]"
+      should_log_including "GET http://localhost:8000/"
+    end
+
+    context "using PUT" do
+      setup do
+        HTTPClient.put("http://localhost:8000/books/1", "test=true")
+      end
+
+      should_log_including "PUT http://localhost:8000/books/1"
+    end
+
+    context "using an asynchronous POST" do
+      setup do
+        body = "title=Infinite%20Jest"
+        client = HTTPClient.new
+        connection = client.post_async("http://localhost:8000/books", body)
+        sleep 0.1 until connection.finished?
+      end
+
+      should_log_including "POST http://localhost:8000/books"
+    end
+
+    context "that raises" do
+      setup do
+        begin
+          HTTPClient.get("http://localhost:8001/")
+        rescue Errno::ECONNREFUSED => @exception
+        end
+      end
+
+      should_log_at_level    :warn
+      should_log_including   "HTTP request"
+      should_log_including   "GET http://localhost:8001/"
+      should_log_including   "Errno::ECONNREFUSED"
+      should_log_including   %r|\d+ms|
+      should_raise_exception Errno::ECONNREFUSED
+    end
+
+    context "using an asynchronous GET that raises" do
+      setup do
+        begin
+          client = HTTPClient.new
+          connection = client.get_async("http://localhost:8001/")
+          sleep 0.1 until connection.finished?
+        rescue Errno::ECONNREFUSED => @exception
+        end
+      end
+
+      should_log_at_level    :warn
+      should_log_including   "HTTP request"
+      should_log_including   "GET http://localhost:8001/"
+      should_log_including   "Errno::ECONNREFUSED"
+      should_log_including   %r|\d+ms|
+      should_raise_exception Errno::ECONNREFUSED
+    end
+
+    context "that responds with a 400-level code" do
+      setup do
+        HTTPClient.get("http://localhost:8000/test?404")
+      end
+
+      should_log_at_level :warn
+      should_log_including "[404 Not Found]"
+    end
+
+    context "that responds with a 500-level code" do
+      setup do
+        HTTPClient.get("http://localhost:8000/test?500")
+      end
+
+      should_log_at_level :warn
+      should_log_including "[500 Internal Server Error]"
+    end
+  end
+
+end

data/test/loader_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+class LoaderTest < Test::Unit::TestCase
+
+  def capture_output(code = "")
+    requires = @requires.map { |lib| "require '#{lib}';" }.join(' ')
+    samuel_dir = "#{File.dirname(__FILE__)}/../lib"
+    `#{ruby_path} -I#{samuel_dir} -e "#{requires} #{code}" 2>&1`
+  end
+
+  context "loading Samuel" do
+    setup do
+      start_test_server
+      @requires = ['samuel']
+    end
+
+    context "when no HTTP drivers are loaded" do
+      should "automatically load Net::HTTP" do
+        output = capture_output "puts defined?(Net::HTTP)"
+        assert_equal "constant", output.strip
+      end
+
+      should "successfully log a Net::HTTP request" do
+        output = capture_output "Net::HTTP.get(URI.parse('http://localhost:8000'))"
+        assert_match %r[HTTP request], output
+      end
+
+      should "not load HTTPClient" do
+        output = capture_output "puts defined?(HTTPClient)"
+        assert_equal "nil", output.strip
+      end
+    end
+
+    context "when Net::HTTP is already loaded" do
+      setup { @requires.unshift('net/http') }
+
+      should "successfully log a Net::HTTP request" do
+        output = capture_output "Net::HTTP.get(URI.parse('http://localhost:8000'))"
+        assert_match %r[HTTP request], output
+      end
+
+      should "not load HTTPClient" do
+        output = capture_output "puts defined?(HTTPClient)"
+        assert_match "nil", output.strip
+      end
+    end
+
+    context "when HTTPClient is already loaded" do
+      setup { @requires.unshift('rubygems', 'httpclient') }
+
+      should "successfully log an HTTPClient request" do
+        output = capture_output "HTTPClient.get('http://localhost:8000')"
+        assert_match %r[HTTP request], output
+      end
+
+      should "not load Net::HTTP" do
+        output = capture_output "puts defined?(Net::HTTP)"
+        assert_match "nil", output.strip
+      end
+    end
+  end
+
+end

data/test/{request_test.rb → net_http_test.rb}

@@ -11,7 +11,8 @@ class RequestTest < Test::Unit::TestCase
     context "to GET http://example.com/test, responding with a 200 in 53ms" do
       setup do
         FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
-        Benchmark.stubs(:realtime).yields.returns(0.053)
+        now = Time.now
+        Time.stubs(:now).returns(now, now + 0.053)
         open "http://example.com/test"
       end
 
@@ -57,7 +58,7 @@ class RequestTest < Test::Unit::TestCase
         FakeWeb.register_uri(:get, "http://example.com/test", :exception => Errno::ECONNREFUSED)
         begin
           Net::HTTP.start("example.com") { |http| http.get("/test") }
-        rescue Errno::ECONNREFUSED => @exception
+        rescue Exception => @exception
         end
       end
 
@@ -69,6 +70,32 @@ class RequestTest < Test::Unit::TestCase
       should_raise_exception Errno::ECONNREFUSED
     end
 
+    context "that raises a SocketError when connecting" do
+      setup do
+        FakeWeb.allow_net_connect = true
+        begin
+          http = Net::HTTP.new("example.com")
+          # This is an implementation-dependent hack; it would be more correct
+          # to stub out TCPSocket.open, but I can't get Mocha to make it raise
+          # correctly. Maybe related to TCPSocket being native code?
+          http.stubs(:connect_without_samuel).raises(SocketError)
+          http.start { |h| h.get("/test") }
+        rescue Exception => @exception
+        end
+      end
+
+      teardown do
+        FakeWeb.allow_net_connect = false
+      end
+
+      should_log_at_level    :warn
+      should_log_including   "HTTP request"
+      should_log_including   "CONNECT http://example.com"
+      should_log_including   "SocketError"
+      should_log_including   %r|\d+ms|
+      should_raise_exception SocketError
+    end
+
     context "that responds with a 500-level code" do
       setup do
         FakeWeb.register_uri(:get, "http://example.com/test", :status => [502, "Bad Gateway"])

data/test/test_helper.rb

@@ -1,16 +1,19 @@
 require 'rubygems'
-require 'test/unit'
+
 require 'shoulda'
 require 'mocha'
+
+require 'net/http'
+require 'httpclient'
+
 require 'open-uri'
 require 'fakeweb'
+require 'webrick'
 
-FakeWeb.allow_net_connect = false
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'samuel'
 
+FakeWeb.allow_net_connect = false
+
 class Test::Unit::TestCase
   TEST_LOG_PATH = File.join(File.dirname(__FILE__), 'test.log')
 
@@ -54,6 +57,12 @@ class Test::Unit::TestCase
     end
   end
 
+  # The path to the current ruby interpreter. Adapted from Rake's FileUtils.
+  def ruby_path
+    ext = ((RbConfig::CONFIG['ruby_install_name'] =~ /\.(com|cmd|exe|bat|rb|sh)$/) ? "" : RbConfig::CONFIG['EXEEXT'])
+    File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'] + ext).sub(/.*\s.*/m, '"\&"')
+  end
+
   def setup_test_logger
     FileUtils.rm_rf TEST_LOG_PATH
     FileUtils.touch TEST_LOG_PATH
@@ -63,4 +72,26 @@ class Test::Unit::TestCase
   def teardown_test_logger
     FileUtils.rm_rf TEST_LOG_PATH
   end
+
+  def start_test_server
+    return if defined?(@@server)
+
+    @@server = WEBrick::HTTPServer.new(
+      :Port => 8000, :AccessLog => [],
+      :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN)
+    )
+    @@server.mount "/", ResponseCodeServer
+    at_exit { @@server.shutdown }
+    Thread.new { @@server.start }
+  end
+end
+
+class ResponseCodeServer < WEBrick::HTTPServlet::AbstractServlet
+  def do_GET(request, response)
+    response_code = request.query_string.nil? ? 200 : request.query_string.to_i
+    response.status = response_code
+  end
+  alias_method :do_POST,   :do_GET
+  alias_method :do_PUT,    :do_GET
+  alias_method :do_DELETE, :do_GET
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: samuel
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
 - Chris Kampmeier
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-15 00:00:00 -07:00
+date: 2010-01-01 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: thoughtbot-shoulda
+  name: shoulda
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -23,7 +23,7 @@ dependencies:
         version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: yard
+  name: mocha
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -33,7 +33,7 @@ dependencies:
         version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: mocha
+  name: httpclient
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
@@ -52,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-description: An automatic logger for HTTP requests in Ruby. Adds Net::HTTP request logging to your Rails logs, and more.
+description: An automatic logger for HTTP requests in Ruby, supporting the Net::HTTP and HTTPClient client libraries.
 email: chris@kampers.net
 executables: []
 
@@ -67,12 +67,18 @@ files:
 - LICENSE
 - README.rdoc
 - Rakefile
-- VERSION
 - lib/samuel.rb
-- lib/samuel/net_http.rb
-- lib/samuel/request.rb
+- lib/samuel/diary.rb
+- lib/samuel/driver_patches/http_client.rb
+- lib/samuel/driver_patches/net_http.rb
+- lib/samuel/loader.rb
+- lib/samuel/log_entries/base.rb
+- lib/samuel/log_entries/http_client.rb
+- lib/samuel/log_entries/net_http.rb
 - samuel.gemspec
-- test/request_test.rb
+- test/http_client_test.rb
+- test/loader_test.rb
+- test/net_http_test.rb
 - test/samuel_test.rb
 - test/test_helper.rb
 - test/thread_test.rb
@@ -105,7 +111,9 @@ signing_key:
 specification_version: 3
 summary: An automatic logger for HTTP requests in Ruby
 test_files: 
-- test/request_test.rb
+- test/http_client_test.rb
+- test/loader_test.rb
+- test/net_http_test.rb
 - test/samuel_test.rb
 - test/test_helper.rb
 - test/thread_test.rb

data/VERSION

@@ -1 +0,0 @@
-0.2.1

data/lib/samuel/net_http.rb

@@ -1,10 +0,0 @@
-class Net::HTTP
-
-  alias request_without_samuel request
-  def request(req, body = nil, &block)
-    Samuel.log_request(self, req) do
-      request_without_samuel(req, body, &block)
-    end
-  end
-
-end

data/lib/samuel/request.rb

@@ -1,96 +0,0 @@
-module Samuel
-  class Request
-
-    attr_accessor :response
-
-    def initialize(http, request, proc)
-      @http, @request, @proc = http, request, proc
-    end
-
-    def perform_and_log!
-      # If an exception is raised in the Benchmark block, it'll interrupt the
-      # benchmark. Instead, use an inner block to record it as the "response"
-      # for raising after the benchmark (and logging) is done.
-      @seconds = Benchmark.realtime do
-        begin; @response = @proc.call; rescue Exception => @response; end
-      end
-      Samuel.logger.add(log_level, log_message)
-      raise @response if @response.is_a?(Exception)
-    end
-
-    private
-
-    def log_message
-      bold      = "\e[1m"
-      blue      = "\e[34m"
-      underline = "\e[4m"
-      reset     = "\e[0m"
-      "  #{bold}#{blue}#{underline}#{label} request (#{milliseconds}ms) " +
-      "#{response_summary}#{reset}  #{method} #{uri}"
-    end
-
-    def milliseconds
-      (@seconds * 1000).round
-    end
-
-    def uri
-      "#{scheme}://#{@http.address}#{port_if_not_default}#{filtered_path}"
-    end
-
-    def filtered_path
-      path_without_query, query = @request.path.split("?")
-      if query
-        patterns = [Samuel.config[:filtered_params]].flatten
-        patterns.map { |pattern|
-          pattern_for_regex = Regexp.escape(pattern.to_s)
-          [/([^&]*#{pattern_for_regex}[^&=]*)=(?:[^&]+)/, '\1=[FILTERED]']
-        }.each { |filter| query.gsub!(*filter) }
-        "#{path_without_query}?#{query}"
-      else
-        @request.path
-      end
-    end
-
-    def scheme
-      @http.use_ssl? ? "https" : "http"
-    end
-
-    def port_if_not_default
-      ssl, port = @http.use_ssl?, @http.port
-      if (!ssl && port == 80) || (ssl && port == 443)
-        ""
-      else
-        ":#{port}"
-      end
-    end
-
-    def method
-      @request.method.to_s.upcase
-    end
-
-    def label
-      return Samuel.config[:label] if Samuel.config[:label]
-
-      pair = Samuel.config[:labels].detect { |domain, label| @http.address.include?(domain) }
-      pair[1] if pair
-    end
-
-    def response_summary
-      if response.is_a?(Exception)
-        response.class
-      else
-        "[#{response.code} #{response.message}]"
-      end
-    end
-
-    def log_level
-      error_classes = [Exception, Net::HTTPClientError, Net::HTTPServerError]
-      if error_classes.any? { |klass| response.is_a?(klass) }
-        level = Logger::WARN
-      else
-        level = Logger::INFO
-      end
-    end
-
-  end
-end