roqua-support 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4aa0d44014dfb644f0d1c89f6d1fc7bf161bd69d
+  data.tar.gz: 480bec91ad5b3b5687c365c82c642302a2fe8064
+SHA512:
+  metadata.gz: 45cdd38e1b846d5456efe2eb76d9cb5757ed6f0d25badb43e74bcb7db2e0626118986077cda6e588a48e416c76fd2e0b56002f70a97c58e09c55e4f81cab963f
+  data.tar.gz: 87bbbd4f07f04b89f9f07674ee2253d3de81ab078c445c7d34d167869e74b999f200f83c62ca02cb39f356e66fe2c3aabb171f9eb22192b8131e68c32b9f7922

data/.gitignore

@@ -0,0 +1,16 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in roqua-support.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    roqua-support (0.1.0)
+      activesupport (~> 3.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.16)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    diff-lcs (1.1.3)
+    i18n (0.6.8)
+    multi_json (1.8.2)
+    rake (10.0.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.0)
+    rspec-expectations (2.12.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  rake
+  roqua-support!
+  rspec (~> 2.12.0)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 RoQua
+
+MIT License
+
+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,54 @@
+# Roqua::Support
+
+This gem contains all sorts of support utilities and helper methods that are
+useful to have in RoQua's applications, but have nothing to with the domain.
+
+## Usage
+
+### Logging
+
+```ruby
+class Example
+  include Roqua::Logging
+
+  def methodname
+    # This writes a single line to the event log with
+    # the given event name and parameters as key=value format.
+    eventlog.info 'example.eventname', optional: 'extra parameters'
+  end
+
+  def another
+    # This automatically emits two lines, one for when the
+    # block begins, one for when the block ends. ':started',
+    # ':finished', ':failed' are appended to the event name
+    # given, and the duration of the block is logged with
+    # the :finished log line.
+    eventlog.lifecycle 'example.lifecycle', optional: 'params' do
+      sleep 5
+    end
+  end
+
+  def third
+    # This example is the same as the `another` example.
+    sleep 5
+  end
+  log :third, 'example.lifecycle', optional: 'params'
+end
+```
+
+### Rails logger
+
+You can also add an additional request logger by adding this to `config/initializers/request_logger.rb`:
+
+```ruby
+require 'roqua/support/request_logger'
+Roqua::Support::RequestLogger.attach_to :action_controller
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit -1
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/roqua-support.rb

@@ -0,0 +1,2 @@
+require "roqua-support/version"
+require "roqua/support"

data/lib/roqua-support/version.rb

@@ -0,0 +1,5 @@
+module Roqua
+  module Support
+    VERSION = "0.1.0"
+  end
+end

data/lib/roqua/core_ext/array/stable_sort_by.rb

@@ -0,0 +1,37 @@
+class Array
+  # Method for stably sorting elements in an array on multiple attributes.
+  #
+  # * Pass the method a block with two arrays containing the attributes for which the
+  #   elements should be subsequently sorted. The first attribute is applied last.
+  #   If for some attribute the sort order should be reversed, the parameters x and y can
+  #   be exchanged between the arrays.
+  #
+  # ==== Example
+  #   my_array.stable_sort_by{|x, y| [
+  #                            x.attribute1,
+  #                            y.attribute2,
+  #                            y.attribute3,
+  #                            y.attribute4
+  #                          ] <=> [
+  #                            y.attribute1,
+  #                            x.attribute2,
+  #                            x.attribute3,
+  #                            x.attribute4
+  #                          ]}
+  #
+  def stable_sort_by
+    sort do |x, y|
+      if not x
+        -1
+      elsif not y
+        1
+      else
+        if block_given?
+          yield x, y
+        else
+          x <=> y
+        end
+      end
+    end
+  end
+end

data/lib/roqua/core_ext/enumerable/sort_by_alphanum.rb

@@ -0,0 +1,49 @@
+module Enumerable
+  def sort_by_alphanum
+    sort do |a, b|
+      if block_given?
+        grouped_compare(yield(a), yield(b))
+      else
+        grouped_compare(a, b)
+      end
+    end
+  end
+
+  def sort_by_alphanum!
+    sort! do |a, b|
+      if block_given?
+        grouped_compare(yield(a), yield(b))
+      else
+        grouped_compare(a, b)
+      end
+    end
+  end
+
+  private
+
+  def grouped_compare(a, b)
+    loop {
+      a_chunk, a = extract_alpha_or_number_group(a)
+      b_chunk, b = extract_alpha_or_number_group(b)
+
+      ret = if a_chunk =~ /\d/ and b_chunk =~ /\d/
+              a_chunk.to_i <=> b_chunk.to_i
+            else
+              a_chunk <=> b_chunk
+            end
+
+      return -1 if a_chunk == ''
+      return ret if ret != 0
+    }
+  end
+
+  def extract_alpha_or_number_group(item)
+    matchdata = /([A-Za-z]+|[\d]+)/.match(item)
+
+    if matchdata.nil?
+      ["", ""]
+    else
+      [matchdata[0], item = item[matchdata.offset(0)[1] .. -1]]
+    end
+  end
+end

data/lib/roqua/core_ext/fabrication/singleton.rb

@@ -0,0 +1,8 @@
+class Fabricate
+  @singletons = {}
+
+  def self.singleton(name, options={}, &block)
+    @singletons[name] ||= Fabricate(name, options={}, &block)
+    return @singletons[name]
+  end
+end

data/lib/roqua/core_ext/fixnum/clamp.rb

@@ -0,0 +1,8 @@
+class Fixnum
+  def clamp(low, high)
+    raise "Low (#{low}) must be lower than high (#{high})" unless low < high
+    return low if self < low
+    return high if self > high
+    self
+  end
+end

data/lib/roqua/support.rb

@@ -0,0 +1,14 @@
+require 'logger'
+require 'roqua/support/logging'
+
+module Roqua
+  class << self
+    def logger
+      @logger ||= LogWrapper.new(Logger.new(STDOUT))
+    end
+
+    def logger=(logger)
+      @logger = LogWrapper.new(logger)
+    end
+  end
+end

data/lib/roqua/support/command_runner.rb

@@ -0,0 +1,24 @@
+require 'pty'
+
+module CommandRunner
+  def self.run_command_and_print(cmd, output)
+    output.puts "Executing #{cmd}\n\n"
+
+    PTY.spawn(cmd) do |read_stream, write_stream, pid|
+      begin
+        while chars = read_stream.read(1)
+          output.print chars
+        end
+      rescue Errno::EIO
+      end
+      Process.wait(pid)
+    end
+    output.puts "\n\n\n"
+
+    if $?
+      exit 1 if $?.exitstatus > 0
+    else
+      raise "Huh?! We didn't get an exit status from that last one: #{cmd}"
+    end
+  end
+end

data/lib/roqua/support/log_wrapper.rb

@@ -0,0 +1,34 @@
+require 'json'
+
+module Roqua
+  class LogWrapper
+    attr_reader :logger
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def add(level, message, options = {})
+      logger.send(level, "#{message} #{options.to_json}".strip)
+    end
+
+    [:fatal, :error, :warn, :info, :debug].each do |level|
+      define_method(level) do |*args|
+        add(level, *args)
+      end
+    end
+
+    def lifecycle(message, options = {})
+      started_at = Time.now.to_f
+      info("#{message}:started", options)
+      value = yield
+      finished_at = Time.now.to_f
+      duration = finished_at - started_at
+      info("#{message}:finished", {duration: duration}.merge(options))
+      value
+    rescue => e
+      error("#{message}:failed", {exception: e.class, message: e.message}.merge(options))
+      raise
+    end
+  end
+end

data/lib/roqua/support/logging.rb

@@ -0,0 +1,26 @@
+require 'active_support/core_ext/module/aliasing'
+require 'roqua/support/log_wrapper'
+
+module Roqua
+  module Logging
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def log(method_name, message, options = {})
+        define_method(:"#{method_name}_with_log") do |*args, &block|
+          eventlog.lifecycle(message, options) do
+            send(:"#{method_name}_without_log", *args, &block)
+          end
+        end
+
+        alias_method_chain method_name, 'log'
+      end
+    end
+
+    def eventlog
+      Roqua.logger
+    end
+  end
+end

data/lib/roqua/support/request_logger.rb

@@ -0,0 +1,108 @@
+require 'roqua/support'
+require 'active_support/log_subscriber'
+
+module Roqua
+  module Support
+    module RequestLogging
+      def add_log_information(key, value)
+        Thread.current[:roqua_request_log] ||= {}
+        Thread.current[:roqua_request_log][key] = value
+      end
+    end
+
+    class RequestLogger < ActiveSupport::LogSubscriber
+      include Roqua::Logging
+
+      def process_action(event)
+        payload = event.payload
+        extra_logged_information = Thread.current[:roqua_request_log] || {}
+        Thread.current[:roqua_request_log] = {}
+
+        data      = extract_request_id(event)
+        data.merge! extract_request(payload)
+        data.merge! extract_status(payload)
+        data.merge! extract_parameters(payload)
+        data.merge! redirect_information
+        data.merge! extra_logged_information
+        data.merge! runtimes(event)
+
+        #eventlog.info event.inspect
+        eventlog.info 'roqua.web', data
+      rescue Exception => e
+        eventlog.info 'roqua.web:logerror', {class: e.class, message: e.message}
+        raise
+      end
+
+      def redirect_to(event)
+        # Unfortunately, when a redirect is triggered by your application's code,
+        # ActionController fires two events. One for the redirect itself, and
+        # another one when the request is finished. Unfortunately the final event
+        # doesn't include the redirect, so we store the redirect URL as a
+        # thread-local attribute and refers to it in process_action.
+        Thread.current[:roqua_request_log_redirect] = event.payload[:location]
+      end
+
+      private
+
+      def extract_request_id(event)
+        {uuid: event.transaction_id}
+      end
+
+      def extract_request(payload)
+        {
+          :method     => payload[:method],
+          :path       => extract_path(payload),
+          :format     => extract_format(payload),
+          :controller => payload[:params]['controller'],
+          :action     => payload[:params]['action']
+        }
+      end
+
+      def extract_path(payload)
+        payload[:path].split("?").first
+      end
+
+      def extract_format(payload)
+        payload[:format]
+      end
+
+      def extract_status(payload)
+        if payload[:status]
+          { :status => payload[:status].to_i }
+        elsif payload[:exception]
+          exception, message = payload[:exception]
+          { :status => 500, :error => "#{exception}:#{message}" }
+        else
+          { :status => 0 }
+        end
+      end
+
+      def redirect_information
+        if location = Thread.current[:roqua_request_log_redirect]
+          Thread.current[:roqua_request_log_redirect] = nil
+          {location: location}
+        else
+          {}
+        end
+      end
+
+      def extract_parameters(payload)
+        filtered_params = payload[:params].reject do |key, value|
+          key == 'controller' or key == 'action'
+        end
+        {params: filtered_params}
+      end
+
+      def runtimes(event)
+        {
+          :duration => event.duration,
+          :view => event.payload[:view_runtime],
+          :db => event.payload[:db_runtime]
+        }.inject({}) do |runtimes, (name, runtime)|
+          runtimes[name] = runtime.to_f.round(2) if runtime
+          runtimes
+        end
+      end
+    end
+  end
+end

data/roqua-support.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'roqua-support/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "roqua-support"
+  gem.version       = Roqua::Support::VERSION
+  gem.summary       = %q{Helper objects and proxies used by a lot of RoQua applications}
+  gem.description   = %q{Logging backend, freedom patches, }
+  gem.license       = "MIT"
+  gem.authors       = ["Marten Veldthuis"]
+  gem.email         = "marten@roqua.nl"
+  gem.homepage      = "https://github.com/roqua/healthy"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'activesupport', '~> 3.2'
+
+  gem.add_development_dependency 'bundler', '~> 1.0'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec', '~> 2.12.0'
+end

data/spec/roqua/core_ext/array/stable_sort_by_spec.rb

@@ -0,0 +1,40 @@
+require 'roqua/core_ext/array/stable_sort_by'
+
+describe Array do
+  describe "#stable_sort_by" do
+    it "wraps #sort" do
+      array = []
+      array.should_receive(:sort)
+      array.stable_sort_by
+    end
+
+    it "sorts nil values before all others" do
+      [1, nil, 3].stable_sort_by.should == [nil, 1, 3]
+    end
+
+    it "defaults to regular comparison" do
+      [1, 3, 2].stable_sort_by.should == [1, 2, 3]
+    end
+
+    it "accepts a block to do complex comparison" do
+      [{a: 2, b: 2, c: 3},
+       {a: 2, b: 2, c: 4},
+       {a: 1, b: 1, c: 6}].stable_sort_by do |x, y|
+        [x[:a], x[:b], x[:c]] <=> [y[:a], y[:b], y[:c]]
+       end.should == [{a: 1, b: 1, c: 6},
+                      {a: 2, b: 2, c: 3},
+                      {a: 2, b: 2, c: 4}]
+    end
+
+    it "leaves items in original order if they are the same" do
+      [{a: 2, b: 2, c: 4},
+       {a: 2, b: 1, c: 3},
+       {a: 1, b: 3, c: 6}].sort do |x, y|
+        [x[:a], x[:b]] <=> [y[:a], y[:b]]
+       end.should == [{a: 1, b: 3, c: 6},
+                      {a: 2, b: 1, c: 3},
+                      {a: 2, b: 2, c: 4}]
+
+    end
+  end
+end

data/spec/roqua/core_ext/enumerable/sort_by_alphanum_spec.rb

@@ -0,0 +1,21 @@
+require 'roqua/core_ext/enumerable/sort_by_alphanum'
+
+describe Enumerable do
+  describe '#sort_by_alphanum' do
+    it 'sorts by chunks' do
+      ["004some11thing",
+       "004some10thing",
+       "3another"].sort_by_alphanum.should == ["3another", "004some10thing", "004some11thing"]
+    end
+
+    it 'can take a block which can transform values before comparison' do
+      ["004some11thing",
+       "004some10thing",
+       "3another"].sort_by_alphanum(&:reverse).should == ["004some10thing", "004some11thing", "3another"]
+    end
+
+    it 'compares number chunks as integers' do
+      %w(004 3).sort_by_alphanum.should == %w(3 004)
+    end
+  end
+end

data/spec/roqua/core_ext/fabrication/singleton_spec.rb

@@ -0,0 +1,16 @@
+require 'roqua/core_ext/fabrication/singleton'
+
+def Fabricate(name, overrides={}, &block)
+  rand
+end
+
+describe Fabricate do
+  it "returns singleton objects" do
+    Fabricate.singleton(:one).should == Fabricate.singleton(:one)
+  end
+
+  it 'maintains multiple singletons' do
+    Fabricate.singleton(:one).should_not == Fabricate.singleton(:two)
+  end
+end
+

data/spec/roqua/core_ext/fixnum/clamp_spec.rb

@@ -0,0 +1,23 @@
+require 'roqua/core_ext/fixnum/clamp'
+
+describe Fixnum do
+  describe '#clamp' do
+    it "returns self if within bounds" do
+      5.clamp(1,10).should == 5
+    end
+
+    it "returns the lower bound if self < low" do
+      5.clamp(8,10).should == 8
+    end
+
+    it "returns the upper bound if self > high" do
+      5.clamp(1,3).should == 3
+    end
+
+    it "should raise an exception if the lower bound is greater than the upper bound" do
+      expect {
+        5.clamp(10,1)
+      }.to raise_error
+    end
+  end
+end

data/spec/roqua/support/logging_spec.rb

@@ -0,0 +1,86 @@
+require 'roqua/support/logging'
+require 'logger'
+require 'stringio'
+
+module Roqua
+  describe LogWrapper do
+    let(:logstream)  { StringIO.new }
+    let(:logger)     { Logger.new(logstream) }
+    let(:logwrapper) { LogWrapper.new(logger) }
+
+    def log
+      logstream.string
+    end
+
+    describe '#add' do
+      it 'writes event name to log' do
+        logwrapper.add :info, "testevent"
+        log.should include("testevent {}\n")
+      end
+
+      it 'writes given parameters as json hash' do
+        logwrapper.add :info, "testevent", extra: 'params', go: 'here'
+        log.should include('testevent {"extra":"params","go":"here"}' + "\n")
+      end
+
+      it 'escapes newline characters in params' do
+        logwrapper.add :info, "testevent", param: "this\nshould not have newlines"
+        log.should include('testevent {"param":"this\nshould not have newlines"')
+      end
+    end
+
+    describe '#lifecycle' do
+      it 'logs the start and finish lifecycle of a block' do
+        logwrapper.lifecycle 'testevent', extra: 'params' do
+          1 + 1
+        end
+        log.should include('testevent:started {"extra":"params"}')
+        log.should match(/testevent:finished.*"extra":"params"/)
+      end
+
+      it 'logs the duration of the block with the finished event' do
+        logwrapper.lifecycle('testevent') { 1 + 1 }
+        log.should match(/testevent:finished.*"duration":/)
+      end
+
+      it 'returns the value returned by the block' do
+        logwrapper.lifecycle('testevent') { 1 + 1 }.should == 2
+      end
+
+      it 'logs the start and failure of a block if it raises' do
+        logwrapper.lifecycle 'testevent' do
+          raise StandardError, "Foo"
+        end rescue nil
+        log.should include('testevent:started')
+        log.should include('testevent:failed {"exception":"StandardError","message":"Foo"}')
+      end
+
+      it 'reraises the exception' do
+        expect {
+          logwrapper.lifecycle 'testevent' do
+            raise "Foo"
+          end
+        }.to raise_error('Foo')
+      end
+    end
+
+    describe '.lifecycle' do
+      it 'wraps given method' do
+        ::Roqua.stub(:logger => logwrapper)
+
+        test = Class.new do
+          include Logging
+
+          def foo
+            'bar'
+          end
+          log :foo, 'roqua.testevent.foo'
+        end
+
+        test.new.foo.should == 'bar'
+        log.should include('roqua.testevent.foo:started')
+        log.should include('roqua.testevent.foo:finished')
+      end
+    end
+  end
+end

data/spec/roqua/support/request_logger_spec.rb

@@ -0,0 +1,147 @@
+require 'roqua/support/logging'
+require 'roqua/support/request_logger'
+require 'active_support/notifications'
+require 'active_support/core_ext/string'
+
+describe Roqua::Support::RequestLogger do
+  let(:logstream)  { StringIO.new }
+  let(:logger)     { Logger.new(logstream) }
+  let(:logwrapper) { Roqua::LogWrapper.new(logger) }
+
+  before { Roqua.stub(logger: logwrapper) }
+
+  def log
+    logstream.string
+  end
+
+  let(:subscriber) { Roqua::Support::RequestLogger.new }
+
+  context 'when processing a request' do
+    let(:event) do
+      ActiveSupport::Notifications::Event.new('process_action.action_controller',
+                                              Time.new(2013, 02, 28, 12, 34, 56),
+                                              Time.new(2013, 02, 28, 12, 34, 57), 2,
+          status: 200, format: 'application/json', method: 'GET', path: '/home?foo=bar',
+          params: {'controller' => 'home', 'action' => 'index', 'foo' => 'bar'},
+          db_runtime: 0.02, view_runtime: 0.01
+      )
+    end
+
+    it "logs the URL" do
+      subscriber.process_action(event)
+      logstream.string.should include('/home')
+    end
+
+    it "does not log the query string" do
+      subscriber.process_action(event)
+      logstream.string.should_not include('?foo=bar')
+    end
+
+    it "logs the HTTP method" do
+      subscriber.process_action(event)
+      logstream.string.should include('"method":"GET"')
+    end
+
+    it "logs the status code returned" do
+      subscriber.process_action(event)
+      logstream.string.should include('"status":200')
+    end
+
+    it "logs the controller and action" do
+      subscriber.process_action(event)
+      logstream.string.should include('"controller":"home","action":"index"')
+    end
+
+    it 'logs request parameters' do
+      subscriber.process_action(event)
+      logstream.string.should include('"params":{"foo":"bar"}')
+    end
+
+    it "logs how long the request took" do
+      subscriber.process_action(event)
+      logstream.string.should =~ /"duration":1000.0/
+    end
+
+    it "logs the view rendering time" do
+      subscriber.process_action(event)
+      logstream.string.should =~ /"view":0.01/
+    end
+
+    it "logs the database rendering time" do
+      subscriber.process_action(event)
+      logstream.string.should =~ /"db":0.02/
+    end
+
+    it 'logs extra information added in the controller' do
+      controller = Class.new do
+        include Roqua::Support::RequestLogging
+
+        def index
+          add_log_information 'current_user', 'johndoe'
+        end
+      end
+      controller.new.index
+      subscriber.process_action(event)
+      logstream.string.should include('"current_user":"johndoe"')
+
+      # next request should not still maintain this data
+      logstream.truncate 0
+      subscriber.process_action(event)
+      logstream.string.should_not include('current_user')
+    end
+  end
+
+  context 'when an exception occured processing the request' do
+    let(:event) do
+      ActiveSupport::Notifications::Event.new('process_action.action_controller',
+                                              Time.now, Time.now, 2,
+          status: nil, format: 'application/json', method: 'GET', path: '/home?foo=bar',
+          exception: ['AbstractController::ActionNotFound', 'Route not found'],
+          params: {'controller' => 'home', 'action' => 'index', 'foo' => 'bar'},
+          db_runtime: 0.02, view_runtime: 0.01
+      )
+    end
+
+    it "logs the 500 status when an exception occurred" do
+      subscriber.process_action(event)
+      logstream.string.should =~ /"status":500/
+      logstream.string.should =~ /"error":"AbstractController::ActionNotFound:Route not found"/
+    end
+
+    it "should return an unknown status when no status or exception is found" do
+      event.payload[:status] = nil
+      event.payload[:exception] = nil
+      subscriber.process_action(event)
+      logstream.string.should =~ /"status":0/
+    end
+  end
+
+  context 'when the request redirected' do
+    let(:event) do
+      ActiveSupport::Notifications::Event.new('process_action.action_controller',
+                                              Time.new(2013, 02, 28, 12, 34, 56),
+                                              Time.new(2013, 02, 28, 12, 34, 57), 2,
+          status: 200, format: 'application/json', method: 'GET', path: '/home?foo=bar',
+          params: {'controller' => 'home', 'action' => 'index', 'foo' => 'bar'},
+          db_runtime: 0.02, view_runtime: 0.01
+      )
+    end
+
+    let(:redirect) {
+      ActiveSupport::Notifications::Event.new(
+        'redirect_to.action_controller', Time.now, Time.now, 1, location: 'http://example.com', status: 302
+      )
+    }
+
+    it 'logs the redirect' do
+      subscriber.redirect_to(redirect)
+      subscriber.process_action(event)
+      log.should include('"location":"http://example.com"')
+
+      # next request should no longer get location
+      logstream.truncate 0
+      subscriber.process_action(event)
+      log.should_not include('location')
+    end
+  end
+end

data/spec/roqua/support_spec.rb

@@ -0,0 +1,19 @@
+require 'roqua/support'
+
+describe Roqua do
+  describe '#logger' do
+    it 'has a default' do
+      Roqua.logger.should be_an_instance_of(Roqua::LogWrapper)
+    end
+  end
+
+  describe '#logger=' do
+    let(:logger) { stub }
+
+    it 'wraps a given logger' do
+      Roqua.logger = logger
+      Roqua.logger.should be_an_instance_of(Roqua::LogWrapper)
+      Roqua.logger.logger.should == logger
+    end
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: roqua-support
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Marten Veldthuis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+description: 'Logging backend, freedom patches, '
+email: marten@roqua.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/roqua-support.rb
+- lib/roqua-support/version.rb
+- lib/roqua/core_ext/array/stable_sort_by.rb
+- lib/roqua/core_ext/enumerable/sort_by_alphanum.rb
+- lib/roqua/core_ext/fabrication/singleton.rb
+- lib/roqua/core_ext/fixnum/clamp.rb
+- lib/roqua/support.rb
+- lib/roqua/support/command_runner.rb
+- lib/roqua/support/log_wrapper.rb
+- lib/roqua/support/logging.rb
+- lib/roqua/support/request_logger.rb
+- roqua-support.gemspec
+- spec/roqua/core_ext/array/stable_sort_by_spec.rb
+- spec/roqua/core_ext/enumerable/sort_by_alphanum_spec.rb
+- spec/roqua/core_ext/fabrication/singleton_spec.rb
+- spec/roqua/core_ext/fixnum/clamp_spec.rb
+- spec/roqua/support/logging_spec.rb
+- spec/roqua/support/request_logger_spec.rb
+- spec/roqua/support_spec.rb
+homepage: https://github.com/roqua/healthy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Helper objects and proxies used by a lot of RoQua applications
+test_files:
+- spec/roqua/core_ext/array/stable_sort_by_spec.rb
+- spec/roqua/core_ext/enumerable/sort_by_alphanum_spec.rb
+- spec/roqua/core_ext/fabrication/singleton_spec.rb
+- spec/roqua/core_ext/fixnum/clamp_spec.rb
+- spec/roqua/support/logging_spec.rb
+- spec/roqua/support/request_logger_spec.rb
+- spec/roqua/support_spec.rb