request_log 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in request_log.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    request_log (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    mocha (0.9.8)
+      rake
+    rack (1.2.1)
+    rake (0.8.7)
+    rspec (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
+      rspec-mocks (= 2.0.0)
+    rspec-core (2.0.0)
+    rspec-expectations (2.0.0)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.0)
+      rspec-core (= 2.0.0)
+      rspec-expectations (= 2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha (~> 0.9.8)
+  rack (~> 1.2.1)
+  request_log!
+  rspec (= 2.0.0)

data/README.rdoc

@@ -0,0 +1,83 @@
+= Request Log - Logging of web requests to MongoDB
+
+Request Log is a Rack middleware for logging web requests to MongoDB. Each web request becomes a document in MongoDB
+with fields like path, method, params, status, time, ip, runtime etc.
+The gem offers support for monitoring the time overhead (usually very small) that the logging incurs.
+The advantages of logging to MongoDB over logging to a plain text file are huge because of the query
+capabilities of MongoDB. Here is an example of what a log document can look like:
+
+  summary: "GET / - 200 0.000303"
+  method: "GET"
+  path: "/"
+  ip: "10.218.1.177"
+  time: 2010-10-28 21:43:38 UTC
+  params: {"hello_world"=>"1"}
+  status: 200
+  runtime: 0.000303
+
+You can easily customize which fields are stored in the log.
+
+== Installation
+
+Add gem dependencies with appropriate version numbers to your Gemfile (assuming you use Bundler):
+
+  gem 'mongo', '~> <latest-version-here>'
+  gem 'bson_ext', '~> <latest-version-here>'
+  gem 'request_log', :git => "http://github.com/peter/request_log.git"
+
+Install with:
+
+  bundle install
+
+Note that it's up to your application how it wants to connect to MongoDB (if at all) and the suggested
+mongo and bson_ext gems are just suggestions.
+
+Next you need to setup a MongoDB connection. Here is a MongoHQ example that in Rails would belong in config/initializers/request_log.rb:
+
+  if ENV['MONGOHQ_URL']
+	  require 'uri'
+	  require 'mongo'      
+	  uri = URI.parse(ENV['MONGOHQ_URL'])
+	  connection = Mongo::Connection.from_uri(uri.to_s)
+	  RequestLog::Db.mongo_db = connection.db(uri.path.gsub(/^\//, ''))
+  end
+
+Now setup the Middleware in your config.ru file:
+
+  use RequestLog::Middleware
+
+Here is an example of how you can customize the middleware:
+
+  use RequestLog::Middleware,
+	  :logger => lambda { |data| ::RequestLog::Db.requests.insert(data.attributes.except(:summary)) },
+	  :timeout => 0.5
+
+In order to use the Rake tasks you need to make sure you have the MongoDB connection setup and that you
+require the tasks in your Rakefile, like this:
+
+  require 'request_log'
+  require 'config/initializers/request_log.rb' # The file where you setup the mongo db connection
+  require 'request_log/tasks'
+
+== Accessing the logs
+
+You can tail the log like this:
+
+  rake request_log:tail
+
+If you want to query the log and print a certain time period you can use request_log:print:
+
+  rake request_log:print from="2010-10-28 17:06:08" to="2010-10-28 17:06:10" conditions='status: 200'
+
+If you are using MONGOHQ, remember to set the MONGOHQ_URL environment variable.
+
+== Profiling
+
+To monitor the time consumption and reliability of the MongoDB logging you can use the RequestLog::Profiler class.
+It records number of failed and successful loggings, average and maximum logging times etc. To persist the profiling
+information to MongoDB you can configure the profiler like this:
+
+  RequestLog::Profiler.persist_enabled = true
+  RequestLog::Profiler.persist_frequency = 1000 # persist profiling info every 1000 requests
+
+The profiling info will then be written to a table (request_log_profiling) in the MongoDB database.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+Bundler.require
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:default)

data/lib/request_log.rb

@@ -0,0 +1,5 @@
+require 'request_log/version'
+require 'request_log/db'
+require 'request_log/data'
+require 'request_log/profiler'
+require 'request_log/middleware'

data/lib/request_log/data.rb

@@ -0,0 +1,37 @@
+module RequestLog
+  class Data
+    attr_accessor :env, :status, :headers, :response, :app_time
+
+    def initialize(env, rack_response, app_time)
+      self.env = env
+      self.status = rack_response[0]
+      self.headers = rack_response[1]
+      self.response = rack_response[2]
+      self.app_time = app_time
+    end
+
+    def self.request_path(env)
+      env['PATH_INFO'] || env['REQUEST_PATH'] || "/"
+    end
+    
+    def attributes
+      method       = env['REQUEST_METHOD']
+      path         = self.class.request_path(env)
+      {
+        :summary           => "#{method} #{path} - #{status} #{app_time}", 
+        :method            => method,
+        :path              => path, 
+        :ip                => env['REMOTE_ADDR'],
+        :time              => Time.now.utc,
+        :params            => params,
+        :status            => status, 
+        :runtime           => app_time
+      }
+    end
+    
+    def params
+      # NOTE: It seems getting POST params with ::Rack::Request.new(env).params does not work well with Rails
+      (env['action_controller.instance'] || ::Rack::Request.new(env)).params      
+    end
+  end
+end

data/lib/request_log/db.rb

@@ -0,0 +1,41 @@
+module RequestLog
+  class Db
+    @@mongo_db = nil
+
+    def self.mongo_db=(mongo_db)
+      @@mongo_db = mongo_db
+    end
+    
+    def self.mongo_db
+      @@mongo_db
+    end
+    
+    def self.requests
+      mongo_db['requests']
+    end
+    
+    def self.profiling
+      mongo_db['request_log_profiling']
+    end
+    
+    def self.printable_request(request)
+      request.keys.reject { |key| key == "_id" }.map do |key|
+        "#{key}: #{request[key].inspect}"
+      end.join("\n")
+    end
+
+    def self.filtered_requests(start_time, end_time, conditions = {})
+      start_time = Time.parse(start_time).utc if start_time.is_a?(String)
+      end_time = Time.parse(end_time).utc if end_time.is_a?(String)
+      time_condition = {"time" => {"$gt" => start_time, "$lt" => end_time}}
+      requests.find(time_condition.merge(conditions))
+    end
+    
+    def self.print_requests(start_time, end_time, conditions = {})
+      filtered_requests(start_time, end_time, conditions).each do |request|
+        puts printable_request(request)
+        puts
+      end
+    end
+  end
+end

data/lib/request_log/middleware.rb

@@ -0,0 +1,40 @@
+module RequestLog
+  class Middleware
+    def initialize(app, options = {})
+      @app = app
+      @logger = options[:logger] || lambda { |data| ::RequestLog::Db.requests.insert(data.attributes) }
+      @profiler = options[:profiler] || ::RequestLog::Profiler
+      @timeout = options[:timeout] || 0.3
+      @only_path = options[:only_path]
+    end
+
+    def call(env)
+      app_start = Time.now 
+      rack_response = @app.call(env)
+      app_time = Time.now - app_start
+      return rack_response unless should_log?(env)
+      begin
+        logger_start = Time.now
+        Timeout::timeout(@timeout) do
+          @logger.call(::RequestLog::Data.new(env, rack_response, app_time))
+        end
+        @profiler.call(:result => :success, :elapsed_time => (Time.now - logger_start))
+      rescue Exception => e
+        @profiler.call(:result => :failure, :exception => e)
+        $stderr.puts("#{self.class}: exception #{e} #{e.backtrace.join("\n")}")
+      ensure
+        return rack_response  
+      end
+    end
+    
+    private
+    
+    def should_log?(env)
+      if @only_path && ::RequestLog::Data.request_path(env) !~ @only_path
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/request_log/profiler.rb

@@ -0,0 +1,106 @@
+module RequestLog
+  class Profiler
+    def self.default_values
+      {
+        :success_count => 0,
+        :failure_count => 0,
+        :failure_exceptions => {},
+        :min_time => nil,
+        :max_time => nil,
+        :avg_time => nil,
+        :persist_enabled => false,
+        :persist_frequency => 2000
+      }
+    end
+
+    def self.attribute_names
+      default_values.keys
+    end
+
+    attribute_names.each do |attribute|
+      # cattr_accessor from ActiveSupport library
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        @@#{attribute} = nil
+
+        def self.#{attribute}=(obj)
+          @@#{attribute} = obj
+        end
+        
+        def self.#{attribute}
+          @@#{attribute}
+        end
+      EOS
+    end
+
+    def self.reset
+      attribute_names.each do |attribute|
+        send("#{attribute}=", default_values[attribute])
+      end
+      self
+    end
+
+    reset
+
+    def self.call(options = {})
+      if options[:result] == :success
+        self.success_count += 1
+        update_times(options[:elapsed_time])
+      else
+        self.failure_count += 1
+        if options[:exception]
+          failure_exceptions[options[:exception].class.name] ||= 0
+          failure_exceptions[options[:exception].class.name] += 1
+        end
+      end
+      persist! if should_persist?
+    end
+
+    def self.total_count
+      success_count + failure_count
+    end
+
+    def self.failure_ratio
+      failure_count.to_f/total_count
+    end
+
+    def self.attributes
+      attribute_names.inject({}) do |hash, attribute|
+        hash[attribute] = send(attribute)
+        hash
+      end
+    end
+
+    def self.persist!
+      ::RequestLog::Db.profiling.insert(
+        :total_count => total_count,
+        :failure_ratio => failure_ratio,
+        :max_time => max_time,
+        :avg_time => avg_time,
+        :data => attributes
+      )
+    end
+
+    def self.should_persist?
+      persist_enabled && (total_count % persist_frequency == 0)
+    end
+
+    def self.to_s
+      attributes.inspect
+    end
+
+    private
+
+    def self.update_times(elapsed_time)
+      initialize_times(elapsed_time)
+      self.min_time = elapsed_time if elapsed_time < min_time
+      self.max_time = elapsed_time if elapsed_time > max_time
+      self.avg_time = (avg_time*(success_count - 1) + elapsed_time)/success_count
+    end
+
+    def self.initialize_times(elapsed_time)
+      self.min_time ||= elapsed_time
+      self.max_time ||= elapsed_time
+      self.avg_time ||= elapsed_time    
+    end
+  end
+end

data/lib/request_log/tasks.rb

@@ -0,0 +1,2 @@
+require 'request_log'
+Dir[File.join(File.dirname(__FILE__), "..", "tasks", "*.rake")].each { |rake_file| load rake_file }

data/lib/request_log/version.rb

@@ -0,0 +1,3 @@
+module RequestLog
+  VERSION = "0.0.1"
+end

data/lib/tasks/request_log.rake

@@ -0,0 +1,33 @@
+require 'set'
+
+namespace :request_log do
+  desc "Tail the request log"
+  task :tail do
+    wait_time = 10
+    printed_ids = Set.new
+    while(true)
+      RequestLog::Db.requests.find("time" => {"$gt" => (Time.now - wait_time).utc}).each do |r|
+        unless printed_ids.include?(r['_id'])
+          puts
+          puts RequestLog::Db.printable_request(r)
+          printed_ids << r['_id']
+        end
+      end
+      sleep (wait_time-1)
+    end
+  end
+  
+  desc %q{Print a part of the log. Parameters: from='YYYY-MM-DD HH:MM' to='YYYY-MM-DD HH:MM' conditions=<ruby-hash-with-mongo-db-conditions>}
+  task :print do
+    from = ENV['from'] || (Time.now-600).utc
+    to = ENV['to'] || Time.now.utc
+    if conditions = ENV['conditions']
+      # We need to parse a Ruby hash here, let's not require braces
+      conditions = "{#{conditions}}" unless conditions[0] == "{"
+      conditions = eval(conditions)
+    else
+      conditions = {}
+    end
+    RequestLog::Db.print_requests(from, to, conditions)
+  end
+end

data/request_log.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "request_log/version"
+
+Gem::Specification.new do |s|
+  s.name        = "request_log"
+  s.version     = RequestLog::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Peter Marklund"]
+  s.email       = ["peter@marklunds.com"]
+  s.homepage    = ""
+  s.summary     = %q{Rack middleware for logging web requests to a MongoDB database. Provides a profiler for monitoring logging overhead.}
+
+  s.rubyforge_project = "request_log"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency "rspec", "2.0.0"
+  s.add_development_dependency "mocha", "~> 0.9.8"
+  s.add_development_dependency "rack", "~> 1.2.1"
+end

data/spec/data_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe RequestLog::Data do
+  describe "attributes" do
+    before(:each) do
+      @env = env
+      @rack_response = [200, {"Content-Type" => "text/html"}, "Hello, World!"]
+      @app_time = 0.22666      
+      @data = RequestLog::Data.new(@env, @rack_response, @app_time)
+    end
+    
+    it "returns a hash with information about a request" do
+      puts "running spec"
+      attributes = @data.attributes
+      attributes[:summary].should =~ %r{GET /images/logo.png - 200 \d+\.\d+}
+      attributes[:runtime].to_s.should == attributes[:summary][/\d+\.\d+$/]
+      attributes[:time].should >= (Time.now-1).utc
+      attributes[:time].should <= Time.now.utc
+      attributes[:method].should == "GET"
+      attributes[:path].should == "/images/logo.png"
+      attributes[:ip].should == "127.0.0.1"
+    end
+  end
+  
+  def env
+    {"GATEWAY_INTERFACE"=>"CGI/1.1", "PATH_INFO"=>"/images/logo.png", "QUERY_STRING"=>"", "REMOTE_ADDR"=>"127.0.0.1", "REMOTE_HOST"=>"www.publish.newsdesk.local", "REQUEST_METHOD"=>"GET", "REQUEST_URI"=>"http://publish.lvh.me:3000/images/logo.png", "SCRIPT_NAME"=>"", "SERVER_NAME"=>"publish.lvh.me", "SERVER_PORT"=>"3000", "SERVER_PROTOCOL"=>"HTTP/1.1", "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/1.9.2/2010-08-18)", "HTTP_HOST"=>"publish.lvh.me:3000", "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; en-US; rv:1.9.2.2) Gecko/20100316 Firefox/3.6.2", "HTTP_ACCEPT"=>"image/png,image/*;q=0.8,*/*;q=0.5", "HTTP_ACCEPT_LANGUAGE"=>"en-us,en;q=0.5", "HTTP_ACCEPT_ENCODING"=>"gzip,deflate", "HTTP_ACCEPT_CHARSET"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.7", "HTTP_KEEP_ALIVE"=>"115", "HTTP_CONNECTION"=>"keep-alive", "HTTP_REFERER"=>"http://publish.lvh.me:3000/system/profiling", "HTTP_AUTHORIZATION"=>"Basic YWRtaW46aWx3d3NwYTIwMTA=", "rack.version"=>[1, 1], "rack.input"=>StringIO.new, "rack.errors"=>$stderr, "rack.multithread"=>true, "rack.multiprocess"=>false, "rack.run_once"=>false, "rack.url_scheme"=>"http", "HTTP_VERSION"=>"HTTP/1.1", "REQUEST_PATH"=>"/"}
+  end
+end

data/spec/db_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe RequestLog::Db do
+  describe "mongo_db" do
+    it "can be set to som custom Mongo DB" do
+      RequestLog::Db.mongo_db = "foobar"
+      RequestLog::Db.mongo_db.should == "foobar"
+    end
+  end
+end

data/spec/middleware_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe RequestLog::Middleware do
+  describe "call" do
+    it "invokes the logger with the data and the profiler in case of success" do
+      @env = {"REQUEST_PATH" => "/v1/foobar", "HTTP_USER_AGENT" => "Mozilla/5.0"}
+      @logger = mock('logger')
+      @logger.expects(:call).with() { |data| data.is_a?(RequestLog::Data) && data.status == 200 && data.env == @env }
+      @profiler = mock('profiler')
+      @profiler.expects(:call).with() { |options| options[:result] == :success && options[:elapsed_time] > 0 }
+      @rack_response = [200, {"Content-Type" => "text/html"}, "Hello, World!"]
+      @app = lambda { |env| @rack_response }
+      @middleware = RequestLog::Middleware.new(@app, :logger => @logger, :profiler => @profiler, :only_path => %r{\A/v\d})
+      @middleware.call(@env).should == @rack_response
+    end
+
+    it "uses RequestLog::Db.requests.insert as a default logger if no logger is specified" do
+      @env = env.merge("REQUEST_PATH" => "/v1/foobar", "HTTP_USER_AGENT" => "Mozilla/5.0")
+      requests = mock('requests')
+      requests.expects(:insert).with() { |attributes| attributes.is_a?(Hash) && attributes[:status] == 200 && attributes[:path] == '/v1/foobar' }
+      ::RequestLog::Db.stubs(:requests).returns(requests)
+      @rack_response = [200, {"Content-Type" => "text/html"}, "Hello, World!"]
+      @app = lambda { |env| @rack_response }
+      @middleware = RequestLog::Middleware.new(@app)
+      @middleware.call(@env).should == @rack_response      
+    end
+
+    it "never calls logger if response content type doesn't match only_path option" do
+      @env = {"REQUEST_PATH" => "/foobar", "HTTP_USER_AGENT" => "Mozilla/5.0"}
+      @logger = mock('logger')
+      @logger.expects(:call).never
+      @profiler = mock('profiler')
+      @profiler.expects(:call).never
+      @rack_response = [200, {"Content-Type" => "text/html"}, "Hello, World!"]
+      @app = lambda { |env| @rack_response }      
+      @middleware = RequestLog::Middleware.new(@app, :logger => @logger, :profiler => @profiler, :only_path => %r{\A/v\d})
+      @middleware.call(@env).should == @rack_response
+    end
+
+    it "invokes the logger with the data and the profiler if RuntimeError is raised" do
+      call_middleware_with_exception(RuntimeError)
+    end
+
+    it "invokes the logger with the data and the profiler if Timeout::Error is raised" do
+      call_middleware_with_exception(Timeout::Error)
+    end
+    
+    def call_middleware_with_exception(exception_class)
+      @env = {"REQUEST_PATH" => "/", "HTTP_USER_AGENT" => "Mozilla/5.0"}
+      @logger = mock('logger')
+      @logger.expects(:call).raises(exception_class)
+      @profiler = mock('profiler')
+      @profiler.expects(:call).with() { |options| options[:result] == :failure && options[:exception].is_a?(exception_class) }
+      @rack_response = [200, {"Content-Type" => "text/html"}, "Hello, World!"]
+      @app = lambda { |env| @rack_response }
+      $stderr.expects(:puts).with() { |error_string| error_string =~ /#{exception_class.name}/ }
+      @middleware = RequestLog::Middleware.new(@app, :logger => @logger, :profiler => @profiler)
+      @middleware.call(@env).should == @rack_response            
+    end
+  end
+
+  def env
+    {"GATEWAY_INTERFACE"=>"CGI/1.1", "QUERY_STRING"=>"", "REMOTE_ADDR"=>"127.0.0.1", "REMOTE_HOST"=>"www.publish.newsdesk.local", "REQUEST_METHOD"=>"GET", "REQUEST_URI"=>"http://publish.lvh.me:3000/images/logo.png", "SCRIPT_NAME"=>"", "SERVER_NAME"=>"publish.lvh.me", "SERVER_PORT"=>"3000", "SERVER_PROTOCOL"=>"HTTP/1.1", "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/1.9.2/2010-08-18)", "HTTP_HOST"=>"publish.lvh.me:3000", "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.6; en-US; rv:1.9.2.2) Gecko/20100316 Firefox/3.6.2", "HTTP_ACCEPT"=>"image/png,image/*;q=0.8,*/*;q=0.5", "HTTP_ACCEPT_LANGUAGE"=>"en-us,en;q=0.5", "HTTP_ACCEPT_ENCODING"=>"gzip,deflate", "HTTP_ACCEPT_CHARSET"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.7", "HTTP_KEEP_ALIVE"=>"115", "HTTP_CONNECTION"=>"keep-alive", "HTTP_REFERER"=>"http://publish.lvh.me:3000/system/profiling", "HTTP_AUTHORIZATION"=>"Basic YWRtaW46aWx3d3NwYTIwMTA=", "rack.version"=>[1, 1], "rack.input"=>StringIO.new, "rack.errors"=>$stderr, "rack.multithread"=>true, "rack.multiprocess"=>false, "rack.run_once"=>false, "rack.url_scheme"=>"http", "HTTP_VERSION"=>"HTTP/1.1", "REQUEST_PATH"=>"/"}
+  end  
+end

data/spec/profiler_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+describe RequestLog::Profiler do
+  before(:each) do
+    profiler.reset
+  end
+  
+  describe "call" do
+    describe "result => success" do
+      it "increments success_count and time stats" do
+        profiler.success_count.should == 0
+        profiler.call(:result => :success, :elapsed_time => 0.5)
+        profiler.success_count.should == 1
+        profiler.total_count.should == 1
+        profiler.min_time.should == 0.5
+        profiler.max_time.should == 0.5
+        profiler.avg_time.should == 0.5
+        profiler.call(:result => :success, :elapsed_time => 0.6)
+        profiler.success_count.should == 2
+        profiler.total_count.should == 2
+        profiler.min_time.should == 0.5
+        profiler.max_time.should == 0.6
+        profiler.avg_time.should == 0.55
+        profiler.call(:result => :success, :elapsed_time => 0.7)
+        profiler.success_count.should == 3
+        profiler.min_time.should == 0.5
+        profiler.max_time.should == 0.7
+        profiler.avg_time.should == 0.6
+      end
+    end
+
+    describe "result => failure" do
+      it "increments failure_count" do
+        profiler.failure_count.should == 0
+        profiler.call(:result => :failure)
+        profiler.failure_count.should == 1
+        profiler.total_count.should == 1
+        profiler.call(:result => :failure)
+        profiler.failure_count.should == 2
+        profiler.total_count.should == 2
+      end
+      
+      it "sets failure_exceptions if an exception is passed" do
+        profiler.failure_count.should == 0
+        profiler.failure_exceptions.should == {}
+        profiler.call(:result => :failure, :exception => RuntimeError.new("some exception"))
+        profiler.failure_count.should == 1
+        profiler.failure_exceptions.should == {"RuntimeError" => 1}
+        profiler.call(:result => :failure, :exception => Timeout::Error.new("some timeout"))
+        profiler.failure_count.should == 2        
+        profiler.failure_exceptions.should == {"RuntimeError" => 1, "Timeout::Error" => 1}
+        profiler.call(:result => :failure, :exception => Timeout::Error.new("some timeout"))
+        profiler.failure_count.should == 3        
+        profiler.failure_exceptions.should == {"RuntimeError" => 1, "Timeout::Error" => 2}
+      end
+    end    
+
+    describe "persist!" do
+      it "does not get invoked if should_persist? == false" do
+        profiler.stubs(:should_persist?).returns(false)
+        profiler.expects(:persist!).never
+        profiler.call(:result => :success, :elapsed_time => 0.6)
+      end
+
+      it "does get invoked if should_persist? == true" do
+        profiler.stubs(:should_persist?).returns(true)        
+        profiler.expects(:persist!).once
+        profiler.call(:result => :success, :elapsed_time => 0.6)
+      end
+    end
+  end
+  
+  describe "total_count" do
+    it "is failure_count + success_count" do
+      profiler.failure_count = 427
+      profiler.success_count = 10000
+      profiler.total_count.should == 10427
+    end
+  end
+  
+  describe "failure_ratio" do
+    it "is failure_count/total_count" do
+      profiler.failure_count = 1
+      profiler.success_count = 0
+      profiler.failure_ratio.should == 1.0
+      
+      profiler.failure_count = 1
+      profiler.success_count = 1
+      profiler.failure_ratio.should == 0.5
+      
+      profiler.failure_count = 1
+      profiler.success_count = 9
+      profiler.failure_ratio.should == 0.1
+    end
+  end
+
+  describe "persist!" do
+    it "stores profiling info in mongo db" do
+      profiler.success_count = 80
+      profiler.failure_count = 20
+      profiler.avg_time = 0.0003
+      profiler.max_time = 0.09
+      profiling = mock('profiling')
+      profiling.expects(:insert).with(
+        :total_count => profiler.total_count,
+        :failure_ratio => profiler.failure_ratio,
+        :max_time => profiler.max_time,
+        :avg_time => profiler.avg_time,
+        :data => profiler.attributes
+      )
+      RequestLog::Db.expects(:profiling).returns(profiling)
+      profiler.persist!
+    end
+  end
+
+  describe "persist_enabled" do
+    it "defaults to false" do
+      profiler.reset.persist_enabled.should == false
+    end
+    
+    it "can be set to true" do
+      profiler.persist_enabled = true
+      profiler.persist_enabled.should == true      
+    end
+  end
+
+  describe "should_persist?" do
+    before(:each) do
+      profiler.persist_enabled = true
+    end
+    
+    it "returns true if total_count % persist_frequency == 0" do
+      profiler.persist_frequency = 10
+      profiler.success_count = 5
+      profiler.failure_count = 5
+      profiler.should_persist?.should be_true
+      
+      profiler.persist_frequency = 3
+      profiler.success_count = 80
+      profiler.failure_count = 10
+      profiler.should_persist?.should be_true      
+    end
+
+    it "returns false if total_count % persist_frequency != 0" do
+      profiler.persist_frequency = 3
+      profiler.success_count = 5
+      profiler.failure_count = 5
+      profiler.should_persist?.should be_false
+    end
+
+    it "returns false if persist_enabled = false" do
+      profiler.persist_frequency = 10
+      profiler.success_count = 5
+      profiler.failure_count = 5
+      profiler.persist_enabled = false
+      profiler.should_persist?.should be_false
+    end    
+  end
+
+  describe "attribute_names" do
+    it "has accessors" do
+      profiler.attribute_names.each do |attribute|
+        profiler.send(attribute).should == profiler.default_values[attribute]
+        profiler.send("#{attribute}=", "foobar")
+        profiler.send(attribute).should == "foobar"        
+      end
+    end
+  end
+
+  describe "attributes" do
+    it "returns a hash with the attribute values" do
+      profiler.min_time = 3.0
+      profiler.attributes.should == profiler.default_values.merge(:min_time => 3.0)
+    end
+  end
+
+  describe "to_s" do
+    it "returns the inspect of the attributes" do
+      profiler.to_s.should == profiler.attributes.inspect
+    end
+  end
+
+  describe "reset" do
+    it "resets all attributes to default values" do
+      profiler.attribute_names.each do |attribute|
+        profiler.send("#{attribute}=", "foobar")
+      end
+      profiler.reset
+      profiler.attribute_names.each do |attribute|
+        profiler.send(attribute).should == profiler.default_values[attribute]
+      end      
+    end
+  end
+  
+  
+  
+  def profiler
+    RequestLog::Profiler
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler.require(:development)
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'request_log'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: request_log
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Peter Marklund
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-29 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 1
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+description: 
+email: 
+- peter@marklunds.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- lib/request_log.rb
+- lib/request_log/data.rb
+- lib/request_log/db.rb
+- lib/request_log/middleware.rb
+- lib/request_log/profiler.rb
+- lib/request_log/tasks.rb
+- lib/request_log/version.rb
+- lib/tasks/request_log.rake
+- request_log.gemspec
+- spec/data_spec.rb
+- spec/db_spec.rb
+- spec/middleware_spec.rb
+- spec/profiler_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -1014350961
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -1014350961
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: request_log
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rack middleware for logging web requests to a MongoDB database. Provides a profiler for monitoring logging overhead.
+test_files: 
+- spec/data_spec.rb
+- spec/db_spec.rb
+- spec/middleware_spec.rb
+- spec/profiler_spec.rb
+- spec/spec_helper.rb