rack-key_value_logger 0.3.1

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,12 @@
+source :rubygems
+
+gem 'rake'
+
+gemspec
+
+group :test do
+  gem 'debugger'
+  gem 'rack'
+  gem 'rspec'
+  gem 'sinatra'
+end

data/HISTORY.md

@@ -0,0 +1,4 @@
+## 0.3.1
+
+* (feature) Add `:ignore_paths` option
+* Add human-readable timestamp to each log line

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012 Alex Sharp
+
+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.md

@@ -0,0 +1,56 @@
+[![Build Status](https://secure.travis-ci.org/zaarly/rack-key_value_logger.png)](http://travis-ci.org/zaarly/rack-key_value_logger)
+
+## What
+
+Structured, key-value logging for your rack apps. Inspired by [lograge](https://github.com/roidrage/lograge).
+
+## Why?
+
+Application logs are an incredibly rich source of information. But digging out
+the information can be extremely painful if your logs are not structured in an
+easily parsable manner.
+
+`Rack::KeyValueLogger` logs key-value pairs, where the key and value are
+separated by a "=" character. Pairs are separated by pipe ("|") characters.
+Here's an example of what a log line looks like:
+
+```
+[1351714706 2012-10-31 20:18:26 UTC] method=GET|url=/homepage|params=page=2|user_id=123|scheme=http|user_agent=curl/7.24.0 (x86_64-apple-darwin12.0) libcurl/7.24.0 OpenSSL/0.9.8r zlib/1.2.5|remote_ip=127.0.0.1|http_version=HTTP/1.1|requested_content_type=text/html|log_source=key_value_logger|status=200|content-length=111|content_type=text/html|runtime=21.553
+```
+
+## Get Started
+
+```ruby
+gem 'rack-key_value_logger'
+```
+
+#### Sinatra
+
+```ruby
+class MyApp < Sinatra::Base
+  use Rack::KeyValueLogger
+end
+```
+
+#### Rails
+
+```ruby
+module MyApp
+  class Application < Rails::Application
+    # ...
+    config.middleware.use "Rack::KeyValueLogger"
+  end
+end
+```
+
+## Configuration
+
+A number of configuration options are supported when adding
+`Rack::KeyValueLogger` to the middleware stack.
+
+* `:log_failure_response_bodies` - `true` or `false`. Logs the entire response
+  body to the `response_body` key on 40x responses. Defaults to `false`.
+* `:ignore_paths` - A regular expression of paths we should not log.
+* `:logger` - A `Logger` instance. Defaults to `Logger($stdout)`.
+* `:user_id` - A string key at which the current user's id is stored in
+  `env["rack.session"]`. Defaults to "user_id".

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/key_value_logger/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class KeyValueLogger
+    VERSION = '0.3.1'
+  end
+end

data/lib/rack/key_value_logger.rb

@@ -0,0 +1,147 @@
+require 'logger'
+require 'multi_json'
+
+module Rack
+  class KeyValueLogger
+    SEPARATOR = "|"
+
+    attr_reader :msg, :logger, :opts, :ignore_paths
+
+    # @example Preventing rails assets from being logged
+    #   use Rack::KeyValueLogger, :ignore_paths => /\/assets/
+    #
+    # @example Logging non-success response bodies
+    #   use Rack::KeyValueLogger, :log_failure_response_bodies => true
+    #   # NOTE: Most fields below have been omitted for brevity and replaced with "..."
+    #   # => [1351712789 2012-10-31 19:46:29 UTC] method=GET|url=/422|params=|...|response_body=["{\"errors\"=>{\"key\"=>\"val\"}}"]|runtime=0.07
+    #
+    # @param opts
+    # @option opts :logger A logger instance. Defaults to logging to $stdout.
+    # @option opts :log_failure_response_bodies Set to `true` to log response
+    #     bodies for non-success codes. Defaults to false.
+    # @option opts :user_id a string key representing the user id key.
+    #     Defaults to 'user_id'
+    # @option opts :ignore_paths a regular expression indicating url paths we don't want to
+    #   in the session hash.
+    def initialize(app, opts = {})
+      @app, @opts = app, opts
+      @logger = @opts[:logger] || ::Logger.new($stdout)
+      @opts[:log_failure_response_bodies] ||= false
+      @opts[:user_id] ||= 'user_id'
+      @ignore_paths = @opts[:ignore_paths]
+    end
+
+    # Logs key=value pairs of useful information about the request and
+    # response to the a log. We either piggy-back off the
+    # env['rack.logger'] or we log to $stdout.
+    #
+    # Components
+    #   * session - session hash, json-encoded
+    #   * accept - Accept-Encoding request header
+    #   * user-agent - User agent string
+    #   * request-time - in seconds since epoch
+    #   * method - request method
+    #   * status - response status code
+    #   * url - the url, without query string
+    #   * query-string - query string params
+    #   * user-id - user's id
+    #   * scheme - http or https
+    #   * content-length - length in bytes of the response body
+    #   * requested-content-type
+    #   * content-type - Content-Type response header
+    #   * remote-ip - User's ip address
+    #   * runtime - Duration of request in milliseconds
+    #   * http-version - http version of the client
+    #   * mobile-device - the mobile device return by rack-mobile-detect
+    def call(env)
+      @msg           = []
+      start          = Time.now
+      request        = Rack::Request.new(env)
+      user_id        = env['rack.session'] && env['rack.session'][opts[:user_id]]
+      mobile_device  = env['X_MOBILE_DEVICE']
+      url            = request.path
+      query_string   = env['QUERY_STRING']
+
+      if ignored_path?(url)
+        return @app.call(env)
+      end
+
+      # record request attributes
+      msg << "method=#{request.request_method}"
+      msg << "url=#{url}"
+      msg << "params=#{query_string}"
+      msg << "user_id=#{user_id}"
+      msg << "scheme=#{request.scheme}"
+      msg << "user_agent=#{request.user_agent}"
+      msg << "remote_ip=#{request.ip}"
+      msg << "http_version=#{env['HTTP_VERSION']}"
+      msg << "mobile_device=#{mobile_device}" if mobile_device
+      msg << "requested_content_type=#{request.content_type}"
+      msg << "log_source=key_value_logger"
+
+      begin
+        status, headers, body = @app.call(env)
+
+        record_response_attributes(status, headers, body)
+      rescue => e
+        msg << 'status=500'
+        raise e
+      ensure
+        record_runtime(start)
+
+        # Don't log Rack::Cascade fake 404's
+        flush_log unless rack_cascade_404?(headers)
+      end
+
+      [status, headers, body]
+    end
+
+    private
+
+    # Returns true if the passed in `url` argument matches the `ignore_paths`
+    # attribute. Return false otherwise, or if `ignore_paths` is not set.
+    #
+    # @param [String] url a url path
+    # @return [Boolean]
+    def ignored_path?(url)
+      return false if ignore_paths.nil?
+      url =~ ignore_paths
+    end
+
+    def record_runtime(start)
+      msg << "runtime=#{((Time.now - start) * 1000).round(5)}"
+    end
+
+    # Flush `msg` to the logger instance.
+    def flush_log
+      result = msg.join(SEPARATOR)
+      now = Time.now
+      result = "[#{now.to_i} #{now.utc}] " + result
+
+      logger.info result
+    end
+
+    def record_response_attributes(status, headers, body)
+      msg << "status=#{status}"
+      msg << "content-length=#{headers['Content-Length']}"
+      msg << "content_type=#{headers['Content-Type']}"
+
+      if status.to_s =~ /^4[0-9]{2}/ && opts[:log_failure_response_bodies]
+        response = Rack::Response.new(body, status, headers)
+        msg << "response_body=#{MultiJson.encode(response.body)}"
+      end
+    end
+
+    # Sinatra adds a "X-Cascade" header with a value of "pass" to the response.
+    # This makes it possible to detect whether this is a 404 worth logging,
+    # or just a Rack::Cascade 404.
+    #
+    # @param [Hash, nil] headers the headers hash from the response
+    # @return [Boolean]
+    def rack_cascade_404?(headers)
+      return false if headers.nil?
+      cascade_header = headers['X-Cascade']
+      cascade_header && cascade_header == 'pass'
+    end
+  end
+end

data/lib/rack-key_value_logger.rb

@@ -0,0 +1 @@
+require 'rack/key_value_logger'

data/rack-key_value_logger.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "key_value_logger/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rack-key_value_logger"
+  s.version     = Rack::KeyValueLogger::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Alex Sharp"]
+  s.email       = ["ajsharp@gmail.com"]
+  s.homepage    = "https://github.com/zaarly/rack-key_value_logger"
+  s.summary     = %q{Structured, key-value logging for your rack apps.}
+  s.description = %q{Structured, key-value logging for your rack apps. Inspired by lograge.}
+
+  s.rubyforge_project = s.name
+
+  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_dependency 'multi_json'
+  s.add_dependency 'rack'
+end

data/spec/integration/sinatra_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module SinatraTest
+  describe 'ignoring rack cascade 404s' do
+    DRAIN = StringIO.new
+    LOGGER = Logger.new(DRAIN)
+
+    before do
+      DRAIN.truncate(0)
+    end
+    let(:drain) { DRAIN } # for shared helpers
+
+    class Base < Sinatra::Base
+      use Rack::KeyValueLogger, :logger => LOGGER
+    end
+
+    class FirstApp < Base
+      get('/other') { status(200) }
+    end
+
+    class SecondApp < Base
+      get('/success') { status(200) }
+    end
+
+    let(:app) do
+      Rack::Builder.app do
+        run Rack::Cascade.new([FirstApp, SecondApp])
+      end
+    end
+
+    before do
+      do_get '/success'
+    end
+
+    it_behaves_like 'it logs', 'status', '200'
+    it_behaves_like 'it logs', 'url', '/success'
+    it_behaves_like 'it does not log', 'status', '404'
+
+    it 'should only log one entry' do
+      drain.rewind
+      drain.lines.count.should == 1
+    end
+  end
+end

data/spec/rack/key_value_logger_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+require 'stringio'
+
+describe "logging non success response bodies" do
+  let(:logger) { Logger.new(drain) }
+  let(:drain) { StringIO.new }
+
+  let(:app) do
+    a = lambda do |env|
+      case env['PATH_INFO']
+      when '/200'
+        [200, default_test_headers, ['Success']]
+      when '/422'
+        [422, default_test_headers, [{'errors' => {'key' => 'val'}}]]
+      when '/401'
+        [401, default_test_headers, ['Unauthorized']]
+      when '/400'
+        [400, default_test_headers, ['Fail']]
+      when '/500'
+        raise "oh noez!"
+      end
+    end
+
+    log = logger # hold scope out of the block
+    Rack::Builder.app do
+      use Rack::KeyValueLogger, :log_failure_response_bodies => true, :logger => log
+      run a
+    end
+  end
+
+  it "should clear the msg attr out after each log line" do
+    do_get('/200')
+    do_get('/401')
+    drain.rewind
+    drain.read.scan('method').size.should == 2
+  end
+
+  context 'when the proper option is passed in' do
+    it "logs the response body for 401's" do
+      do_get('/401')
+      drain.should include_entry "response_body=.*Unauthorized.*"
+    end
+
+    it "logs the response body for 400's" do
+      do_get('/400')
+      drain.should include_entry "response_body=.*Fail.*"
+    end
+
+    it "logs the response body for 422's" do
+      do_get('/422')
+      drain.should include_entry 'response_body=.*errors.*'
+    end
+  end
+
+  context 'a 200 response' do
+    before do
+      do_get('/200')
+    end
+
+    it_behaves_like "it logs", 'status', 200
+
+    it 'does not log the response body for success endpoints' do
+      drain.should_not include_entry 'response_body=Unauthorized'
+    end
+  end
+
+  context 'a 400 bad request response' do
+    before do
+      do_get('/400')
+    end
+
+    it_behaves_like 'it logs', 'status', 400
+  end
+
+  context 'an unexpected 500 response' do
+    before do
+      begin
+        do_get('/500')
+      rescue => e
+        # raise other exceptions
+        raise e unless e.message == 'oh noez!'
+      end
+    end
+
+    it_behaves_like 'it logs', 'url', '/500'
+    it_behaves_like 'it logs', 'status', 500
+  end
+end
+
+describe "ignoring certain paths" do
+  let(:logger) { Logger.new(drain) }
+  let(:drain) { StringIO.new }
+
+  let(:app) do
+    ignore_app = lambda do |env|
+      case env['PATH_INFO']
+      when '/ignore'
+        [200, default_test_headers, ['ignore me!']]
+      when '/do-not-ignore'
+        [200, default_test_headers, ["don't ignore me!"]]
+      end
+    end
+
+    log = logger
+    Rack::Builder.app do
+      use Rack::KeyValueLogger, :logger => log, :ignore_paths => /^\/ignore/
+      run ignore_app
+    end
+  end
+
+  it 'does not log anything for ignored paths' do
+    do_get('/ignore')
+    drain.should_not include_entry "url=/ignore"
+  end
+
+  context 'logging non-ignored paths' do
+    before do
+      do_get '/do-not-ignore'
+    end
+
+    it_behaves_like 'it logs', 'status', '200'
+    it_behaves_like 'it logs', 'url', '/do-not-ignore'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'rspec'
+require 'rack'
+require 'sinatra/base'
+
+$:.push(File.expand_path(File.dirname(__FILE__)))
+$:.push(File.expand_path(File.dirname(__FILE__)) + '/../lib')
+
+require 'rack-key_value_logger'
+require 'rack/key_value_logger'
+require 'debugger'
+
+RSpec.configure do |c|
+  def do_get(url)
+    Rack::MockRequest.new(app).get(url)
+  end
+
+  def default_test_headers
+    {'Content-Type' => 'text/plain'}
+  end
+end
+
+# @example
+#   $drain.should include_entry 'status=500'
+RSpec::Matchers.define :include_entry do |expected|
+  match do |actual|
+    actual.rewind
+    !!actual.detect { |l| l =~ /#{expected}/ }
+  end
+end
+
+shared_examples 'it logs' do |field, value|
+  it "logs #{field} = #{value}" do
+    drain.should include_entry "#{field}=#{value}"
+  end
+end
+
+shared_examples 'it does not log' do |field, value|
+  it "does not log #{field} = #{value}" do
+    drain.should_not include_entry "#{field}=#{value}"
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: rack-key_value_logger
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+  prerelease: 
+platform: ruby
+authors:
+- Alex Sharp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Structured, key-value logging for your rack apps. Inspired by lograge.
+email:
+- ajsharp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- HISTORY.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/key_value_logger/version.rb
+- lib/rack-key_value_logger.rb
+- lib/rack/key_value_logger.rb
+- rack-key_value_logger.gemspec
+- spec/integration/sinatra_spec.rb
+- spec/rack/key_value_logger_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/zaarly/rack-key_value_logger
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rack-key_value_logger
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Structured, key-value logging for your rack apps.
+test_files:
+- spec/integration/sinatra_spec.rb
+- spec/rack/key_value_logger_spec.rb
+- spec/spec_helper.rb
+has_rdoc: