contrast-exceptional 0.0.1 → 0.0.6

data/lib/exceptional/bootstrap.rb

@@ -0,0 +1,23 @@
+module Exceptional
+  module Bootstrap
+    
+    # called from init.rb
+    def bootstrap(environment, application_root)
+      begin
+        setup_config(environment, File.join(application_root,"config", "exceptional.yml"))
+        setup_log(File.join(application_root, "log"), log_level)
+
+        if enabled?
+          if authenticate
+            require File.join('exceptional', 'integration', 'rails')
+          else
+            STDERR.puts "Exceptional plugin not authenticated, check your API Key"
+          end
+        end
+      rescue Exception => e
+        STDERR.puts e
+        STDERR.puts "Exceptional Plugin disabled."
+      end
+    end
+  end
+end

data/lib/exceptional/config.rb

@@ -0,0 +1,74 @@
+require 'yaml'
+
+module Exceptional
+  module Config
+
+    # Defaults for configuration variables
+    REMOTE_HOST = "getexceptional.com"
+    REMOTE_PORT = 80
+    REMOTE_SSL_PORT = 443
+    SSL = false
+    LOG_LEVEL = 'info'
+    LOG_PATH = nil
+
+    class ConfigurationException < StandardError; end
+
+    attr_reader :api_key
+    attr_writer :ssl_enabled, :remote_host, :remote_port, :api_key
+
+    def setup_config(environment, config_file)
+      begin
+        config = YAML::load(File.open(config_file))[environment]
+        @api_key = config['api-key'] unless config['api-key'].nil?
+        @ssl_enabled = config['ssl'] unless config['ssl'].nil?
+        @log_level = config['log-level'] unless config['log-level'].nil?
+        @enabled = config['enabled'] unless config['enabled'].nil?
+        @remote_port = config['remote-port'].to_i unless config['remote-port'].nil?
+        @remote_host = config['remote-host'] unless config['remote-host'].nil?
+        @applicaton_root = application_root
+
+        log_config_info
+      rescue Exception => e
+        raise ConfigurationException.new("Unable to load configuration #{config_file} for environment #{environment} : #{e.message}")
+      end
+    end
+
+    def application_root
+      @applicaton_root || (File.dirname(__FILE__) + '/../..')
+    end
+
+    def remote_host
+      @remote_host || REMOTE_HOST
+    end
+
+    def remote_port
+      @remote_port || default_port
+    end
+
+    def log_level
+      @log_level || LOG_LEVEL
+    end
+
+    def default_port
+      ssl_enabled? ? REMOTE_SSL_PORT : REMOTE_PORT
+    end
+
+    def ssl_enabled?
+      @ssl_enabled || SSL
+    end
+
+    def enabled?
+      @enabled || false
+    end
+
+    def valid_api_key?
+      @api_key && @api_key.length == 40 ? true : false
+    end
+
+    def log_config_info
+      Exceptional.to_log('debug', "API Key: #{api_key}")
+      Exceptional.to_log('debug', "Remote Host: #{remote_host}:#{remote_port}")
+      Exceptional.to_log('debug', "Log level: #{log_level}")
+    end
+  end
+end

data/lib/exceptional/exception_data.rb

@@ -32,15 +32,13 @@ module Exceptional
       hash = {}
       ::ATTRS.each do |attribute|
         value = send(attribute)
-        hash[attribute] = value unless (value.nil? || value.empty?)
+        hash[attribute] = value unless (value.nil? || value.empty? || attribute.is_a?(TCPSocket) || attribute.is_a?(TCPServer)) 
       end
       hash
     end
     
     def to_json
       self.to_hash.to_json
-    end
-    
+    end    
   end
-  
 end

data/lib/exceptional/integration/rails.rb

@@ -1,20 +1,32 @@
+if defined? ActiveSupport
+  
+  # Hack to force Rails version prior to 2.0 to use quoted JSON as per the JSON standard... (TODO: could be cleaner!)
+  if (defined?(ActiveSupport::JSON) && ActiveSupport::JSON.respond_to?(:unquote_hash_key_identifiers))
+    ActiveSupport::JSON.unquote_hash_key_identifiers = false 
+  end
+
+end
+
 if defined? ActionController
 
