exception_hub 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm use @exception_hub --create

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in exception_hub.gemspec
+gemspec
+
+gem 'guard'
+gem 'guard-rspec'
+group :osx do
+  gem 'growl'
+end
+gem 'yard'
+gem 'octokit'
+gem 'rails', '~> 3.2.6'
+group :test do
+  gem 'simplecov', :require => false
+end

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+  
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jesse Dearing
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# ExceptionHub
+
+ExceptionHub will take your applications exceptions as they are thrown
+and will log them in Github issues.
+
+Currently this gem is in alpha and not ready for production use.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'exception_hub'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install exception_hub
+
+## Usage
+
+### Rails
+
+In Rails 3, you can run the rake task to enter in the information needed
+for the initializer and it will fetch the Github token for you.
+
+`rake exception_hub:generate_initializer`
+
+The initializer needs the following fields:
+* `github_api_token`
+* `github_user_name`
+* `repo_name`
+* `repo_owner`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'yard'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new
+YARD::Rake::YardocTask.new
+
+task :default => :spec

data/exception_hub.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/exception_hub/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jesse Dearing"]
+  gem.email         = ["jesse.dearing@gmail.com"]
+  gem.description   = %q{exception_hub logs exceptions in your Rails application to Github issues}
+  gem.summary       = %q{Logs exceptions in your application to Github issues}
+  gem.homepage      = "https://github.com/jessedearing/exception_hub"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "exception_hub"
+  gem.require_paths = ["lib"]
+  gem.version       = ExceptionHub::VERSION
+
+  gem.add_dependency('octokit', '~> 1.8.1')
+  gem.add_dependency('faraday')
+  gem.add_dependency('faraday_middleware')
+
+  gem.add_development_dependency('rspec', '~> 2.10.0')
+end

data/lib/exception_hub/client/authorization.rb

@@ -0,0 +1,26 @@
+require 'erb'
+
+module ExceptionHub
+  module Client
+    module Authorization
+      INITIALIZER_TEMPLATE = File.read(__FILE__).split("__END__\n").last
+
+      def get_api_token(user, password, note = 'ExceptionHub', url = 'http://github.com/jessedearing/exception_hub')
+        o = Octokit::Client.new(:login => user, :password => password)
+        o.create_authorization(:scopes => [:repo], :note => note, :note_url => url)
+      end
+
+      def generate_initializer(user, api_token, auth_id)
+        t = ERB.new(INITIALIZER_TEMPLATE)
+        t.result binding
+      end
+    end
+  end
+end
+
+__END__
+ExceptionHub.configure do |config|
+  # Github Authorization #<%= auth_id %>
+  config.github_user_name = '<%= user %>'
+  config.github_api_token = '<%= api_token %>'
+end

data/lib/exception_hub/client.rb

@@ -0,0 +1,26 @@
+require 'exception_hub/client/authorization'
+
+module ExceptionHub
+  module Client
+    include Authorization
+
+    # @returns [Octokit::Client] Returns an Octokit client singleton
+    def current_octokit
+      @current_octokit ||= get_octokit_client
+    end
+
+    # @returns [Octokit::Client] Creates new instance of the Octokit client singleton
+    def reload_octokit!
+      @current_octokit = get_octokit_client
+    end
+
+    protected
+    def get_octokit_client
+      if ExceptionHub.github_user_name && ExceptionHub.github_api_token
+        Octokit::Client.new(:login => ExceptionHub.github_user_name, :oauth_token => ExceptionHub.github_api_token)
+      else
+        Octokit::Client.new
+      end
+    end
+  end
+end

data/lib/exception_hub/configuration.rb

