radar 0.1.0 → 0.2.0

data/.yardopts

@@ -1,2 +1,3 @@
+-m markdown
 --files
 docs/user_guide.md

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+## 0.2.0 (unreleased)
+
+  - Built in matcher: `:backtrace` (or `BacktraceMatcher`) which checks that
+    the backtrace includes the given text. [GH-18]
+  - Built in matcher: `:class` (or `ClassMatcher`) which checks against the
+    exception class. [GH-17]
+  - Add `config.match` to conditionally match exceptions before reporting
+    them so that exceptions can be better filtered per application. [GH-11]
+  - Changed the way reporters and data extensions are enabled. You must now
+    use methods `use`, `swap`, `insert`, `delete`, etc. See the user guide
+    for details. [GH-16]
+  - Added `prune_time` configuration to `FileReporter` which automatically prunes
+    files older than the specified age. [GH-15]
+  - Extra data in the form of a hash can be passed to `Application#report` now,
+    which is available in `ExceptionEvent#extra`, so that reporters and data
+    extensions can take advantage of this. [GH-14]
+  - Added LICENSE file. Oops!
+
+## 0.1.0
+
+  - Initial version.

data/Gemfile.lock

@@ -7,7 +7,7 @@ GIT
 PATH
   remote: .
   specs:
-    radar (0.1.0)
+    radar (0.2.0)
       json (>= 1.4.6)
 
 GEM

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010 Mitchell Hashimoto
+
+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

@@ -29,7 +29,7 @@ ask for any more information 90% of the time.
 Then just begin logging exceptions in your application:
 
     r = Radar::Application.new(:my_application)
-    r.config.reporter Radar::Reporter::FileReporter
+    r.config.reporters.use Radar::Reporter::FileReporter
     r.report(exception)
 
 You can also tell Radar to attach itself to Ruby's `at_exit` hook

data/docs/user_guide.md

@@ -32,7 +32,7 @@ remote server, etc.). Radar comes with some built-in reporters. Below, we config
 the application to log errors to a file (by default at `~/.radar/errors/my_application`):
 
     Radar::Application.new(:my_application) do |app|
-      app.config.reporter Radar::Reporter::FileReporter
+      app.config.reporters.use Radar::Reporter::FileReporter
     end
 
 ### Reporting Errors
@@ -80,15 +80,15 @@ of what this means with a few examples:
 Reporters are enabled using the appilication configuration:
 
     Radar::Application.new(:my_application) do |app|
-      app.config.reporter FileReporter
+      app.config.reporters.use FileReporter
     end
 
 And can be configured by passing a block to the reporter, which is yielded with
 the instance of that reporter:
 
     Radar::Application.new(:my_application) do |app|
-      app.config.reporter FileReporter do |reporter|
-        reporter.storage_directory = "~/.radar/exceptions"
+      app.config.reporters.use FileReporter do |reporter|
+        reporter.output_directory = "~/.radar/exceptions"
       end
     end
 
@@ -96,8 +96,8 @@ Radar also allows multiple reporters to be used, which are then called
 in the order they are defined when an exception occurs:
 
     Radar::Application.new(:my_application) do |app|
-      app.config.reporter FileReporter
-      app.config.reporter AnotherReporter
+      app.config.reporters.use FileReporter
+      app.config.reporters.use AnotherReporter
     end
 
 ### Built-in Reporters
@@ -112,7 +112,7 @@ where `timestamp` is the time that the exception occurred and `uniquehash` is th
 The directory where these files will be stored is configurable:
 
     Radar::Application.new(:my_application) do |app|
-      app.config.reporter Radar::Reporter::FileReporter do |reporter|
+      app.config.reporters.use Radar::Reporter::FileReporter do |reporter|
         reporter.output_directory = "~/my_application_errors"
       end
     end
@@ -130,6 +130,9 @@ A few notes:
   JSON and pretty print it if you wish it to be easily human readable. There are
   [services](http://jsonformatter.curiousconcept.com/) out there to do this.
 
+For complete documentation on this reporter, please see the actual {Radar::Reporter::FileReporter}
+page.
+
 ### Custom Reporters
 
 It is very easy to write custom reporters. A reporter is simply a class which
@@ -146,7 +149,7 @@ occurred:
 And then using that reporter is just as easy:
 
     Radar::Application.new(:my_application) do |app|
-      app.config.reporter StdoutReporter
+      app.config.reporters.use StdoutReporter
     end
 
 ## Data Extensions
@@ -181,7 +184,7 @@ Data extensions are enabled via the application configuration like most other
 things:
 
     Radar::Application.new(:my_application) do |app|
-      app.config.data_extension UnameExtension
+      app.config.data_extensions.use UnameExtension
     end
 
 ### Built-In Data Extensions
@@ -195,3 +198,96 @@ Some of these are enabled by default, which are designated by the `*` on the nam
   host such as Ruby version and operating system.
 
 `*`: Enabled by default on every application.
+
+## Matchers
+
+Matchers allow Radar applications to conditionally match exceptions so that
+a Radar application doesn't catch unwanted exceptions, such as exceptions which
+may not be caused by the library in question, or perhaps exceptions which aren't
+really exceptional.
+
+### Enabling a Matcher
+
+Matchers are enabled in the application configuration:
+
+    Radar::Application.new(:app) do |app|
+      app.config.match :class, StandardError
+      app.config.match :backtrace, /file.rb$/
+    end
+
+As you can see, multiple matchers may be enabled. In this case, as long as at
+least one matches, then the exception will be reported. The first argument to
+{Radar::Config#match match} is a symbol or class of a matcher. If it is a symbol,
+the symbol is constantized and expects to exist under the `Radar::Matchers` namespace.
+If it is a class, that class will be used as the matcher. Any additional arguments
+are passed directly into the initializer of the matcher. For more information
+on writing a custom matcher, see the section below.
+
+If no matchers are specified (the default), then all exceptions are caught.
+
+### Built-in Matchers
+
+#### `:backtrace`
+
+A matcher which matches against the backtrace of the exception. It allows:
+
+* Match that a string is a substring of a line in the backtrace
+* Match that a regexp matches a line in the backtrace
+* Match one of the above up to a maximum depth in the backtrace
+
+Examples of each are shown below (respective to the above order):
+
+    app.config.match :backtrace, "my_file.rb"
+    app.config.match :backtrace, /.+_test.rb/
+    app.config.match :backtrace, /.+_test.rb/, :depth => 5
+
+If an exception doesn't have a backtrace (can happen if you don't actually
+`raise` an exception, but instantiate one) then the matcher always returns
+`false`.
+
+#### `:class`
+
+A matcher which matches against the class of the exception. It is configurable
+so it can check against:
+
+* An exact match
+* Match class or any subclasses
+* Match a regexp name of a class
+
+Examples of each are shown below (in the above order):
+
+    app.config.match :class, StandardError
+    app.config.match :class, StandardError, :include_subclasses => true
+    app.config.match :class, /.*Error/
+
+### Custom Matchers
+
+Matchers are simply classes which respond to `matches?` which returns a boolean
+noting if the given {Radar::ExceptionEvent} matches. If true, then the exception
+is reported, otherwise other matchers are tried, or if there are no other matchers,
+the exception is ignored.
+
+Below is a simple custom matcher which only matches exceptions with the
+configured message:
+
+    class ErrorMessageMatcher
+      def initialize(message)
+        @message = message
+      end
+
+      def matches?(event)
+        event.exception.message == @message
+      end
+    end
+
+And the usage is shown below:
+
+    Radar::Application.new(:app) do |app|
+      app.config.match ErrorMessageMatcher, "sample message"
+    end
+
+And this results in the following behavior:
+
+    raise "Hello, World"   # not reported
+    raise "sample message" # reported since it matches the message
+

data/lib/radar.rb

@@ -15,4 +15,9 @@ module Radar
   class Reporter
     autoload :FileReporter, 'radar/reporter/file_reporter'
   end
+
+  module Matchers
+    autoload :BacktraceMatcher, 'radar/matchers/backtrace_matcher'
+    autoload :ClassMatcher,     'radar/matchers/class_matcher'
+  end
 end

data/lib/radar/application.rb

@@ -56,9 +56,13 @@ module Radar
     #
     #     $app = Radar::Application.new
     #     $app.config do |config|
-    #       config.storage_directory = "foo"
+    #       config.reporters.use Radar::Reporter::FileReporter
     #     end
     #
+    # You can also just use it without a block:
+    #
+    #    $app.config.reporters.use Radar::Reporter::FileReporter
+    #
     # @yield [Config] Configuration object, only if block is given.
     # @return [Config]
     def config
@@ -68,14 +72,20 @@ module Radar
     end
 
     # Reports an exception. This will send the exception on to the
-    # various reporters configured for this application.
+    # various reporters configured for this application. If any
+    # matchers are defined, using {Config#match}, then at least one
+    # must match for the report to go forward to reporters.
     #
     # @param [Exception] exception
-    def report(exception)
-      data = ExceptionEvent.new(self, exception)
+    def report(exception, extra=nil)
+      data = ExceptionEvent.new(self, exception, extra)
+
+      # If there are matchers, then verify that at least one matches
+      # before continuing
+      return if !config.matchers.empty? && !config.matchers.values.find { |m| m.matches?(data) }
 
       # Report the exception to each of the reporters
-      config.reporters.each do |reporter|
+      config.reporters.values.each do |reporter|
         reporter.report(data)
       end
     end

data/lib/radar/config.rb

@@ -1,35 +1,129 @@
+require 'forwardable'
+
 module Radar
+  # The configuration class used for applications. To configure your application
+  # see {Application#config}. This is also where all the examples are.
   class Config
     attr_reader :reporters
     attr_reader :data_extensions
+    attr_reader :matchers
 
     def initialize
-      @reporters = []
-      @data_extensions = [DataExtensions::HostEnvironment]
+      @reporters = UseArray.new do |klass, &block|
+        instance = klass.new
+        block.call(instance) if block
+        [klass, instance]
+      end
+
+      @data_extensions = UseArray.new
+      @data_extensions.use DataExtensions::HostEnvironment
+
+      @matchers = UseArray.new do |matcher, *args|
+        matcher = Support::Inflector.constantize("Radar::Matchers::" + Support::Inflector.camelize(matcher)) if !matcher.is_a?(Class)
+        [matcher, matcher.new(*args)]
+      end
     end
 
-    # Add a reporter to an application. If a block is given, it
-    # will be yielded later (since reporters are initialized lazily)
-    # with the instance of the reporter.
+    # 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.
+    #
+    # To use a matcher, there are two options. The first is to use a
+    # symbol for the name:
+    #
+    #     config.match :class, StandardError
     #
-    # @param [Class] klass A {Reporter} class.
-    def reporter(klass)
-      instance = klass.new
-      yield instance if block_given?
-      @reporters << instance
+    # This will cause Radar to search for a class named "ClassMatcher"
+    # under the namespace {Radar::Matchers}.
+    #
+    # A second option is to use a class itself:
+    #
+    #     config.match Radar::Matchers::ClassMatcher, StandardError
+    #
+    # Radar will then use the specified class as the matcher.
+    #
+    def match(matcher, *args)
+      @matchers.use(matcher, *args)
     end
+  end
 
-    # Adds a data extension to an application. Data extensions allow
-    # extra data to be included into an {ExceptionEvent} (they appear
-    # in the {ExceptionEvent#to_hash} output). For more information,
-    # please read the Radar user guide.
+  class Config
+    # A subclass of Array which allows for slightly different usage, based
+    # on `ActionDispatch::MiddlewareStack` in Rails 3. The main methods are
+    # enumerated below:
     #
-    # This method takes a class. This class is expected to be initialized
-    # with an {ExceptionEvent}, and must implement the `to_hash` method.
+    # - {#use}
+    # - {#insert}
+    # - {#insert_before}
+    # - {#insert_after}
+    # - {#swap}
+    # - {#delete}
     #
-    # @param [Class] klass
-    def data_extension(klass)
-      @data_extensions << klass
+    class UseArray
+      extend Forwardable
+      def_delegators :@_array, :empty?, :length, :clear
+
+      # Initializes the UseArray with the given block used to generate
+      # the value created for the {#use} method. The block given determines
+      # how the {#use} method stores the key/value.
+      def initialize(*args, &block)
+        @_array = []
+        @_use_block = block || Proc.new { |key, *args| [key, key] }
+      end
+
+      # Use the given key. It is up to the configured use block (given by
+      # the initializer) to generate the actual key/value stored in the array.
+      def use(*args, &block)
+        insert(length, *args, &block)
+      end
+
+      # Insert the given key at the given index or directly before the
+      # given object (by key).
+      def insert(key, *args, &block)
+        @_array.insert(index(key), @_use_block.call(*args, &block))
+      end
+      alias_method :insert_before, :insert
+
+      # Insert after the given key.
+      def insert_after(key, *args, &block)
+        i = index(key)
+        raise ArgumentError.new("No such key found: #{key}") if !i
+        insert(i + 1, *args, &block)
+      end
+
+      # Swaps out the given object at the given index or key with a new
+      # object.
+      def swap(key, *args, &block)
+        i = index(key)
+        raise ArgumentError.new("No such key found: #{key}") if !i
+        delete(i)
+        insert(i, *args, &block)
+      end
+
+      # Delete the object with the given key or index.
+      def delete(key)
+        @_array.delete_at(index(key))
+      end
+
+      # Returns the value for the given key. If the key is an integer,
+      # it is returned as-is. Otherwise, do a lookup on the array for the
+      # the given key and return the index of it.
+      def index(key)
+        return key if key.is_a?(Integer)
+        @_array.each_with_index do |data, i|
+          return i if data[0] == key
+        end
+
+        nil
+      end
+
+      # Returns the values of this array.
+      def values
+        @_array.inject([]) do |acc, data|
+          acc << data[1]
+          acc
+        end
+      end
     end
   end
 end

data/lib/radar/exception_event.rb

@@ -9,16 +9,18 @@ module Radar
     attr_reader :application
     attr_reader :exception
     attr_reader :occurred_at
+    attr_reader :extra
 
-    def initialize(application, exception)
+    def initialize(application, exception, extra=nil)
       @application = application
       @exception = exception
+      @extra = extra || {}
       @occurred_at = Time.now
     end
 
     # A hash of information about this exception event. This includes
     # {Application#to_hash} as well as information about the exception.
-    # This also includes any {Config#data_extension data_extensions} if
+    # This also includes any {Config#data_extensions data_extensions} if
     # specified.
     #
     # @return [Hash]
@@ -34,7 +36,7 @@ module Radar
       }
 
       if !application.config.data_extensions.empty?
