radar 0.2.0 → 0.3.0

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

@@ -0,0 +1,19 @@
+# Provides a generator to rails 3 to generate the initializer
+# file in `config/initializers/radar.rb`. This class is not
+# scoped since Rails generates the generator scope based on
+# the Ruby scope (e.g. this allows the command to just be
+# "rails g radar" instead of "rails g radar:integrations:rails3:radar"
+# or some other crazy string).
+class RadarGenerator < Rails::Generators::Base
+  source_root File.expand_path("../templates", __FILE__)
+
+  desc "Creates a Radar initializer"
+
+  def copy_initializer
+    template "radar.rb", "config/initializers/radar.rb"
+  end
+
+  def show_readme
+    readme "README"
+  end
+end

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

@@ -0,0 +1,12 @@
+require "rails"
+
+module Radar
+  # The Radar Railtie allows Radar to integrate with Rails 3 by
+  # adding generators. **This file is only loaded automatically
+  # for Rails 3**.
+  class Railtie < Rails::Railtie
+    generators do
+      require File.expand_path("../generator", __FILE__)
+    end
+  end
+end

data/lib/radar/integration/rails3/templates/README

@@ -0,0 +1,17 @@
+
+================================================================================
+
+Radar has been setup for this Rails 3 project! BUT...
+
+Some manual work you must complete before Radar is completely prepared:
+
+  * Open `config/initializers/radar.rb` and add at least one reporter to
+    the Radar application so Radar knows how you'd like your exceptions
+    handled. Example (this would go in the block in that file):
+
+      app.config.reporters.use :file
+
+Once a reporter is added, Radar has already been setup to integrate with
+Rails 3, so you may use your application like normal.
+
+================================================================================

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

@@ -0,0 +1,15 @@
+# This creates a Radar application for your Rails app. Use the block
+# to configure it. For detailed documentation, please see the user guide
+# online at: http://radargem.com/file.user_guide.html
+Radar::Application.new(:<%= Rails.application.class.to_s.underscore.tr('/', '_') %>) do |app|
+  # ==> Reporter Configuration
+  # Configure any reporters here. Reporters tell Radar how to report exceptions.
+  # This may be to a file, to a server, to a stream, etc. At least one reporter
+  # is required for Radar to do something with your exceptions. By default,
+  # Radar reports to the Rails logger. Change this if you want to report to
+  # a file, a server, etc.
+  app.reporters.use :logger, :log_object => Rails.logger, :log_level => :error
+
+  # Tell Radar to integrate this application with Rails 3.
+  app.integrate :rails3
+end

data/lib/radar/logger.rb

@@ -0,0 +1,37 @@
+require 'logger'
+require 'fileutils'
+
+module Radar
+  # A lightweight logger which logs what Radar does to a single
+  # configurable location. This logger is simply meant as a way
+  # you can verify that Radar is working as intended, and not meant
+  # as a logger of every exception's data; this is the job of {Reporter}s.
+  class Logger < ::Logger
+    attr_reader :application
+
+    def initialize(application)
+      @application = application
+      super(log_location)
+    end
+
+    def format_message(severity, timestamp, progname, message)
+      "[#{application.name}][#{severity[0,1].upcase}][#{timestamp}] -- #{message}\n"
+    end
+
+    # Returns the location of the logfile. This is configurable using
+    # {Config#log_location=}.
+    #
+    # @return [String]
+    def log_location
+      location = @application.config.log_location
+      location = location.is_a?(Proc) ? location.call(application) : location
+
+      if location.is_a?(String)
+        directory = File.dirname(location)
+        FileUtils.mkdir_p(directory) if !File.directory?(directory)
+      end
+
+      location
+    end
+  end
+end

data/lib/radar/reporter/file_reporter.rb

@@ -35,23 +35,34 @@ module Radar
       attr_accessor :output_directory
       attr_accessor :prune_time
 
-      def initialize
-        @output_directory = lambda { |event| "~/.radar/errors/#{event.application.name}" }
-        @prune_time = nil
+      def initialize(opts=nil)
+        (opts || {}).each do |k,v|
+          send("#{k}=", v)
+        end
+
+        @output_directory ||= lambda { |event| "~/.radar/errors/#{event.application.name}" }
       end
 
       def report(event)
+        @event = 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 directory
+        begin
+          # Attempt to make the directory if it doesn't exist
+          FileUtils.mkdir_p(directory) if !File.directory?(directory)
 
