lookout-rack-utils 1.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmNkMzhmMTMyZTI2N2FiODZhMDk0ZDMzYTM1NjA0Yzc4ZDg5MWRlYQ==
+  data.tar.gz: !binary |-
+    OGYzNThmOTViMWY1NmZjNWEwZjEzMDhjY2MxNTcxYmMyYjFkNDA3Yg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MjU0Y2FlMjBhZTYxOTg2Zjg1M2Y4ODQxZjQ5ODczMzk2ZjVkOTk0NWU0MWRk
+    ODFlZmM1OGYwYThmZmRlMDM1N2QyODM0OGVhZWEyOTUxZjBiZmU0OGEzYjEy
+    YzllNmY0YzI4OThmODRmZDI3MzQ1MzI4YzQ3MWJjMzIwYWFlNDg=
+  data.tar.gz: !binary |-
+    OGI4N2E4ZGY5ZTliYTQ1Mzg3Y2I2NWYzZjE0ZGFjZmQ4Yjg5Njg3YTcyNDhk
+    N2EwODY4YTllNzFhOThjNjQwZjE1NWNmMzQ4ZmVkM2QyNTI3MmUzYmM1OWNm
+    NDk5ZTBkNTE1MTlhZGM1YmNhNGRlMWUwMTRkNzI3YWRjMzVjMWQ=

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Lookout, Inc
+
+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,101 @@
+# Lookout::Rack::Utils
+
+Assorted Rack utils.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lookout-rack-utils'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lookout-rack-utils
+
+## Usage
+  Require pieces of this in your project as needed; details below.
+
+### Lookout::Rack::Utils::Graphite
+  You'll need configatron set up:
+
+  ```ruby
+  configatron.statsd do |s|
+    s.prefix = 'app'
+    s.host = 'localhost'
+    s.port = 8125
+  end
+  ```
+### Lookout::Rack::Utils::I18n
+  You'll need configatron set up:
+
+ ```ruby
+    configatron.default_locale = :en
+    configatron.locales = [:en]
+ ```
+
+  You'll also need to set the load path somewhere in your
+app:
+  ```ruby
+  I18n.load_path = Dir["./config/locales/**/*.yml"]
+  ```
+
+  Note that we expect `t(*args)` to be called in the context of a request.
+
+### Lookout::Rack::Utils::Log
+  You'll need configatron set up.  If `Lookout::Rack::Utils::Graphite` is
+present, it will increment those stats whenever a log is written.
+
+  ```ruby
+  configatron.project_name = 'My project name'
+  configatron.logging do |l|
+    l.enabled = true
+    l.level = 'WARN'
+    l.file = 'log/some_file.log'
+  end
+  ```
+
+### Lookout::Rack::Utils::Request
+  `Lookout::Rack::Utils::Request` will log errors using
+`Lookout::Rack::Utils::Log` if it has been required elsewhere.
+
+### Lookout::Rack::Utils::Subroute
+  `subroute!(relative_path)` will fire off a request to the specified relative
+path; the result can then be used, or just returned immediately to the browser.
+
+  Examples (Used in a Sinatra application):
+  ```ruby
+  require 'lookout/rack/utils/subroute'
+  include Lookout::Rack::Utils::Subroute
+
+  # Return the status of a request to /api/public/v1/original_route and throw
+  # away the response body
+  get '/status' do
+    sub_status, sub_data = subroute!('/api/public/v1/original_route')
+
+    halt sub_status
+  end
+
+  # Assuming we have a method 'current_user', make /api/public/v1/user route
+  # to the current user
+  get '/api/public/v1/user' do
+    subroute!("/api/public/v1/user/#{current_user.id}")
+  end
+
+  # Same as above, but a POST request - the verb and all other parts of the
+  # request's env will be preserved
+  post '/api/public/v1/user' do
+    subroute!("/api/public/v1/user/#{current_user.id}")
+  end
+  ```
+
+## 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,9 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--fail-fast --color --order random'
+end
+
+task :test => :spec
+task :default => :test

data/lib/lookout/rack/utils.rb

