exceptional 2.0.0

data/bin/exceptional

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+case command
+  when 'help'
+    puts <<USAGE
+help               # show this usage
+test               # send a test exception to exceptional
+install <api_key>  # create config/exceptional.yml with your api_key. Overrites existing one.
+USAGE
+  when 'test'
+    puts "Loading Rails environment."
+    require(File.join('config', 'boot'))
+    require(File.join(RAILS_ROOT, 'config', 'environment'))
+    require "exceptional/integration/tester"
+    unless Exceptional::Config.api_key.blank?
+      Exceptional::Integration.test
+    end
+  when 'install'
+    api_key = args[0]
+    if (api_key.nil?)
+      puts 'missing required paramater <api-key>. Check your app configuration at http://getexceptional.com'
+    else
+      unless File.file?('config/environment.rb')
+        puts "Run this command from the root of your rails application"
+      else
+        config_file = File.open('config/exceptional.yml', 'w')
+        config_file.puts("api-key: #{api_key}\n")
+        config_file.close
+        puts "Config file written as config/exceptional.yml"
+      end
+    end
+end

data/exceptional.gemspec

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name = %q{exceptional}
+  s.version = "2.0.0"
+  s.authors = ["Contrast"]
+  s.summary = %q{Exceptional is the core Ruby library for communicating with http://getexceptional.com (hosted error tracking service)}
+  s.description = %q{Exceptional is the core Ruby library for communicating with http://getexceptional.com (hosted error tracking service). Use it to find out about errors that happen in your live app. It captures lots of helpful information to help you fix the errors.}
+  s.email = %q{hello@contrast.ie}
+  s.files =  Dir['lib/**/*'] + Dir['spec/**/*'] + Dir['spec/**/*'] + Dir['rails/**/*'] + Dir['tasks/**/*'] + Dir['*.rb'] + ["exceptional.gemspec"]
+  s.homepage = %q{http://getexceptional.com/}
+  s.require_paths = ["lib"]
+  s.executables << 'exceptional'
+  s.rubyforge_project = %q{exceptional}
+  s.add_dependency('json', ">= 1.0.0")
+end

data/init.rb

@@ -0,0 +1,24 @@
+require 'exceptional'
+
+# If old plugin still installed then we don't want to install this one.
+# In production environments we should continue to work as before, but in development/test we should
+# advise how to correct the problem and exit
+if defined?(Exceptional::VERSION::STRING) && %w(development test).include?(RAILS_ENV)
+  message = %Q(
+  ***********************************************************************
+  You seem to still have an old version of the exceptional plugin installed.
+  Remove it from /vendor/plugins and try again.
+  ***********************************************************************
+  )
+  puts message
+  exit -1
+else
+  begin
+    Exceptional::Config.load(File.join(RAILS_ROOT, "/config/exceptional.yml"))
+    Exceptional::Startup.announce
+    require File.join('exceptional', 'integration', 'rails')
+  rescue => e
+    STDERR.puts "Problem starting Exceptional Plugin. Your app will run as normal."
+    STDERR.puts e
+  end
+end

data/install.rb

@@ -0,0 +1,19 @@
+# This is the post install hook for when Exceptional is installed as a plugin.
+require 'ftools'
+
+# puts IO.read(File.join(File.dirname(__FILE__), 'README'))
+
+config_file = File.expand_path("#{File.dirname(__FILE__)}/../../../config/exceptional.yml")
+example_config_file = "#{File.dirname(__FILE__)}/exceptional.yml"
+
+if File::exists? config_file
+  puts "Exceptional config file already exists. Please ensure it is up-to-date with the current format."
+  puts "See #{example_config_file}"
+else  
+  puts "Installing default Exceptional config"
+  puts "  From #{example_config_file}"
+  puts "For exceptional to work you need to configure your API Key"
+  puts "  See #{example_config_file}"
+  puts "If you don't have an API Key, get one at http://getexceptional.com/"
+  File.copy example_config_file, config_file
+end

data/lib/exceptional.rb

@@ -0,0 +1,33 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'exceptional/catcher'
+require 'exceptional/startup'
+require 'exceptional/log_factory'
+require 'exceptional/config'
+require 'exceptional/application_environment'
+require 'exceptional/exception_data'
+require 'exceptional/remote'
+require 'exceptional/integration/rack'
+
+module Exceptional
+  PROTOCOL_VERSION = 5
+  VERSION = '0.2.0'
+  CLIENT_NAME = 'getexceptional-rails-plugin'
+
+  def self.logger
+    ::Exceptional::LogFactory.logger
+  end
+
+  def self.configure(api_key)
+    Exceptional::Config.api_key = api_key
+  end
+
+  def self.rescue(&block)
+    begin
+      block.call
+    rescue Exception => e
+      Exceptional::Catcher.handle(e)
+      raise(e)
+    end
+  end
+end

data/lib/exceptional/application_environment.rb

@@ -0,0 +1,62 @@
+require 'digest/md5'
+
+module Exceptional
+  class ApplicationEnvironment
+    def self.to_hash
+      hash = {
+        'client' => {
+          'name' => Exceptional::CLIENT_NAME,
+          'version' => Exceptional::VERSION,
+          'protocol_version' => Exceptional::PROTOCOL_VERSION
+        },
+        'application_environment' => {
+          'environment' => environment,
+          'env' => extract_environment(ENV),
+          'host' => get_hostname,
+          'run_as_user' => get_username,
+          'application_root_directory' => application_root,
+          'language' => 'ruby',
+          'language_version' => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} #{RUBY_RELEASE_DATE} #{RUBY_PLATFORM}",
+          'framework' => framework,
+          'libraries_loaded' => libraries_loaded
+        }
+      }
+      hash
+    end
+
+    def self.framework
+      defined?(RAILS_ENV) ? "rails" : nil
+    end
+
+    def self.environment
+      Config.application_environment
+    end
+
+    def self.application_root
+      Config.application_root
+    end
+
+    def self.extract_environment(env)
+      env.reject{|k, v| k =~ /^HTTP_/}
+    end
+
+    def self.get_hostname
+      require 'socket' unless defined?(Socket)
+      Socket.gethostname
+    rescue
+      'UNKNOWN'
+    end
+
+    def self.get_username
+      ENV['LOGNAME'] || ENV['USER'] || ENV['USERNAME'] || ENV['APACHE_RUN_USER'] || 'UNKNOWN'
+    end
+
+    def self.libraries_loaded
+      begin
+        return Hash[*Gem.loaded_specs.map{|name, gem_specification| [name, gem_specification.version.to_s]}.flatten]
+      rescue
+      end
+      {}
+    end
+  end
+end

data/lib/exceptional/catcher.rb

@@ -0,0 +1,12 @@
+module Exceptional
+  class Catcher
+    class << self
+      def handle(exception, controller=nil, request=nil)
+        if Config.should_send_to_api?
+          data = ExceptionData.new(exception, controller, request)
+          Remote.error(data)
+        end
+      end
+    end
+  end
+end

data/lib/exceptional/config.rb

@@ -0,0 +1,85 @@
+module Exceptional
+  class Config
+    class << self
+      DEFAULTS = {
+        :ssl_enabled => false,
+        :remote_host_http => 'api.getexceptional.com',
+        :remote_port_http => 80,
+        :remote_host_https => 'getexceptional.appspot.com',
+        :remote_port_https => 443,
+        :http_open_timeout => 2,
+        :http_read_timeout => 4,
+        :disabled_by_default => %w(development test)
+      }
+
+      attr_accessor :api_key
+      attr_accessor :http_proxy_host, :http_proxy_port, :http_proxy_username, :http_proxy_password
+      attr_writer :ssl_enabled
+
+      def load(config_file=nil)
+        if (config_file && File.file?(config_file))
+          begin
+            config = YAML::load(File.open(config_file))
+            env_config = config[application_environment] || {}
+            @api_key = config['api-key'] || env_config['api-key']
+
+            @http_proxy_host = config['http-proxy-host']
+            @http_proxy_port = config['http-proxy-port']
+            @http_proxy_username = config['http-proxy-username']
+            @http_proxy_password = config['http-proxy-password']
+            @http_open_timeout = config['http-open-timeout']
+            @http_read_timeout = config['http-read-timeout'] 
+
+            @ssl_enabled = config['ssl'] || env_config['ssl']
+            @enabled = env_config['enabled']
+            @remote_port = config['remote-port'].to_i unless config['remote-port'].nil?
+            @remote_host = config['remote-host'] unless config['remote-host'].nil?
+          rescue Exception => e
+            raise ConfigurationException.new("Unable to load configuration #{config_file} for environment #{application_environment} : #{e.message}")
+          end
+        end
+      end
+
+      def api_key
+        return @api_key unless @api_key.nil?
+        @api_key ||= ENV['EXCEPTIONAL_API_KEY'] unless ENV['EXCEPTIONAL_API_KEY'].nil?
+      end
+
+      def application_environment
+        ENV['RACK_ENV'] || ENV['RAILS_ENV']|| 'development'
+      end
+
+      def should_send_to_api?
+        @enabled ||= DEFAULTS[:disabled_by_default].include?(application_environment) ? false : true
+      end
+
+      def application_root
+        defined?(RAILS_ROOT) ? RAILS_ROOT : Dir.pwd
+      end
+
+      def ssl_enabled?
+        @ssl_enabled ||= DEFAULTS[:ssl_enabled]
+      end
+
+      def remote_host
+        @remote_host ||= ssl_enabled? ? DEFAULTS[:remote_host_https] : DEFAULTS[:remote_host_http]
+      end
+
+      def remote_port
+        @remote_port ||= ssl_enabled? ? DEFAULTS[:remote_port_https] : DEFAULTS[:remote_port_http]
+      end
+
+      def reset
+        @enabled = @ssl_enabled = @remote_host = @remote_port = @api_key = nil
+      end
+
+      def http_open_timeout
+        @http_open_timeout ||= DEFAULTS[:http_open_timeout]
+      end
+
+      def http_read_timeout
+        @http_read_timeout ||= DEFAULTS[:http_read_timeout]
+      end
+    end
+  end
+end

data/lib/exceptional/exception_data.rb

@@ -0,0 +1,95 @@
+require 'digest/md5'
+
+module Exceptional
+  class ExceptionData
+    def initialize(exception, controller=nil, request=nil)
+      @exception = exception
+      @request = request
+      @controller = controller
+    end
+
+    def to_hash
+      hash = ::Exceptional::ApplicationEnvironment.to_hash
+      hash.merge!({
+        'exception' => {
+          'exception_class' => @exception.class.to_s,
+          'message' => @exception.message,
+          'backtrace' => @exception.backtrace,
+          'occurred_at' => Time.now.strftime("%Y%m%d %H:%M:%S %Z")
+        }
+      })
+      unless @request.nil?
+        hash.merge!({
+          'request' => {
+            'url' => "#{@request.protocol}#{@request.host}#{@request.request_uri}",
+            'controller' => @controller.class.to_s,
+            'action' => @request.parameters['action'],
+            'parameters' => filter_paramaters(@request.parameters),
+            'request_method' => @request.request_method.to_s,
+            'remote_ip' => @request.remote_ip,
+            'headers' => extract_http_headers(@request.env),
+            'session' => Exceptional::ExceptionData.sanitize_session(@request)
+          }
+        })
+      end
+      hash
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def uniqueness_hash
+      return nil if @exception.backtrace.blank?
+      Digest::MD5.hexdigest(@exception.backtrace.join)
+    end
+
+    def filter_paramaters(hash)
+      if @controller.respond_to?(:filter_parameters)
+        @controller.send(:filter_parameters, hash)
+      else
+        hash
+      end
+    end
+
+    def extract_http_headers(env)
+      headers = {}
+      env.select{|k, v| k =~ /^HTTP_/}.each do |name, value|
+        proper_name = name.sub(/^HTTP_/, '').split('_').map{|upper_case| upper_case.capitalize}.join('-')
+        headers[proper_name] = value
+      end
+      unless headers['Cookie'].nil?
+        headers['Cookie'] = headers['Cookie'].sub(/_session=\S+/, '_session=[FILTERED]')
+      end
+      headers
+    end
+
+    def self.sanitize_hash(hash)
+      case hash
+        when Hash
+          hash.inject({}) do |result, (key, value)|
+            result.update(key => sanitize_hash(value))
+          end
+        when Fixnum, Array, String, Bignum
+          hash
+        else
+          hash.to_s
+      end
+    rescue
+      {}
+    end
+
+    def self.sanitize_session(request)
+      session = request.session
+      session_hash = {}
+      session_hash['session_id'] = request.session_options ? request.session_options[:id] : nil
+      session_hash['session_id'] ||= session.respond_to?(:session_id) ? session.session_id : session.instance_variable_get("@session_id")
+      session_hash['data'] = session.respond_to?(:to_hash) ? session.to_hash : session.instance_variable_get("@data") || {}
+      session_hash['session_id'] ||= session_hash['data'][:session_id]
+      session_hash['data'].delete(:session_id)
+      ExceptionData.sanitize_hash(session_hash)
+    rescue
+      {}
+    end
+  end
+end

data/lib/exceptional/integration/rack.rb

@@ -0,0 +1,14 @@
+module Exceptional
+  class Rack
+    def initialize(app, api_key)
+      @app = app
+      @api_key= api_key
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => e
+      raise e
+    end
+  end
+end

data/lib/exceptional/integration/rails.rb

@@ -0,0 +1,26 @@
+# force Rails < 2.0 to use quote keys as per the JSON standard...
+if defined?(ActiveSupport) && defined?(ActiveSupport::JSON) && ActiveSupport::JSON.respond_to?(:unquote_hash_key_identifiers)
+  ActiveSupport::JSON.unquote_hash_key_identifiers = false
+end
+
+if defined? ActionController
+  module ActionController
+    class Base
+      def rescue_action_with_exceptional(exception)
+        unless exception_handled_by_rescue_from?(exception)
+          Exceptional::Catcher.handle(exception, self, request)
+        end
+        rescue_action_without_exceptional exception
+      end
+
+      alias_method :rescue_action_without_exceptional, :rescue_action
+      alias_method :rescue_action, :rescue_action_with_exceptional
+      protected :rescue_action
+
+      private
+      def exception_handled_by_rescue_from?(exception)
+        respond_to?(:handler_for_rescue) && handler_for_rescue(exception)
+      end
+    end
+  end
+end

data/lib/exceptional/integration/tester.rb

@@ -0,0 +1,17 @@
+module Exceptional
+  module Integration
+    class ExceptionalTestException <StandardError;
+    end
+
+    def self.test
+      data = Exceptional::ExceptionData.new(ExceptionalTestException.new)
+      unless Exceptional::Remote.error(data)
+        puts "Problem sending error to Exceptional. Check your api key"
+      else
+        puts "Exception sent successfully"
+      end
+    end
+  end
+end
+
+

data/lib/exceptional/log_factory.rb

@@ -0,0 +1,39 @@
+require 'logger'
+
+module Exceptional
+  class LogFactory
+    def self.logger
+      @logger ||= create_logger_with_fallback
+    end
+
+    private
+    def self.create_logger_with_fallback
+      begin
+        log_dir = File.join(Config.application_root, 'log')
+        Dir.mkdir(log_dir) unless File.directory?(log_dir)
+        log_path = File.join(log_dir, "/exceptional.log")
+        log = Logger.new(log_path)
+        log.level = Logger::INFO
+        def log.format_message(severity, timestamp, progname, msg)
+          "[#{severity.upcase}] (#{[Kernel.caller[2].split('/').last]}) #{timestamp.utc.to_s} - #{msg2str(msg).gsub(/\n/, '').lstrip}\n"
+        end
+        def log.msg2str(msg)
+          case msg
+            when ::String
+              msg
+            when ::Exception
+              "#{ msg.message } (#{ msg.class }): " <<
+                (msg.backtrace || []).join(" | ")
+            else
+              msg.inspect
+          end
+        end
+        log
+      rescue
+        return Rails.logger if defined?(Rails) && defined?(Rails.logger)
+        return RAILS_DEFAULT_LOGGER if defined?(RAILS_DEFAULT_LOGGER)
+        return Logger.new(STDERR)
+      end
+    end
+  end
+end

data/lib/exceptional/remote.rb

@@ -0,0 +1,51 @@
+require 'zlib'
+require 'cgi'
+require 'net/http'
+require 'digest/md5'
+
+module Exceptional
+  class Remote
+    class << self
+      def startup_announce(startup_data)
+        url = "/api/announcements?api_key=#{::Exceptional::Config.api_key}&protocol_version=#{::Exceptional::PROTOCOL_VERSION}"
+        compressed = Zlib::Deflate.deflate(startup_data.to_json, Zlib::BEST_SPEED)
+        call_remote(url, compressed)
+      end
+
+      def error(exception_data)
+        Exceptional.logger.info "Notifying Exceptional about an error"
+        uniqueness_hash = exception_data.uniqueness_hash
+        hash_param = uniqueness_hash.nil? ? nil: "&hash=#{uniqueness_hash}"
+        url = "/api/errors?api_key=#{::Exceptional::Config.api_key}&protocol_version=#{::Exceptional::PROTOCOL_VERSION}#{hash_param}"
+        compressed = Zlib::Deflate.deflate(exception_data.to_json, Zlib::BEST_SPEED)
+        call_remote(url, compressed)
+      end
+
+      def call_remote(url, data)
+        config = Exceptional::Config
+        optional_proxy = Net::HTTP::Proxy(config.http_proxy_host,
+                                          config.http_proxy_port,
+                                          config.http_proxy_username,
+                                          config.http_proxy_password)
+        client = optional_proxy.new(config.remote_host, config.remote_port)
+        client.open_timeout = config.http_open_timeout
+        client.read_timeout = config.http_read_timeout
+        client.use_ssl = config.ssl_enabled?
+        begin
+          response = client.post(url, data)
+          case response
+            when Net::HTTPSuccess
+              Exceptional.logger.info('Successful')
+              return true
+            else
+              Exceptional.logger.error('Failed')
+          end
+        rescue Exception => e
+          Exceptional.logger.error('Problem notifying Exceptional about the error')
+          Exceptional.logger.error(e)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/exceptional/startup.rb

@@ -0,0 +1,14 @@
+module Exceptional
+  class StartupException < StandardError;
+  end
+  class Startup
+    class << self
+      def announce
+        if Config.api_key.blank?
+          raise StartupException, 'API Key must be configured (/config/exceptional.yml)'
+        end
+        Remote.startup_announce(::Exceptional::ApplicationEnvironment.to_hash)
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__) , '../init.rb')

