radar 0.3.0 → 0.4.0

data/examples/rack/config.ru

@@ -5,7 +5,7 @@ require "radar"
 # Create a Radar::Application, configured to simply log to the
 # STDERR stream.
 app = Radar::Application.new(:rack_example) do |a|
-  a.config.reporters.use :io, :io_object => STDERR
+  a.reporter :io, :io_object => STDERR
 end
 
 # Use the Radar Rack middleware for the created application,

data/examples/sinatra/README.md

@@ -0,0 +1,15 @@
+# Radar Examples: Sinatra
+
+This example shows Radar's Sinatra integration.
+
+## Usage
+
+First make sure you install the dependencies using Bundler, then just
+run `rackup` (`bundle exec` is used to verify that it uses the bundle
+environment to get the binary):
+
+    bundle install
+    ruby example.rb
+
+Then access `localhost:4567`, which should throw an exception. Go back
+to your console and see that Radar caught and reported the exception!

data/examples/sinatra/example.rb

@@ -0,0 +1,18 @@
+require "rubygems"
+require "bundler/setup"
+require "radar"
+require "sinatra"
+
+Radar::Application.new(:sinatra_example) do |a|
+  a.reporter :io, :io_object => STDERR
+end
+
+class MyApp < Sinatra::Base
+  use Rack::Radar, :application => Radar[:sinatra_example]
+
+  get '/' do
+    raise "UH OH"
+  end
+end
+
+MyApp.run!

data/lib/radar.rb

@@ -4,6 +4,7 @@ require 'radar/integration/rails3/railtie' if defined?(Rails::Railtie)
 
 module Radar
   autoload :Application,    'radar/application'
+  autoload :Backtrace,      'radar/backtrace'
   autoload :Config,         'radar/config'
   autoload :ExceptionEvent, 'radar/exception_event'
   autoload :Logger,         'radar/logger'
@@ -12,7 +13,8 @@ module Radar
 
   module DataExtensions
     autoload :HostEnvironment, 'radar/data_extensions/host_environment'
-    autoload :Rack, 'radar/data_extensions/rack'
+    autoload :Rack,            'radar/data_extensions/rack'
+    autoload :Rails2,          'radar/data_extensions/rails2'
   end
 
   module Filters
@@ -20,17 +22,21 @@ module Radar
   end
 
   module Integration
-    autoload :Rack,   'radar/integration/rack'
-    autoload :Rails3, 'radar/integration/rails3'
+    autoload :Rack,    'radar/integration/rack'
+    autoload :Rails2,  'radar/integration/rails2'
+    autoload :Rails3,  'radar/integration/rails3'
+    autoload :Sinatra, 'radar/integration/sinatra'
   end
 
   module Matchers
-    autoload :BacktraceMatcher, 'radar/matchers/backtrace_matcher'
-    autoload :ClassMatcher,     'radar/matchers/class_matcher'
+    autoload :BacktraceMatcher,    'radar/matchers/backtrace_matcher'
+    autoload :ClassMatcher,        'radar/matchers/class_matcher'
+    autoload :LocalRequestMatcher, 'radar/matchers/local_request_matcher'
   end
 
   class Reporter
     autoload :FileReporter,   'radar/reporter/file_reporter'
+    autoload :HoptoadReporter,'radar/reporter/hoptoad_reporter'
     autoload :IoReporter,     'radar/reporter/io_reporter'
     autoload :LoggerReporter, 'radar/reporter/logger_reporter'
   end

data/lib/radar/application.rb

@@ -19,7 +19,8 @@ module Radar
     attr_reader :name
     attr_reader :creation_location
 
-    def_delegators :config, :reporters, :data_extensions, :matchers, :filters
+    def_delegators :config, :reporters, :data_extensions, :matchers, :filters, :rejecters,
+                            :reporter, :data_extension, :match, :filter, :reject
 
     # Looks up an application which was registered with the given name.
     #