-        # Prune files if enabled
-        prune(directory) if prune_time
+          # 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) }
+          # Write out the JSON to the output file
+          log("#{self.class}: Reported to #{output_file}")
+          File.open(output_file, 'w') { |f| f.write(event.to_json) }
+        rescue Errno::EACCES
+          # Rebrand the exception so its easier to tell what exactly
+          # is going on.
+          raise ReporterError.new("#{self.class}: Failed to create directory or log to: #{output_file}")
+        end
       end
 
       # Prunes the files in the given directory according to the age limit
@@ -59,11 +70,19 @@ module Radar
       #
       # @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
+        count = Dir[File.join(directory, "*.txt")].inject(0) do |acc, file|
+          next acc unless File.file?(file)
+          next acc unless (Time.now.to_i - File.ctime(file).to_i) >= prune_time.to_i
           File.delete(file)
+          acc + 1
         end
+
+        log("Pruned #{count} file(s) in #{directory}.") if count > 0
+      end
+
+      # Convenience method for logging.
+      def log(message)
+        @event.application.logger.info("#{self.class}: #{message}") if @event
       end
 
       # Returns the currently configured output directory. If `event` is given

data/lib/radar/reporter/io_reporter.rb

@@ -0,0 +1,35 @@
+module Radar
+  class Reporter
+    # A reporter which simply dumps the event JSON out to some IO
+    # object. If you're outputting to a file, you should look into
+    # {FileReporter} instead, which will automatically create unique
+    # filenames per exception.
+    #
+    # Some uses for this reporter:
+    #
+    #   - Output to `stderr`, since a process's `stderr` may be redirected
+    #     to a log file already.
+    #   - Output to `stdout`, just for testing.
+    #   - Output to some network IO stream to talk to a server across
+    #     a network.
+    #
+    class IoReporter
+      attr_accessor :io_object
+
+      def initialize(opts=nil)
+        (opts || {}).each do |k,v|
+          send("#{k}=", v)
+        end
+      end
+
+      def report(event)
+        return if !io_object
+        raise ArgumentError.new("IoReporter `io_object` must be an IO object.") if !io_object.is_a?(IO)
+
+        # Straight push the object to the object and flush immediately
+        io_object.puts(event.to_json)
+        io_object.flush
+      end
+    end
+  end
+end

data/lib/radar/reporter/logger_reporter.rb

@@ -0,0 +1,31 @@
+module Radar
+  class Reporter
+    # A reporter which logs to a Ruby `Logger`-like object (any object
+    # which responds to the various log levels). This reporter is useful
+    # 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
+    #
+    class LoggerReporter
+      attr_accessor :log_object
+      attr_accessor :log_level
+
+      def initialize(opts=nil)
+        (opts || {}).each do |k,v|
+          send("#{k}=", v)
+        end
+
+        @log_level ||= :error
+      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)
+      end
+    end
+  end
+end

data/lib/radar/version.rb

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

data/radar.gemspec

