samuel 0.1.0 → 0.2.0

data/README.rdoc

@@ -7,24 +7,56 @@ 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 in Rails:
+== 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"
 
-That's about it! For now, Samuel automatically uses Rails' logger, and logs at
-the +INFO+ level using an ActiveRecord-like format. Failed requests log at the
-+WARN+ level.
-
-== Usage in general:
+And Samuel will automatically use Rails's logger and an ActiveRecord-like format.
 
-When Rails isn't loaded, you'll have to manually configure logging, like this:
+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/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/samuel/request.rb

@@ -25,7 +25,8 @@ module Samuel
       blue      = "\e[34m"
       underline = "\e[4m"
       reset     = "\e[0m"
-      "  #{bold}#{blue}#{underline}HTTP request (#{milliseconds}ms) " +
+      label     = Samuel.config[:label]
+      "  #{bold}#{blue}#{underline}#{label} request (#{milliseconds}ms) " +
       "#{response_summary}#{reset}  #{method} #{uri}"
     end
 
@@ -34,7 +35,21 @@ module Samuel
     end
 
     def uri
-      "#{scheme}://#{@http.address}#{port_if_not_default}#{@request.path}"
+      "#{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

data/lib/samuel.rb

@@ -10,11 +10,10 @@ require "samuel/request"
 module Samuel
   extend self
 
-  def logger=(new_logger)
-    @logger = new_logger
-  end
+  attr_writer :config, :logger
 
   def logger
+    @logger = nil if !defined?(@logger)
     return @logger if !@logger.nil?
 
     if defined?(RAILS_DEFAULT_LOGGER)
@@ -24,10 +23,30 @@ module Samuel
     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

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{samuel}
-  s.version = "0.1.0"
+  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-11}
+  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 = [
@@ -27,8 +27,10 @@ Gem::Specification.new do |s|
      "lib/samuel/net_http.rb",
      "lib/samuel/request.rb",
      "samuel.gemspec",
+     "test/request_test.rb",
      "test/samuel_test.rb",
-     "test/test_helper.rb"
+     "test/test_helper.rb",
+     "test/thread_test.rb"
   ]
   s.homepage = %q{http://github.com/chrisk/samuel}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -37,8 +39,10 @@ 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/samuel_test.rb",
-     "test/test_helper.rb"
+    "test/request_test.rb",
+     "test/samuel_test.rb",
+     "test/test_helper.rb",
+     "test/thread_test.rb"
   ]
 
   if s.respond_to? :specification_version then

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

@@ -2,88 +2,40 @@ require 'test_helper'
 
 class SamuelTest < Test::Unit::TestCase
 
-  context "making an HTTP request" do
-    setup    { setup_test_logger
-               FakeWeb.clean_registry }
-    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"
+  context "logger configuration" do
+    setup do
+      Samuel.logger = nil
+      if Object.const_defined?(:RAILS_DEFAULT_LOGGER)
+        Object.send(:remove_const, :RAILS_DEFAULT_LOGGER)
       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"
+    teardown do
+      Samuel.logger = nil
     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 "when Rails's logger is available" do
+      setup { Object.const_set(:RAILS_DEFAULT_LOGGER, :mock_logger) }
 
-    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"
+      should "use the same logger" do
+        assert_equal :mock_logger, Samuel.logger
       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
+    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
-
-      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
+  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
+  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
 

data/test/test_helper.rb

@@ -27,7 +27,8 @@ class Test::Unit::TestCase
       if what.is_a?(Regexp)
         assert_match what, contents
       else
-        assert contents.include?(what)
+        assert contents.include?(what),
+               "Expected #{contents.inspect} to include #{what.inspect}"
       end
     end
   end
@@ -45,6 +46,14 @@ class Test::Unit::TestCase
     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

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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: samuel
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Chris Kampmeier
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-11 00:00:00 -07:00
+date: 2009-09-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -72,8 +72,10 @@ files:
 - 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: true
 homepage: http://github.com/chrisk/samuel
 licenses: []
@@ -103,5 +105,7 @@ 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