-        application.config.data_extensions.each do |extension|
+        application.config.data_extensions.values.each do |extension|
           Support::Hash.deep_merge!(result, extension.new(self).to_hash)
         end
       end

data/lib/radar/matchers/backtrace_matcher.rb

@@ -0,0 +1,31 @@
+module Radar
+  module Matchers
+    # A matcher which matches exceptions which contain a certain
+    # file in their backtrace.
+    #
+    #     app.config.match :backtrace, "my_file"
+    #     app.config.match :backtrace, %r{lib/my_application}
+    #     app.config.match :backtrace, %r{lib/my_application}, :depth => 5
+    #
+    # By default this will search the entire backtrace, unless a depth
+    # is specified.
+    class BacktraceMatcher
+      def initialize(file, opts=nil)
+        @file = file
+        @opts = { :depth => nil }.merge(opts || {})
+      end
+
+      def matches?(event)
+        return false if !event.exception.backtrace
+
+        event.exception.backtrace.each_with_index do |line, depth|
+          return true if @file.is_a?(Regexp) && line =~ @file
+          return true if @file.is_a?(String) && line.include?(@file)
+          return false if @opts[:depth] && @opts[:depth].to_i <= (depth + 1)
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/radar/matchers/class_matcher.rb

@@ -0,0 +1,30 @@
+module Radar
+  module Matchers
+    # A matcher which matches exceptions with a specific class.
+    #
+    #     app.config.match :class, StandardError
+    #     app.config.match :class, StandardError, :include_subclasses => true
+    #     app.config.match :class, /.*Error/
+    #
+    class ClassMatcher
+      def initialize(klass, opts=nil)
+        @klass = klass
+        @opts = { :include_subclasses => false }.merge(opts || {})
+      end
+
+      def matches?(event)
+        return event.exception.class.to_s =~ @klass if @klass.is_a?(Regexp)
+        return event.exception.class == @klass if !@opts[:include_subclasses]
+
+        # Check for subclass matches
+        current = event.exception.class
+        while current
+          return true if current == @klass
+          current = current.superclass
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/radar/reporter/file_reporter.rb

