rack-request_logger 0.0.4

data/lib/rack/request_logger.rb

@@ -0,0 +1,187 @@
+# Set Rack::RequestLogger.log_handler to an object with a write(params_hash) method
+# This class can be extended and have the following methods overriden as desired:
+#
+#   For logging more fields than the defaults, override:
+#     add_log_params(env_hash, status, response_headers, response_body, params_hash) # => modifies params_hash
+#
+#   For filtering information from data to be logged, override:
+#     filter_request_headers(hash)  # => returns hash with filtered values
+#     filter_request_body(string)   # => returns filterd string
+#     filter_response_headers(hash) # => returns hash with filtered values
+#     filter_response_body(string)  # => returns filterd string
+#
+#   For special error handling, override:
+#     app_error(env_hash) # => returns an error to be logged
+#     The default app_error will handle errors thrown by Sinatra
+#     To set your own errors for logging,
+#       In Sintatra: env['request_logger.error'] = error
+#       In Rails:    request.env['request_logger.error'] = error
+#     Or, override the method and handle it as desired.
+#
+#   To control when logging happens, override:
+#     log_request?(env_hash, request, status, response_headers, response_body) # => returns boolean
+#     By default, this is always true
+
+require 'rack'
+require 'rack/tasks/request_log_readers'
+
+module Rack
+  class RequestLogger
+    class << self
+      def log_handler=(log_handler)
+        @log_handler = log_handler
+        #Explicity set the logger on this class so everything works when this is inherited from
+        Rack::RequestLogger.instance_variable_set(:@log_handler, log_handler)
+      end
+
+      def log_handler
+        @log_handler
+      end
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        request_time = Time.now
+        request = Rack::Request.new env
+        status, response_headers, response_body = @app.call(env)
+      rescue => e
+        #TODO: Should return a better message, but this should basically never happen anyway,
+        #      since @app.call won't throw execeptions, but rather catches and wraps them
+        status = 500
+        response_headers = {}
+        response_body = e.message
+        error = e
+      end
+
+      if log_handler.respond_to?(:write) && log_request?(env, request, status, response_headers, response_body)
+        begin
+          params = {
+            :url              => request.url,
+            :method           => request.request_method,
+            :request_headers  => format_header_hash(filter_request_headers(request_headers(env))),
+            :request_body     => filter_request_body(read_stream(request.body)),
+            :request_time     => request_time,
+            :status           => status,
+            :response_headers => format_header_hash(filter_response_headers(response_headers)),
+            :response_body    => filter_response_body(response_body_to_s(response_body)),
+            :response_time    => Time.now
+          }
+
+          add_log_params(env, status, response_headers, response_body, params)
+
+          remote_host = remote_host(env)
+          params[:remote_host] = remote_host if remote_host
+
+          error ||= app_error(env)
+          params[:error] = format_error(error) if error
+
+          log_handler.write params
+        rescue => e
+          begin
+            log_handler.write(
+              #TODO: Log more things that are safe, or ensure they are safe first
+              :error => format_error(e)
+            )
+          rescue
+          end
+        end
+      end
+
+      [status, response_headers, response_body]
+    end
+
+    protected
+
+    def log_handler
+      self.class.log_handler
+    end
+
+    def read_stream(data)
+      return nil unless data
+      string = data.read
+      data.rewind
+      string
+    end
+
+    def request_headers(env)
+      hash = {}
+      hash['Content-Type'] = env['CONTENT_TYPE'] if env['CONTENT_TYPE']
+      hash['Content-Length'] = env['CONTENT_LENGTH'] if env['CONTENT_LENGTH']
+
+      env.each do |key, value|
+        if header = key[/http_(.+)/i, 1]
+          hash[header.downcase.gsub('_','-')] = value
+        end
+      end
+
+      hash
+    end
+
+    def remote_host(env)
+      env['REMOTE_HOST'] || env['REMOTE_ADDR']
+    end
+
+    def format_header_hash(hash)
+      hash.map { |k, v| "#{k}: #{v}" }.join "\n" if hash
+    end
+
+    def format_error(error)
+      "#{error.class}: #{error.message}\n#{error.backtrace.join("\n") if error.backtrace}"
+    end
+
+    def response_body_to_s(response_body)
+      if sinatra? response_body
+        response_body.first
+      elsif rails? response_body
+        response_body.body
+      elsif response_body.is_a? StringIO
+        read_stream response_body
+      else
+        response_body
+      end
+    end
+
+    def sinatra?(response_body)
+      response_body.is_a?(Array) && response_body.first.is_a?(String)
+    end
+
+    #Check with string to avoid Rails dependency
+    def rails?(response_body)
+      response_body.class.to_s == 'ActionDispatch::Response'
+    end
+
+
+    #Template methods
+    def add_log_params(env, status, response_headers, response_body, params)
+    end
+
+    def filter_request_headers(hash)
+      hash
+    end
+
+    def filter_request_body(string)
+      string
+    end
+
+    def filter_response_headers(hash)
+      hash
+    end
+
+    def filter_response_body(string)
+      string
+    end
+
+    def app_error(env)
+      env['request_logger.error'] || env['sinatra.error']
+    end
+
+    def log_request?(env, request, status, response_headers, response_body)
+      true
+    end
+
+  end
+end

