radar 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle/*
+doc/*
+.yardoc/*
+test.rb

data/.yardopts

@@ -0,0 +1,2 @@
+--files
+docs/user_guide.md

data/Gemfile

@@ -0,0 +1,11 @@
+source :gemcutter
+
+# Specify your gem's dependencies in radar.gemspec
+gemspec
+
+# Additional gems which I don't really want in the gemspec but
+# are useful for development
+group :development do
+  gem "yard", :git => "http://github.com/lsegal/yard.git"
+  gem "bluecloth"
+end

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GIT
+  remote: http://github.com/lsegal/yard.git
+  revision: bf84275
+  specs:
+    yard (0.6.0.rc1)
+
+PATH
+  remote: .
+  specs:
+    radar (0.1.0)
+      json (>= 1.4.6)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bluecloth (2.0.7)
+    json (1.4.6)
+    mocha (0.9.8)
+      rake
+    rake (0.8.7)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bluecloth
+  bundler (>= 1.0.0.rc.5)
+  json (>= 1.4.6)
+  mocha
+  radar!
+  rake
+  shoulda
+  yard!

data/README.md

@@ -0,0 +1,107 @@
+# Radar
+
+* Source: [http://github.com/mitchellh/radar](http://github.com/mitchellh/radar)
+* IRC: `#vagrant` on Freenode
+* User Guide: [http://mitchellh.github.com/radar/file.user_guide.html](http://mitchellh.github.com/radar/file.user_guide.html)
+* Documentation: [http://mitchellh.github.com/radar](http://mitchellh.github.com/radar)
+
+Radar is a tool which provides a drop-in solution to catching and reporting
+errors in your Ruby applications in customizable ways.
+
+Radar is not a typical exception notifier such as Hoptoad and Exceptional
+since the former are built with Rails apps in mind, logging to a central
+server. Instead, Radar was initially built for [Vagrant](http://vagrantup.com),
+a command line tool. And instead of solely logging to a central server,
+Radar supports logging in configurable ways (to a file, to a server, to
+a growl notification, etc.)
+
+Radar was built out of the need for an easy automated solution to catching
+exceptions and gathering information, since I noticed that every time a stack
+trace was outputted for [Vagrant](http://vagrantup.com), I was asking the
+user all the same questions which could've easily have been gathered automatically.
+Now, Vagrant users can simply send me the radar output and I don't have to
+ask for any more information 90% of the time.
+
+## Quick Start
+
+    gem install radar
+
+Then just begin logging exceptions in your application:
+
+    r = Radar::Application.new(:my_application)
+    r.config.reporter Radar::Reporter::FileReporter
+    r.report(exception)
+
+You can also tell Radar to attach itself to Ruby's `at_exit` hook
+so it can catch application-crashing exceptions automatically:
+
+    r.rescue_at_exit!
+
+Both of the above methods can be used together, of course.
+
+Since the above enabled the `FileReporter` for the application, reported
+exceptions will be stored in a text file on the local filesystem, by default
+at `~/.radar/errors/my_application`. Sample contents of the exception
+data generated by default is shown below. Note that you can add your own
+custom data to this output by using data extensions (covered in the user
+guide).
+
+    {
+       "application":{
+          "name":"my_application"
+       },
+       "exception":{
+          "klass":"RuntimeError",
+          "message":"This was an example exception",
+          "backtrace":[
+             "test.rb:28:in `<main>'"
+          ],
+          "uniqueness_hash":"296d169e7928c4433ccfcf091b4d737aabe83dcb"
+       },
+       "occurred_at":1281894743,
+       "host_environment":{
+          "ruby_version":"1.9.2",
+          "ruby_pl":-1,
+          "ruby_release_date":"2010-07-11",
+          "ruby_platform":"x86_64-darwin10.4.0"
+       }
+    }
+
+Also, instead of assigning the application to a variable, you may also
+look it up later anywhere in your application:
+
+    Radar::Application.find(:my_application).report(exception)
+
+    # Or the shorthand:
+    Radar[:my_application].report(exception)
+
+## Documentation and User Guide
+
+For more details on configuring Radar, please view the
+[user guide](http://mitchellh.github.com/radar/file.user_guide.html), which
+is a detailed overview of Radar and all of its features.
+
+## Reporting Bugs and Requesting Features
+
+Please use the [issues section](http://github.com/mitchellh/radar/issues) to report
+bugs and request features. This section is also used as the TODO area for the
+Radar gem.
+
+## Contributing
+
+To hack on Radar, you'll need [bundler](http://github.com/carlhuda/bundler) which
+can be installed with a simple `gem install bundler`. Then, do the following:
+
+    bundle install
+    rake
+
+This will run the test suite, which should come back all green! Then you're
+good to go.
+
+The general steps to contributing a new change are:
+
+1. Fork the repository
+2. Make your changes, writing tests if necessary
+3. Open an [issue](http://github.com/mitchellh/radar/issues) with the feature and
+   a link to your fork or a gist with a patch.
+4. Wait patiently, for I am but one man.

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rake/testtask'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = 'test/**/*_test.rb'
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+end