data/spec/bin/ginger

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'ginger'
+rescue LoadError
+  puts <<-INSTALL_GINGER
+Install ginger to test plugin against multiple environments:
+
+sudo gem install freelancing-god-ginger --source=http://gems.github.com
+
+More details: http://github.com/freelancing-god/ginger
+  INSTALL_GINGER
+  exit 0
+end
+
+require 'rake'
+
+if ARGV.length == 0
+  puts <<-USAGE
+ginger #{Ginger::Version::String}
+Use ginger to run specs for each scenario defined. Scenarios must be set out in
+a file called ginger_scenarios.rb wherever this tool is run. Once they're
+defined, then you can run this tool and provide the rake task that would
+normally be called.
+
+Examples:
+  ginger spec
+  ginger test
+  ginger spec:models
+  USAGE
+  exit 0
+end
+
+file_path = File.join Dir.pwd, ".ginger"
+
+File.delete(file_path) if File.exists?(file_path)
+
+scenarios = Ginger::Configuration.instance.scenarios
+puts "No Ginger Scenarios defined" if scenarios.empty?
+
+scenarios.each_with_index do |scenario, index|
+  puts <<-SCENARIO
+
+-------------------
+Ginger Scenario: #{scenario.name || index+1}
+-------------------
+  SCENARIO
+
+  File.open('.ginger', 'w') { |f| f.write index.to_s }
+  system("rake #{ARGV.join(" ")}") || system("rake.bat #{ARGV.join(" ")}")
+end
+
+File.delete(file_path) if File.exists?(file_path)

