flyingmachine-merb_whoops_notifier 1.0

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2008 Corey Donohoe<atmos@atmos.org>, Joakim Kolsjö<trejje@gmail.com>,
+Daniel Higginbotham<daniel@flyingmachinestudios.com>
+
+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

@@ -0,0 +1,59 @@
+merb_whoops_notifier
+---------------------------------------------
+This is merb plugin for exception notification with whoops. It should work with
+any merb app that's based on merb 1.0 and higher
+
+This plugin: http://github.com/atmos/merb_whoops_notifier/tree/master
+The original: http://github.com/thoughtbot/whoops_notifier/tree/master
+
+Usage:
+
+1) Get your api key for your app from whoopsapp.com
+
+2) Add the api key to config/whoops.yml with a similar syntax as the following
+---
+:development: &defaults
+  :api_key: ZOMGLOLROFLMAO
+
+:rake:
+  <<: *defaults
+
+:test:
+  <<: *defaults
+
+:production:
+  :api_key: UBERSECRETSHIT
+
+
+3) Require whoops in init.rb
+require 'merb_whoops_notifier'
+
+4) Add the following method to your Exceptions controller.  Depending on your merb version you'll need to use the exceptions,standard_error, or internal_server error as the action name.  Kinda weak, but the API changed a lot in 0.9.x
+
+class Exceptions < Merb::Controller
+  if %w( staging production ).include?(Merb.env)
+    def standard_error
+      WhoopsNotifier.notify_whoops(request, session)
+      render
+    end
+  end
+end
+
+5) Restart the server, trigger an error(in staging or prod) and check that it arrived at whoops :)
+
+
+Filtersing your post environment
+--------------------------------
+If you have environmental variables set in your ruby process that should not be sent to whoops,
+there's a mechanism for filtering those attributes now.  Throw something like this in 
+config/init.rb
+
+Merb::BootLoader.after_app_loads do
+  WhoopsNotifier.environment_filters = %w(^AWS ^EC2 SECRET PRIVATE KEY)
+end
+
+Each of these words will be compiled into a regex so you should be able to use anchors if needed.
+
+Thanks to the following GitHubbers
+----------------------------------
+joakimk, fairchild and cv.

data/Rakefile

@@ -0,0 +1,74 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'merb-core/version'
+require 'merb-core/tasks/merb_rake_helper'
+require 'spec/rake/spectask'
+
+install_home = ENV['GEM_HOME'] ? "-i #{ENV['GEM_HOME']}" : ""
+ 
+def sudo
+  windows = (PLATFORM =~ /win32|cygwin/) rescue nil
+  ENV['MERB_SUDO'] ||= "sudo"
+  sudo = windows ? "" : ENV['MERB_SUDO']
+end
+
+NAME = "merb_whoops_notifier"
+GEM_VERSION = "1.0"
+AUTHOR = "Daniel Higginbotham"
+EMAIL = 'daniel@flyingmachinestudios.com'
+HOMEPAGE = "http://github.com/flyingmachine/merb_whoops_notifier"
+SUMMARY = "Merb plugin that provides whoops exception notification"
+
+spec = Gem::Specification.new do |s|
+  s.rubyforge_project = 'merb'
+  s.name = NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency('merb-core', '>= 1.0.9')
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the plugin locally"
+task :install => [:package] do
+  sh %{#{sudo} gem install #{install_home} pkg/#{NAME}-#{GEM_VERSION} --no-update-sources}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+namespace :jruby do
+  desc "Run :package and install the resulting .gem with jruby"
+  task :install => :package do
+    sh %{#{sudo} jruby -S gem install #{install_home} pkg/#{NAME}-#{GEM_VERSION}.gem --no-rdoc --no-ri}
+  end
+end
+
+Spec::Rake::SpecTask.new(:default) do |t|
+  t.spec_opts << %w(-fs --color) << %w(-O spec/spec.opts)
+  t.spec_opts << '--loadby' << 'random'
+  t.spec_files = Dir["spec/*_spec.rb"]
+  t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+  t.rcov_opts << '--exclude' << '.gem/'
+  
+  t.rcov_opts << '--text-summary'
+  t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  t.rcov_opts << '--only-uncovered'
+end

data/TODO

@@ -0,0 +1,2 @@
+TODO:
+See if there's any more rich information we could provide to whoops

data/lib/merb_whoops_notifier/merbtasks.rb

@@ -0,0 +1,2 @@
+namespace :merb_whoops_notifier do
+end

data/lib/merb_whoops_notifier/whoops_mixin.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__)+'/whoops_notifier')
+
+module WhoopsMixin
+  def notify_whoops(request=nil, session=nil)
+    request ||= self.request
+    session ||= self.session
+    
+    WhoopsNotifier.notify_whoops(request, session)
+  end
+  
+  def warn_whoops(message, request=nil, session=nil, options={})
+    request ||= self.request
+    session ||= self.session
+    
+    WhoopsNotifier.warn_whoops(message, request, session, options)
+  end
+end