@@ -5,25 +5,67 @@ module Radar
     # Reports exceptions by dumping the JSON data out to a file on the
     # local filesystem. The reporter is configurable:
     #
-    # * {#output_directory=}
+    # ## Configurable Values
+    #
+    # ### `output_directory`
+    #
+    # Specifies the directory where the outputted files are stored. This value
+    # can be either a string or a lambda which takes an {ExceptionEvent} as its
+    # only parameter. The reporter will automatically attempt to make the configured
+    # directory if it doesn't already exist. Examples of both methods of specifying
+    # the directory are shown below:
+    #
+    #     reporter.output_directory = "~/hard/coded/path"
+    #
+    # Or:
+    #
+    #     reporter.output_directory = lambda { |event| "~/.radar/errors/#{event.application.name}" }
+    #
+    # ### `prune_time`
+    #
+    # Specifies the maximum age (in seconds) that a previously outputted file
+    # is allowed to reach before being pruned. When an exception is raised, the
+    # FileReporter will automatically prune existing files which are older than
+    # the specified amount. By default this is `nil` (no pruning occurs).
+    #
+    #     # One week:
+    #     reporter.prune_time = 60 * 60 * 24 * 7
     #
     class FileReporter
       attr_accessor :output_directory
+      attr_accessor :prune_time
 
       def initialize
         @output_directory = lambda { |event| "~/.radar/errors/#{event.application.name}" }