data/spec/exceptional/catcher_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Exceptional::Catcher do
+  it "should create exception_data object and send json to the api" do
+    Exceptional::Config.should_receive(:should_send_to_api?).and_return(true)
+    exception = mock('exception')
+    controller = mock('controller')
+    request = mock('request')
+    Exceptional::ExceptionData.should_receive(:new).with(exception,controller,request).and_return(data = mock('exception_data'))
+    Exceptional::Remote.should_receive(:error).with(data)
+    Exceptional::Catcher.handle(exception,controller,request)
+  end
+end

data/spec/exceptional/config_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Exceptional::Config, 'defaults' do
+  before :each do
+    Exceptional::Config.reset
+  end
+  it "have sensible defaults" do
+    Exceptional::Config.ssl_enabled?.should == false
+    Exceptional::Config.remote_host.should == 'api.getexceptional.com'
+    Exceptional::Config.remote_port.should == 80
+    Exceptional::Config.application_root.should == Dir.pwd
+    Exceptional::Config.http_proxy_host.should be_nil
+    Exceptional::Config.http_proxy_port.should be_nil
+    Exceptional::Config.http_proxy_username.should be_nil
+    Exceptional::Config.http_proxy_password.should be_nil
+    Exceptional::Config.http_open_timeout.should == 2
+    Exceptional::Config.http_read_timeout.should == 4
+  end
+  it "have correct defaults when ssl_enabled" do
+    Exceptional::Config.ssl_enabled = true
+    Exceptional::Config.remote_host.should == 'getexceptional.appspot.com'
+    Exceptional::Config.remote_port.should == 443
+  end
+  it "be enabled based on environment by default" do
+    %w(development test).each do |env|
+      Exceptional::Config.stub!(:application_environment).and_return(env)
+      Exceptional::Config.should_send_to_api?.should == false
+    end
+    %w(production staging).each do |env|
+      Exceptional::Config.stub!(:application_environment).and_return(env)
+      Exceptional::Config.should_send_to_api?.should == true
+    end
+  end
+  context 'production environment' do
+    before :each do
+      Exceptional::Config.stub!(:application_environment).and_return('production')
+    end
+    it "allow a new simpler format for exception.yml" do
+      Exceptional::Config.load('spec/fixtures/exceptional.yml')
+      Exceptional::Config.api_key.should == 'abc123'
+      Exceptional::Config.ssl_enabled?.should == true
+      Exceptional::Config.remote_host.should == 'example.com'
+      Exceptional::Config.remote_port.should == 123
+      Exceptional::Config.should_send_to_api?.should == true
+      Exceptional::Config.http_proxy_host.should == 'annoying-proxy.example.com'
+      Exceptional::Config.http_proxy_port.should == 1066
+      Exceptional::Config.http_proxy_username.should == 'bob'
+      Exceptional::Config.http_proxy_password.should == 'jack'
+      Exceptional::Config.http_open_timeout.should == 5
+      Exceptional::Config.http_read_timeout.should == 10
+    end
+    it "allow olded format for exception.yml" do
+      Exceptional::Config.load('spec/fixtures/exceptional_old.yml')
+      Exceptional::Config.api_key.should == 'abc123'
+      Exceptional::Config.ssl_enabled?.should == true
+      Exceptional::Config.should_send_to_api?.should == true
+    end
+    it "load api_key from environment variable" do
+      ENV.should_receive(:[]).with('EXCEPTIONAL_API_KEY').any_number_of_times.and_return('98765')
+      Exceptional::Config.api_key.should == '98765'
+    end
+  end
+end