@@ -0,0 +1,81 @@
+module ExceptionHub
+  module Configuration
+    IGNORED_EXCEPTIONS_DEFAULT = ['ActiveRecord::RecordNotFound',
+                                  'ActionController::RoutingError',
+                                  'ActionController::InvalidAuthenticityToken',
+                                  'CGI::Session::CookieStore::TamperedWithCookie',
+                                  'ActionController::UnknownAction',
+                                  'AbstractController::ActionNotFound',
+                                  'Mongoid::Errors::DocumentNotFound']
+    # @!attribute [rw]
+    # @return [String] Name of the Github repository
+    attr_accessor :repo_name
+
+    # @!attribute [rw]
+    # @return [String] Github username for the user account that will make the API calls
+    attr_accessor :github_user_name
+
+    # @!attribute [rw]
+    # @return [String] Name of the user or organization that hosts the repository
+    attr_accessor :repo_owner
+
+    # @!attribute [rw]
+    # @return [Boolean] If true, sends all exceptions to Github including duplicates.
+    attr_accessor :send_all_exceptions
+
+    # @!attribute [rw]
+    # @return [String] Github token to make API calls with
+    attr_accessor :github_api_token
+
+    # @!attribute [r]
+    # @return [Array<Proc>] Callbacks after the exception is created
+    attr_reader :after_create_exception_callbacks
+
+    # @!attribute [r]
+    # @return [Array<Proc>] Callbacks before the exception is created
+    attr_reader :before_create_exception_callbacks
+
+    # @!attribute [rw]
+    # @return [Array<String>] Exception types as strings of the message to ignore
+    attr_accessor :ignored_exceptions
+
+    # @!attribute [rw]
+    # @return [Array<Symbol>] Environments to send exceptions from
+    attr_accessor :reporting_environments
+
+    # @!attribute [rw]
+    # @return [Logger] Logger to send output messages to
+    attr_accessor :logger
+
+    # Provides configuration block for ExceptionHub
+    #
+    # @example
+    #   ExceptionHub.configure do |config|
+    #     config.repo_name = 'exception_hub'
+    #     # ...
+    #   end
+    # @yield [config] Current instance of ExceptionHub::Configuration
+    def configure
+      define_defaults
+      yield(self) if block_given?
+      true
+    end
+    alias_method :config, :configure
+
+    def define_defaults
+      @after_create_exception_callbacks ||= []
+      @before_create_exception_callbacks ||= []
+      @ignored_exceptions ||= IGNORED_EXCEPTIONS_DEFAULT.dup
+      @reporting_environments ||= [:production]
+      @logger ||= defined?(::Rails) && ::Rails.logger || Logger.new(STDOUT)
+    end
+
+    def after_create_exception(&block)
+      @after_create_exception_callbacks << block if block
+    end
+
+    def before_create_exception(&block)
+      @before_create_exception_callbacks << block if block
+    end
+  end
+end

data/lib/exception_hub/interceptor.rb

@@ -0,0 +1,34 @@
+module ExceptionHub
+  class Interceptor
+    def initialize(exception, rack_env)
+      @exception = exception
+      @env = rack_env
+    end
+
+    def intercept!
+      if should_create_issue?
+        n = ExceptionHub::Notifier.new(@exception, @env)
+        ExceptionHub.before_create_exception_callbacks.each do |callback|
+          callback.call(n, @env)
+        end
+
+        n.notify!
+
+        ExceptionHub.after_create_exception_callbacks.each do |callback|
+          callback.call(n, @env)
+        end
+      end
+      self
+    end
+
+    def should_create_issue?
+      return false if ExceptionHub.ignored_exceptions.include? @exception.class.name
+
+      return true if defined?(::Rails) && ExceptionHub.reporting_environments.include?(::Rails.env.to_sym)
+      return true if defined?(Sinatra::Base) && ExceptionHub.reporting_environments.include?(Sinatra::Base.environment)
+      return true if ENV['RACK_ENV'] && ExceptionHub.reporting_environments.include?(ENV['RACK_ENV'].to_sym)
+      #TODO Compare exception to YAML cache here
+      false
+    end
+  end
+end

data/lib/exception_hub/issue.rb

@@ -0,0 +1,25 @@
+module ExceptionHub
+  # Issue marshals exception information
+  class Issue
+    # !@attribute [rw]
+    # @return [Integer] The issue ID in Github
+    attr_accessor :github_issue_id
+
+    # !@attribute [rw]
+    # @return [String] Title of the Github issue
+    attr_accessor :title
+
+    # !@attribute [rw]
+    # @return [String] Description to be displayed in the body of the Github issue
+    attr_accessor :description
+
+    # Creates the current Issue in Github
+    def send_to_github
+      ExceptionHub.current_octokit.create_issue("#{ExceptionHub.repo_owner}/#{ExceptionHub.repo_name}", self.title, self.description, :open_timeout => 5)
+    end
+
+    def to_yaml_properties
+      ['@github_issue_id', '@title']
+    end
+  end
+end