+        @prune_time = nil
       end
 
       def report(event)
         output_file = File.join(File.expand_path(output_directory(event)), "#{event.occurred_at.to_i}-#{event.uniqueness_hash}.txt")
+        directory = File.dirname(output_file)
 
         # Attempt to make the directory if it doesn't exist
-        FileUtils.mkdir_p File.dirname(output_file)
+        FileUtils.mkdir_p directory
+
+        # Prune files if enabled
+        prune(directory) if prune_time
 
         # Write out the JSON to the output file
         File.open(output_file, 'w') { |f| f.write(event.to_json) }
       end
 
+      # Prunes the files in the given directory according to the age limit
+      # set by the {#prune_time} variable.
+      #
+      # @param [String] directory Directory to prune
+      def prune(directory)
+        Dir[File.join(directory, "*.txt")].each do |file|
+          next unless File.file?(file)
+          next unless (Time.now.to_i - File.ctime(file).to_i) >= prune_time.to_i
+          File.delete(file)
+        end
+      end
+
       # Returns the currently configured output directory. If `event` is given
       # as a parameter and the currently set directory is a lambda, then the
       # lambda will be evaluated then returned. If no event is given, the lambda

data/lib/radar/support.rb

@@ -1,10 +1,11 @@
 module Radar
   class Support
+    # Hash support methods:
+    #
+    # * {#deep_merge} and {#deep_merge!} - Does what it says: deep merges a
+    #   hash with another hash. Taken from ActiveSupport in Rails 3.
+    #
     class Hash
-      #----------------------------------------------------------------------
-      # Deep Merging - Taken from Ruby on Rails ActiveSupport
-      #----------------------------------------------------------------------
-
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
       def self.deep_merge(source, other)
         deep_merge!(source.dup, other)
@@ -21,5 +22,26 @@ module Radar
         source
       end
     end
+
+    # Inflector methods:
+    #
+    # * {#camelize} - Convert a string or symbol to UpperCamelCase.
+    # * {#constantize} - Convert a string to a constant.
+    #
+    # Both of these inflector methods are taken directly from ActiveSupport
+    # in Rails 3.
+    class Inflector
+      def self.camelize(string)
+        string.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      end
+
+      def self.constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+        names.inject(Object) do |acc, name|
+          acc.const_defined?(name) ? acc.const_get(name) : acc.const_missing(name)
+        end
+      end
+    end
   end
 end

data/lib/radar/version.rb

@@ -1,3 +1,3 @@
 module Radar
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/radar/application_test.rb