@@ -0,0 +1,24 @@
+require "lookout/rack/utils/version"
+
+module Lookout
+  module Rack
+    module Utils
+    end
+  end
+end
+
+if RUBY_PLATFORM == 'java'
+  # This is required because YAML is messed up and incompatible with our version
+  # of Configatron under JRuby
+  module Psych
+    module Yecht
+      MergeKey = nil
+    end
+  end
+end
+
+require 'lookout/rack/utils/graphite'
+require 'lookout/rack/utils/i18n'
+require 'lookout/rack/utils/log'
+require 'lookout/rack/utils/request'
+require 'lookout/rack/utils/subroute'

data/lib/lookout/rack/utils/graphite.rb

@@ -0,0 +1,35 @@
+require 'singleton'
+require 'configatron'
+require 'statsd'
+
+module Lookout::Rack::Utils
+  # Statsd proxy.  This class initializes the Statsd client and
+  # delegates all stats related calls to it.
+  #
+  # Use as:
+  #   Lookout::Rack::Utils::Graphite.increment('device.associated')
+  #   Lookout::Rack::Utils::Graphite.update_counter('device.associated', 5)
+  #
+  class Graphite
+    include Singleton
+
+    def initialize
+      prefix = configatron.statsd.prefix
+      unless ENV['RACK_ENV'] == 'production'
+        prefix = "dev.#{ENV['USER']}.#{prefix}"
+      end
+
+      Statsd.create_instance(:host => configatron.statsd.host,
+                             :port => configatron.statsd.port,
+                             :prefix => prefix)
+    end
+
+    def self.method_missing(meth, *args, &block)
+      self.instance && Statsd.instance.send(meth, *args)
+    end
+
+    def self.respond_to?(method, include_private = false)
+      super || (self.instance && Statsd.instance.respond_to?(method, include_private))
+    end
+  end
+end

data/lib/lookout/rack/utils/i18n.rb

@@ -0,0 +1,52 @@
+require 'i18n'
+require 'configatron'
+
+module Lookout::Rack::Utils
+  module I18n
+    ::I18n.default_locale = configatron.default_locale
+
+    def t(*args)
+      ::I18n.t(*args)
+    end
+
+    def current_locale
+      return @locale unless @locale.nil?
+
+      accepted_languages.each do |lang, quality|
+        if configatron.locales.include?(lang)
+          @locale = lang
+          return @locale
+        end
+      end
+
+      # Just fallback to what we have set for the default
+      @locale = configatron.default_locale
+      return @locale
+    end
+
+    # We expect this to be called in a Rack request, but it will default to
+    # returning [] if not.
+    def accepted_languages
+      accepted = defined?(request.env) && request.env['HTTP_ACCEPT_LANGUAGE']
+      return [] if accepted.nil?
+
+      # parse Accept-Language
+      accepted = accepted.split(',')
+      accepted = accepted.map { |l| l.strip.split(";") }
+      accepted = accepted.map { |l|
+        # en-US -> :en
+        lang = l[0].split('-').first.downcase.to_sym
+
+        if (l.size == 2)
+          # quality present
+          [lang, l[1].sub(/^q=/, "").to_f ]
+        else
+          # no quality specified => quality == 1
+          [ lang, 1.0 ]
+        end
+      }
+      # sort by quality
+      accepted.sort { |left, right| right[1] <=> left[1] }
+    end
+  end
+end

data/lib/lookout/rack/utils/log.rb