data/docs/user_guide.md

@@ -0,0 +1,197 @@
+# Radar User's Guide
+
+## Overview
+
+Radar is a tool which provides a drop-in solution to catching and reporting
+errors in your Ruby application via customizable mediums.
+
+## Installation
+
+Install via RubyGems:
+
+    gem install radar
+
+Or specify in your own library or application's `Gemfile` or `gemspec` so
+that the gem is included properly.
+
+## Basic Usage
+
+### Setup
+
+First, as early as possible in your application so that Radar can begin
+catching exceptions right away, create a new {Radar::Application}
+instance for your own app, replacing `my_application` with a unique name for your
+application.
+
+    Radar::Application.new(:my_application)
+
+But this alone won't do anything, since you haven't configured any reporters
+for the application. Reporters are what handle taking an {Radar::ExceptionEvent ExceptionEvent}
+and doing something with it (such as storing it in a file, reporting it to a
+remote server, etc.). Radar comes with some built-in reporters. Below, we configure
+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
+    end
+
+### Reporting Errors
+
+Once the application is setup, there are two methods to report errors:
+
+1. Manually call the {Radar::Application#report report} method on the application.
+2. Tell the application to {Radar::Application#rescue_at_exit! rescue at exit} so
+   Radar automatically catches any exceptions before your application crashes.
+
+Calling the report method manually:
+
+    app = Radar::Application.new(:my_application)
+    app.report(exception)
+
+The use case for this is in a `rescue` block somewhere, and forces Radar
+to report the given exception.
+
+Telling Radar to catch exceptions on exit is equally simple, and can be
+used in conjunction with the above method as well:
+
+    app = Radar::Application.new(:my_application)
+    app.rescue_at_exit!
+
+Now, whenever your application is about to crash (an exception not caught by
+a `rescue`), Radar will catch your exception and report it just prior to
+crashing.
+
+# Features
+
+## Reporters
+
+On its own, Radar does nothing but catch and shuttle exceptions to reporters. Without
+reporters, Radar is basically useless! A reporter is a class which takes an
+{Radar::ExceptionEvent} and does something with it. Its easier to get a better idea
+of what this means with a few examples:
+
+* `FileReporter` - Stores the data from an exception on the filesystem for each
+  exception.
+* `ServerReporter` - Transfers information about an exception to some remote
+  server.
+
+### Enabling and Configuring a Reporter
+
+Reporters are enabled using the appilication configuration:
+
+    Radar::Application.new(:my_application) do |app|
+      app.config.reporter 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"
+      end
+    end
+
+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
+    end
+
+### Built-in Reporters
+
+#### FileReporter
+
+{Radar::Reporter::FileReporter FileReporter} outputs exception information as JSON to a file
+on the local filesystem. The filename is in the format of `timestamp-uniquehash.txt`,
+where `timestamp` is the time that the exception occurred and `uniquehash` is the
+{Radar::ExceptionEvent#uniqueness_hash}.
+
+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|
+        reporter.output_directory = "~/my_application_errors"
+      end
+    end
+
+You may also use a lambda. Below is also the default value for the FileReporter:
+
+    reporter.output_directory = lambda { |event| "~/.radar/#{event.application.name}" }
+
+A few notes:
+
+* The FileReporter does not automatically handle cleaning up old exception files or reporting
+  these files to any remote server. It is up to you, if you wish, to clean up old
+  exception information.
+* The JSON output is compressed JSON, and is not pretty printed. It is up to you to take the
+  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.
+
+### Custom Reporters
+
+It is very easy to write custom reporters. A reporter is simply a class which
+responds to `report` and takes a single {Radar::ExceptionEvent} as a parameter.
+Below is an example of a reporter which simply prints out that an error
+occurred:
+
+    class StdoutReporter
+      def report(event)
+        puts "An exception occurred! Message: #{event.exception.message}"
+      end
+    end
+
+And then using that reporter is just as easy:
+
+    Radar::Application.new(:my_application) do |app|
+      app.config.reporter StdoutReporter
+    end
+
+## Data Extensions
+
+Data extensions allow you to easily extend the data represented by {Radar::ExceptionEvent#to_hash}.
+By default, Radar only sends a small amount of information about the host environment and the
+exception when an exception occurs. Often its more helpful to get more information about the
+environment to more easily track down a bug. Some examples:
+
+* HTTP request headers for a web application
+* Configuration settings for a desktop application
+
+### Defining Data Extensions
+
+Data extensions are defined with classes which are expected to be initialized
+with a reference to a {Radar::ExceptionEvent} and must implement the `to_hash`
+method. Below is a data extension to add the output of `uname -a` to the event:
+
+    class UnameExtension
+      def initialize(event)
+        @event = event
+      end
+
+      def to_hash
+        { :uname => `uname -a` }
+      end
+    end
+
+### Enabling Data Extensions
+
+Data extensions are enabled via the application configuration like most other
+things:
+
+    Radar::Application.new(:my_application) do |app|
+      app.config.data_extension UnameExtension
+    end
+
+### Built-In Data Extensions
+
+By default, {Radar::ExceptionEvent#to_hash} (view the source) returns very little
+information on its own. To be as general and extensible as possible, even the data
+such as information about the host are created using built-in data extensions.
+Some of these are enabled by default, which are designated by the `*` on the name.
+
+* {Radar::DataExtensions::HostEnvironment HostEnvironment}* - Adds information about the
+  host such as Ruby version and operating system.
+
+`*`: Enabled by default on every application.

data/lib/radar.rb

@@ -0,0 +1,18 @@
+require 'radar/version'
+require 'radar/error'
+
+module Radar
+  autoload :Application,    'radar/application'
+  autoload :Config,         'radar/config'
+  autoload :ExceptionEvent, 'radar/exception_event'
+  autoload :Reporter,       'radar/reporter'
+  autoload :Support,        'radar/support'
+
+  module DataExtensions
+    autoload :HostEnvironment, 'radar/data_extensions/host_environment'
+  end
+
+  class Reporter
+    autoload :FileReporter, 'radar/reporter/file_reporter'
+  end
+end

data/lib/radar/application.rb

@@ -0,0 +1,96 @@
+require 'thread'
+
+module Radar
+  # A shortcut for {Application.find}.
+  def [](*args)
+    Application.find(*args)
+  end
+  module_function :[]
+
+  # Represents an instance of Radar for a given application. Every
+  # application which uses Radar must instantiate an {Application}.
+  class Application
+    @@registered = {}
+    @@mutex = Mutex.new
+
+    attr_reader :name
+    attr_reader :creation_location
+
+    # Looks up an application which was registered with the given name.
+    #
+    # @param [String] name Application name.
+    # @return [Application]
+    def self.find(name)
+      @@registered[name]
+    end
+
+    # Removes all registered applications. **This is only exposed for testing
+    # purposes.**
+    def self.clear!
+      @@registered.clear
+    end
+
+    # Creates a new application with the given name and registers
+    # it for lookup later. If a block is given, it will be yielded with
+    # the new instantiated {Application} so you can also {#config} it
+    # all in one go.
+    #
+    # @param [String] name Application name. This must be unique for
+    #   any given application or an exception will be raised.
+    # @return [Application]
+    def initialize(name, register=true)
+      @@mutex.synchronize do
+        raise ApplicationAlreadyExists.new("'#{name}' already defined at '#{self.class.find(name).creation_location}'") if self.class.find(name)
+
+        @name = name
+        @creation_location = caller.first
+        yield self if block_given?
+        @@registered[name] = self if register
+      end
+    end
+
+    # Configures the application by returning the configuration
+    # object. If a block is given, the configuration object will be
+    # passed into it, allowing for a cleaner way of configuring your
+    # applications.
+    #
+    #     $app = Radar::Application.new
+    #     $app.config do |config|
+    #       config.storage_directory = "foo"
+    #     end
+    #
+    # @yield [Config] Configuration object, only if block is given.
+    # @return [Config]
+    def config
+      @_config ||= Config.new
+      yield @_config if block_given?
+      @_config
+    end
+
+    # Reports an exception. This will send the exception on to the
+    # various reporters configured for this application.
+    #
+    # @param [Exception] exception
+    def report(exception)
+      data = ExceptionEvent.new(self, exception)
+
+      # Report the exception to each of the reporters
+      config.reporters.each do |reporter|
+        reporter.report(data)
+      end
+    end
+
+    # Hooks this application into the `at_exit` handler so that
+    # application crashing exceptions are properly reported.
+    def rescue_at_exit!
+      at_exit { report($!) if $! }
+    end
+
+    # Converts application to a serialization-friendly hash.
+    #
+    # @return [Hash]
+    def to_hash
+      { :name => name }
+    end
+  end
+end

data/lib/radar/config.rb

@@ -0,0 +1,35 @@
+module Radar
+  class Config
+    attr_reader :reporters
+    attr_reader :data_extensions
+
+    def initialize
+      @reporters = []
+      @data_extensions = [DataExtensions::HostEnvironment]
+    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.
+    #
+    # @param [Class] klass A {Reporter} class.
+    def reporter(klass)
+      instance = klass.new
+      yield instance if block_given?
+      @reporters << instance
+    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.
+    #
+    # This method takes a class. This class is expected to be initialized
+    # with an {ExceptionEvent}, and must implement the `to_hash` method.
+    #
+    # @param [Class] klass
+    def data_extension(klass)
+      @data_extensions << klass
+    end
+  end
+end

data/lib/radar/data_extensions/host_environment.rb

@@ -0,0 +1,24 @@
+module Radar
+  module DataExtensions
+    # Data extension which adds information about the host environment:
+    #
+    # * Operating system
+    # * Ruby version
+    #
+    class HostEnvironment
+      def initialize(event)
+        @event = event
+      end
+
+      def to_hash
+        { :host_environment => {
+            :ruby_version      => (RUBY_VERSION rescue '?'),
+            :ruby_pl           => (RUBY_PATCHLEVEL rescue '?'),
+            :ruby_release_date => (RUBY_RELEASE_DATE rescue '?'),
+            :ruby_platform     => (RUBY_PLATFORM rescue '?')
+          }
+        }
+      end
+    end
+  end
+end

data/lib/radar/error.rb

@@ -0,0 +1,6 @@
+module Radar
+  # Represents an internal radar error. This class is made so its easy
+  # for users of radar to catch all radar related errors.
+  class Error < StandardError; end
+  class ApplicationAlreadyExists < Error; end
+end

data/lib/radar/exception_event.rb

@@ -0,0 +1,61 @@
+require 'digest/sha1'
+require 'json'
+
+module Radar
+  # Represents the event of an exception being captured. This class
+  # contains references to the {Application} and exception which is
+  # raised.
+  class ExceptionEvent
+    attr_reader :application
+    attr_reader :exception
+    attr_reader :occurred_at
+
+    def initialize(application, exception)
+      @application = application
+      @exception = exception
+      @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
+    # specified.
+    #
+    # @return [Hash]
+    def to_hash
+      result = { :application => application.to_hash,
+        :exception => {
+          :klass => exception.class.to_s,
+          :message => exception.message,
+          :backtrace => exception.backtrace,
+          :uniqueness_hash => uniqueness_hash
+        },
+        :occurred_at => occurred_at.to_i
+      }
+
+      if !application.config.data_extensions.empty?
+        application.config.data_extensions.each do |extension|
+          Support::Hash.deep_merge!(result, extension.new(self).to_hash)
+        end
+      end
+
+      result
+    end
+
+    # JSONified {#to_hash} output.
+    #
+    # @return [String]
+    def to_json
+      to_hash.to_json
+    end
+
+    # Returns uniqueness hash to test if one event is roughly equivalent to
+    # another. The uniqueness hash is generated by taking the exception
+    # backtrace and class and generating the SHA1 hash of those concatenated.
+    #
+    # @return [String]
+    def uniqueness_hash
+      Digest::SHA1.hexdigest("#{exception.class}-#{exception.backtrace rescue 'blank'}")
+    end
+  end
+end

data/lib/radar/reporter.rb

@@ -0,0 +1,29 @@
+module Radar
+  # This class defines the interface for a {Reporter}. A reporter
+  # is a class which takes exception information and "reports" it
+  # in some way. Examples of reporters (note that not all of these
+  # may be implemented; they are ideas):
+  #
+  # - FileReporter - Logs the exception out to a timestamped
+  #   file in a specified directory.
+  # - ServerReporter - Logs the exception to a server somewhere for
+  #   later retrieval.
+  # - GrowlReporter - Causes a Growl notification to occur, noting
+  #   that an exception occurred.
+  #
+  # From the examples above it is clear to see that the reporter doesn't
+  # necessarilly need to store the exception information anywhere, it
+  # is simply required to take some action in the event that an exception
+  # occurred.
+  #
+  # Radar allows for multiple reporters to be used together, so a reporter
+  # doesn't need to do everything. They're meant to be small units of
+  # functionality.
+  #
+  class Reporter
+    # Report the environment.
+    def report(environment)
+      raise "Implement the `report` method in #{self.class}"
+    end
+  end
+end

data/lib/radar/reporter/file_reporter.rb

@@ -0,0 +1,37 @@
+require 'fileutils'
+
+module Radar
+  class Reporter
+    # Reports exceptions by dumping the JSON data out to a file on the
+    # local filesystem. The reporter is configurable:
+    #
+    # * {#output_directory=}
+    #
+    class FileReporter
+      attr_accessor :output_directory
+
+      def initialize
+        @output_directory = lambda { |event| "~/.radar/errors/#{event.application.name}" }
+      end
+
+      def report(event)
+        output_file = File.join(File.expand_path(output_directory(event)), "#{event.occurred_at.to_i}-#{event.uniqueness_hash}.txt")
+
+        # Attempt to make the directory if it doesn't exist
+        FileUtils.mkdir_p File.dirname(output_file)
+
+        # Write out the JSON to the output file
+        File.open(output_file, 'w') { |f| f.write(event.to_json) }
+      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
+      # is returned as-is.
+      def output_directory(event=nil)
+        return @output_directory.call(event) if event && @output_directory.is_a?(Proc)
+        @output_directory
+      end
+    end
+  end
+end

data/lib/radar/support.rb

@@ -0,0 +1,25 @@
+module Radar
+  class Support
+    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)
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      # Modifies the receiver in place.
+      def self.deep_merge!(source, other)
+        other.each_pair do |k,v|
+          tv = source[k]
+          source[k] = tv.is_a?(::Hash) && v.is_a?(::Hash) ? deep_merge(tv, v) : v
+        end
+
+        source
+      end
+    end
+  end
+end

data/lib/radar/version.rb

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

data/radar.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'radar/version'
+
+Gem::Specification.new do |s|
+  s.name        = "radar"
+  s.version     = Radar::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mitchell Hashimoto"]
+  s.email       = ["mitchell.hashimoto@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/radar"
+  s.summary     = "Easily catch and report errors in your Ruby libraries and applications any way you want!"
+  s.description = "Radar provides a drop-in solution to catching and reporting errors in your libraries and applications."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "radar"
+
+  s.add_dependency "json", ">= 1.4.6"
+
+  s.add_development_dependency "bundler", ">= 1.0.0.rc.5"
+  s.add_development_dependency "shoulda"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "rake"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").select{|f| f =~ /^bin/}
+  s.require_path = 'lib'
+end

data/test/radar/application_test.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+class ApplicationTest < Test::Unit::TestCase
+  context "application class" do
+    setup do
+      @klass = Radar::Application
+      @instance = @klass.new("bar", false)
+    end
+
+    context "initializing" do
+      teardown do
+        @klass.clear!
+      end
+
+      should "be able to create for a name" do
+        instance = @klass.new("foo")
+        assert_equal "foo", instance.name
+      end
+
+      should "be able to lookup after created" do
+        instance = @klass.new("foo")
+        assert_equal instance, @klass.find("foo")
+      end
+
+      should "allow creation of unregistered applications" do
+        instance = @klass.new("foo", false)
+        assert_nil @klass.find("foo")
+      end
+
+      should "raise an exception if duplicate name is used" do
+        assert_raises(Radar::ApplicationAlreadyExists) {
+          @klass.new("foo")
+          @klass.new("foo")
+        }
+      end
+
+      should "yield with the instance if a block is given" do
+        @klass.new("foo") do |instance|
+          assert instance.is_a?(@klass)
+        end
+      end
+    end
+
+    context "configuration" do
+      setup do
+        @instance.config.reporters.clear
+
+        @reporter = Class.new
+      end
+
+      should "be able to configure an application" do
+        @instance.config.reporter(@reporter)
+        assert !@instance.config.reporters.empty?
+      end
+
+      should "be able to configure using a block" do
+        @instance.config do |config|
+          config.reporter(@reporter)
+        end
+
+        assert !@instance.config.reporters.empty?
+      end
+    end
+
+    context "reporting" do
+      setup do
+        # The fake reporter class
+        reporter = Class.new do
+          def report(environment)
+            raise "success"
+          end
+        end
+
+        # Setup the application to use the fake reporter
+        @instance.config do |config|
+          config.reporter reporter
+        end
+      end
+
+      should "call report on each registered reporter" do
+        assert_raises(RuntimeError) do
+          begin
+            @instance.report(Exception.new)
+          rescue => e
+            assert_equal "success", e.message
+            raise
+          end
+        end
+      end
+    end
+
+    context "to_hash" do
+      setup do
+        @hash = @instance.to_hash
+      end
+
+      should "contain name" do
+        assert_equal @instance.name, @hash[:name]
+      end
+    end
+
+    # Untested: Application#rescue_at_exit! since I'm not aware of an
+    # [easy] way of testing it without spawning out a separate process.
+  end
+end

data/test/radar/config_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class ConfigTest < Test::Unit::TestCase
+  context "configuration" do
+    setup do
+      @klass = Radar::Config
+      @instance = @klass.new
+    end
+
+    context "reporters" do
+      setup do
+        @reporter_klass = Class.new
+      end
+
+      teardown do
+        @instance.reporters.clear
+      end
+
+      should "initially have no reporters" do
+        assert @instance.reporters.empty?
+      end
+
+      should "be able to add reporters" do
+        @instance.reporter @reporter_klass
+        assert !@instance.reporters.empty?
+        assert @instance.reporters.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|
+          reporter.some_method
+        end
+      end
+    end
+
+    context "data extensions" do
+      setup do
+        @extension = Class.new do
+          def initialize(event)
+          end
+        end
+      end
+
+      teardown do
+        @instance.data_extensions.clear
+      end
+
+      should "initially have some data extensions" do
+        assert_equal [Radar::DataExtensions::HostEnvironment], @instance.data_extensions
+      end
+
+      should "be able to add data extensions" do
+        @instance.data_extension @extension
+        assert !@instance.data_extensions.empty?
+      end
+    end
+  end
+end

data/test/radar/data_extensions/host_environment_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class HostEnvironmentDataTest < Test::Unit::TestCase
+  context "host environment class" do
+    setup do
+      @klass = Radar::DataExtensions::HostEnvironment
+      @instance = @klass.new(create_exception_event)
+    end
+
+    should "be able to convert to a hash" do
+      result = @instance.to_hash
+      assert result.is_a?(Hash)
+    end
+  end
+end

data/test/radar/exception_event_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class ExceptionEventTest < Test::Unit::TestCase
+  context "ExceptionEvent class" do
+    setup do
+      @klass = Radar::ExceptionEvent
+      @instance = create_exception_event
+    end
+
+    context "to_hash" do
+      context "data extensions" do
+        setup do
+          @extension = Class.new do
+            def initialize(event); @event = event; end
+            def to_hash; { :exception => { :foo => :bar } }; end
+          end
+
+          @instance.application.config.data_extension @extension
+          @result = @instance.to_hash
+        end
+
+        should "include data extensions if defined" do
+          assert @result[:exception].has_key?(:foo), "instance should have key: foo"
+          assert_equal :bar, @result[:exception][:foo]
+        end
+
+        should "deep merge information" do
+          assert @result[:exception].has_key?(:klass)
+        end
+      end
+    end
+
+    context "to_json" do
+      should "just jsonify hash output" do
+        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/reporter/file_reporter_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class FileReporterTest < Test::Unit::TestCase
+  context "file reporter class" do
+    setup do
+      @klass = Radar::Reporter::FileReporter
+      @instance = @klass.new
+    end
+
+    should "allow output directory to be a lambda" do
+      @instance.output_directory = lambda { |event| event.application.name }
+      event = create_exception_event
+      assert_equal event.application.name, @instance.output_directory(event)
+    end
+
+    should "allow output directory to be a string" do
+      value = "value"
+      @instance.output_directory = value
+      assert_equal value, @instance.output_directory
+    end
+
+    should "just return the lambda if no event is given to read" do
+      @instance.output_directory = lambda {}
+      assert @instance.output_directory.is_a?(Proc)
+    end
+  end
+end

data/test/radar/reporter_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class ReporterTest < Test::Unit::TestCase
+  context "reporter class" do
+    setup do
+      @klass = Radar::Reporter
+      @instance = @klass.new
+    end
+
+    should "raise an exception for an unimplemented reporter" do
+      assert_raises(RuntimeError) { @instance.report(nil) }
+    end
+  end
+end

data/test/radar/support_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class SupportTest < Test::Unit::TestCase
+  context "Support class" do
+    setup do
+      @klass = Radar::Support
+    end
+
+    context "hash" do
+      should "deep merge simple hashes" do
+        result = @klass::Hash.deep_merge({ :a => 1 }, { :b => 2 })
+        assert_equal 1, result[:a]
+        assert_equal 2, result[:b]
+      end
+
+      should "support deep merging" do
+        a = { :a => { :a => 1 } }
+        b = { :a => { :b => 2 } }
+
+        result = @klass::Hash.deep_merge(a, b)
+        assert_equal 1, result[:a][:a]
+        assert_equal 2, result[:a][:b]
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require "rubygems"
+require "bundler/setup"
+require "test/unit"
+require "shoulda"
+require "mocha"
+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
+    application = Radar::Application.new(:foo, false)
+    exception = nil
+
+    begin
+      raise "Something bad happened!"
+    rescue => e
+      exception = e
+    end
+
+    Radar::ExceptionEvent.new(application, exception)
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification 
+name: radar
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mitchell Hashimoto
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-15 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 6
+        version: 1.4.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        - rc
+        - 5
+        version: 1.0.0.rc.5
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+description: Radar provides a drop-in solution to catching and reporting errors in your libraries and applications.
+email: 
+- mitchell.hashimoto@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .yardopts
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- docs/user_guide.md
+- lib/radar.rb
+- lib/radar/application.rb
+- lib/radar/config.rb
+- lib/radar/data_extensions/host_environment.rb
+- lib/radar/error.rb
+- lib/radar/exception_event.rb
+- lib/radar/reporter.rb
+- lib/radar/reporter/file_reporter.rb
+- lib/radar/support.rb
+- lib/radar/version.rb
+- radar.gemspec
+- test/radar/application_test.rb
+- test/radar/config_test.rb
+- test/radar/data_extensions/host_environment_test.rb
+- test/radar/exception_event_test.rb
+- test/radar/reporter/file_reporter_test.rb
+- test/radar/reporter_test.rb
+- test/radar/support_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/radar
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 4451322989948183573
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: radar
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Easily catch and report errors in your Ruby libraries and applications any way you want!
+test_files: []
+