@@ -49,13 +49,13 @@ class ApplicationTest < Test::Unit::TestCase
       end
 
       should "be able to configure an application" do
-        @instance.config.reporter(@reporter)
+        @instance.config.reporters.use @reporter
         assert !@instance.config.reporters.empty?
       end
 
       should "be able to configure using a block" do
         @instance.config do |config|
-          config.reporter(@reporter)
+          config.reporters.use @reporter
         end
 
         assert !@instance.config.reporters.empty?
@@ -63,21 +63,13 @@ class ApplicationTest < Test::Unit::TestCase
     end
 
     context "reporting" do
-      setup do
-        # The fake reporter class
+      should "call report on each registered reporter" do
         reporter = Class.new do
-          def report(environment)
-            raise "success"
-          end
+          def report(environment); raise "success"; end
         end
 
-        # Setup the application to use the fake reporter
-        @instance.config do |config|
-          config.reporter reporter
-        end
-      end
+        @instance.config.reporters.use reporter
 
-      should "call report on each registered reporter" do
         assert_raises(RuntimeError) do
           begin
             @instance.report(Exception.new)
@@ -87,6 +79,42 @@ class ApplicationTest < Test::Unit::TestCase
           end
         end
       end
+
+      should "add extra data to the event if given" do
+        reporter = Class.new do
+          def report(event); raise event.extra[:foo]; end
+        end
+
+        @instance.config.reporters.use reporter
+
+        begin
+          @instance.report(Exception.new, :foo => "BAR")
+        rescue => e
+          assert_equal "BAR", e.message
+        end
+      end
+
+      context "with a matcher" do
+        setup do
+          @matcher = Class.new do
+            def matches?(event); event.extra[:foo] == :bar; end
+          end
+
+          @reporter = Class.new
+          @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)
+        end
+
+        should "report if a matcher matches" do
+          @reporter.any_instance.expects(:report).once
+          @instance.report(Exception.new, :foo => :bar)
+        end
+      end
     end
 
     context "to_hash" do

data/test/radar/config_test.rb

@@ -21,14 +21,14 @@ class ConfigTest < Test::Unit::TestCase
       end
 
       should "be able to add reporters" do
-        @instance.reporter @reporter_klass
+        @instance.reporters.use @reporter_klass
         assert !@instance.reporters.empty?
-        assert @instance.reporters.first.is_a?(@reporter_klass)
+        assert @instance.reporters.values.first.is_a?(@reporter_klass)
       end
 
       should "yield the reporter instance if a block is given" do
         @reporter_klass.any_instance.expects(:some_method).once
-        @instance.reporter @reporter_klass do |reporter|
+        @instance.reporters.use @reporter_klass do |reporter|
           reporter.some_method
         end
       end
@@ -47,13 +47,108 @@ class ConfigTest < Test::Unit::TestCase
       end
 
       should "initially have some data extensions" do
-        assert_equal [Radar::DataExtensions::HostEnvironment], @instance.data_extensions
+        assert_equal [Radar::DataExtensions::HostEnvironment], @instance.data_extensions.values
       end
 
       should "be able to add data extensions" do
-        @instance.data_extension @extension
+        @instance.data_extensions.use @extension
         assert !@instance.data_extensions.empty?
       end
     end
