chrisk-samuel 0.2.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+.yardoc
+/coverage
+/doc
+/pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2009 Chris Kampmeier
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,62 @@
+= Samuel
+
+Samuel is a gem for automatic logging of your Net::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:
+
+When Rails is loaded, Samuel configures a few things automatically. So all you
+need to do is this:
+
+  # config/environment.rb
+  config.gem "samuel"
+
+And Samuel will automatically use Rails's logger and an ActiveRecord-like format.
+
+For non-Rails projects, you'll have to manually configure logging, like this:
+
+  require 'samuel'
+  Samuel.logger = Logger.new('http_requests.log')
+
+If you don't assign a logger, Samuel will configure a default logger on +STDOUT+.
+
+== Configuration
+
+There are two ways to specify configuration options for Samuel: global and
+inline. Global configs look like this:
+
+  Samuel.config[:label]           = "Twitter API"
+  Samuel.config[:filtered_params] = :password
+
+You should put global configuration somewhere early-on in your program. If
+you're using Rails, <tt>config/initializers/samuel.rb</tt> will do the trick.
+
+Alternatively, an inline configuration block temporarily overrides any global
+configuration for a set of HTTP requests:
+
+  Samuel.with_config :label => "Twitter API" do
+    Net::HTTP.start("twitter.com") { |http| http.get("/help/test") }
+  end
+
+Right now, there are two configuration changes you can make in either style:
+
+* +:label+ - This is the very first part of each log entry, and it gets
+  <tt>"Request"</tt> appended to it. By default, it's <tt>"HTTP"</tt> -- but if
+  you want your log to say +Twitter API Request+ instead of the default +HTTP
+  Request+, set this to <tt>"Twitter API"</tt>.
+* +: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.
+
+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.

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "samuel"
+    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.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 "mocha"
+    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"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+  test.warning = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.rcov_opts << "--sort coverage"
+    test.rcov_opts << "--exclude gems"
+    test.verbose = false
+    test.warning = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+begin
+  require 'yard'
+  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"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/samuel/net_http.rb

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,90 @@
+module Samuel
+  class Request
+
+    attr_accessor :response
+
+    def initialize(http, request, proc)
+      @http, @request, @proc = http, request, proc
+    end
+
+    def execute_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"
+      label     = Samuel.config[:label]
+      "  #{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 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

data/lib/samuel.rb

@@ -0,0 +1,52 @@
+require "logger"
+require "net/http"
+require "net/https"
+require "benchmark"
+
+require "samuel/net_http"
+require "samuel/request"
+
+
+module Samuel
+  extend self
+
+  attr_writer :config, :logger
+
+  def logger
+    @logger = nil if !defined?(@logger)
+    return @logger if !@logger.nil?
+
+    if defined?(RAILS_DEFAULT_LOGGER)
+      @logger = RAILS_DEFAULT_LOGGER
+    else
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  def config
+    Thread.current[:__samuel_config] ? Thread.current[:__samuel_config] : @config
+  end
+
+  def log_request(http, request, &block)
+    request = Request.new(http, request, block)
+    request.execute_and_log!
+    request.response
+  end
+
+  def with_config(options = {})
+    original_config = config.dup
+    nested = !Thread.current[:__samuel_config].nil?
+
+    Thread.current[:__samuel_config] = original_config.merge(options)
+    yield
+    Thread.current[:__samuel_config] = nested ? original_config : nil
+  end
+
+  def reset_config
+    Thread.current[:__samuel_config] = nil
+    @config = {:label => "HTTP", :filtered_params => []}
+  end
+
+end
+
+Samuel.reset_config