@@ -95,18 +96,28 @@ module Radar
     def report(exception, extra=nil)
       data = ExceptionEvent.new(self, exception, extra)
 
+      # If there are rejecters, then verify that they all fail
+      if !config.rejecters.empty?
+        config.rejecters.values.each do |r|
+          if r.call(data)
+            logger.info("Ignoring exception. Matches rejecter: #{r}")
+            return
+          end
+        end
+      end
+
       # If there are matchers, then verify that at least one matches
       # before continuing
       if !config.matchers.empty?
         return if !config.matchers.values.find do |m|
-          m.matches?(data) && logger.info("Reporting exception. Matches: #{m}")
+          m.call(data) && logger.info("Reporting exception. Matches: #{m}")
         end
       end
 
       # Report the exception to each of the reporters
       logger.info "Invoking reporters for exception: #{exception.class}"
       config.reporters.values.each do |reporter|
-        reporter.report(data)
+        reporter.call(data)
       end
     end
 

data/lib/radar/backtrace.rb

@@ -0,0 +1,42 @@
+module Radar
+  # The backtrace class helps to parse the given Ruby backtrace
+  # lines into proper file, line, and method, so it can better be
+  # organized and filtered later.
+  class Backtrace < Array
+    attr_reader :original
+
+    def initialize(backtrace)
+      @original = backtrace
+      parse if backtrace
+    end
+
+    protected
+
+    # Parses the backtrace into the proper {Line} objects which
+    # are inserted into the array.
+    def parse
+      original.each do |line|
+        push(Entry.new(line))
+      end
+    end
+
+    # Represents a single line of a backtrace, giving access to the
+    # file, line, and method.
+    class Entry < Hash
+      def initialize(line)
+        # Regex pulled from HoptoadNotifier. Thanks!
+        _, file, line, method = line.match(/^([^:]+):(\d+)(?::in `([^']+)')?$/).to_a
+        self[:file] = file
+        self[:line] = line
+        self[:method] = method
+      end
+
+      # Helpers to access the file, line, and method.
+      [:file, :line, :method].each do |attr|
+        define_method(attr) do
+          self[attr]
+        end
+      end
+    end
+  end
+end

data/lib/radar/config.rb

@@ -7,6 +7,7 @@ module Radar
     attr_reader :reporters
     attr_reader :data_extensions
     attr_reader :matchers
+    attr_reader :rejecters
     attr_reader :filters
     attr_accessor :log_location
 
@@ -14,12 +15,58 @@ module Radar
       @reporters       = UseArray.new(&method(:add_reporter))
       @data_extensions = UseArray.new(&method(:add_data_extension))
       @matchers        = UseArray.new(&method(:add_matcher))
+      @rejecters       = UseArray.new(&method(:add_matcher))
       @filters         = UseArray.new(&method(:add_filter))
       @log_location    = nil
 
       @data_extensions.use DataExtensions::HostEnvironment
     end
 
+    # Adds a reporter to the application. Unlike most exception notifiers,
+    # Radar on its own doesn't actually do anything with the exception data
+    # once it has processed it. Instead, it is up to reporters to take the
+    # exception data and do something with it. Using this method, you can
+    # enable reporters.
+    #
+    # Built-in reporters can be accessed via a symbol:
+    #
+    #     config.reporter :file
+    #
+    # Custom reporters can be accessed via a class:
+    #
+    #     config.reporter MyCustomReporter
+    #
+    # And for simple reporters, you may even just use a block:
+    #
+    #     config.reporter do |event|
+    #       # Do something with the event
+    #     end
+    #
+    # Any arguments other than the first, including any given blocks,
+    # are passed on to the reporter class.
+    def reporter(*args, &block)
+      @reporters.use(*args, &block)
+    end
+
+    # Adds a data extension to the application. By default, the exception
+    # data generated by Radar is quite lean and only includes the basic
+    # information about the application and exception. Through the use
+    # of data extensions, you can add any sort of information to the
+    # exception data that you want.
+    #
+    # Built-in data extensions can be enabled via a symbol:
+    #
+    #     config.data_extension :host_environment
+    #
+    # Custom data extensions can be enabled via a class:
+    #
+    #     config.data_extension MyCustomExtension
+    #
+    # Any arguments given will be passed on to the data extension class.
+    def data_extension(*args, &block)
+      @data_extensions.use(*args, &block)
+    end
+
     # Adds a matcher rule to the application. An application will only
     # report an exception if the event agrees with at least one of the
     # matchers.
@@ -37,23 +84,54 @@ module Radar
     #     config.match Radar::Matchers::ClassMatcher, StandardError
     #
     # Radar will then use the specified class as the matcher.
+    def match(*args, &block)
+      @matchers.use(*args, &block)
+    end
+
+    # Adds a rejecter rule to the application. A rejecter is the same as a
+    # matcher, so if you're not familiar with matchers, please read the documentation
+    # above {#match} first. The only difference with a rejecter is that if
+    # any of the rejecters return true, then the exception event is not sent
+    # to reporters.
     #
-    def match(matcher, *args)
-      @matchers.use(matcher, *args)
+    # Another important note is that rejecters always take precedence over
+    # matchers. So even if a matcher would have matched the exception, if it
+    # matches a rejecter, then it won't continue.
+    def reject(*args, &block)
+      @rejecters.use(*args, &block)
+    end
+
+    # Adds a filter to the application. Filters provide a method of filtering
+    # the exception data just prior to the data being sent to the reporters.
+    # This enables you to filter out sensitive information such as passwords,
+    # or even just to remove unnecessary keys.
+    #
+    # Built-in filters can be enabled using a symbol shortcut:
+    #
+    #     config.filter :key, :key => :password
+    #
+    # Custom filters can be enabled using a class:
+    #
+    #     config.filter MyCustomFilter
+    #
+    # Or simple filters can be created using lambda functions:
+    #
+    #     config.filter do |data|
+    #       # do something with the data and return it
+    #       data
+    #     end
+    #
+    # Any arguments given will be passed on to the filter class.
+    def filter(*args, &block)
+      @filters.use(*args, &block)
     end
 
     protected
 
     # The callback that is used to add a reporter to the {UseArray}
     # when `reporters.use` is called.
-    def add_reporter(klass, *args)
-      klass = Support::Inflector.constantize("Radar::Reporter::#{Support::Inflector.camelize(klass)}Reporter") if !klass.is_a?(Class)
-
-      block = args.pop if args.last.is_a?(Proc)
-      instance = klass.new(*args)
-      block.call(instance) if block
-
-      [klass, instance]
+    def add_reporter(*args)
+      callable_method(:report, "Radar::Reporter::%sReporter", *args)
     end
 
     # The callback that is used to add a data extension to the {UseArray}
@@ -65,26 +143,40 @@ module Radar
 
     # The callback that is used to add a matcher to the {UseArray}
     # when `matchers.use` is called.
-    def add_matcher(matcher, *args)
-      matcher = Support::Inflector.constantize("Radar::Matchers::#{Support::Inflector.camelize(matcher)}Matcher") if !matcher.is_a?(Class)
-      [matcher, matcher.new(*args)]
+    def add_matcher(*args)
+      callable_method(:matches?, "Radar::Matchers::%sMatcher",  *args)
     end
 
     # The callback that is used to add a filter to the {UseArray}
     # when `filters.use` is called.
     def add_filter(*args)
-      block = args.pop if args.last.is_a?(Proc)
-      raise ArgumentError.new("`filters.use` requires at least a class or a lambda to be given.") if args.empty? && !block
+      callable_method(:filter, "Radar::Filters::%sFilter",  *args)
+    end
+
+    def callable_method(method, inflectorspace, *args)
+      block = args.pop if args.length == 1 && args.first.is_a?(Proc)
+      raise ArgumentError.new("Requires at least a class or a lambda to be given.") if args.empty? && !block
+      name = block || args.first
 
       if !args.empty?
-        # Detect the proper class then get the `filter` method from it,
-        # since that is all we care about
         klass = args.shift
-        klass = Support::Inflector.constantize("Radar::Filters::#{Support::Inflector.camelize(klass)}Filter") if !klass.is_a?(Class)
-        block = klass.new.method(:filter)
+
+        if !klass.is_a?(Class)
+          space = inflectorspace % Support::Inflector.camelize(klass)
+          klass = Support::Inflector.constantize(space)
+        end
+
+        # Instantiate the class and yield the block if it was given
+        # with the instance.
+        instance_block = args.pop if args.last.is_a?(Proc)
+        instance = klass.new(*args)
+        instance_block.call(instance) if instance_block
+
+        # Store the callable method away as the callable for later.
+        block = instance.method(method)
       end
 
-      [block, block]
+      [name, block]
     end
   end
 

data/lib/radar/data_extensions/rack.rb

@@ -1,8 +1,12 @@
+require 'radar/data_extensions/request_helper'
+
 module Radar
   module DataExtensions
     # Data extensions which adds information about a rack request,
     # if it exists in the `:rack_request` extra data of the {ExceptionEvent}.
     class Rack
+      include RequestHelper
+
       def initialize(event)
         @event = event
       end
@@ -31,27 +35,6 @@ module Radar
 
       protected
 
-      # Extracts only the HTTP headers from the rack environment,
-      # converting them to the proper HTTP format: `HTTP_CONTENT_TYPE`
-      # to `Content-Type`
-      #
-      # @param [Hash] env
-      # @return [Hash]
-      def extract_http_headers(env)
-        env.inject({}) do |acc, data|
-          k, v = data
-
-          if k =~ /^HTTP_(.+)$/
-            # Convert things like HTTP_CONTENT_TYPE to Content-Type (standard
-            # HTTP header style)
-            k = $1.to_s.split("_").map { |c| c.capitalize }.join("-")
-            acc[k] = v
-          end
-
-          acc
-        end
-      end
-
       # Extracts the rack environment, ignoring HTTP headers and
       # converting the values to strings if they're not an Array
       # or Hash.

data/lib/radar/data_extensions/rails2.rb

@@ -0,0 +1,31 @@
+require 'radar/data_extensions/request_helper'
+
+module Radar
+  module DataExtensions
+    # Takes a `:rails2_request` from the {ExceptionEvent} extra data which is
+    # added by the rails 2 integrator and extracts it into the data hash.
+    #
+    # **This data extension is automatically enabled by the Rails 2 integrator.**
+    class Rails2
+      include RequestHelper
+
+      def initialize(event)
+        @event = event
+      end
+
+      def to_hash
+        request = @event.extra[:rails2_request]
+        return if !request
+
+        { :request => {
+            :request_method => request.request_method.to_s,
+            :url => request.url.to_s,
+            :parameters => request.parameters,
+            :remote_ip => request.remote_ip,
+            :headers => extract_http_headers(request.env)
+          }
+        }
+      end
+    end
+  end
+end

data/lib/radar/data_extensions/request_helper.rb

@@ -0,0 +1,28 @@
+module Radar
+  module DataExtensions
+    # A mixin which contains helper methods for dealing with request
+    # objects.
+    module RequestHelper
+      # Extracts only the HTTP headers from the rack environment,
+      # converting them to the proper HTTP format: `HTTP_CONTENT_TYPE`
+      # to `Content-Type`
+      #
+      # @param [Hash] env
+      # @return [Hash]
+      def extract_http_headers(env)
+        env.inject({}) do |acc, data|
+          k, v = data
+
+          if k =~ /^HTTP_(.+)$/
+            # Convert things like HTTP_CONTENT_TYPE to Content-Type (standard
+            # HTTP header style)
+            k = $1.to_s.split("_").map { |c| c.capitalize }.join("-")
+            acc[k] = v
+          end
+
+          acc
+        end
+      end
+    end
+  end
+end