+
+    context "matchers" do
+      setup do
+        @matcher = Class.new do
+          def matches?(event); false; end
+        end
+      end
+
+      teardown do
+        @instance.matchers.clear
+      end
+
+      should "initially have no matchers" do
+        assert @instance.matchers.empty?
+      end
+
+      should "be able to add matchers" do
+        @instance.match @matcher
+        assert !@instance.matchers.empty?
+      end
+    end
+  end
+
+  context "UseArray class" do
+    setup do
+      @klass = Radar::Config::UseArray
+      @instance = @klass.new
+    end
+
+    should "allow inserting objects via use" do
+      assert @instance.empty?
+      @instance.use(:foo)
+      assert !@instance.empty?
+    end
+
+    should "store the length" do
+      assert_equal 0, @instance.length
+      @instance.use(:foo)
+      @instance.use(:bar)
+      assert_equal 2, @instance.length
+    end
+
+    should "allow inserting objects at specific indexes" do
+      @instance.use(:foo)
+      @instance.insert(0, :bar)
+      assert_equal [:bar, :foo], @instance.values
+    end
+
+    should "allow inserting objects at specified key" do
+      @instance.use(:foo)
+      @instance.insert_before(:foo, :bar)
+      assert_equal [:bar, :foo], @instance.values
+    end
+
+    should "allow inserting objects after specified key" do
+      @instance.use(:foo)
+      @instance.insert_after(:foo, :bar)
+      assert_equal [:foo, :bar], @instance.values
+    end
+
+    should "raise an exception if inserting after a nonexistent key" do
+      assert_raises(ArgumentError) {
+        @instance.insert_after(:foo, :bar)
+      }
+    end
+
+    should "allow swapping objects" do
+      @instance.use(:foo)
+      @instance.swap(:foo, :bar)
+      assert_equal :bar, @instance.values.first
+    end
+
+    should "allow deleting objects" do
+      @instance.use(:foo)
+      @instance.delete(:foo)
+      assert @instance.empty?
+    end
+
+    should "allow querying for the values in the array" do
+      @instance.use(:foo)
+      @instance.use(:bar)
+      assert_equal [:foo, :bar], @instance.values
+    end
+
+    should "return the index of the given items" do
+      @instance.use(:foo)
+      @instance.use(:bar)
+
+      assert_equal 0, @instance.index(:foo)
+      assert_equal 1, @instance.index(:bar)
+    end
+
+    should "return the numeric index untouched if given" do
+      assert_equal 12, @instance.index(12)
+    end
   end
 end

data/test/radar/exception_event_test.rb

@@ -7,6 +7,24 @@ class ExceptionEventTest < Test::Unit::TestCase
       @instance = create_exception_event
     end
 
+    should "generate a uniqueness hash" do
+      assert @instance.uniqueness_hash, "should have generated a uniqueness hash"
+    end
+
+    should "have a timestamp of when the exception occurred" do
+      assert @instance.occurred_at
+      assert @instance.occurred_at.is_a?(Time)
+    end
+
+    should "not have extra data by default" do
+      assert @instance.extra.empty?
+    end
+
+    should "allow for extra data to be present" do
+      @instance = create_exception_event(:foo => :bar)
+      assert_equal :bar, @instance.extra[:foo]
+    end
+
     context "to_hash" do
       context "data extensions" do
         setup do
@@ -15,7 +33,7 @@ class ExceptionEventTest < Test::Unit::TestCase
             def to_hash; { :exception => { :foo => :bar } }; end
           end
 
-          @instance.application.config.data_extension @extension
+          @instance.application.config.data_extensions.use @extension
           @result = @instance.to_hash
         end
 
@@ -35,14 +53,5 @@ class ExceptionEventTest < Test::Unit::TestCase
         assert_equal @instance.to_hash.to_json, @instance.to_json
       end
     end
-
-    should "generate a uniqueness hash" do
-      assert @instance.uniqueness_hash, "should have generated a uniqueness hash"
-    end
-
-    should "have a timestamp of when the exception occurred" do
-      assert @instance.occurred_at
-      assert @instance.occurred_at.is_a?(Time)
-    end
   end
 end

data/test/radar/matchers/backtrace_matcher_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class BacktraceMatcherTest < Test::Unit::TestCase
+  context "backtrace matcher class" do
+    setup do
+      @klass = Radar::Matchers::BacktraceMatcher
+    end
+
+    should "match if the backtrace matches a regexp" do
+      standard_event = create_exception_event { raise StandardError.new("An error") }
+      assert @klass.new(%r{/matchers/(.+)_test.rb}).matches?(standard_event)
+      assert !@klass.new(%r{/not_matchers/(.+)_test.rb}).matches?(standard_event)
+    end
+
+    should "match if the backtrace includes a substring" do
+      standard_event = create_exception_event { raise StandardError.new("An error") }
+      assert @klass.new("backtrace_matcher_test.rb").matches?(standard_event)
+      assert !@klass.new("not_real_matcher_test.rb").matches?(standard_event)
+    end
+
+    should "match only up to the specified depth" do
+      standard_event = create_exception_event { raise StandardError.new("An error") }
+      assert @klass.new("test_helper.rb", :depth => 5).matches?(standard_event)
+      assert !@klass.new("test_helper.rb", :depth => 1).matches?(standard_event)
+    end
+  end
+end