data/lib/merb_whoops_notifier/whoops_notifier.rb

@@ -0,0 +1,144 @@
+require 'net/http'
+
+module WhoopsNotifier
+  class << self
+    attr_accessor :host, :logger
+
+    def configure
+      key = YAML.load_file(Merb.root / 'config' / 'whoops.yml')
+      if key
+        env = key[Merb.env.to_sym]
+        env ? @host = env[:host] : raise(ArgumentError, "No whoops host for Merb environment #{Merb.env}")
+      end
+    end
+
+    def logger
+      @logger || Merb.logger
+    end
+
+    def environment_filters
+      @environment_filters ||= %w(AWS_ACCESS_KEY  AWS_SECRET_ACCESS_KEY AWS_ACCOUNT SSH_AUTH_SOCK)
+    end
+
+    def warn_whoops(message, request, session, options={})
+      return if request.nil?
+      params = request.params
+
+      data = {
+        :error_class   => options[:error_class] || message,
+        :error_message => message,
+        :backtrace     => caller,
+        :environment   => ENV.to_hash
+      }
+
+      data[:request] = {
+        :params => params
+      }
+
+      data[:environment] = clean_whoops_environment(ENV.to_hash.merge(request.env))
+      data[:environment][:RAILS_ENV] = Merb.env
+
+      data[:session] = {
+         :key         => session.instance_variable_get("@session_id"),
+         :data        => session.to_hash
+      }
+
+      send_to_whoops :notice => default_notice_options.merge(data)
+      true
+    end
+    
+    def notify_whoops(request, session)
+      return if request.nil?
+      params = request.params
+
+      request.exceptions.each do |exception|
+        data = {
+          :error_class   => Extlib::Inflection.camelize(exception.class.name),
+          :error_message => "#{Extlib::Inflection.camelize(exception.class.name)}: #{exception.message}",
+          :backtrace     => exception.backtrace,
+          :environment   => ENV.to_hash
+        }
+
+        data[:request] = {
+          :params => params
+        }
+
+        data[:environment] = clean_whoops_environment(ENV.to_hash.merge(request.env))
+        data[:environment][:RAILS_ENV] = Merb.env
+
+        data[:session] = {
+           :key         => session.instance_variable_get("@session_id"),
+           :data        => session.to_hash
+        }
+
+        send_to_whoops :notice => default_notice_options.merge(data)
+      end
+      true
+    end
+
+    def send_to_whoops(data) #:nodoc:
+      url = URI.parse(WhoopsNotifier.host)
+
+      Net::HTTP.start(url.host, url.port) do |http|
+        headers = {
+          'Content-type' => 'application/x-yaml',
+          'Accept' => 'text/xml, application/xml'
+        }
+        http.read_timeout = 5 # seconds
+        http.open_timeout = 2 # seconds
+        # http.use_ssl = WhoopsNotifier.secure
+        response = begin
+                     http.post("/error_reports", clean_non_serializable_data(data).to_yaml, headers)
+                   rescue TimeoutError => e
+                     logger.error "Timeout while contacting the Whoops server."
+                     nil
+                   end
+        case response
+        when Net::HTTPSuccess then
+          logger.info "Whoops Success: #{response.class}"
+        else
+          logger.error "Whoops Failure: #{response.class}\n#{response.body if response.respond_to? :body}"
+        end
+      end            
+    end
+    
+    def default_notice_options #:nodoc:
+      {
+        :error_message => 'Notification',
+        :backtrace     => nil,
+        :request       => {},
+        :session       => {},
+        :environment   => {}
+      }
+    end     
+    
+    def clean_non_serializable_data(notice) #:nodoc:
+      notice.select{|k,v| serializable?(v) }.inject({}) do |h, pair|
+        h[pair.first] = pair.last.is_a?(Hash) ? clean_non_serializable_data(pair.last) : pair.last
+        h
+      end
+    end
+
+    def serializable?(value) #:nodoc:
+      value.is_a?(Fixnum) || 
+      value.is_a?(Array)  || 
+      value.is_a?(String) || 
+      value.is_a?(Hash)   || 
+      value.is_a?(Bignum)
+    end
+
+    def stringify_keys(hash) #:nodoc:
+      hash.inject({}) do |h, pair|
+        h[pair.first.to_s] = pair.last.is_a?(Hash) ? stringify_keys(pair.last) : pair.last
+        h
+      end
+    end
+    def clean_whoops_environment(env) #:nodoc:
+      env.each do |k, v|
+        env[k] = "[FILTERED]" if WhoopsNotifier.environment_filters.any? do |filter|
+          k.to_s.match(/#{filter}/)
+        end
+      end
+    end
+  end
+end

data/lib/merb_whoops_notifier.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__)+'/merb_whoops_notifier/whoops_notifier')
+require File.expand_path(File.dirname(__FILE__)+'/merb_whoops_notifier/whoops_mixin')
+
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+  Merb::BootLoader.after_app_loads do
+    WhoopsNotifier.configure
+  end
+  Merb::Plugins.add_rakefiles "merb_whoops_notifier/merbtasks"
+end