-module ActionController
-  class Base
-    def rescue_action_with_exceptional(exception)
-      
-      params_to_send = (respond_to? :filter_parameters) ? filter_parameters(params) : params
-      
-      Exceptional.handle(exception, self, request, params_to_send)
+  module ActionController
+    class Base
+    
+      def rescue_action_with_exceptional(exception)
+        # TODO potentially hook onto rescue_without_handler if it exists? would negate need to check handler_for_rescue every time.
+        # if there's handler defined with rescue_from() do not call Exceptional
+        if !(respond_to?(:handler_for_rescue) && handler_for_rescue(exception))
+          params_to_send = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+          Exceptional.handle(exception, self, request, params_to_send)
+        end
             
-      rescue_action_without_exceptional exception
-    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
+      alias_method :rescue_action_without_exceptional, :rescue_action
+      alias_method :rescue_action, :rescue_action_with_exceptional
+      protected :rescue_action
+    end
   end
-end
 
 end

data/lib/exceptional/log.rb

@@ -0,0 +1,50 @@
+require 'logger'
+
+module Exceptional
+  module Log
+
+    attr_reader :log
+    
+    def setup_log(log_dir, log_level = Logger::INFO)
+      begin
+        Dir.mkdir(log_dir) unless File.directory?(log_dir)
+
+        
+        log_path = File.join(log_dir, "/exceptional.log")
+        log = Logger.new log_path
+        
+        log.level = log_level
+
+        allowed_log_levels = ['debug', 'info', 'warn', 'error', 'fatal']
+        if log_level && allowed_log_levels.include?(log_level)
+          log.level = eval("Logger::#{log_level.upcase}")
+        end
+
+        @log = log
+      rescue Exception => e
+        raise Exceptional::Config::ConfigurationException.new("Unable to create log file #{log_path} #{e.message}")
+      end
+    end
+
+    def log!(msg, level = 'info')
+      to_log level, msg
+      to_stderr msg
+    end
+
+    def to_stderr(msg)
+      STDERR.puts format_log_message(msg)
+    end
+
+    protected
+
+    def to_log(level, msg)
+      @log.send level, msg if @log
+    end
+
+    private
+
+    def format_log_message(msg)
+      "** [Exceptional] " + msg
+    end
+  end
+end

data/lib/exceptional/remote.rb

@@ -0,0 +1,75 @@
+require 'zlib'
+require 'cgi'
+require 'net/http'
+
+module Exceptional
+  module Remote
+
+    class RemoteException < StandardError; end
+
+    ::PROTOCOL_VERSION = 3
+
+    # authenticate with getexceptional.com
+    # returns true if the configured api_key is registered and can send data
+    # otherwise false
+    def authenticate
+
+      return @authenticated if @authenticated
+
+      if Exceptional.api_key.nil?
+        raise Exceptional::Config::ConfigurationException.new("API Key must be configured")
+      end
+
+      begin
+        # TODO No data required to authenticate, send a nil string? hacky
+        # TODO should retry if a http connection failed
+        authenticated = call_remote(:authenticate, "")
+        
+        @authenticated = authenticated =~ /true/ ? true : false
+      rescue
+        @authenticated = false
+      ensure
+        return @authenticated
+      end
+    end
+
+    def authenticated?
+      @authenticated || false
+    end
+
+    def post_exception(data)
+      if !authenticated?
+        authenticate
+      end
+
+      call_remote(:errors, data)
+    end
+
+    protected
+
+    def call_remote(method, data)
+      begin
+        http = Net::HTTP.new(Exceptional.remote_host, Exceptional.remote_port)
+        http.use_ssl = true if Exceptional.ssl_enabled?
+        uri = "/#{method.to_s}?&api_key=#{Exceptional.api_key}&protocol_version=#{::PROTOCOL_VERSION}"
+        headers = method.to_s == 'errors' ? { 'Content-Type' => 'application/x-gzip', 'Accept' => 'application/x-gzip' } : {}
+
+        compressed_data = CGI::escape(Zlib::Deflate.deflate(data, Zlib::BEST_SPEED))
+        response = http.start do |http|
+          http.post(uri, compressed_data, headers)
+        end
+
+        if response.kind_of? Net::HTTPSuccess
+          return response.body
+        else
+          raise RemoteException.new("#{response.code}: #{response.message}")
+        end
+
+      rescue Exception => e
+        Exceptional.log! "Error contacting Exceptional: #{e}", 'info'
+        Exceptional.log! e.backtrace.join("\n"), 'debug'
+        raise e
+      end
+    end
+  end
+end

