justlogging-rails 0.0.1

data/.gitignore

@@ -0,0 +1,16 @@
+*.rbc
+*.sassc
+.sass-cache
+capybara-*.html
+.rspec
+/.bundle
+/vendor/bundle
+/log/*
+/tmp/*
+/db/*.sqlite3
+/public/system/*
+/coverage/
+/spec/tmp/*
+**.orig
+rerun.txt
+pickle-email-*.html

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,103 @@
+PATH
+  remote: .
+  specs:
+    justlogging-rails (0.0.1)
+      activesupport
+      rails
+      rake
+      rspec
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (3.2.7)
+      actionpack (= 3.2.7)
+      mail (~> 2.4.4)
+    actionpack (3.2.7)
+      activemodel (= 3.2.7)
+      activesupport (= 3.2.7)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.3)
+    activemodel (3.2.7)
+      activesupport (= 3.2.7)
+      builder (~> 3.0.0)
+    activerecord (3.2.7)
+      activemodel (= 3.2.7)
+      activesupport (= 3.2.7)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.7)
+      activemodel (= 3.2.7)
+      activesupport (= 3.2.7)
+    activesupport (3.2.7)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    journey (1.0.4)
+    json (1.7.4)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.19)
+    multi_json (1.3.6)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.2.7)
+      actionmailer (= 3.2.7)
+      actionpack (= 3.2.7)
+      activerecord (= 3.2.7)
+      activeresource (= 3.2.7)
+      activesupport (= 3.2.7)
+      bundler (~> 1.0)
+      railties (= 3.2.7)
+    railties (3.2.7)
+      actionpack (= 3.2.7)
+      activesupport (= 3.2.7)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+    sprockets (2.1.3)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.16.0)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  justlogging-rails!

data/README.md

@@ -0,0 +1,2 @@
+justlogging-gem
+===============

data/config/justlogging.yml

@@ -0,0 +1,4 @@
+development:
+  endpoint: "http://localhost:3000/api/1/log_entries"
+  api_key: "abc"
+  active: true

data/doc/justlogging-mongo.markdown

@@ -0,0 +1,15 @@
+
+    module Mongo
+      module Logging
+        alias_method "instrument_without_notification", 'instrument'
+        def instrument(name, payload={})
+          ActiveSupport::Notifications.instrument(
+            'query.mongodb',
+            :query => payload.merge(:method => name)) do
+              send "instrument_without_notification", name, payload do
+                yield
+              end
+          end
+        end
+      end
+    end

data/justlogging-rails.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/justlogging/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Robert Beekman"]
+  gem.email         = ["robert@80beans.com"]
+  gem.description   = %q{The official justlogging.com gem}
+  gem.summary       = %q{Logs rails's notifications to justlogging.com}
+  gem.homepage      = "http://github.com/80beans/justlogging-rails"
+
+  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.name          = "justlogging-rails"
+  gem.require_paths = ["lib"]
+  gem.version       = Justlogging::VERSION
+
+  gem.add_dependency 'rails'
+  gem.add_dependency 'rspec'
+  gem.add_dependency 'activesupport'
+  gem.add_dependency 'rake'
+end

data/lib/justlogging/agent.rb

@@ -0,0 +1,68 @@
+module Justlogging
+
+  class Agent
+
+    attr_reader :queue, :active, :sleep_time
+
+    def initialize
+      @sleep_time = 5
+      @queue = []
+      @active = true
+      @thread = Thread.new do
+        while true do
+          if (@queue.any? && @active == true)
+            send_queue
+          end
+          sleep @sleep_time
+        end
+      end
+    end
+
+    def add_to_queue(transaction)
+      @queue << transaction
+    end
+
+    def uri
+      URI(Justlogging.config[:endpoint])
+    end
+
+    def http_client
+      Net::HTTP.new(uri.host, uri.port).tap do |http|
+        if uri.scheme == 'https'
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+      end
+    end
+
+    def send_queue
+      json = ActiveSupport::JSON.encode @queue
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.set_form_data('api_key' => Justlogging.config[:api_key], 'log_entries' => json)
+
+      begin
+        result = http_client.request(request)
+        code = result.code
+      rescue
+        code = nil
+      end
+      handle_result(code)
+    end
+
+    # Empty queue is result is 200 ok.
+    # Throttle connection when result is 403
+    # Unsubscribe and stop sending all together on any other code.
+    def handle_result(code)
+      if code == '200'
+        @queue = []
+      elsif code == '403'
+        @sleep_time = @sleep_time * 1.5
+      else
+        ActiveSupport::Notifications.unsubscribe(Justlogging.subscriber)
+        @active = false
+      end
+    end
+
+  end
+
+end

data/lib/justlogging/exception_notification.rb

@@ -0,0 +1,29 @@
+module Justlogging
+  class MissingController
+    def method_missing(*args, &block)
+    end
+  end
+
+  class ExceptionNotification
+
+    attr_reader :env, :exception, :kontroller, :request, :backtrace
+
+    def initialize(env, exception)
+      #@env        = env
+      @exception  = exception
+      #@kontroller = env['action_controller.instance'] || Justlogging::MissingController.new
+      #@request    = ActionDispatch::Request.new(env)
+      @backtrace  = Rails.respond_to?(:backtrace_cleaner) ?
+          Rails.backtrace_cleaner.send(:filter, exception.backtrace) :
+          exception.backtrace
+    end
+
+    def name
+      @exception.class.name
+    end
+
+    def message
+      @exception.message
+    end
+  end
+end

data/lib/justlogging/middleware.rb

@@ -0,0 +1,25 @@
+require 'action_dispatch'
+
+module Justlogging
+  class Middleware
+
+    def initialize(app, options = {})
+      @app, @options = app, options
+    end
+
+    def call(env)
+      Justlogging::Transaction.create(env['action_dispatch.request_id'], env)
+      @app.call(env)
+    rescue Exception => exception
+      unless Array.wrap(Justlogging.config[:ignore_exceptions]).include?(exception.class.name)
+        Justlogging::Transaction.current.add_exception(
+          Justlogging::ExceptionNotification.new(env, exception)
+        )
+      end
+      raise exception
+    ensure
+      Justlogging::Transaction.current.complete!
+    end
+
+  end
+end

data/lib/justlogging/railtie.rb

@@ -0,0 +1,20 @@
+require 'justlogging'
+
+module Justlogging
+  class Railtie < Rails::Railtie
+
+    initializer "justlogging.configure_rails_initialization" do |app|
+      app.middleware.insert_after ActionDispatch::DebugExceptions, Justlogging::Middleware
+
+      Justlogging.subscriber = ActiveSupport::Notifications.subscribe do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        if event.name == 'process_action.action_controller'
+          Justlogging::Transaction.current.set_log_entry(event)
+        else
+          Justlogging::Transaction.current.add_event(event)
+        end
+      end
+    end
+
+  end
+end

data/lib/justlogging/transaction.rb

@@ -0,0 +1,91 @@
+module Justlogging
+  class Transaction
+
+    def self.create(key, env)
+      Thread.current[:justlogging_transaction_id] = key
+      Justlogging.transactions[key] = Justlogging::Transaction.new(key, env)
+    end
+
+    def self.current
+      Justlogging.transactions[Thread.current[:justlogging_transaction_id]]
+    end
+
+    attr_reader :id, :events, :exception, :env, :log_entry
+
+    def initialize(id, env)
+      @id = id
+      @events = []
+      @log_entry = nil
+      @exception = nil
+      @env = env
+    end
+
+    def request
+      ActionDispatch::Request.new(@env)
+    end
+
+    def set_log_entry(event)
+      @log_entry = event
+    end
+
+    def add_event(event)
+      @events << event
+    end
+
+    def add_exception(ex)
+      @exception = ex
+    end
+
+    def formatted_exception
+      return {} unless @exception
+      {
+        :backtrace => @exception.backtrace,
+        :exception => @exception.name,
+        :message => @exception.message
+      }
+    end
+
+    def formatted_events
+      @events.map do |event|
+        {
+          :name => event.name,
+          :duration => event.duration,
+          :time => event.time,
+          :end => event.end,
+          :payload => event.payload
+        }
+      end
+    end
+
+    def formatted_log_entry
+      @log_entry.payload.merge(
+        :duration => @log_entry.duration,
+        :time => @log_entry.time,
+        :end => @log_entry.end,
+        :name => request.fullpath,
+        :environment => Rails.env,
+        :server => @env['SERVER_NAME']
+      )
+    end
+
+    def to_hash
+      {
+        :request_id => @id,
+        :log_entry => formatted_log_entry,
+        :events => formatted_events,
+        :exception => formatted_exception,
+        :failed => exception.present?
+      }
+    end
+
+    def complete!
+      Thread.current[:justlogging_transaction_id] = nil
+      current_transaction = Justlogging.transactions.delete(@id)
+      if @events.any? || @exception.present?
+        Justlogging.agent.add_to_queue(
+          current_transaction.to_hash
+        )
+      end
+    end
+  end
+end

data/lib/justlogging/version.rb

@@ -0,0 +1,3 @@
+module Justlogging
+  VERSION = '0.0.1'
+end

data/lib/justlogging.rb

@@ -0,0 +1,30 @@
+raise 'This justlogging gem only works with rails' unless defined?(Rails)
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+module Justlogging
+
+  class << self
+    attr_accessor :subscriber
+
+    def transactions
+      @transactions ||= {}
+    end
+
+    def agent
+      @agent ||= Justlogging::Agent.new
+    end
+
+    def config
+      @config ||= {:ignore_exceptions => []}.merge(YAML.load_file("#{Rails.root}/config/justlogging.yml")[Rails.env].symbolize_keys)
+    end
+  end
+
+end
+
+require 'justlogging/agent'
+require 'justlogging/middleware'
+require 'justlogging/transaction'
+require 'justlogging/exception_notification'
+require 'justlogging/version'

data/spec/justlogging/agent_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Justlogging::Agent do
+  before :each do
+    Thread.stub(:new)
+  end
+
+  let(:agent) { Justlogging::Agent.new }
+  let(:event) { stub(:name => 'event') }
+
+  describe '#add_to_queue' do
+    it 'should add the event to the queue' do
+      expect {
+        agent.add_to_queue(event)
+      }.to change(agent, :queue).to([event])
+    end
+  end
+
+  describe '#send_queue' do
+    before do
+      agent.add_to_queue(event)
+      ActiveSupport::JSON.stub(:encode => '{"abc":"def"}')
+      Net::HTTP.stub(:post_form).and_return(stub(:code => '200'))
+    end
+
+    it 'should call Net::HTTP.post_form with the correct params' do
+      Net::HTTP.should_receive(:post_form).with(
+        URI('http://localhost:3000/api/1/log_entries'),
+        'api_key' => 'abc',
+        'log_entries' => '{"abc":"def"}'
+      ).and_return(stub(:code => '200'))
+    end
+
+    it "should call handle_result" do
+      agent.should_receive(:handle_result).with('200')
+    end
+
+    after { agent.send_queue }
+  end
+
+  describe '#handle_result' do
+    before do
+      agent.add_to_queue(event)
+    end
+
+    it "should empty the queue for 200" do
+      expect {
+        agent.handle_result('200')
+      }.to change(agent, :queue).to([])
+    end
+
+    it "should raise the sleep_time time for 403" do
+      expect {
+        agent.handle_result('403')
+      }.to change(agent, :sleep_time).to(7.5)
+    end
+
+    context "any other response" do
+
+      it "should deactivate for any other response code" do
+        expect {
+          agent.handle_result('500')
+        }.to change(agent, :active).to(false)
+      end
+
+      it "should unsubscribe from the justlogging subscriber" do
+        ActiveSupport::Notifications.should_receive(:unsubscribe)
+        agent.handle_result('500')
+      end
+    end
+
+  end
+
+end

data/spec/justlogging/exception_notification_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Justlogging::ExceptionNotification do
+  before { Rails.stub(:respond_to? => false) }
+  let(:error) { StandardError.new('moo') }
+  let(:notification) { Justlogging::ExceptionNotification.new({}, error) }
+  subject { notification }
+
+  its(:exception) { should == error }
+  its(:name) { should == 'StandardError' }
+  its(:message) { should == 'moo' }
+end

data/spec/justlogging/middleware_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Justlogging
+  class IgnoreMeError < StandardError
+  end
+end
+
+class AppWithError
+
+  def self.call(env)
+    raise Justlogging::IgnoreMeError, 'the roof'
+  end
+end
+
+describe Justlogging::Middleware do
+
+  describe '#call' do
+    let(:app) { stub(:call => true) }
+    let(:env) { {'action_dispatch.request_id' => '1'} }
+    let(:middleware) { Justlogging::Middleware.new(app, {})}
+    let(:current) { stub(:complete! => true, :add_exception => true) }
+    before { Justlogging::Transaction.stub(:current => current) }
+
+    describe 'around call' do
+
+      it 'should call justlogging transaction' do
+        Justlogging::Transaction.should_receive(:create).with('1', env)
+      end
+
+      it 'should call complete! after the call' do
+        current.should_receive(:complete!)
+      end
+
+      after { middleware.call(env) }
+    end
+
+    describe 'with exception' do
+      let(:app) { AppWithError }
+
+      it 'should re-raise the exception' do
+        expect {
+          middleware.call(env)
+        }.to raise_error
+      end
+
+      it 'should catch the exception and notify the transaction of it' do
+        Justlogging::ExceptionNotification.should_receive(:new)
+        current.should_receive(:add_exception)
+        middleware.call(env) rescue nil
+      end
+
+      context 'when ignoring exception' do
+        before { Justlogging.stub(:config => {:ignore_exceptions => 'Justlogging::IgnoreMeError'})}
+
+        it 'should re-raise the exception' do
+          expect {
+            middleware.call(env)
+          }.to raise_error
+        end
+
+        it 'should ignore the error' do
+          Justlogging::ExceptionNotification.should_not_receive(:new)
+          current.should_not_receive(:add_exception)
+          middleware.call(env) rescue nil
+        end
+
+      end
+
+      describe 'after an error' do
+
+        it 'should call complete! after the call' do
+          current.should_receive(:complete!)
+        end
+
+        after { middleware.call(env) rescue nil }
+      end
+    end
+
+  end
+end

data/spec/justlogging/railtie_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'action_controller/railtie'
+require 'justlogging/railtie'
+
+describe Justlogging::Railtie do
+
+  before :all do
+    MyApp::Application.initialize!
+  end
+
+  it "should have set the justlogging subscriber" do
+    Justlogging.subscriber.should be_a ActiveSupport::Notifications::Fanout::Subscriber
+  end
+
+  it "should have added the middleware for exceptions" do
+    MyApp::Application.middleware.middlewares.should include Justlogging::Middleware
+  end
+
+  context "non action_controller event" do
+
+    it "should call add_event for non action_controller event" do
+      current = stub
+      current.should_receive(:add_event)
+      Justlogging::Transaction.should_receive(:current).and_return(current)
+    end
+
+    after do
+      ActiveSupport::Notifications.instrument 'query.mongoid'
+    end
+
+  end
+
+  context "action_controller event" do
+
+    it "should call set_log_entry for action_controller event" do
+      current = stub
+      current.should_receive(:set_log_entry)
+      Justlogging::Transaction.should_receive(:current).and_return(current)
+    end
+
+    after do
+      ActiveSupport::Notifications.instrument 'process_action.action_controller'
+    end
+
+  end
+
+end

data/spec/justlogging/transaction_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe Justlogging::Transaction do
+
+  describe '.create' do
+    before { Justlogging::Transaction.create('1', {}) }
+
+    it 'should add the id to the thread' do
+      Thread.current[:justlogging_transaction_id].should == '1'
+    end
+
+    it 'should add the transaction to the list' do
+      Justlogging.transactions['1'].should be_a Justlogging::Transaction
+    end
+  end
+
+  describe '.current' do
+    let(:transaction) { Justlogging::Transaction.create('1', {}) }
+    before { transaction }
+    subject { Justlogging::Transaction.current }
+
+    it 'should return the correct transaction' do
+      should eq transaction
+    end
+  end
+
+  describe 'transaction instance' do
+    let(:transaction) { Justlogging::Transaction.create('1', {'SERVER_NAME' => 'localhost'}) }
+
+    describe '#request' do
+      subject { transaction.request }
+
+      it { should be_a ActionDispatch::Request }
+    end
+
+    describe '#set_log_entry' do
+      let(:log_entry) {stub(:name => 'test') }
+
+      it 'should add a log entry' do
+        expect {
+          transaction.set_log_entry(log_entry)
+        }.to change(transaction, :log_entry).to(log_entry)
+      end
+    end
+
+    describe '#add_exception' do
+      let(:exception) {stub(:name => 'test') }
+
+      it 'should add an exception' do
+        expect {
+          transaction.add_exception(exception)
+        }.to change(transaction, :exception).to(exception)
+      end
+    end
+
+    describe '#add_event' do
+      let(:event) {stub(:name => 'test') }
+
+      it 'should add a log entry' do
+        expect {
+          transaction.add_event(event)
+        }.to change(transaction, :events).to([event])
+      end
+    end
+
+    describe '#formatted_exception' do
+      let(:exception) { stub(:backtrace => ['test'], :name => 'Justlogging::Error', :message => 'nooo') }
+
+      before { transaction.add_exception(exception) }
+
+      subject { transaction.formatted_exception }
+
+      it 'should return a formatted exception' do
+        should == {
+          :backtrace => ['test'],
+          :exception => 'Justlogging::Error',
+          :message => 'nooo'
+        }
+      end
+    end
+
+    describe '#formatted_events' do
+      let(:start_time) { Time.parse('01-01-2001 10:00:00') }
+      let(:end_time) { Time.parse('01-01-2001 10:00:01') }
+      let(:event) { stub(:name => 'name', :duration => 2, :time => start_time, :end => end_time, :payload => {}) }
+
+      before { transaction.add_event(event) }
+
+      subject { transaction.formatted_events }
+
+      it 'should return formatted events' do
+        should == [{:name=>'name', :duration=>2, :time=>start_time, :end=>end_time, :payload=>{}}]
+      end
+    end
+
+    describe '#formatted_log_entry' do
+      let(:start_time) { Time.parse('01-01-2001 10:00:00') }
+      let(:end_time) { Time.parse('01-01-2001 10:00:01') }
+      let(:log_entry) { stub(:name => 'name', :duration => 2, :time => start_time, :end => end_time, :payload => {:controller => 'JustSayinController'}) }
+      let(:request) { stub(:fullpath => '/blog') }
+
+      before { transaction.stub(:request => request) }
+      before { transaction.set_log_entry(log_entry) }
+
+      subject { transaction.formatted_log_entry }
+
+      it 'should return formatted log_entry' do
+        should == {
+          :controller => 'JustSayinController',
+          :duration => 2,
+          :time => start_time,
+          :end => end_time,
+          :name => '/blog',
+          :environment => "development",
+          :server => 'localhost'
+        }
+      end
+    end
+
+    describe '#to_hash' do
+      before { transaction.stub(
+        :formatted_log_entry => {:name => 'log_entry'},
+        :formatted_events => [{:name => 'event'}],
+        :formatted_exception => {:name => 'exception'},
+        :failed => false
+      )}
+
+      subject { transaction.to_hash }
+
+      it 'should return a formatted hash of the transaction data' do
+        should == {
+          :request_id => '1',
+          :log_entry => {:name => 'log_entry'},
+          :events => [{:name => 'event'}],
+          :exception => {:name => 'exception'},
+          :failed => false
+        }
+      end
+    end
+
+    describe '#complete!' do
+      before { transaction }
+
+      it 'should remove transaction from the queue' do
+        expect {
+          transaction.complete!
+        }.to change(Justlogging.transactions, :length).by(-1)
+      end
+
+      context 'calling the justlogging agent' do
+
+        context 'without events and exception' do
+          it 'should not add transaction to the agent' do
+            Justlogging.agent.should_not_receive(:add_to_queue)
+          end
+        end
+
+        context 'with events' do
+          before { transaction.add_event(stub) }
+          before { transaction.stub(:to_hash => {})}
+
+          it 'should add transaction to the agent' do
+            Justlogging.agent.should_receive(:add_to_queue)
+          end
+        end
+
+        context 'with exception' do
+          before { transaction.add_exception(stub) }
+          before { transaction.stub(:to_hash => {})}
+
+          it 'should add transaction to the agent' do
+            Justlogging.agent.should_receive(:add_to_queue)
+          end
+        end
+
+        after { transaction.complete! }
+      end
+
+      context 'thread' do
+        before { transaction.complete! }
+
+        it 'should reset the thread transaction id' do
+          Thread.current[:justlogging_transaction_id].should be_nil
+        end
+      end
+
+    end
+  end
+
+end

data/spec/justlogging_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Justlogging do
+
+  it { should respond_to :subscriber }
+
+  describe ".transactions" do
+    subject { Justlogging.transactions }
+
+    it { should be_a Hash }
+  end
+
+  describe '.agent' do
+    subject { Justlogging.agent }
+
+    it { should be_a Justlogging::Agent }
+  end
+
+  describe '.config' do
+    subject { Justlogging.config }
+
+    it 'should return the endpoint' do
+      subject[:endpoint].should eq 'http://localhost:3000/api/1/log_entries'
+    end
+
+    it 'should return the api key' do
+      subject[:api_key].should eq 'abc'
+    end
+
+    it 'should return ignored exceptions' do
+      subject[:ignore_exceptions].should eq []
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'rspec'
+require 'rails'
+
+module Rails
+  class Application
+  end
+end
+
+module MyApp
+  class Application < Rails::Application
+    config.active_support.deprecation = proc { |message, stack| }
+
+  end
+end
+
+require 'justlogging'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: justlogging-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Robert Beekman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: rspec
+  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: activesupport
+  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: rake
+  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: The official justlogging.com gem
+email:
+- robert@80beans.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- !binary |-
+  LmdpdGlnbm9yZQ==
+- !binary |-
+  LnJ2bXJj
+- !binary |-
+  R2VtZmlsZQ==
+- !binary |-
+  R2VtZmlsZS5sb2Nr
+- !binary |-
+  UkVBRE1FLm1k
+- !binary |-
+  Y29uZmlnL2p1c3Rsb2dnaW5nLnltbA==
+- !binary |-
+  ZG9jL2p1c3Rsb2dnaW5nLW1vbmdvLm1hcmtkb3du
+- !binary |-
+  anVzdGxvZ2dpbmctcmFpbHMuZ2Vtc3BlYw==
+- !binary |-
+  bGliL2p1c3Rsb2dnaW5nLnJi
+- !binary |-
+  bGliL2p1c3Rsb2dnaW5nL2FnZW50LnJi
+- !binary |-
+  bGliL2p1c3Rsb2dnaW5nL2V4Y2VwdGlvbl9ub3RpZmljYXRpb24ucmI=
+- !binary |-
+  bGliL2p1c3Rsb2dnaW5nL21pZGRsZXdhcmUucmI=
+- !binary |-
+  bGliL2p1c3Rsb2dnaW5nL3JhaWx0aWUucmI=
+- !binary |-
+  bGliL2p1c3Rsb2dnaW5nL3RyYW5zYWN0aW9uLnJi
+- !binary |-
+  bGliL2p1c3Rsb2dnaW5nL3ZlcnNpb24ucmI=
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy9hZ2VudF9zcGVjLnJi
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy9leGNlcHRpb25fbm90aWZpY2F0aW9uX3NwZWMu
+  cmI=
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy9taWRkbGV3YXJlX3NwZWMucmI=
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy9yYWlsdGllX3NwZWMucmI=
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy90cmFuc2FjdGlvbl9zcGVjLnJi
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZ19zcGVjLnJi
+- !binary |-
+  c3BlYy9zcGVjX2hlbHBlci5yYg==
+homepage: http://github.com/80beans/justlogging-rails
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Logs rails's notifications to justlogging.com
+test_files:
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy9hZ2VudF9zcGVjLnJi
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy9leGNlcHRpb25fbm90aWZpY2F0aW9uX3NwZWMu
+  cmI=
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy9taWRkbGV3YXJlX3NwZWMucmI=
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy9yYWlsdGllX3NwZWMucmI=
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZy90cmFuc2FjdGlvbl9zcGVjLnJi
+- !binary |-
+  c3BlYy9qdXN0bG9nZ2luZ19zcGVjLnJi
+- !binary |-
+  c3BlYy9zcGVjX2hlbHBlci5yYg==