data/samuel.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{samuel}
+  s.version = "0.2.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-13}
+  s.description = %q{An automatic logger for HTTP requests in Ruby. Adds Net::HTTP request logging to your Rails logs, and more.}
+  s.email = %q{chris@kampers.net}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/samuel.rb",
+     "lib/samuel/net_http.rb",
+     "lib/samuel/request.rb",
+     "samuel.gemspec",
+     "test/request_test.rb",
+     "test/samuel_test.rb",
+     "test/test_helper.rb",
+     "test/thread_test.rb"
+  ]
+  s.homepage = %q{http://github.com/chrisk/samuel}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{samuel}
+  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/samuel_test.rb",
+     "test/test_helper.rb",
+     "test/thread_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    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<mocha>, [">= 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<mocha>, [">= 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<mocha>, [">= 0"])
+    s.add_dependency(%q<fakeweb>, [">= 0"])
+  end
+end

data/test/request_test.rb

@@ -0,0 +1,178 @@
+require 'test_helper'
+
+class RequestTest < Test::Unit::TestCase
+
+  context "making an HTTP request" do
+    setup    { setup_test_logger
+               FakeWeb.clean_registry
+               Samuel.reset_config }
+    teardown { teardown_test_logger }
+
+    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)
+        open "http://example.com/test"
+      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://example.com/test"
+    end
+
+    context "on a non-standard port" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com:8080/test", :status => [200, "OK"])
+        open "http://example.com:8080/test"
+      end
+
+      should_log_including "GET http://example.com:8080/test"
+    end
+
+    context "with SSL" do
+      setup do
+        FakeWeb.register_uri(:get, "https://example.com/test", :status => [200, "OK"])
+        open "https://example.com/test"
+      end
+
+      should_log_including "HTTP request"
+      should_log_including "GET https://example.com/test"
+    end
+
+    context "with SSL on a non-standard port" do
+      setup do
+        FakeWeb.register_uri(:get, "https://example.com:80/test", :status => [200, "OK"])
+        open "https://example.com:80/test"
+      end
+
+      should_log_including "HTTP request"
+      should_log_including "GET https://example.com:80/test"
+    end
+
+    context "that raises" do
+      setup do
+        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
+        end
+      end
+
+      should_log_at_level    :warn
+      should_log_including   "HTTP request"
+      should_log_including   "GET http://example.com/test"
+      should_log_including   "Errno::ECONNREFUSED"
+      should_log_including   %r|\d+ms|
+      should_raise_exception Errno::ECONNREFUSED
+    end
+
+    context "that responds with a 500-level code" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [502, "Bad Gateway"])
+        Net::HTTP.start("example.com") { |http| http.get("/test") }
+      end
+
+      should_log_at_level :warn
+    end
+
+    context "that responds with a 400-level code" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [404, "Not Found"])
+        Net::HTTP.start("example.com") { |http| http.get("/test") }
+      end
+
+      should_log_at_level :warn
+    end
+
+    context "inside a configuration block with :label => 'Example'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.with_config :label => "Example" do
+          open "http://example.com/test"
+        end
+      end
+
+      should_log_including "Example request"
+      should_have_config_afterwards_including :label => "HTTP"
+    end
+
+    context "inside a configuration block with :filter_params" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test?password=secret&username=chrisk",
+                             :status => [200, "OK"])
+        @uri = "http://example.com/test?password=secret&username=chrisk"
+      end
+
+      context "=> :password" do
+        setup { Samuel.with_config(:filtered_params => :password) { open @uri } }
+        should_log_including "http://example.com/test?password=[FILTERED]&username=chrisk"
+      end
+
+      context "=> :ass" do
+        setup { Samuel.with_config(:filtered_params => :ass) { open @uri } }
+        should_log_including "http://example.com/test?password=[FILTERED]&username=chrisk"
+      end
+
+      context "=> ['pass', 'name']" do
+        setup { Samuel.with_config(:filtered_params => %w(pass name)) { open @uri } }
+        should_log_including "http://example.com/test?password=[FILTERED]&username=[FILTERED]"
+      end
+    end
+
+    context "with a global config including :label => 'Example'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.config[:label] = "Example"
+        open "http://example.com/test"
+      end
+
+      should_log_including "Example request"
+      should_have_config_afterwards_including :label => "Example"
+    end
+
+    context "with a global config including :label => 'Example' but inside config block that changes it to 'Example 2'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.config[:label] = "Example"
+        Samuel.with_config(:label => "Example 2") { open "http://example.com/test" }
+      end
+
+      should_log_including "Example 2 request"
+      should_have_config_afterwards_including :label => "Example"
+    end
+
+    context "inside a config block of :label => 'Example 2' nested inside a config block of :label => 'Example'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.with_config :label => "Example" do
+          Samuel.with_config :label => "Example 2" do
+            open "http://example.com/test"
+          end
+        end
+      end
+
+      should_log_including "Example 2 request"
+      should_have_config_afterwards_including :label => "HTTP"
+    end
+
+    context "wth a global config including :label => 'Example' but inside a config block of :label => 'Example 3' nested inside a config block of :label => 'Example 2'" do
+      setup do
+        FakeWeb.register_uri(:get, "http://example.com/test", :status => [200, "OK"])
+        Samuel.config[:label] = "Example"
+        Samuel.with_config :label => "Example 2" do
+          Samuel.with_config :label => "Example 3" do
+            open "http://example.com/test"
+          end
+        end
+      end
+
+      should_log_including "Example 3 request"
+      should_have_config_afterwards_including :label => "Example"
+    end
+
+  end
+
+end