data/lib/exception_hub/notifier.rb

@@ -0,0 +1,64 @@
+require 'json'
+
+module ExceptionHub
+  class Notifier
+    def initialize(exception, env)
+      @exception = exception
+      @env = env
+    end
+
+    def notify!
+      begin
+        issue = Issue.new
+        issue.description = build_description
+        issue.title = "#{@exception.class.name}: #{@exception.message}"
+
+        issue.send_to_github
+      rescue Exception => ex
+        ExceptionHub.logger.error("ExceptionHub: #{ex.class.name}: #{ex.message}")
+        ExceptionHub.logger.error(ex.backtrace.reduce("") {|memo, line| memo << line << "\n"})
+      end
+    end
+
+    private
+    def build_description
+      backtrace = if @exception.backtrace
+                    @exception.backtrace.reduce("") {|memo, line| memo << line << "\n"}
+                  else
+                    ""
+                  end
+      description = <<-DESC
+## Exception Message
+#{@exception.message}
+
+## Data
+### Backtrace
+```
+#{backtrace}
+```
+
+### Rack Env
+```
+#{pretty_jsonify(@env)}
+```
+      DESC
+    end
+
+    def pretty_jsonify(env)
+      json = env_to_hash(env)
+      JSON.pretty_generate(JSON.parse(json.to_json))
+    end
+
+    def env_to_hash(env)
+      hash = {}
+      env.keys do |key|
+        if env[key].is_a?(Hash)
+          hash[key] = env_to_hash(env[key])
+        else
+          hash[key] = env[key].to_s
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/exception_hub/rack.rb

@@ -0,0 +1,27 @@
+module ExceptionHub
+  # Rack middleware to intercept exceptions
+  class Rack
+    def initialize(app)
+      @app = app
+    end
+
+    def handle_exception(exception, env)
+      ExceptionHub.handle_exception(exception, env)
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => ex
+        env['exception_hub.issue_id'] = handle_exception(ex, env)
+        raise
+      end
+
+      if env['rack.exception']
+        env['exception_hub.issue_id'] = handle_exception(ex, env)
+      end
+
+      response
+    end
+  end
+end

data/lib/exception_hub/rails/controller_interceptor.rb

@@ -0,0 +1,21 @@
+module ExceptionHub
+  module Rails
+    module ContollerInterceptor
+      def self.included(base)
+        base.send(:alias_method, :rescue_action_in_public_without_exception_hub, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_exception_hub)
+      end
+
+      private
+
+      def rescue_action_in_public_with_exception_hub(exception)
+        begin
+          ExceptionHub.handle_exception(exception, {})
+        rescue Exception => ex
+          ExceptionHub.logger.error("ExceptionHub: #{ex.class.name}: #{ex.message}")
+          ExceptionHub.logger.error(ex.backtrace.reduce("") {|memo, line| memo << line << "\n"})
+        end
+      end
+    end
+  end
+end

data/lib/exception_hub/rails/middleware/exceptions_interceptor.rb

@@ -0,0 +1,22 @@
+module ExceptionHub
+  module Rails
+    module Middleware
+      module ExceptionsInterceptor
+        def self.included(base)
+          base.send(:alias_method_chain, :render_exception, :exception_hub_intercept)
+        end
+
+        private
+        def render_exception_with_exception_hub_intercept(env, exception)
+          begin
+            ExceptionHub.handle_exception(exception, env)
+            render_exception_without_exception_hub_intercept(env, exception)
+          rescue Exception => ex
+            ExceptionHub.logger.error("ExceptionHub: #{ex.class.name}: #{ex.message}")
+            ExceptionHub.logger.error(ex.backtrace.reduce("") {|memo, line| memo << line << "\n"})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/exception_hub/railtie.rb