data/spec/exceptional/exception_data_spec.rb

@@ -0,0 +1,123 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'digest/md5'
+
+class Exceptional::FunkyError < StandardError
+  def backtrace
+    'backtrace'
+  end
+end
+
+describe Exceptional::ExceptionData, 'when no request/controller/params' do
+  before :each do
+    ENV['LOGNAME'] = 'bob'
+    ENV['SOMEVAR'] = 'something'
+    ENV['HTTP_SOMETHING'] = 'should be stripped'
+    RAILS_ENV = 'test' unless defined?(RAILS_ENV)
+    Time.stub!(:now).and_return(Time.mktime(1970,1,1))
+    error = Exceptional::FunkyError.new('some message')
+    data = Exceptional::ExceptionData.new(error)
+    @hash = data.to_hash
+  end
+
+  it "capture exception details" do
+    error_hash = @hash['exception']
+    error_hash['exception_class'].should == 'Exceptional::FunkyError'
+    error_hash['message'].should == 'some message'
+    error_hash['backtrace'].should == 'backtrace'
+    error_hash['occurred_at'].should == Time.now.strftime("%Y%m%d %H:%M:%S %Z")
+    client_hash = @hash['client']
+    client_hash['name'].should == Exceptional::CLIENT_NAME
+    client_hash['version'].should == Exceptional::VERSION    
+    client_hash['protocol_version'].should == Exceptional::PROTOCOL_VERSION
+  end
+
+  it "capture application_environment" do
+    application_env_hash = @hash['application_environment']
+    application_env_hash['environment'].should == 'test'
+    application_env_hash['env'].should_not be_nil
+    application_env_hash['env']['SOMEVAR'].should == 'something'
+    application_env_hash['host'].should == `hostname`.strip
+    application_env_hash['run_as_user'].should == 'bob'
+    application_env_hash['application_root_directory'].should == Dir.pwd
+    application_env_hash['language'].should == 'ruby'
+    application_env_hash['language_version'].should == "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} #{RUBY_RELEASE_DATE} #{RUBY_PLATFORM}"
+    application_env_hash['framework'].should == "rails"
+    application_env_hash['libraries_loaded']['rails'].should =~ /\d\.\d\.\d/
+  end
+end
+
+describe Exceptional::ExceptionData, 'with request/controller/params' do
+  class Exceptional::SomeController < ActionController::Base
+      filter_parameter_logging :filter_me
+  end
+  
+  before :each do
+    @controller = Exceptional::SomeController.new
+    @request = ActionController::TestRequest.new({'action' => 'some_action' })
+    @request.request_uri = '/some_path?var1=abc' 
+    @request.stub!(:parameters).and_return({'var1' => 'abc', 'action' => 'some_action', 'filter_me' => 'private'})
+    @request.stub!(:request_method).and_return(:get)
+    @request.stub!(:remote_ip).and_return('1.2.3.4')
+    @request.stub!(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_CONTENT_TYPE' => 'text/html'})
+    error = Exceptional::FunkyError.new('some message')
+    data = Exceptional::ExceptionData.new(error, @controller, @request)
+    @hash = data.to_hash
+  end
+
+  it "captures request" do
+    request_hash = @hash['request']
+    request_hash['url'].should == 'http://test.host/some_path?var1=abc'
+    request_hash['controller'].should == 'Exceptional::SomeController'
+    request_hash['action'].should == 'some_action'
+    request_hash['parameters'].should == {'var1' => 'abc', 'action' => 'some_action', 'filter_me' => '[FILTERED]'}
+    request_hash['request_method'].should == 'get'
+    request_hash['remote_ip'].should == '1.2.3.4'
+    request_hash['headers'].should == {'Content-Type' => 'text/html'}
+  end
+
+  it "filter out objects that aren't jsonable" do
+    class Crazy
+      def initialize
+        @bar = self
+      end
+    end
+    crazy = Crazy.new
+    input = {'crazy' => crazy, :simple => '123', :some_hash => {'1' => '2'}, :array => ['1','2']}
+    Exceptional::ExceptionData.sanitize_hash(input).should == {'crazy' => crazy.to_s, :simple => '123', :some_hash => {'1' => '2'}, :array => ['1','2']}
+  end
+
+  it "handles session objects with various interfaces" do
+    class SessionWithInstanceVariables
+      def initialize
+        @data = {'a' => '1'}
+        @session_id = '123'
+      end
+    end
+    request = ActionController::TestRequest.new
+    session = SessionWithInstanceVariables.new
+    request.stub!(:session).and_return(session)
+    request.stub!(:session_options).and_return({})
+    Exceptional::ExceptionData.sanitize_session(request).should == {'session_id' => '123', 'data' => {'a' => '1'}}
+    session = mock('session', :session_id => '123', :instance_variable_get => {'a' => '1'})
+    request.stub!(:session).and_return(session)
+    Exceptional::ExceptionData.sanitize_session(request).should == {'session_id' => '123', 'data' => {'a' => '1'}}
+    session = mock('session', :session_id => nil, :to_hash => {:session_id => '123', 'a' => '1'})
+    request.stub!(:session).and_return(session)
+    Exceptional::ExceptionData.sanitize_session(request).should == {'session_id' => '123', 'data' => {'a' => '1'}}
+    request.stub!(:session_options).and_return({:id => 'xyz'})
+    Exceptional::ExceptionData.sanitize_session(request).should == {'session_id' => 'xyz', 'data' => {'a' => '1'}}
+  end
+
+  it "filter session cookies from headers" do
+    @request.stub!(:env).and_return({'SOME_VAR' => 'abc', 'HTTP_COOKIE' => '_something_else=faafsafafasfa; _myapp-lick-nation_session=BAh7DDoMbnVtYmVyc1sJaQZpB2kIaQk6FnNvbWVfY3Jhenlfb2JqZWN0bzobU3Bpa2VDb250cm9sbGVyOjpDcmF6eQY6CUBiYXJABzoTc29tZXRoaW5nX2Vsc2UiCGNjYzoKYXBwbGUiDUJyYWVidXJuOgloYXNoewdpBmkHaQhpCToPc2Vzc2lvbl9pZCIlMmJjZTM4MjVjMThkNzYxOWEyZDA4NTJhNWY1NGQzMmU6C3RvbWF0byIJQmVlZg%3D%3D--66fb4606851f06bf409b8bc4ba7aea47a0259bf7'})
+    @hash = Exceptional::ExceptionData.new(Exceptional::FunkyError.new('some message'), @controller, @request).to_hash
+    @hash['request']['headers'].should == {'Cookie' => '_something_else=faafsafafasfa; _myapp-lick-nation_session=[FILTERED]'}
+  end
+
+  it "creates a uniqueness_hash from backtrace" do
+    myException = Exception.new
+    myException.stub!(:backtrace).and_return(['123'])
+    data = Exceptional::ExceptionData.new(myException)
+    data.uniqueness_hash.should == Digest::MD5.hexdigest('123')
+  end
+end

data/spec/exceptional/remote_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'zlib'
+require 'digest/md5'
+
+describe Exceptional::Remote do
+  before :each do
+    Exceptional::Config.reset
+    Exceptional::Config.api_key = 'abc123'
+  end
+
+  it "calls remote with api_key, protocol_version and json" do
+    expected_url = "/api/errors?api_key=abc123&protocol_version=#{Exceptional::PROTOCOL_VERSION}"
+    expected_data = mock('data',:uniqueness_hash => nil, :to_json => '123')
+    Exceptional::Remote.should_receive(:call_remote).with(expected_url, Zlib::Deflate.deflate(expected_data.to_json,Zlib::BEST_SPEED))
+    Exceptional::Remote.error(expected_data)
+  end
+
+  it "adds hash of backtrace as paramater if it is present" do
+    expected_url = "/api/errors?api_key=abc123&protocol_version=#{Exceptional::PROTOCOL_VERSION}&hash=blah"
+    expected_data = mock('data',:uniqueness_hash => 'blah', :to_json => '123')
+    Exceptional::Remote.should_receive(:call_remote).with(expected_url, Zlib::Deflate.deflate(expected_data.to_json,Zlib::BEST_SPEED))
+    Exceptional::Remote.error(expected_data)
+  end
+
+  it "calls remote for startup" do
+    expected_url = "/api/announcements?api_key=abc123&protocol_version=#{Exceptional::PROTOCOL_VERSION}"
+    startup_data = mock('data',:to_json => '123')
+    Exceptional::Remote.should_receive(:call_remote).with(expected_url, Zlib::Deflate.deflate(startup_data.to_json,Zlib::BEST_SPEED))
+    Exceptional::Remote.startup_announce(startup_data)
+  end
+end

data/spec/exceptional/startup_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Exceptional::Startup, 'announce_and_authenticate' do
+  it "raise StartupException if api_key is nil" do
+    Exceptional::Config.api_key = ''
+    lambda { Exceptional::Startup.announce }.should raise_error(Exceptional::StartupException, /API Key/)
+  end
+  it "calls Remote announce" do
+    Exceptional::Config.api_key = '123'
+    Exceptional::Remote.should_receive(:startup_announce).with(hash_including({'client' => { 'name' => Exceptional::CLIENT_NAME,
+                                                                                     'version' => Exceptional::VERSION,
+                                                                                     'protocol_version' => Exceptional::PROTOCOL_VERSION}}))
+    Exceptional::Startup.announce
+  end
+end

data/spec/exceptional_rescue_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+context 'resuce errors from within a block' do
+  class FunkyException < StandardError; end
+  it "send them to catcher and reraise" do
+    to_raise = FunkyException.new
+    Exceptional::Catcher.should_receive(:handle).with(to_raise)
+    begin
+      Exceptional.rescue do
+        raise to_raise
+      end
+      fail "expected to raise"
+    rescue FunkyException => e
+      e.should == to_raise
+    end
+  end
+end

data/spec/fixtures/exceptional.yml

@@ -0,0 +1,10 @@
+api-key: abc123
+ssl: true
+remote-port: 123
+remote-host: example.com
+http-proxy-host: annoying-proxy.example.com
+http-proxy-port: 1066
+http-proxy-username: bob
+http-proxy-password: jack
+http-open-timeout: 5
+http-read-timeout: 10

data/spec/fixtures/exceptional_old.yml

@@ -0,0 +1,35 @@
+# here are the settings that are common to all environments
+common: &default_settings
+  # You must specify your Exceptional API key here.
+  api-key: abc123
+  # Exceptional creates a separate log file from your application's logs
+  # available levels are debug, info, warn, error, fatal
+  log-level: info
+  # The exceptional agent sends data via regular http by default
+  # Setting this value to true will send data over SSL, increasing security
+  # There will be an additional CPU overhead in encrypting the data, however
+  # as long as your deployment environment is not Passenger (mod_rails), this
+  # happens in the background so as not to incur a page wait for your users.
+  ssl: false
+
+development:
+  <<: *default_settings
+  # Normally no reason to collect exceptions in development
+  # NOTE: for trial purposes you may want to enable exceptional in development
+  enabled: false
+
+test:
+  <<: *default_settings
+  # No reason to collect exceptions when running tests by default
+  enabled: false
+
+production:
+  <<: *default_settings
+  enabled: true
+  ssl: true
+
+staging:
+  # It's common development practice to have a staging environment that closely
+  # mirrors production, by default catch errors in this environment too.
+  <<: *default_settings
+  enabled: true

data/spec/ginger_scenarios.rb

@@ -0,0 +1,39 @@
+require 'ginger'
+
+class ScenarioWithName < Ginger::Scenario
+  attr_accessor :name
+  def initialize(name)
+    @name = name
+  end
+end
+
+def create_scenario(version)
+  scenario = ScenarioWithName.new("Rails #{version}")
+  scenario[/^active_?support$/]    = version
+  scenario[/^active_?record$/]     = version
+  scenario[/^action_?pack$/]       = version
+  scenario[/^action_?controller$/] = version
+  scenario[/^rails$/] = version
+  scenario
+end
+
+Ginger.configure do |config|
+  config.aliases["active_record"] = "activerecord"
+  config.aliases["active_support"] = "activesupport"
+  config.aliases["action_controller"] = "actionpack"
+
+  rails_1_2_6 = ScenarioWithName.new("Rails 1.2.6")
+  rails_1_2_6[/^active_?support$/] = "1.4.4"
+  rails_1_2_6[/^active_?record$/] = "1.15.6"
+  rails_1_2_6[/^action_?pack$/] = "1.13.6"
+  rails_1_2_6[/^action_?controller$/] = "1.13.6"
+  rails_1_2_6[/^rails$/] = "1.2.6"
+
+  config.scenarios << rails_1_2_6
+  config.scenarios << create_scenario("2.0.2")
+  config.scenarios << create_scenario("2.1.2")
+  config.scenarios << create_scenario("2.2.2")
+  config.scenarios << create_scenario("2.3.2")
+  config.scenarios << create_scenario("2.3.3")
+  config.scenarios << create_scenario("2.3.4")
+end

data/spec/rails_integration_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'exceptional', 'integration', 'rails')
+
+describe Exceptional, 'version number' do
+  it "be available proramatically" do
+    Exceptional::VERSION.should == '0.2.0'
+  end
+end
+
+describe ActiveSupport::JSON, 'standards compliant json' do
+  it "quote keys" do
+    {:a => '123'}.to_json.gsub(/ /,'').should == '{"a":"123"}'
+  end
+end
+
+class TestingController < ActionController::Base
+  def raises_something
+    raise StandardError
+  end
+end
+
+describe TestingController do
+  before :each do
+    @controller = TestingController.new
+  end
+
+  it 'handle exception with Exceptional::Catcher' do
+    Exceptional::Catcher.should_receive(:handle).with(an_instance_of(StandardError), @controller, an_instance_of(ActionController::TestRequest))
+    send_request(:raises_something)
+  end
+
+  it "still return an error response to the user" do
+    Exceptional::Catcher.stub!(:handle)
+    send_request(:raises_something)
+    @response.code.should == '500'
+  end
+end
+
+if ActionController::Base.respond_to?(:rescue_from)
+  class CustomError < StandardError; end
+  class TestingWithRescueFromController < ActionController::Base
+    rescue_from CustomError, :with => :custom_handler
+    def raises_custom_error
+      raise CustomError.new
+    end
+    def raises_other_error
+      raise StandardError.new
+    end
+    def custom_handler
+      head :ok
+    end
+  end
+
+  describe TestingWithRescueFromController do
+    before :each do
+      @controller = TestingWithRescueFromController.new
+    end
+
+    it 'not handle exception with Exceptional that is dealt with by rescue_from' do
+      Exceptional::Catcher.should_not_receive(:handle)
+      send_request(:raises_custom_error)
+    end
+    it 'handle exception with Exceptional that is not dealt with by rescue_from' do
+      Exceptional::Catcher.should_receive(:handle)
+      send_request(:raises_other_error)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+begin
+  require 'ginger'
+rescue LoadError
+  raise "cant load ginger"
+end
+gem 'rails'
+require File.dirname(__FILE__) + '/../lib/exceptional' unless defined?(Exceptional)
+
+ENV['RAILS_ENV'] = 'test'
+
+require 'action_controller'
+require 'action_controller/test_process'
+
+def send_request(action = nil)
+  @request = ActionController::TestRequest.new
+  @request.action = action ? action.to_s : ""
+  @response = ActionController::TestResponse.new
+  @controller.process(@request, @response)
+end