data/lib/rack/request_logger_version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class RequestLogger
+    VERSION = '0.0.4'
+  end
+end

data/lib/rack/tasks/request_log_readers.rb

@@ -0,0 +1,111 @@
+#Defines tasks for printing latest log entries
+#Requires Rack::RequestLogger.log_handler to inherit from ActiveRecord::Base
+
+if defined?(namespace)
+  namespace :log do
+    class Rack::RequestLogger
+      module TaskHelpers
+
+        class << self
+          def print_entry(entry)
+            unless entry
+              puts 'No matching log entry found!'
+              exit 1
+            end
+
+            #No guarantee of Ruby 1.9.x or greater, so hashes may not be ordered
+            #Use arrays and each_slice instead
+            small_fields = [
+              :id,             'ID',
+              :request_id,     'GUID',
+              :user_id,        'User ID',
+              [:method, :url], 'Request',
+              :remote_host,    'Remote host',
+              :request_time,   'Request time',
+              :response_time,  'Response time',
+              :status,         'Status'
+            ]
+            large_fields = [
+              :request_headers,  'Request headers',
+              :request_body,     'Request body',
+              :response_headers, 'Response headers',
+              :response_body,    'Response body',
+              :error,            'Error'
+            ]
+
+            name_size = 0
+            small_fields.each_slice(2) { |field, name| name_size = name.size if name.size > name_size }
+
+            puts
+            printed = []
+            small_fields.each_slice(2) do |field, name|
+              print_field entry, "#{name}:".ljust(name_size + 1), field, false, printed
+            end
+            large_fields.each_slice(2) do |field, name|
+              print_field entry, name, field, true, printed
+            end
+            puts
+
+            custom_fields = entry.class.columns.map(&:name) - printed.map(&:to_s)
+            custom_fields.each { |field| print_field entry, field + ':', field }
+            puts
+          end
+
+          def print_field(entry, field_name, field, large = nil, printed = [])
+            return unless entry
+
+            field = Array(field)
+            values = []
+            field.each do |f|
+              if entry.respond_to?(f)
+                values << entry.send(f)
+                printed << f
+              end
+            end
+            value = values.join(' ')
+            
+            unless value.nil? || value.to_s.empty?
+              if large || (large.nil? && value.to_s.include?("\n"))
+                s = '-' * field_name.length
+                puts "\n#{s}\n#{field_name}\n#{s}\n#{value}\n#{s}\n\n"
+              else
+                puts "#{field_name} #{value}"
+              end
+            end
+          end
+
+          def request_logger
+            Rack::RequestLogger.log_handler.tap do |logger|
+              unless !logger.nil? && logger.respond_to?(:ancestors) && logger.ancestors.map { |a| a.to_s }.include?('ActiveRecord::Base')
+                puts 'Must have Rack::RequestLogger.log_handler set to an ActiveRecord based class to use this task!'
+                exit 1
+              end
+            end
+          end
+
+          def conditions(args, existing = nil)
+            conditions = []
+            conditions << "(#{existing})" if existing
+            conditions << "(#{args[:conditions]})" if args[:conditions]
+            conditions.empty? ? {} : { :conditions => conditions }
+          end
+        end
+
+        desc 'Print the most recent request'
+        task :request, [:conditions] => :environment do |task, args|
+          print_entry request_logger.last(conditions(args))
+        end
+
+        namespace :request do
+          %w(GET POST PUT DELETE).each do |method|
+            desc "Print the most recent #{method} request"
+            task method.downcase, [:conditions] => :environment do |task, args|
+              print_entry request_logger.last(conditions(args, "upper(method) = '#{method}'"))
+            end
+          end
+        end
+
+      end
+    end unless defined?(Rack::RequestLogger::TaskHelpers)
+  end
+end

data/spec/rack/request_logger_spec.rb