@@ -0,0 +1,24 @@
+require 'exception_hub'
+require 'rails'
+
+module ExceptionHub
+  class Railtie < Rails::Railtie
+    railtie_name :exception_hub
+
+    initializer "exception_hub rack middleware" do |app|
+      app.config.middleware.insert 0, "ExceptionHub::Rack"
+    end
+
+    if defined?(::ActionDispatch::DebugExceptions)
+      require 'exception_hub/rails/middleware/exceptions_interceptor'
+      ::ActionDispatch::DebugExceptions.send(:include, ExceptionHub::Rails::Middleware::ExceptionsInterceptor)
+    elsif defined(::ActionDispatch::ShowExceptions)
+      require 'exception_hub/rails/controller_interceptor'
+      ::ActionDispatch::ShowExceptions.send(:include, ExceptionHub::Rails::ControllerInterceptor)
+    end
+
+    rake_tasks do
+      load 'tasks/exception_hub.rake'
+    end
+  end
+end

data/lib/exception_hub/rake_task.rb

@@ -0,0 +1,27 @@
+require 'exception_hub'
+
+module ExceptionHub
+  class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    def initialize(*args)
+      namespace :exception_hub do
+        desc "Generate ExceptionHub initializer"
+        task :generate_initializer do
+          puts "Github username:"
+          username = STDIN.gets.chomp
+          puts "Github password:"
+          system('stty -echo')
+          password = STDIN.gets.chomp
+          system('stty echo')
+
+          puts "Getting authorization from Github"
+          auth = ExceptionHub.get_api_token(username, password)
+
+          puts "Generating initializer"
+          File.write('./config/initializers/exception_hub.rb', ExceptionHub.generate_initializer(username, auth.token, auth.id))
+        end
+      end
+    end
+  end
+end

data/lib/exception_hub/version.rb

@@ -0,0 +1,3 @@
+module ExceptionHub
+  VERSION = "0.0.1"
+end

data/lib/exception_hub.rb

@@ -0,0 +1,20 @@
+require 'exception_hub/version'
+require 'exception_hub/configuration'
+require 'exception_hub/issue'
+require 'exception_hub/client'
+require 'exception_hub/rack'
+require 'exception_hub/notifier'
+require 'exception_hub/interceptor'
+require 'octokit'
+
+require 'exception_hub/railtie' if defined?(Rails)
+
+# @author Jesse Dearing <jesse.dearing@gmail.com>
+module ExceptionHub
+  extend Configuration
+  extend Client
+
+  def self.handle_exception(exception, env)
+    Interceptor.new(exception, env).intercept!
+  end
+end

data/lib/tasks/exception_hub.rake

@@ -0,0 +1,3 @@
+require 'exception_hub/rake_task'
+
+ExceptionHub::RakeTask.new

data/spec/integration/exception_hub_integration/.gitignore

@@ -0,0 +1,17 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp
+
+config/initializers/exception_hub.rb

data/spec/integration/exception_hub_integration/Gemfile

@@ -0,0 +1,40 @@
+source 'https://rubygems.org'
+
+gem 'rails', '3.2.6'
+
+# Bundle edge Rails instead:
+# gem 'rails', :git => 'git://github.com/rails/rails.git'
+
+gem 'sqlite3'
+
+
+# Gems used only for assets and not required
+# in production environments by default.
+group :assets do
+  gem 'sass-rails',   '~> 3.2.3'
+  gem 'coffee-rails', '~> 3.2.1'
+
+  # See https://github.com/sstephenson/execjs#readme for more supported runtimes
+  # gem 'therubyracer', :platforms => :ruby
+
+  gem 'uglifier', '>= 1.0.3'
+end
+
+gem 'jquery-rails'
+
+gem 'exception_hub', :path => File.expand_path('../../../', File.dirname(__FILE__))
+
+# To use ActiveModel has_secure_password
+# gem 'bcrypt-ruby', '~> 3.0.0'
+
+# To use Jbuilder templates for JSON
+# gem 'jbuilder'
+
+# Use unicorn as the app server
+# gem 'unicorn'
+
+# Deploy with Capistrano
+# gem 'capistrano'
+
+# To use debugger
+# gem 'debugger'