data/test/samuel_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class SamuelTest < Test::Unit::TestCase
+
+  context "logger configuration" do
+    setup do
+      Samuel.logger = nil
+      if Object.const_defined?(:RAILS_DEFAULT_LOGGER)
+        Object.send(:remove_const, :RAILS_DEFAULT_LOGGER)
+      end
+    end
+
+    teardown do
+      Samuel.logger = nil
+    end
+
+    context "when Rails's logger is available" do
+      setup { Object.const_set(:RAILS_DEFAULT_LOGGER, :mock_logger) }
+
+      should "use the same logger" do
+        assert_equal :mock_logger, Samuel.logger
+      end
+    end
+
+    context "when Rails's logger is not available" do
+      should "use a new Logger instance pointed to STDOUT" do
+        assert_instance_of Logger, Samuel.logger
+        assert_equal STDOUT, Samuel.logger.instance_variable_get(:"@logdev").dev
+      end
+    end
+  end
+
+
+  context ".reset_config" do
+    should "reset the config to default vaules" do
+      Samuel.config = {:foo => "bar"}
+      Samuel.reset_config
+      assert_equal({:label => "HTTP", :filtered_params => []}, Samuel.config)
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'open-uri'
+require 'fakeweb'
+
+FakeWeb.allow_net_connect = false
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'samuel'
+
+class Test::Unit::TestCase
+  TEST_LOG_PATH = File.join(File.dirname(__FILE__), 'test.log')
+
+  def self.should_log_lines(expected_count)
+    should "log #{expected_count} line#{'s' unless expected_count == 1}" do
+      lines = File.readlines(TEST_LOG_PATH)
+      assert_equal expected_count, lines.length
+    end
+  end
+
+  def self.should_log_including(what)
+    should "log a line including #{what.inspect}" do
+      contents = File.read(TEST_LOG_PATH)
+      if what.is_a?(Regexp)
+        assert_match what, contents
+      else
+        assert contents.include?(what),
+               "Expected #{contents.inspect} to include #{what.inspect}"
+      end
+    end
+  end
+
+  def self.should_log_at_level(level)
+    level = level.to_s.upcase
+    should "log at the #{level} level" do
+      assert File.read(TEST_LOG_PATH).include?("  #{level} -- :")
+    end
+  end
+
+  def self.should_raise_exception(klass)
+    should "raise an #{klass} exception" do
+      assert @exception.is_a?(klass)
+    end
+  end
+
+  def self.should_have_config_afterwards_including(config)
+    config.each_pair do |key, value|
+      should "continue afterwards with Samuel.config[#{key.inspect}] set to #{value.inspect}" do
+        assert_equal value, Samuel.config[key]
+      end
+    end
+  end
+
+  def setup_test_logger
+    FileUtils.rm_rf TEST_LOG_PATH
+    FileUtils.touch TEST_LOG_PATH
+    Samuel.logger = Logger.new(TEST_LOG_PATH)
+  end
+
+  def teardown_test_logger
+    FileUtils.rm_rf TEST_LOG_PATH
+  end
+end

data/test/thread_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class ThreadTest < Test::Unit::TestCase
+
+  context "when logging multiple requests at once" do
+    setup do
+      @log = StringIO.new
+      Samuel.logger = Logger.new(@log)
+      FakeWeb.register_uri(:get, /example\.com/, :status => [200, "OK"])
+      threads = []
+      5.times do |i|
+        threads << Thread.new(i) do |n|
+          Samuel.with_config :label => "Example #{n}" do
+            Thread.pass
+            open "http://example.com/#{n}"
+          end
+        end
+      end
+      threads.each { |t| t.join }
+      @log.rewind
+    end
+
+    should "not let configuration blocks interfere with eachother" do
+      @log.each_line do |line|
+        matches = %r|Example (\d+).*example\.com/(\d+)|.match(line)
+        assert_not_nil matches
+        assert_equal matches[1], matches[2]
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: chrisk-samuel
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Chris Kampmeier
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !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.
+email: chris@kampers.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/samuel.rb
+- lib/samuel/net_http.rb
+- lib/samuel/request.rb
+- samuel.gemspec
+- test/request_test.rb
+- test/samuel_test.rb
+- test/test_helper.rb
+- test/thread_test.rb
+has_rdoc: false
+homepage: http://github.com/chrisk/samuel
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: samuel
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An automatic logger for HTTP requests in Ruby
+test_files: 
+- test/request_test.rb
+- test/samuel_test.rb
+- test/test_helper.rb
+- test/thread_test.rb