data/spec/fixtures/whoops.yml

@@ -0,0 +1,9 @@
+---
+:development: &defaults
+  :host: http://localhost:3000/
+
+:test:
+  <<: *defaults
+
+:production:
+  <<: *defaults

data/spec/merb_whoops_notifier_spec.rb

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "WhoopsNotifier" do
+  include Merb::Spec::Helpers
+
+  before(:each) do
+    stub(Merb).env { :production }
+    stub(Merb).root { Dir.tmpdir }
+
+    @http = Net::HTTP.new('localhost')
+    @headers = { "Content-type" => "application/x-yaml", "Accept" => "text/xml, application/xml" }
+    host = "http://localhost:3000/"
+    @config = {:development => {:host=>host}, :production => {:host=>host}, :test => {:host=>host}}
+  end
+
+  it "should define a constant" do
+    WhoopsNotifier.should_not be_nil
+  end
+
+  describe ".configure" do
+    before(:each) do
+      mock(YAML).load_file(File.join(Merb.root / 'config' / 'whoops.yml')) { @config }
+      WhoopsNotifier.configure
+    end
+    it "should know the host key after configuring" do
+      WhoopsNotifier.host.should == 'http://localhost:3000/'
+    end
+  end
+
+  describe ".stringify_key" do
+    it "should turn string keys into symbols" do
+      WhoopsNotifier.stringify_keys({'foo' => 'bar', :baz => 'foo', :bar => 'foo'}).should == { 'foo' => 'bar', 'baz' => 'foo', 'bar' => 'foo'}
+    end
+  end
+
+
+  describe "notification" do
+    before(:each) do
+      stub(Net::HTTP).new('localhost', 3000, nil, nil, nil, nil) { @http }
+      mock(YAML).load_file(File.join(Merb.root / 'config' / 'whoops.yml')) { @config }
+      WhoopsNotifier.configure
+    end
+
+    describe ".default_notice_options" do
+      it "should return sane defaults" do
+        WhoopsNotifier.default_notice_options.should == {
+          :error_message => 'Notification',
+          :backtrace     => nil,
+          :request       => {},
+          :session       => {},
+          :environment   => {}
+        }
+      end
+    end
+
+    describe ".notify_whoops" do
+      describe "bad input" do
+        it "should handle nil input" do
+          WhoopsNotifier.notify_whoops(nil, nil).should be_nil
+        end
+      end
+
+      describe "good input" do
+        before(:each) do
+          mock(WhoopsNotifier).send_to_whoops(anything).times(2) { true }
+          @request = setup_merb_request
+          mock(@request).exceptions { [RuntimeError.new('ZOMG'), RuntimeError.new('ORLY')]}
+          mock(@request).params { {"q"=>"0017000000SmnJ0"} }
+        end
+        it "should return true" do
+          WhoopsNotifier.notify_whoops(@request, {}).should be_true
+        end
+      end
+    end
+
+    describe ".send_to_whoops" do
+      describe "any 2XX response" do
+        before(:each) do
+          response = Net::HTTPOK.new('1.1', 200, 'Wazzup?')
+          mock(@http).post("/error_reports", "--- {}\n\n", @headers) { response }
+        end
+        it "should log success" do
+          mock(WhoopsNotifier.logger).info "Whoops Success: Net::HTTPOK"
+          WhoopsNotifier.send_to_whoops({})
+        end
+      end
+      describe "any non 2XX response" do
+        before(:each) do
+          response = Net::HTTPInternalServerError.new('1.1', 500, 'Upstream unavailable')
+          mock(response).body { 'Upstream unavailable' }
+
+          stub(@http.instance_variable_get('@socket')).closed? { true }
+          mock(@http).post("/error_reports", "--- {}\n\n", @headers) { response }
+        end
+        it "should log failure" do
+          mock(WhoopsNotifier.logger).error "Whoops Failure: Net::HTTPInternalServerError\nUpstream unavailable"
+          WhoopsNotifier.send_to_whoops({})
+        end
+      end
+      describe "a timeout exception is thrown" do
+        before(:each) do
+          response = TimeoutError.new("It took too fucking long")
+          mock(@http).post("/error_reports", "--- {}\n\n", @headers) { raise response }
+        end
+        it "should log failure" do
+          mock(WhoopsNotifier.logger).error("Whoops Failure: NilClass\n")
+          mock(WhoopsNotifier.logger).error("Timeout while contacting the Whoops server.")
+          WhoopsNotifier.send_to_whoops({})
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rr'
+require 'merb-core'
+require 'merb_whoops_notifier'
+require 'tmpdir'
+require 'pp'
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end
+
+module Merb
+  module Spec
+    module Helpers
+      def setup_merb_request
+        rack_env = {"SERVER_NAME"=>"localhost",
+          "rack.run_once"=>false, "rack.url_scheme"=>"http", "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_5; en-us) AppleWebKit/526.1+ (KHTML, like Gecko) Version/3.1.2 Safari/525.20.1", 
+          "HTTP_ACCEPT_ENCODING"=>"gzip, deflate", "PATH_INFO"=>"/search/", "HTTP_CACHE_CONTROL"=>"max-age=0", 
+          "HTTP_ACCEPT_LANGUAGE"=>"en-us", "HTTP_HOST"=>"localhost:4000", "SERVER_PROTOCOL"=>"HTTP/1.1", "SCRIPT_NAME"=>"", 
+          "REQUEST_PATH"=>"/search/", "SERVER_SOFTWARE"=>"Mongrel 1.1.5", "REMOTE_ADDR"=>"127.0.0.1", "rack.streaming"=>true, 
+          "rack.version"=>[0, 1], "rack.multithread"=>true, "HTTP_VERSION"=>"HTTP/1.1", "rack.multiprocess"=>false, 
+          "REQUEST_URI"=>"/search/?q=0017000000SmnJ0", "SERVER_PORT"=>"4000", "QUERY_STRING"=>"q=0017000000SmnJ0", 
+          "GATEWAY_INTERFACE"=>"CGI/1.2", "HTTP_ACCEPT"=>"text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5", 
+          "REQUEST_METHOD"=>"GET", "HTTP_CONNECTION"=>"keep-alive"}
+
+        request = Merb::Request.new(rack_env)
+        stub(request).env { rack_env }
+        request
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: flyingmachine-merb_whoops_notifier
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Daniel Higginbotham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-03 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.9
+    version: 
+description: Merb plugin that provides whoops exception notification
+email: daniel@flyingmachinestudios.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/merb_whoops_notifier
+- lib/merb_whoops_notifier/merbtasks.rb
+- lib/merb_whoops_notifier/whoops_mixin.rb
+- lib/merb_whoops_notifier/whoops_notifier.rb
+- lib/merb_whoops_notifier.rb
+- spec/fixtures
+- spec/fixtures/whoops.yml
+- spec/merb_whoops_notifier_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/flyingmachine/merb_whoops_notifier
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: merb
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Merb plugin that provides whoops exception notification
+test_files: []
+