@@ -1,6 +1,4 @@
-# -*- encoding: utf-8 -*-
-$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
-require 'radar/version'
+require File.expand_path("../lib/radar/version", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "radar"
@@ -23,6 +21,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake"
 
   s.files        = `git ls-files`.split("\n")
-  s.executables  = `git ls-files`.split("\n").select{|f| f =~ /^bin/}
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
   s.require_path = 'lib'
 end

data/test/radar/application_test.rb

@@ -62,6 +62,14 @@ class ApplicationTest < Test::Unit::TestCase
       end
     end
 
+    context "logger" do
+      should "provide a logger which is initialized on access" do
+        Radar::Logger.expects(:new).with(@instance).once.returns("foo")
+        @instance.logger
+        @instance.logger
+      end
+    end
+
     context "reporting" do
       should "call report on each registered reporter" do
         reporter = Class.new do
@@ -117,6 +125,18 @@ class ApplicationTest < Test::Unit::TestCase
       end
     end
 
+    context "integrations" do
+      should "integrate with built-in integrators" do
+        Radar::Integration::Rack.expects(:integrate!).with(@instance)
+        @instance.integrate(:rack)
+      end
+
+      should "integrate with specified classes" do
+        Radar::Integration::Rack.expects(:integrate!).with(@instance)
+        @instance.integrate(Radar::Integration::Rack)
+      end
+    end
+
     context "to_hash" do
       setup do
         @hash = @instance.to_hash
@@ -127,6 +147,24 @@ class ApplicationTest < Test::Unit::TestCase
       end
     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
+      end
+
+      should "delegate filters" do
+        assert_equal @instance.config.filters, @instance.filters
+      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

data/test/radar/config_test.rb

@@ -26,6 +26,12 @@ class ConfigTest < Test::Unit::TestCase
         assert @instance.reporters.values.first.is_a?(@reporter_klass)
       end
 
+      should "be able to add reporters via built-in symbols" do
+        @instance.reporters.use :file
+        assert !@instance.reporters.empty?
+        assert @instance.reporters.values.first.is_a?(Radar::Reporter::FileReporter)
+      end
+
       should "yield the reporter instance if a block is given" do
         @reporter_klass.any_instance.expects(:some_method).once
         @instance.reporters.use @reporter_klass do |reporter|
@@ -54,6 +60,11 @@ class ConfigTest < Test::Unit::TestCase
         @instance.data_extensions.use @extension
         assert !@instance.data_extensions.empty?
       end
+
+      should "be able to add built-in extensions via symbols" do
+        @instance.data_extensions.use :rack
+        assert_equal Radar::DataExtensions::Rack, @instance.data_extensions.values.last
+      end
     end
 
     context "matchers" do
@@ -75,6 +86,29 @@ class ConfigTest < Test::Unit::TestCase
         @instance.match @matcher
         assert !@instance.matchers.empty?
       end
+
+      should "be able to use built-in matchers as symbols" do
+        @instance.match :class, Object
+        assert @instance.matchers.values.first.is_a?(Radar::Matchers::ClassMatcher)
+      end
+    end
+
+    context "filters" do
+      teardown do
+        @instance.filters.clear
+      end
+
+      should "raise an ArgumentError if no class or lambda is given" do
+        assert_raises(ArgumentError) { @instance.filters.use }
+      end
+
+      should "be able to use just a block" do
+        assert_nothing_raised {
+          @instance.filters.use do |foo|
+          end
+        }
+        assert_equal 1, @instance.filters.length
+      end
     end
   end
 

data/test/radar/data_extensions/rack_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class RackDataTest < Test::Unit::TestCase
+  context "rack data extension class" do
+    setup do
+      @klass = Radar::DataExtensions::Rack
+      @event = create_exception_event
+      @instance = @klass.new(@event)
+    end
+
+    should "be able to convert to a hash" do
+      assert @instance.respond_to?(:to_hash)
+      assert @instance.to_hash.is_a?(Hash)
+    end
+
+    should "merge in only HTTP headers" do
+      @event.extra[:rack_env] = {
+        "HTTP_CONTENT_TYPE" => "text/html",
+        "other"    => "baz"
+      }
+
+      result = @instance.to_hash
+      assert result[:request][:headers].has_key?("Content-Type")
+      assert !result[:request][:headers].has_key?("other")
+    end
+
+    context "merging in rack environment properly" do
+      setup do
+        @event.extra[:rack_env] = {
+          "HTTP_CONTENT_TYPE" => "text/html",
+          "other"             => 7,
+          "else"              => Class.new.new
+        }
+
+        @result = @instance.to_hash[:request][:rack_env]
+      end
+
+      should "not merge in the HTTP headers" do
+        assert !@result.has_key?("HTTP_CONTENT_TYPE")
+      end
+
+      should "merge in the numeric value as-is" do
+        assert_equal 7, @result["other"]
+      end
+
+      should "merge in the foreign class as a string" do
+        assert_equal @event.extra[:rack_env]["else"].to_s, @result["else"]
+      end
+    end
+  end
+end

data/test/radar/exception_event_test.rb

@@ -45,6 +45,26 @@ class ExceptionEventTest < Test::Unit::TestCase
         should "deep merge information" do
           assert @result[:exception].has_key?(:klass)
         end
+
+        should "deep merge properly even if to_hash returns nil" do
+          @extension.any_instance.stubs(:to_hash).returns(nil)
+          assert_nothing_raised { @instance.to_hash }
+        end
+      end
+
+      context "filters" do
+        should "have an application key by default" do
+          assert @instance.to_hash.has_key?(:application)
+        end
+
+        should "not filter out the application key with filter" do
+          @instance.application.config.filters.use do |data|
+            data.delete(:application)
+            data
+          end
+
+          assert !@instance.to_hash.has_key?(:application)
+        end
       end
     end