data/spec/standalone_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'exceptional', 'integration', 'rails')
+
+describe Exceptional do
+  it "set the api key" do
+    Exceptional.configure('api-key')
+    Exceptional::Config.api_key.should == 'api-key'
+  end
+end

data/tasks/exceptional_tasks.rake

@@ -0,0 +1,11 @@
+namespace :exceptional do
+  desc 'Send a test exception to Exceptional.'
+  task :test => :environment do
+    unless Exceptional::Config.api_key.blank?
+      puts "Sending test exception to Exceptional"
+      require "exceptional/integration/tester"
+      Exceptional::Integration.test
+      puts "Done."
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: exceptional
+version: !ruby/object:Gem::Version 
+  version: 2.0.0
+platform: ruby
+authors: 
+- Contrast
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-13 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+description: Exceptional is the core Ruby library for communicating with http://getexceptional.com (hosted error tracking service). Use it to find out about errors that happen in your live app. It captures lots of helpful information to help you fix the errors.
+email: hello@contrast.ie
+executables: 
+- exceptional
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/exceptional/application_environment.rb
+- lib/exceptional/catcher.rb
+- lib/exceptional/config.rb
+- lib/exceptional/exception_data.rb
+- lib/exceptional/integration/rack.rb
+- lib/exceptional/integration/rails.rb
+- lib/exceptional/integration/tester.rb
+- lib/exceptional/log_factory.rb
+- lib/exceptional/remote.rb
+- lib/exceptional/startup.rb
+- lib/exceptional.rb
+- spec/bin/ginger
+- spec/exceptional/catcher_spec.rb
+- spec/exceptional/config_spec.rb
+- spec/exceptional/exception_data_spec.rb
+- spec/exceptional/remote_spec.rb
+- spec/exceptional/startup_spec.rb
+- spec/exceptional_rescue_spec.rb
+- spec/fixtures/exceptional.yml
+- spec/fixtures/exceptional_old.yml
+- spec/ginger_scenarios.rb
+- spec/rails_integration_spec.rb
+- spec/spec_helper.rb
+- spec/standalone_spec.rb
+- rails/init.rb
+- tasks/exceptional_tasks.rake
+- init.rb
+- install.rb
+- exceptional.gemspec
+has_rdoc: true
+homepage: http://getexceptional.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: exceptional
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Exceptional is the core Ruby library for communicating with http://getexceptional.com (hosted error tracking service)
+test_files: []
+