radar 0.3.0 → 0.4.0

data/lib/radar/exception_event.rb

@@ -8,13 +8,15 @@ module Radar
   class ExceptionEvent
     attr_reader :application
     attr_reader :exception
-    attr_reader :occurred_at
+    attr_reader :backtrace
     attr_reader :extra
+    attr_reader :occurred_at
 
     def initialize(application, exception, extra=nil)
       @application = application
-      @exception = exception
-      @extra = extra || {}
+      @exception   = exception
+      @backtrace   = Backtrace.new(exception.backtrace)
+      @extra       = extra || {}
       @occurred_at = Time.now
     end
 
@@ -25,11 +27,13 @@ module Radar
     #
     # @return [Hash]
     def to_hash
+      return @_to_hash_result if @_to_hash_result
+
       result = { :application => application.to_hash,
         :exception => {
           :klass => exception.class.to_s,
           :message => exception.message,
-          :backtrace => exception.backtrace,
+          :backtrace => backtrace,
           :uniqueness_hash => uniqueness_hash
         },
         :occurred_at => occurred_at.to_i
@@ -43,6 +47,8 @@ module Radar
         result = filter.call(result)
       end
 
+      # Cache the resulting hash to it is only generated once.
+      @_to_hash_result = result
       result
     end
 

data/lib/radar/integration/rails2.rb

@@ -0,0 +1,31 @@
+require 'radar/integration/rails2/action_controller_rescue'
+
+module Radar
+  module Integration
+    # Allows drop-in integration with Rails 2 for Radar. This monkeypatches
+    # `ActionController::Base` to capture errors and also enables a data
+    # extension to extract the Rails 2 request information into the exception
+    # event.
+    class Rails2
+      @@integrated_apps = []
+
+      def self.integrate!(app)
+        # Only monkeypatch ActionController::Base once
+        ActionController::Base.send(:include, ActionControllerRescue) if @@integrated_apps.empty?
+
+        # Only integrate each application once
+        if !@@integrated_apps.include?(app)
+          app.data_extensions.use :rails2
+          @@integrated_apps << app
+        end
+      end
+
+      # Returns all the Radar applications which have been integrated with
+      # Rails 2, in the order that they were integrated. This Array is `dup`ed
+      # so that no modifications can be made to it.
+      def self.integrated_apps
+        @@integrated_apps.dup
+      end
+    end
+  end
+end

data/lib/radar/integration/rails2/action_controller_rescue.rb

@@ -0,0 +1,30 @@
+module Radar
+  module Integration
+    class Rails2
+      module ActionControllerRescue
+        def self.included(base)
+          # Unfortunate alias method chain... solution: upgrade to rails 3 ;)
+          base.send(:alias_method, :rescue_action_without_radar, :rescue_action)
+          base.send(:alias_method, :rescue_action, :rescue_action_with_radar)
+          base.send(:protected, :rescue_action)
+        end
+
+        private
+
+        def rescue_action_with_radar(exception)
+          report_exception_to_radar(exception)
+          rescue_action_without_radar(exception)
+        end
+
+        # Report an exception to all Radar applications which chose to integrate
+        # with Rails 2.
+        def report_exception_to_radar(exception)
+          Radar::Integration::Rails2.integrated_apps.each do |app|
+            app.report(exception, :rails2_request => request)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/radar/integration/rails3.rb

@@ -1,5 +1,3 @@
-require "rails"
-
 module Radar
   module Integration
     # Allows drop-in integration with Rails 3 for Radar. This

data/lib/radar/integration/rails3/railtie.rb

@@ -1,5 +1,3 @@
-require "rails"
-
 module Radar
   # The Radar Railtie allows Radar to integrate with Rails 3 by
   # adding generators. **This file is only loaded automatically

data/lib/radar/integration/sinatra.rb

@@ -0,0 +1,21 @@
+module Radar
+  module Integration
+    # Allows drop-in integration with Sinatra for Radar. This class
+    # should not ever actually be used {Application#integrate}. Instead,
+    # use the middlware provided by {Rack::Radar}.
+    #
+    #     Radar::Application.new(:app) do |app|
+    #       # configure...
+    #     end
+    #
+    #     class MyApp < Sinatra::Base
+    #       use Rack::Radar, :application => Radar[:app]
+    #     end
+    #
+    class Sinatra
+      def self.integrate!(app)
+        raise "To enable Sinatra integration, please use `Rack::Radar` middleware instead. View the user guide for more information."
+      end
+    end
+  end
+end

data/lib/radar/matchers/local_request_matcher.rb

@@ -0,0 +1,43 @@
+module Radar
+  module Matchers
+    # A matcher which matches exceptions if the request is from
+    # a local IP. The IPs which constitute a "local request" are
+    # those which match any of the following:
+    #
+    #     [/^127\.0\.0\.\d{1,3}$/, "::1", /^0:0:0:0:0:0:0:1(%.*)?$/]
+    #
+    # If there is no request information found in the exception event
+    # data, then it will not match.
+    #
+    # This matcher expects the IP to be accessible at `event.to_hash[:request][:remote_ip]`,
+    # though this is configurable. Examples of usage are shown below:
+    #
+    #     app.match :local_request
+    #
+    # With a custom IP field:
+    #
+    #     app.match :local_request, :remote_ip_getter => lamdba { |event| event.to_hash[:remote_ip] }
+    #
+    class LocalRequestMatcher
+      attr_accessor :localhost
+      attr_accessor :remote_ip_getter
+
+      def initialize(opts=nil)
+        (opts || {}).each do |k,v|
+          send("#{k}=", v)
+        end
+
+        @localhost        ||= [/^127\.0\.0\.\d{1,3}$/, "::1", /^0:0:0:0:0:0:0:1(%.*)?$/]
+        @remote_ip_getter ||= Proc.new { |event| event.to_hash[:request][:remote_ip] }
+      end
+
+      def matches?(event)
+        remote_ip = remote_ip_getter.call(event)
+        localhost.any? { |local_ip| local_ip === remote_ip }
+      rescue Exception
+        # Any exceptions assume that we didn't match.
+        false
+      end
+    end
+  end
+end

data/lib/radar/reporter/hoptoad_reporter.rb

@@ -0,0 +1,204 @@
+require 'builder'
+require 'net/http'
+require 'net/https'
+
+module Radar
+  class Reporter
+    # Thanks to the Hoptoad Notifier library for the format of the XML and
+    # also the `net/http` code. Writing this reporter would have been much
+    # more trying if Thoughtbot's code wasn't open.
+
+    # Reports exceptions to the Hoptoad server (http://hoptoadapp.com). Enabling
+    # this in your Radar application is easy:
+    #
+    #     app.reporters.use :hoptoad, :api_key => "hoptoad-api-key"
+    #
+    # The API key is your project's API key which can be found on the Hoptoad
+    # website. There are many additional options which can be set, but the most
+    # useful are probably `project_root` and `environment_name`. These will be
+    # auto-detected in a Rails application but for all others, its helpful
+    # to set them:
+    #
+    #     app.reporters.use :hoptoad do |r|
+    #       r.api_key          = "api-key"
+    #       r.project_root     = File.expand_path("../../", __FILE__)
+    #       r.environment_name = "development"
+    #     end
+    #
+    class HoptoadReporter
+      API_VERSION = "2.0"
+      NOTICES_URL = "/notifier_api/v2/notices/"
+
+      # Options which should be set:
+      attr_accessor :api_key
+      attr_accessor :project_root
+      attr_accessor :environment_name
+
+      # The rest can probably be left alone:
+      # HTTP settings
+      attr_accessor :host
+      attr_accessor :headers
+      attr_accessor :secure
+      attr_accessor :http_open_timeout
+      attr_accessor :http_read_timeout
+
+      # Proxy settings
+      attr_accessor :proxy_host
+      attr_accessor :proxy_port
+      attr_accessor :proxy_user
+      attr_accessor :proxy_pass
+
+      # Notifier information. This defaults to Radar information.
+      attr_accessor :notifier_name
+      attr_accessor :notifier_version
+      attr_accessor :notifier_url
+
+      def initialize(opts=nil)
+        (opts || {}).each do |k,v|
+          send("#{k}=", v)
+        end
+
+        @project_root      ||= defined?(Rails) ? Rails.root.to_s : '/not/set'
+        @environment_name  ||= defined?(Rails) ? Rails.env.to_s  : 'radar'
+
+        @host              ||= 'hoptoadapp.com'
+        @headers           ||= { 'Content-type' => 'text/xml', 'Accept' => 'text/xml, application/xml' }
+        @secure            ||= false
+        @http_open_timeout ||= 2
+        @http_read_timeout ||= 5
+
+        @notifier_name     ||= "Radar"
+        @notifier_version  ||= Radar::VERSION
+        @notifier_url      ||= "http://radargem.com"
+      end
+
+      def report(event)
+        raise ArgumentError.new("`api_key` is required.") if !api_key
+
+        http = Net::HTTP.Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).new(url.host, url.port)
+        http.read_timeout = http_read_timeout
+        http.open_timeout = http_open_timeout
+        http.use_ssl      = secure
+
+        response = begin
+                     http.post(url.path, event_xml(event), headers)
+                   rescue TimeoutError => e
+                     event.application.logger.error("#{self.class}: POST timeout.")
+                     nil
+                   end
+
+        if !response.is_a?(Net::HTTPSuccess)
+          event.application.logger.error("#{self.class}: Failed to send: #{response.body}")
+        end
+      end
+
+      # Converts an event to the properly formatted XML for transmission
+      # to Hoptoad.
+      def event_xml(event)
+        request_data = request_info(event)
+
+        builder = Builder::XmlMarkup.new
+        builder.instruct!
+        xml = builder.notice(:version => API_VERSION) do |notice|
+          notice.tag!("api-key", api_key)
+
+          notice.notifier do |notifier|
+            notifier.name(notifier_name)
+            notifier.version(notifier_version)
+            notifier.url(notifier_url)
+          end
+
+          notice.error do |error|
+            error.tag!("class", event.exception.class.to_s)
+            error.message(event.exception.message)
+            error.backtrace do |backtrace|
+              event.backtrace.each do |entry|
+                backtrace.line(:number => entry.line, :file => entry.file, :method => entry.method)
+              end
+            end
+          end
+
+          if !request_data.empty?
+            notice.request do |request|
+              request.url(request_data[:url])
+              request.component(request_data[:controller])
+              request.action(request_data[:action])
+
+              if !request_data[:parameters].empty?
+                request.params do |params|
+                  xml_vars_for_hash(params, request_data[:parameters])
+                end
+              end
+
+              if !request_data[:session].empty?
+                request.session do |session|
+                  xml_vars_for_hash(session, request_data[:session])
+                end
+              end
+
+              if !request_data[:cgi_data].empty?
+                request.tag!("cgi-data") do |cgi|
+                  xml_vars_for_hash(cgi, request_data[:cgi_data])
+                end
+              end
+            end
+          end
+
+          notice.tag!("server-environment") do |env|
+            env.tag!("project-root", project_root)
+            env.tag!("environment-name", environment_name)
+          end
+        end
+
+        xml.to_s
+      end
+
+      # Returns a URI object pointed to the proper endpoint for the
+      # Hoptoad API.
+      def url
+        protocol = secure ? 'https' : 'http'
+        port     = secure ? 443 : 80
+
+        URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URL)
+      end
+
+      # Returns information about the request based on the event, such
+      # as URL, controller, action, parameters, etc.
+      def request_info(event)
+        return @_request_info if @_request_info
+
+        # Use the hash of the event so that if any filters deleted data, it is properly
+        # removed.
+        hash = event.to_hash.dup
+        hash[:request] ||= {}
+        hash[:request][:rack_env] ||= {}
+
+        @_request_info = {}
+
+        if hash[:request]
+          @_request_info[:url]        = hash[:request][:url]
+          @_request_info[:parameters] = hash[:request][:rack_env]['action_dispatch.request.parameters'] ||
+            hash[:request][:parameters] ||
+            {}
+          @_request_info[:controller] = @_request_info[:parameters]['controller']
+          @_request_info[:action]     = @_request_info[:parameters]['action']
+          @_request_info[:cgi_data]   = hash[:request][:rack_env] || hash[:request][:headers] || {}
+          @_request_info[:session]    = hash[:request][:rack_env]['rack.session'] || {}
+        end
+
+        @_request_info
+      end
+
+      # Turns a hash into the proper XML vars
+      def xml_vars_for_hash(builder, hash)
+        hash.each do |k,v|
+          if v.is_a?(Hash)
+            builder.var(:key => k.to_s) { |b| xml_vars_for_hash(b, v) }
+          else
+            builder.var(v.to_s, :key => k.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/radar/reporter/logger_reporter.rb

@@ -5,8 +5,8 @@ module Radar
     # if you wish to integrate Radar into your already existing logging
     # systems.
     #
-    #     app.config.reporters.use :logger, :log_object => Logger.new(STDOUT)
-    #     app.config.reporters.use :logger, :log_object => Logger.new(STDOUT), :log_level => :warn
+    #     app.reporters.use :logger, :log_object => Logger.new(STDOUT)
+    #     app.reporters.use :logger, :log_object => Logger.new(STDOUT), :log_level => :warn
     #
     class LoggerReporter
       attr_accessor :log_object
@@ -21,7 +21,6 @@ module Radar
       end
 
       def report(event)
-        raise ArgumentError.new("#{self.class} `log_object` must be set to a valid logger.") if !log_object.is_a?(Logger)
         raise ArgumentError.new("#{self.class} `log_object` must respond to specified `log_level`.") if !log_object.respond_to?(log_level)
 
         log_object.send(log_level, event.to_json)

data/lib/radar/version.rb

@@ -1,3 +1,3 @@
 module Radar
-  VERSION = "0.3.0"
+  VERSION = "0.4.0" if !defined?(Radar::VERSION)
 end

data/radar.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project         = "radar"
 
   s.add_dependency "json", ">= 1.4.6"
+  s.add_dependency "builder", "~> 2.0"
 
   s.add_development_dependency "bundler", ">= 1.0.0.rc.5"
   s.add_development_dependency "shoulda"

data/test/radar/application_test.rb

@@ -45,7 +45,9 @@ class ApplicationTest < Test::Unit::TestCase
       setup do
         @instance.config.reporters.clear
 
-        @reporter = Class.new
+        @reporter = Class.new do
+          def report(event); end
+        end
       end
 
       should "be able to configure an application" do
@@ -108,19 +110,39 @@ class ApplicationTest < Test::Unit::TestCase
             def matches?(event); event.extra[:foo] == :bar; end
           end
 
-          @reporter = Class.new
+          @reporter = Class.new do
+            def report(event); raise "Reported"; end
+          end
+
           @instance.config.reporters.use @reporter
           @instance.config.match @matcher
         end
 
         should "not report if a matcher is specified and doesn't match" do
-          @reporter.any_instance.expects(:report).never
-          @instance.report(Exception.new, :foo => :wrong)
+          assert_nothing_raised { @instance.report(Exception.new, :foo => :wrong) }
         end
 
         should "report if a matcher matches" do
-          @reporter.any_instance.expects(:report).once
-          @instance.report(Exception.new, :foo => :bar)
+          assert_raises(RuntimeError) { @instance.report(Exception.new, :foo => :bar) }
+        end
+      end
+
+      context "with a rejecter" do
+        setup do
+          @rejecter = Class.new do
+            def matches?(event); event.extra[:foo] == :bar; end
+          end
+
+          @instance.reject @rejecter
+          @instance.reporter { |event| raise "Reported" }
+        end
+
+        should "not report if a rejecter is specified and matches" do
+          assert_nothing_raised { @instance.report(Exception.new, :foo => :bar) }
+        end
+
+        should "report if the rejecter doesn't match" do
+          assert_raises(RuntimeError) { @instance.report(Exception.new) }
         end
       end
     end
@@ -148,20 +170,19 @@ class ApplicationTest < Test::Unit::TestCase
     end
 
     context "delegation to config" do
-      should "delegate reporters" do
-        assert_equal @instance.config.reporters, @instance.reporters
-      end
-
-      should "delegate data extensions" do
-        assert_equal @instance.config.data_extensions, @instance.data_extensions
-      end
-
-      should "delegate matchers" do
-        assert_equal @instance.config.matchers, @instance.matchers
+      # Test delegating of accessors
+      [:reporters, :data_extensions, :matchers, :filters, :rejecters].each do |attr|
+        should "delegate #{attr}" do
+          assert_equal @instance.config.send(attr), @instance.send(attr)
+        end
       end
 
-      should "delegate filters" do
-        assert_equal @instance.config.filters, @instance.filters
+      # Test delegating of methods.
+      [:reporter, :data_extension, :match, :filter, :reject].each do |method|
+        should "delegate `#{method}` method" do
+          @instance.config.expects(method).once
+          @instance.send(method)
+        end
       end
     end