@@ -0,0 +1,395 @@
+require 'spec_helper'
+
+module Rack
+  describe RequestLogger do
+
+    class TestLogHandler
+      def self.write(params={}) end
+    end
+
+    class BadLogHandler
+      def self.write(params={}) raise 'Should not have called write!' end
+      def self.respond_to?(method) method == :write ? false : super end
+    end
+
+    before do
+      @log_handler = TestLogHandler
+      RequestLogger.log_handler = @log_handler
+
+      @app = Object.new
+      @logger = RequestLogger.new @app
+    end
+
+    describe 'call' do
+      def test_write_call(expected_hash)
+        @log_handler.should_receive(:write).with(hash_including(expected_hash))
+        @logger.call @env
+      end
+
+      before do
+        @user_id = 'someuser'
+        @request_id = 'somerequest'
+        @body = "user_id=#{@user_id}&other=stuff&request_id=#{@request_id}"
+
+        @url = 'http://this.server/path'
+
+        @env = {
+          'rack.input' => StringIO.new(@body),
+          'REQUEST_METHOD' => 'INFO',
+          'rack.url_scheme' => 'http',
+          'HTTP_HOST' => 'this.server',
+          'PATH_INFO' => '/path',
+          'SERVER_PORT' => 80
+        }
+
+        @status = 123
+        @response_headers = {:response => 'headers'}
+        @resopnse_body = 'the response'
+        @app.should_receive(:call).with(@env).and_return([@status, @response_headers, @response_body])
+
+        @logger.stub!(:log_request?).and_return(true)
+      end
+
+      it 'should return result of app.call' do
+        status, headers, body = @logger.call @env
+        status.should == @status
+        headers.should == @response_headers
+        body.should == @response_body
+      end
+
+      it 'should not log if the log_handler is not set' do
+        RequestLogger.log_handler = nil
+        @logger.call @env
+        #All is well if nothing blows up
+      end
+
+      it 'should not log if the log_handler does not respond to write' do
+        #Can't use expecatations for this, as using should_not_receive will define the method
+        RequestLogger.log_handler = BadLogHandler
+        @logger.call @env
+        #All is well if nothing blows up
+      end
+
+      it 'should not log if log_request? returns false' do
+        @log_handler.should_not_receive(:write)
+        @logger.should_receive(:log_request?).and_return(false)
+        @logger.call @env
+      end
+
+      it 'should call add_log_params with env, response results, and params' do
+        @logger.should_receive(:add_log_params).with(@env, @status, @response_headers, @response_body, hash_including(:url => @url))
+        @logger.call @env
+      end
+
+      it 'should log url' do
+        test_write_call :url => @url
+      end
+
+      it 'should log request_method' do
+        test_write_call :method => @env['REQUEST_METHOD']
+      end
+
+      it 'should log obfucated and formatted request headers' do
+        headers = { :some => 'headers' }
+        filtered_headers = { :some => '*****' }
+        formatted_headers = 'some formatted headers'
+
+        @logger.should_receive(:request_headers).with(@env).and_return(headers)
+        @logger.should_receive(:filter_request_headers).with(headers).and_return(filtered_headers)
+        @logger.should_receive(:format_header_hash).with(filtered_headers).and_return(formatted_headers)
+        @logger.stub!(:format_header_hash).with(@response_headers).and_return('other headers')
+
+        test_write_call :request_headers => formatted_headers
+      end
+
+      it 'should log filtered request body' do
+        filtered_body = 'some **** body'
+
+        @logger.should_receive(:read_stream).with(@env['rack.input']).and_return(@body)
+        @logger.should_receive(:filter_request_body).with(@body).and_return(filtered_body)
+
+        test_write_call :request_body => filtered_body
+      end
+
+      it 'should log request and response times' do
+        request, response = 1, 2
+        Time.should_receive(:now).and_return(request, response)
+        test_write_call :request_time => request, :response_time => response
+      end
+
+      it 'should log response status' do
+        test_write_call :status => @status
+      end
+
+      it 'should log filtered and formatted response headers' do
+        request_headers = { :other => 'request headers' }
+        @logger.stub!(:request_headers).and_return(request_headers)
+        @logger.stub!(:format_header_hash).with(request_headers).and_return('other headers')
+
+        filtered_headers = { :some => '*****' }
+        formatted_headers = 'some formatted headers'
+        @logger.should_receive(:filter_response_headers).with(@response_headers).and_return(filtered_headers)
+        @logger.should_receive(:format_header_hash).with(filtered_headers).and_return(formatted_headers)
+
+        test_write_call :response_headers => formatted_headers
+      end
+
+      it 'should log filtered response body' do
+        filtered_body = 'some **** body'
+        @logger.should_receive(:filter_response_body).with(@response_body).and_return(filtered_body)
+        test_write_call :response_body => filtered_body
+      end
+
+      it 'should not log remote host if not present' do
+        @logger.should_receive(:remote_host).and_return(nil)
+        @log_handler.should_not_receive(:write).with(hash_including(:remote_host => anything()))
+        @log_handler.should_receive(:write)
+
+        @logger.call @env
+      end
+
+      it 'should log remote host if present' do
+        remote_host = 'some.user.com'
+        @logger.should_receive(:remote_host).and_return(remote_host)
+        test_write_call :remote_host => remote_host
+      end
+
+      it 'should not log any error if none is present' do
+        @logger.should_receive(:app_error).and_return(nil)
+        @log_handler.should_not_receive(:write).with(hash_including(:error => anything()))
+        @log_handler.should_receive(:write)
+
+        @logger.call @env
+      end
+
+      it 'shoud format and log any present error' do
+        formatted_error = 'some formatted error'
+        error = RuntimeError.new 'some error'
+
+        @logger.should_receive(:app_error).and_return(error)
+        @logger.should_receive(:format_error).with(error).and_return(formatted_error)
+
+        test_write_call :error => formatted_error
+      end
+
+      it 'should not allow logging errors to propogate' do
+        @log_handler.should_receive(:write).twice.and_raise('some error')
+        @logger.call @env
+        #All is well if nothing blows up
+      end
+
+      it 'should attempt to format and log any logging errors' do
+        error = RuntimeError.new 'some error'
+
+        @log_handler.should_receive(:write).with(hash_including(:url => @url)).and_raise('some error')
+        @log_handler.should_receive(:write).with(instance_of(Hash)) do |params|
+          params[:error].message.should == error.message
+        end
+
+        @logger.call @env
+      end
+    end
+
+    describe 'read_stream' do
+      it 'should return nil if parameter is nil' do
+        @logger.send(:read_stream, nil).should be_nil
+      end
+
+      it 'should rewind stream' do
+        string = 'some data'
+        stream = StringIO.new string
+        value = @logger.send(:read_stream, stream)
+
+        value.should == string
+        stream.gets.should == string
+      end
+    end
+
+    describe 'filter_request_headers' do
+      it 'should return the same hash provided, since it is intended to be overridden' do
+        hash = { :login => 'login', :password => 'password' }
+        @logger.send(:filter_request_headers, nil).should be_nil
+        @logger.send(:filter_request_headers, hash).should == hash
+      end
+    end
+
+    describe 'filter_request_body' do
+      it 'should return the same string provided, since it is intended to be overridden' do
+        string = 'login=l&password=p&key=k&user=u'
+        @logger.send(:filter_request_body, nil).should be_nil
+        @logger.send(:filter_request_body, string).should == string
+      end
+    end
+
+    describe 'filter_response_headers' do
+      it 'should return the same hash provided, since it is intended to be overridden' do
+        hash = { :login => 'login', :password => 'password' }
+        @logger.send(:filter_response_headers, nil).should be_nil
+        @logger.send(:filter_response_headers, hash).should == hash
+      end
+    end
+
+    describe 'filter_response_body' do
+      it 'should return the same string provided, since it is intended to be overridden' do
+        string = 'login=l&password=p&key=k&user=u'
+        @logger.send(:filter_response_body, nil).should be_nil
+        @logger.send(:filter_response_body, string).should == string
+      end
+    end
+
+    describe 'request_headers' do
+      it 'should pull content type' do
+        content_type = 'some/type'
+        headers = @logger.send(:request_headers, 'CONTENT_TYPE' => content_type)
+        headers['Content-Type'].should == content_type
+      end
+
+      it 'should pull content length' do
+        content_length = 53188
+        headers = @logger.send(:request_headers, 'CONTENT_LENGTH' => content_length)
+        headers['Content-Length'].should == content_length
+      end
+
+      it 'should pull and format anything starting with "HTTP_"' do
+        env = {
+          'HTTP_SOME_HEADER' => 'something',
+          'HTTP_ANOTHER_HEADER' => 'another thing',
+          'http_lowercase_header' => 'lowercase',
+          'hTtp_CrAZy_HEadeR' => 'multicase'
+        }
+
+        headers = @logger.send(:request_headers, env)
+
+        env.each do |header, value|
+          formatted_header = header.downcase.sub('http_', '').gsub('_', '-')
+          headers[formatted_header].should == value
+        end
+      end
+
+      it 'should ignore anything not covered by tests above' do
+        @logger.send(:request_headers, 'IGNORED_VALUE' => 'JUNK').should be_empty
+      end
+    end
+
+    describe 'remote_host' do
+      before do
+        @host = 'some.host'
+      end
+
+      it 'should return remote host for Rails requests' do
+        @logger.send(:remote_host, 'REMOTE_ADDR' => @host).should == @host
+      end
+
+      it 'should return remote host for Sinatra requests' do
+        @logger.send(:remote_host, 'REMOTE_HOST' => @host).should == @host
+      end
+
+      it 'should return nil if nothing found' do
+        @logger.send(:remote_host, 'nothing' => 'useful').should be_nil
+      end
+    end
+
+    describe 'app_error' do
+      it 'should return sinatra.error if present in env' do
+        error = RuntimeError.new 'some sinatra-set error'
+        @logger.send(:app_error, 'sinatra.error' => error).should == error
+      end
+
+      it 'should return request_logger.error if present in env' do
+        error = RuntimeError.new 'some manually set error'
+        @logger.send(:app_error, 'request_logger.error' => error).should == error
+      end
+
+      it 'should let manually set errors take precedence over Sinatra set errors' do
+        sinatra_error = RuntimeError.new 'some sinatra-set error'
+        manual_error = RuntimeError.new 'some manually set error'
+        env = { 'sinatra.error' => sinatra_error, 'request_logger.error' => manual_error }
+        @logger.send(:app_error, env).should == manual_error
+      end
+
+      it 'should return nil if no error is found' do
+        @logger.send(:app_error, {}).should == nil
+      end
+    end
+
+    describe 'format_header_hash' do
+      it 'should return nil if hash is nil' do
+        @logger.send(:format_header_hash, nil).should be_nil
+      end
+
+      it 'should turn hash into a header string' do
+        hash = { :key1 => 'value1', :key2 => 'value2' }
+        string_possibilities = [[]]
+        hash.each do |k, v|
+          string_possibilities.first << "#{k}: #{v}"
+        end
+        string_possibilities << string_possibilities.first.reverse
+        string_possibilities.map! { |s| s.join "\n" }
+        string_possibilities.should include(@logger.send(:format_header_hash, hash))
+      end
+    end
+
+    describe 'format_error' do
+      before do
+        @message = 'the message'
+        @error = RuntimeError.new(@message)
+      end
+
+      it 'should include class' do
+        string = @logger.send(:format_error, @error)
+        string.should include(@error.class.to_s)
+      end
+
+      it 'should include message' do
+        string = @logger.send(:format_error, @error)
+        string.should include(@error.message)
+      end
+
+      it 'should include backtrace' do
+        begin
+          #Raise it to get a backtrace
+          raise @error
+        rescue => e
+          string = @logger.send(:format_error, e)
+          e.backtrace.each do |frame|
+            string.should include(frame)
+          end
+        end
+      end
+    end
+
+    describe 'response_body_to_s' do
+      it 'should handle Sinatra responses' do
+        body = 'An array with a single element'
+        sinatra_response = [ body ]
+        @logger.send(:response_body_to_s, sinatra_response).should == body
+      end
+
+      it 'should handle Rails responses' do
+        body = 'Part of an ActionDispatch::Response object'
+        hacked_rails_response = Object.new
+        hacked_rails_response.should_receive(:body).and_return(body)
+        hacked_rails_response.should_receive(:class).and_return('ActionDispatch::Response')
+        @logger.send(:response_body_to_s, hacked_rails_response).should == body
+      end
+
+      it 'should read streams' do
+        body = 'a stream'
+        stream = StringIO.new body
+        @logger.should_receive(:read_stream).with(stream).and_return(body)
+        @logger.send(:response_body_to_s, stream).should == body
+      end
+
+      it 'should simply return the object if it is a string' do
+        body = 'a string'
+        @logger.send(:response_body_to_s, body).should == body
+      end
+
+      it 'should simply return the object if it is an unknown type' do
+        object = { :a => 'hash' }
+        @logger.send(:response_body_to_s, object).should == object
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'rspec'
+require 'rspec/autorun'
+require 'stringio'
+
+require 'rack/request_logger'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: rack-request_logger
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Mike Marion
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 6
+        version: "2.6"
+  type: :development
+  version_requirements: *id003
+description: |-
+  This gem is Rack middleware that gathers information about
+                       all requests and responses, allowing for detailed logging.
+email: mike.marion@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rack/request_logger.rb
+- lib/rack/request_logger_version.rb
+- lib/rack/tasks/request_log_readers.rb
+has_rdoc: true
+homepage: https://github.com/BLC/rack-request_logger
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Rack Request Logger
+test_files: 
+- spec/rack/request_logger_spec.rb
+- spec/spec_helper.rb