data/test/radar/matchers/class_matcher_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class ClassMatcherTest < Test::Unit::TestCase
+  context "class matcher class" do
+    setup do
+      @klass = Radar::Matchers::ClassMatcher
+    end
+
+    should "match if the class match exactly" do
+      standard_event = create_exception_event { raise StandardError.new("An error") }
+      assert @klass.new(RuntimeError).matches?(create_exception_event)
+      assert !@klass.new(RuntimeError).matches?(standard_event)
+    end
+
+    should "match regular expressions properly" do
+      standard_event = create_exception_event { raise StandardError.new("An error") }
+      assert @klass.new(/.*Error/).matches?(create_exception_event)
+      assert @klass.new(/.*Error/).matches?(standard_event)
+    end
+
+    should "match subclasses if specified" do
+      assert @klass.new(Exception, :include_subclasses => true).matches?(create_exception_event)
+      assert !@klass.new(Exception).matches?(create_exception_event)
+    end
+  end
+end

data/test/radar/reporter/file_reporter_test.rb

@@ -7,6 +7,10 @@ class FileReporterTest < Test::Unit::TestCase
       @instance = @klass.new
     end
 
+    should "default prune time to nil" do
+      assert @instance.prune_time.nil?
+    end
+
     should "allow output directory to be a lambda" do
       @instance.output_directory = lambda { |event| event.application.name }
       event = create_exception_event

data/test/radar/support_test.rb

@@ -22,5 +22,21 @@ class SupportTest < Test::Unit::TestCase
         assert_equal 2, result[:a][:b]
       end
     end
+
+    context "inflector" do
+      setup do
+        @klass = @klass::Inflector
+      end
+
+      should "camelize a string" do
+        assert_equal "ActiveRecord", @klass.camelize("active_record")
+        assert_equal "ActiveRecord::Errors", @klass.camelize("active_record/errors")
+      end
+
+      should "constantize a string" do
+        assert_equal Radar::Application, @klass.constantize("Radar::Application")
+        assert_equal Radar::Reporter::FileReporter, @klass.constantize("Radar::Reporter::FileReporter")
+      end
+    end
   end
 end

data/test/test_helper.rb

@@ -10,16 +10,17 @@ require "radar"
 class Test::Unit::TestCase
   # Returns a real {Radar::ExceptionEvent} object with a newly created
   # {Radar::Application} and a valid (has a backtrace) exception.
-  def create_exception_event
+  def create_exception_event(extra=nil)
     application = Radar::Application.new(:foo, false)
     exception = nil
 
     begin
+      yield if block_given?
       raise "Something bad happened!"
     rescue => e
       exception = e
     end
 
-    Radar::ExceptionEvent.new(application, exception)
+    Radar::ExceptionEvent.new(application, exception, extra)
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Mitchell Hashimoto
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-15 00:00:00 -07:00
+date: 2010-08-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -100,8 +100,10 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - .yardopts
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - README.md
 - Rakefile
 - docs/user_guide.md
@@ -111,6 +113,8 @@ files:
 - lib/radar/data_extensions/host_environment.rb
 - lib/radar/error.rb
 - lib/radar/exception_event.rb
+- lib/radar/matchers/backtrace_matcher.rb
+- lib/radar/matchers/class_matcher.rb
 - lib/radar/reporter.rb
 - lib/radar/reporter/file_reporter.rb
 - lib/radar/support.rb
@@ -120,6 +124,8 @@ files:
 - test/radar/config_test.rb
 - test/radar/data_extensions/host_environment_test.rb
 - test/radar/exception_event_test.rb
+- test/radar/matchers/backtrace_matcher_test.rb
+- test/radar/matchers/class_matcher_test.rb
 - test/radar/reporter/file_reporter_test.rb
 - test/radar/reporter_test.rb
 - test/radar/support_test.rb
@@ -138,7 +144,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 4451322989948183573
+      hash: -4581519538816896341
       segments: 
       - 0
       version: "0"