@@ -0,0 +1,104 @@
+require 'rubygems'
+require 'log4r'
+require 'singleton'
+require 'rack/requestash/log4r'
+require 'time'
+require 'configatron'
+
+module Lookout::Rack::Utils
+  # Logging.  Logs to log/<project_name>.log with the format:
+  #
+  #   [Log Level]: [Timestamp (ISO-8601)]: [File:linenum]: [Log Message]
+  #
+  # Use through the helper:
+  #   log.warn 'This is my log message'
+  #
+  class Log
+    include Singleton
+    include Log4r
+
+    # Formatter that include the filename and relative path, and line number in
+    # output of the caller.
+    #
+    # Since all callers go through the methods defined in this class to log, we
+    # look at the second line of the tracer output, removing everything but the
+    # directories after the project directory.
+    #
+    class LookoutFormatter < Log4r::Formatter
+      # Return the project base directory for filtering to help with
+      # identifiying the filename and line number when formatting the log
+      # message
+      #
+      # @return [String] Base directory for the project
+      def basedir
+        @basedir ||= File.expand_path(File.join(File.dirname(__FILE__), ".."))
+      end
+
+      # Return a trimmed version of the filename from where a LogEvent occurred
+      # @param [String] tracer A line from the LogEvent#tracer Array
+      # @return [String] Trimmed and parsed version of the file ane line number
+      def event_filename(tracer)
+        parts = tracer.match(/#{basedir}\/(.*:[0-9]+).*:/)
+
+        # If we get no matches back, we're probably in a jar file in which case
+        # the format of the tracer is going to be abbreviated
+        if parts.nil?
+          parts = tracer.match(/(.*:[0-9]+).*:/)
+        end
+        return parts[-1] if parts
+      end
+
+      # Receive the LogEvent and pull out the log message and format it for
+      # display in the logs
+      #
+      # @param [Log4r::LogEvent] event
+      # @return [String] Formatted log message
+      def format(event)
+        filename = event_filename(event.tracer[1])
+        time = Time.now.utc.iso8601
+        return "#{Log4r::LNAMES[event.level]}: #{time}: #{filename}: #{event.data}\n"
+      end
+    end
+
+
+    attr_reader :outputter
+
+    def initialize
+      logger_name = configatron.project_name.to_s.gsub(/\s*/, '_')
+      if logger_name.nil? || logger_name.empty?
+        logger_name = 'no_name_given'
+      end
+
+      @logger = Logger.new(logger_name)
+
+      if configatron.logging.enabled
+        index = Log4r::LNAMES.index(configatron.logging.level)
+        # if loggel.level is not in LNAMES an exception will be thrown
+        @logger.level = index unless index.nil?
+      else
+        @logger.level = Log4r::OFF
+      end
+
+      @outputter = FileOutputter.new("#{logger_name.to_s}fileoutput",
+                                     {:filename => configatron.logging.file,
+                                      :trunc => false})
+      @logger.trace = true
+      @outputter.formatter = LookoutFormatter
+
+      if ENV['RACK_ENV'] == 'production'
+        @outputter.formatter = Rack::Requestash::Log4r::Formatter
+      end
+      @logger.outputters = @outputter
+    end
+
+
+    [:debug, :info, :warn, :error, :level].each do |method|
+      define_method(method) do |*args|
+        if defined?(Lookout::Rack::Utils::Graphite)
+          Lookout::Rack::Utils::Graphite.increment("log.#{method}") unless method == :level
+        end
+        @logger.send(method, *args)
+      end
+    end
+  end
+end

data/lib/lookout/rack/utils/request.rb

@@ -0,0 +1,35 @@
+module Lookout::Rack::Utils
+  module Request
+    ILLEGAL_CHARS_REGEX = /[<>]/
+
+    # Return the raw, unprocessed request body
+    #
+    # @return  [String]
+    def raw_body
+      # Rewind the StringIO object in case somebody else read it first
+      request.body.rewind
+      return request.body.read
+    end
+
+    # Process and parse the request body as JSON
+    #
+    # Will halt and create a a 400 status code if there is something wrong with
+    # the body
+    #
+    def body_as_json
+      body = raw_body
+
+      halt 400, { :error => t('error.body_was_nil') }.to_json if body.nil?
+      halt 400, { :error => t('error.body_was_blank') }.to_json if body.blank?
+
+      begin
+        return JSON.parse(body)
+      rescue JSON::ParserError
+        if defined?(Lookout::Rack::Utils::Log)
+          Lookout::Rack::Utils::Log.instance.warn "ParserError encountered parsing the request body (#{body})"
+        end
+        halt 400, "{}"
+      end
+    end
+  end
+end

data/lib/lookout/rack/utils/subroute.rb

@@ -0,0 +1,22 @@
+module Lookout::Rack::Utils
+  module Subroute
+    def subroute!(relative_path)
+      subcode, subheaders, body = call(env.merge('PATH_INFO' => relative_path))
+      return [subcode, body.first]
+    end
+
+    # Returns true if the status given is 20x
+    #
+    # @param [Integer] status
+    def succeeded?(status)
+      status.is_a?(Fixnum) && (200..299).include?(status)
+    end
+
+    # Returns false if the status given is 20x
+    #
+    # @param [Integer] status
+    def failed?(status)
+      !succeeded?(status)
+    end
+  end
+end

data/lib/lookout/rack/utils/version.rb

@@ -0,0 +1,7 @@
+module Lookout
+  module Rack
+    module Utils
+      VERSION = "1.2.0"
+    end
+  end
+end

data/lookout-rack-utils.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lookout/rack/utils/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lookout-rack-utils"
+  spec.version       = Lookout::Rack::Utils::VERSION
+  spec.authors       = ["Ian Smith"]
+  spec.email         = ["ian.smith@lookout.com"]
+  spec.description   = %q{A collection of rack utils.}
+  spec.summary       = %q{}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "sinatra"
+  spec.add_development_dependency "timecop"
+
+  spec.add_runtime_dependency "i18n"
+
+  spec.add_dependency "rack"
+  spec.add_dependency "rack-graphite"
+  spec.add_dependency "rack-requestash"
+  spec.add_dependency "configatron"
+  spec.add_dependency "log4r"
+  spec.add_dependency "lookout-statsd", '>= 0.7.0'
+end

data/spec/graphite_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'lookout/rack/utils/graphite'
+
+describe Lookout::Rack::Utils::Graphite do
+  subject(:graphite) { described_class }
+
+  before :each do
+    graphite.instance # Initialize statsd singleton
+    configatron.statsd.stub(:prefix).and_return('test')
+  end
+
+  context 'offers statsd methods' do
+    it { should respond_to :increment }
+    it { should respond_to :decrement }
+    it { should respond_to :timing }
+    it { should respond_to :update_counter }
+  end
+
+  it 'should delegate to statsd' do
+    Statsd.instance.should_receive(:increment).once.with('device.associated')
+    Lookout::Rack::Utils::Graphite.increment('device.associated')
+  end
+end

data/spec/i18n_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'lookout/rack/utils/i18n'
+
+class TestHelper
+  attr_accessor :locale
+  attr_accessor :request
+  attr_accessor :configatron
+
+  include Lookout::Rack::Utils::I18n
+
+  def initialize
+  end
+end
+
+describe Lookout::Rack::Utils::I18n do
+  let(:helper) { TestHelper.new }
+
+  describe '.t' do
+    let(:args) { double('mock arguments') }
+
+    before :each do
+      ::I18n.should_receive(:t).with(args)
+    end
+
+    it 'should call out to ::I18n.t' do
+      helper.t(args)
+    end
+  end
+
+  describe 'accepted_languages' do
+    subject { helper.accepted_languages }
+
+    before :each do
+      helper.request = Object.new
+      helper.request.stub(:env).and_return({'HTTP_ACCEPT_LANGUAGE' => accepted_langs})
+    end    
+
+    context 'if HTTP_ACCEPT_LANGUAGE is not set' do
+      let(:accepted_langs) { nil }
+
+      before :each do
+        helper.configatron = Object.new
+        helper.configatron.stub(:locales).and_return([])
+      end
+
+      it { should be_empty }
+    end
+
+    context 'if HTTP_ACCEPT_LANGUAGE is set' do
+      # Example borrowed from http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+      let(:accepted_langs) { 'da, en-gb;q=0.8, en;q=0.7' }
+      before :each do
+        helper.configatron = Object.new
+        helper.configatron.stub(:locales).and_return(['en'])
+      end
+
+      it { should_not be_empty }
+    end
+  end
+
+  describe '.current_locale' do
+
+    let(:target_locale) { 'target locale' }
+    let(:default_locale) { 'default locale' }
+    let(:accepted_langs) { [target_locale] }
+
+    before :each do
+      helper.stub(:accepted_languages).and_return(accepted_langs)
+    end
+
+    subject (:current_locale) { helper.current_locale }
+
+    context 'if locale is not nil' do
+      before :each do
+        helper.locale = target_locale
+      end
+
+      it { should eql target_locale }
+    end
+    
+    context 'if locale is nil' do
+      context 'if configatron does not contain any of the accepted langs' do
+        before :each do
+          helper.configatron = Object.new
+          helper.configatron.stub(:locales).and_return([])
+          helper.configatron.stub(:default_locale).and_return(default_locale)
+        end
+
+        it { should eql default_locale }
+      end
+
+      context 'if configatron.locales contains one of the accepted languages' do
+        before :each do
+          helper.configatron = Object.new
+          helper.configatron.stub(:locales).and_return([target_locale])
+        end
+
+        it { should eql target_locale }
+      end
+    end
+  end
+end

data/spec/log_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'lookout/rack/utils/log'
+require 'timecop'
+require 'configatron'
+
+describe Lookout::Rack::Utils::Log do
+  subject(:log) { described_class.instance }
+
+  before :all do
+    configatron.logging.enabled = false
+    configatron.logging.file = "log"
+  end
+
+  describe '.debug' do
+    it 'should log a graphite stat' do
+      Lookout::Rack::Utils::Graphite.should_receive(:increment).with('log.debug')
+      log.debug 'foo'
+    end
+  end
+
+  describe '.info' do
+    it 'should log a graphite stat' do
+      Lookout::Rack::Utils::Graphite.should_receive(:increment).with('log.info')
+      log.info 'foo'
+    end
+  end
+
+  describe '.warn' do
+    it 'should log a graphite stat' do
+      Lookout::Rack::Utils::Graphite.should_receive(:increment).with('log.warn')
+      log.warn 'foo'
+    end
+  end
+
+  describe '.error' do
+    it 'should log a graphite stat' do
+      Lookout::Rack::Utils::Graphite.should_receive(:increment).with('log.error')
+      log.error 'foo'
+    end
+  end
+end
+
+describe Lookout::Rack::Utils::Log::LookoutFormatter do
+  subject(:formatter) { described_class.new }
+  let(:logger) do
+    logger = double('Mock Logger')
+    logger.stub(:name).and_return('RSpec Logger')
+    logger.stub(:fullname).and_return('RSpec Logger')
+    logger
+  end
+  let(:project_name) { 'some_project' }
+  let(:basedir) { "/home/rspec/#{project_name}" }
+  let(:tracer) do
+    [
+      "#{basedir}/log.rb:63:in `warn'",
+      "#{basedir}/spec/log_spec.rb:9:in `block (2 levels) in <top (required)>'"
+    ]
+  end
+
+  before :all do
+    # The root logger creates the log levels, so making sure it's been
+    # created
+    Log4r::RootLogger.instance
+  end
+
+
+  before :each do
+    formatter.stub(:basedir).and_return(basedir)
+  end
+
+
+  describe '#event_filename' do
+    subject(:filename) { formatter.event_filename(tracer[1]) }
+
+    context 'with a normal MRI LogEvent' do
+      it { should eql('spec/log_spec.rb:9') }
+    end
+
+    # We have slightly different log formats under packaged .jar files
+    context 'with a LogEvent from a packaged .jar' do
+      let(:tracer) { [nil, "backend/metrics.rb:52:in `runloop'"] }
+      let(:basedir) { 'file:/home/user/source/projects/stuff.jar!/project' }
+
+      it { should eql('backend/metrics.rb:52') }
+    end
+  end
+
+  describe '#format' do
+    before :each do
+      Timecop.freeze
+    end
+
+    after :each do
+      Timecop.return
+    end
+
+    context 'with a valid LogEvent' do
+      # Level 3 is the Log4r "warn" level
+      let(:level) { 3 }
+      let(:data) { 'rspec' }
+      let(:timestamp) { Time.now.utc.iso8601 }
+
+      let(:event) do
+        event = Log4r::LogEvent.new(level, logger, tracer, data)
+      end
+
+      it 'should be properly formatted' do
+        expect(formatter.format(event)).to eql("WARN: #{timestamp}: spec/log_spec.rb:9: #{data}\n")
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib/')
+
+require 'lookout/rack/utils'
+
+require 'rspec'
+
+require 'rack/test'
+
+Dir["./spec/support/**/*.rb"].sort.each do |f|
+  require f
+end
+
+RSpec.configure do |c|
+  c.include(Rack::Test::Methods, :type => :route)
+  c.include(RouteHelpers, :type => :route)
+end

data/spec/subroute_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Lookout::Rack::Utils::Subroute, :type => :route do
+  describe '#subroute' do
+    let(:route) { '/test_route' }
+    let(:original) { get route }
+
+    subject(:subrouted) { get "/subrouted" }
+
+    before :each do
+      class RouteHelpers::Server
+        include Lookout::Rack::Utils::Subroute
+        get '/subrouted' do
+          subroute!('/test_route')
+        end
+      end
+    end
+
+    it 'should return the status code and body of the route' do
+      expect([subrouted.status, subrouted.body]).to eql [original.status, original.body]
+    end
+  end
+
+  describe '#succeeded?' do
+    subject { SubrouteTestHelper.new.succeeded?(status) }
+    context 'with status 200' do
+      let(:status) { 200 }
+      it { should be_true }
+    end
+
+    context 'with status 299' do
+      let(:status) { 299 }
+      it { should be_true }
+    end
+
+    context 'with a non-20x status' do
+      let(:status) { 300 }
+      it { should be_false }
+    end
+  end
+
+  describe '#failed?' do
+    subject { SubrouteTestHelper.new.failed?(status) }
+    context 'with status 200' do
+      let(:status) { 200 }
+      it { should be_false }
+    end
+
+    context 'with status 299' do
+      let(:status) { 299 }
+      it { should be_false }
+    end
+
+    context 'with a non-20x status' do
+      let(:status) { 300 }
+      it { should be_true }
+    end
+  end
+end

data/spec/support/routehelpers.rb

@@ -0,0 +1,13 @@
+require 'sinatra'
+
+module RouteHelpers
+  class Server < Sinatra::Base
+    get '/test_route' do
+      status 200
+    end
+  end
+
+  def app
+    Server.new
+  end
+end

data/spec/support/subroutehelpers.rb

@@ -0,0 +1,5 @@
+require 'lookout/rack/utils/subroute'
+
+class SubrouteTestHelper
+  include Lookout::Rack::Utils::Subroute
+end

metadata

@@ -0,0 +1,254 @@
+--- !ruby/object:Gem::Specification
+name: lookout-rack-utils
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Ian Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  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: sinatra
+  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: timecop
+  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: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-graphite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-requestash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: configatron
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: lookout-statsd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+description: A collection of rack utils.
+email:
+- ian.smith@lookout.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/lookout/rack/utils.rb
+- lib/lookout/rack/utils/graphite.rb
+- lib/lookout/rack/utils/i18n.rb
+- lib/lookout/rack/utils/log.rb
+- lib/lookout/rack/utils/request.rb
+- lib/lookout/rack/utils/subroute.rb
+- lib/lookout/rack/utils/version.rb
+- log
+- lookout-rack-utils.gemspec
+- spec/graphite_spec.rb
+- spec/i18n_spec.rb
+- spec/log_spec.rb
+- spec/spec_helper.rb
+- spec/subroute_spec.rb
+- spec/support/routehelpers.rb
+- spec/support/subroutehelpers.rb
+homepage: ''
+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.5
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- spec/graphite_spec.rb
+- spec/i18n_spec.rb
+- spec/log_spec.rb
+- spec/spec_helper.rb
+- spec/subroute_spec.rb
+- spec/support/routehelpers.rb
+- spec/support/subroutehelpers.rb