data/lib/exceptional/version.rb

@@ -2,7 +2,7 @@ module Exceptional #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 6
  
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/api_spec.rb

@@ -0,0 +1,211 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+describe Exceptional::Api do
+
+
+  describe "with no configuration" do
+    before(:each) do
+    Exceptional.stub!(:to_stderr) # Don't print error when testing
+    end
+
+    after(:each) do
+      Exceptional.api_key= nil
+    end
+
+    it "should connect to getexceptional.com by default" do
+      Exceptional.remote_host.should == "getexceptional.com"
+    end
+
+    it "should connect to port 80 by default" do
+      Exceptional.remote_port.should == 80
+    end
+
+    it "should parse exception into exception data object" do
+      exception = mock(Exception, :message => "Something bad has happened",
+      :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"])
+      exception_data = Exceptional.parse(exception)
+      exception_data.kind_of?(Exceptional::ExceptionData).should be_true
+      exception_data.exception_message.should == exception.message
+      exception_data.exception_backtrace.should == exception.backtrace
+      exception_data.exception_class.should == exception.class.to_s
+
+
+    end
+
+    it "should post exception" do
+
+      exception_data = mock(Exceptional::ExceptionData,
+      :message => "Something bad has happened",
+      :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"],
+      :class => Exception, :to_hash => { :message => "Something bad has happened" })
+      Exceptional.api_key = "TEST_API_KEY"
+      Exceptional.should_receive(:authenticate).once.and_return(true)
+      Exceptional.should_receive(:call_remote, :with => [:errors, exception_data]).once
+      Exceptional.post(exception_data)
+
+    end
+
+    it "should catch exception" do
+      exception = mock(Exception, :message => "Something bad has happened",
+      :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"])
+
+      exception_data = mock(Exceptional::ExceptionData,
+      :message => "Something bad has happened",
+      :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"],
+      :class => Exception, :to_hash => { :message => "Something bad has happened" })
+      exception_data.should_receive(:controller_name=).with(File.basename($0))
+
+      Exceptional.should_receive(:parse, :with => [exception]).and_return(exception_data)
+      Exceptional.should_receive(:post, :with => [exception_data])
+
+      Exceptional.catch(exception)
+    end
+
+    it "should raise a license exception if api key is not set" do
+      exception_data = mock(Exceptional::ExceptionData,
+      :message => "Something bad has happened",
+      :backtrace => ["/app/controllers/buggy_controller.rb:29:in `index'"],
+      :class => Exception,
+      :to_hash => { :message => "Something bad has happened" })
+      Exceptional.api_key.should == nil
+      lambda { Exceptional.post(exception_data) }.should raise_error(Exceptional::Config::ConfigurationException)
+    end
+  end
+
+  describe "rescue" do
+
+    it "should send exception data onto catch" do
+      Exceptional.should_receive(:catch)
+      lambda{ Exceptional.rescue do
+        raise IOError
+      end}.should raise_error(IOError)
+
+    end
+  end
+
+  describe "handle" do
+    before(:each) do
+    Exceptional.stub!(:to_stderr) # Don't print error when testing
+    Exceptional.stub!(:log!) # Don't even attempt to log
+    end
+
+    it "should send exception data onto post" do
+      exception = mock(Exception, :message => "Something bad has happened",
+      :backtrace => "/app/controllers/buggy_controller.rb:29:in `index'")
+
+      controller = mock("controller", :controller_name => "Test Controller Name", :action_name => "Test Action Name")
+
+      class SessionHelper
+        def initialize
+          @some_var = 1
+          @cgi_var = 2
+          @x_db = 3
+        end
+      end
+
+      request = mock("request", :env => {"key1" => "val1"}, :protocol => "http", :host => "getexceptional.com", :request_uri => "/path/to/resource", :session => SessionHelper.new)
+
+      Exceptional.should_receive(:post_exception).once
+      Exceptional.handle(exception, controller, request, {:clients => {:name => "bar"}})
+    end
+  end
+
+  describe "with helper methods" do
+
+    it "safe_environment() should delete all rack related stuff from environment" do
+      request = mock(request, :env => { 'rack_var' => 'value', 'non_ack' => 'value2' })
+      Exceptional.send(:safe_environment, request).should == { 'non_ack' => 'value2' }
+    end
+
+    it "safe_environment() should handle array type parameters" do
+      
+      request = mock(request, :env => { 
+          'string_array_var' => ['value', 'another value'], 
+          'bool_array_var' => [false, false, true],
+          'numb_array_var' => [3,2,1],
+          'nil_array_var' => [nil, nil],
+          'non_ack' => 'value2' }
+          )
+      Exceptional.send(:safe_environment, request).should == { 
+        'string_array_var' => ['value', 'another value'], 
+        'bool_array_var' => [false, false, true],
+        'numb_array_var' => [3,2,1],
+        'nil_array_var' => [nil, nil],
+        'non_ack' => 'value2' }
+
+    end
+
+    it "safe_session() should handle array type parameters" do
+      mock_session = mock("session")
+      mock_session.should_receive(:instance_variables).and_return(['var1', 'var2'])
+      mock_session.should_receive(:instance_variable_get).with('var1').and_return(['value', 'another value'])
+      mock_session.should_receive(:instance_variable_get).with('var2').and_return('value2')
+      Exceptional.send(:safe_session, mock_session).should == { 'var1' => ['value', 'another value'], 'var2' => 'value2' }
+    end
+
+
+    it "safe_session() should filter all /db/, /cgi/ variables and sub @ for blank" do
+      class SessionHelper
+        def initialize
+          @some_var = 1
+          @cgi_var = 2
+          @x_db = 3
+        end
+      end
+
+      session = SessionHelper.new
+      Exceptional.send(:safe_session, session).should == { 'some_var' => 1 }
+    end
+
+    it "sanitize_hash() should sanitize cyclic problem for to_json" do
+      class MyClass
+        def initialize
+          @test = self
+        end
+
+        def to_hash
+          { :test => self }
+        end
+      end
+      my_class = MyClass.new
+      
+      lambda { my_class.to_json }.should raise_error(ActiveSupport::JSON::CircularReferenceError)
+      Exceptional.send(:sanitize_hash, my_class.to_hash).to_json.should == "{}"
+    end
+    
+    it "sanitize_hash() should sanitize cyclic problem for to_json passing hash" do
+      class MyClass
+        def initialize
+          @test = self
+        end
+
+        def to_hash
+          { :test => self }
+        end
+      end
+      my_class = MyClass.new
+      
+      
+      lambda { my_class.to_json }.should raise_error(ActiveSupport::JSON::CircularReferenceError)
+      Exceptional.send(:sanitize_hash, {'hkey' => my_class}).to_json.should == "{}"
+    end
+    
+    it "sanitize_hash() should sanitize cyclic problem for to_json passing hash mult params" do
+      class MyClass
+        def initialize
+          @test = self
+        end
+
+        def to_hash
+          { :test => self }
+        end
+      end
+      my_class = MyClass.new
+      
+      
+      lambda { my_class.to_json }.should raise_error(ActiveSupport::JSON::CircularReferenceError)
+      Exceptional.send(:sanitize_hash, {'hkey' => my_class, 'ruby' => 'tuesday'}).to_json.should == "{\"ruby\": \"tuesday\"}"
+    end
+  end
+end