party_foul 0.0.0 → 0.1.0

data/README.md

@@ -6,25 +6,96 @@
 
 Rails exceptions automatically opened as issues on Github
 
+## About ##
+
+`PartyFoul` will capture exceptions in your application and will do the
+following:
+
+1. Will attempt to find a matching issue in your Github repo
+2. If no matching issue is found an new issue will be created with a
+   unique title, session information, and stack trace. The issue will be
+tagged as a `bug`
+3. If an open issue is found the occurance count and time stamp will be
+   updated
+4. If a closed issue is found the occurance count and time stamp will be
+   updated. The issue will be reopened and a `regression` tag will be
+added.
+5. If the issue is marked as `wontfix` the issue is not updated nor is
+   a new issue created.
+
 ## Installation ##
 
+Prior to installing the gem you will need to set up an OAuth application
+on Github to provide access to your repository. Once this OAuth
+application is setup you will have a `ClientID` and `ClientSecret` that
+you will need to complete the installation.
+
+**Note** We highly recommend that you create a new Github account that is
+a collaborator on your repository. Use this new account's credentials
+for the installation below. If you use your own account you will
+not receive emails when issues are created, updated, reopened, etc...
+because all of the work will be done as your account.
+
 In your Gemfile add the following:
 
 ```ruby
 gem 'party_foul'
 ```
 
+### Rails ###
+If you are using Rails you can run the install generator.
 
-## Usage ##
+```
+rails g party_foul:install
+```
+
+This will prompt you for the Github credentials of the account that will
+be opening the issues. The OAuth token for that account will be stored
+in `config/initializers/party_foul.rb`. You may want to remove the token
+string and store in an environment variable. It is best not to store the
+token in version control.
+
+Add as the very last middleware in your production `Rack` stack in `config/environments/production.rb`
+
+```ruby
+config.middleware.insert_before(-1, 'PartyFoul::Middleware')
+```
+### Other ###
 
+You will need to initialize `PartyFoul`, you can use the following to do
+so:
 
-## What you get ##
+```ruby
+PartyFoul.configure do |config|
+  # the collection of exceptions to be ignored by PartyFoul
+  # The constants here *must* be represented as strings
+  config.ignored_exceptions = ['ActiveRecord::RecordNotFound']
+
+  # The OAuth token for the account that will be opening the issues on Github
+  config.oauth_token        = 'abcdefgh1234567890'
+
+  # The API endpoint for Github. Unless you are hosting a private
+  # instance of Enterprise Github you do not need to include this
+  config.endpoint           = 'https://api.github.com'
+
+  # The organization or user that owns the target repository
+  config.owner              = 'owner_name'
+
+  # The repository for this application
+  config.repo               = 'repo_name'
+end
+```
+
+Add as the very last middleware in your production `Rack` stack.
+
+## Usage ##
 
 
 ## Authors ##
 
 [Brian Cardarella](http://twitter.com/bcardarella)
-[Dan McClain](http://twitter.com/danmcclain)
+
+[Dan McClain](http://twitter.com/_danmcclain)
 
 [We are very thankful for the many contributors](https://github.com/dockyard/party_foul/graphs/contributors)
 
@@ -45,4 +116,3 @@ on how to properly submit issues and pull requests.
 [@dockyard](http://twitter.com/dockyard)
 
 [Licensed under the MIT license](http://www.opensource.org/licenses/mit-license.php)
-

data/Rakefile

@@ -4,24 +4,6 @@ begin
 rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
-begin
-  require 'rdoc/task'
-rescue LoadError
-  require 'rdoc/rdoc'
-  require 'rake/rdoctask'
-  RDoc::Task = Rake::RDocTask
-end
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'PartyFoul'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-
-
 
 Bundler::GemHelper.install_tasks
 
@@ -34,5 +16,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-
 task :default => :test

data/lib/generators/party_foul/install_generator.rb

@@ -0,0 +1,74 @@
+require 'rails/generators'
+require 'io/console'
+require 'net/http'
+
+module PartyFoul
+  class InstallGenerator < Rails::Generators::Base
+
+    def create_initializer_file
+      puts 'A Github Application is required'
+
+      client_id = ask 'Github App Client ID:'
+      client_secret = ask 'Github App Client Secret:'
+      username = ask 'Github username:'
+      password = STDIN.noecho do
+        ask 'Github password:'
+      end
+      say ''
+
+      owner = ask 'Repository owner:'
+      repo  = ask 'Repository name:'
+      auth_uri = URI("https://api.github.com/authorizations")
+
+      response = nil
+      Net::HTTP.start(auth_uri.host, auth_uri.port, :use_ssl => auth_uri.scheme == 'https') do |http|
+        request = Net::HTTP::Post.new auth_uri.request_uri
+        body = { :scopes => ['repo'], :client_id => client_id, :client_secret => client_secret }
+        request.body = body.to_json
+
+        request.basic_auth username, password
+
+        response = http.request request
+      end
+
+      if response.code == '201'
+        oauth_token = JSON.parse(response.body)['token']
+
+        File.open('config/initializers/party_foul.rb', 'w') do |f|
+          f.puts <<-CONTENTS
+PartyFoul.configure do |config|
+  # the collection of exceptions to be ignored by PartyFoul
+  # The constants here *must* be represented as strings
+  config.ignored_exceptions = ['ActiveRecord::RecordNotFound']
+
+  # The OAuth token for the account that will be opening the issues on Github
+  config.oauth_token        = '#{oauth_token}'
+
+  # The API endpoint for Github. Unless you are hosting a private
+  # instance of Enterprise Github you do not need to include this
+  config.endpoint           = 'https://api.github.com'
+
+  # The organization or user that owns the target repository
+  config.owner              = '#{owner}'
+
+  # The repository for this application
+  config.repo               = '#{repo}'
+end
+CONTENTS
+        end
+      else
+        say 'There was an error retrieving your Github OAuth token'
+      end
+
+      say 'Done'
+    end
+
+    private
+
+    def self.installation_message
+      'Generates the configuration file'
+    end
+
+    desc installation_message
+  end
+end

data/lib/party_foul/exception_handler.rb

@@ -0,0 +1,118 @@
+class PartyFoul::ExceptionHandler
+  attr_accessor :exception, :env
+
+  def self.handle(exception, env)
+    handler = self.new(exception, env)
+    handler.run
+  end
+
+  def initialize(exception, env)
+    self.exception = exception
+    self.env       = env
+  end
+
+  def run
+    if issue = find_issue
+      update_issue(issue)
+    else
+      create_issue
+    end
+  end
+
+  def find_issue
+    unless issue = PartyFoul.github.search.issues(owner: PartyFoul.owner, repo: PartyFoul.repo, state: 'open', keyword: fingerprint).issues.first
+      issue = PartyFoul.github.search.issues(owner: PartyFoul.owner, repo: PartyFoul.repo, state: 'closed', keyword: fingerprint).issues.first
+    end
+
+    issue
+  end
+
+  def stack_trace
+    exception.backtrace.map do |line|
+      if matches = extract_file_name_and_line_number(line)
+        "<a href='../tree/master/#{matches[2]}#L#{matches[3]}'>#{line}</a>"
+      else
+        line
+      end
+    end.join("\n")
+  end
+
+  def create_issue
+    PartyFoul.github.issues.create(PartyFoul.owner, PartyFoul.repo, title: issue_title, body: issue_body, labels: ['bug'])
+  end
+
+  def update_issue(issue)
+    unless issue.key?('labels') && issue['labels'].include?('wontfix')
+      params = {body: update_body(issue['body']), state: 'open'}
+
+      if issue['state'] == 'closed'
+        params[:labels] = ['bug', 'regression']
+      end
+
+      PartyFoul.github.issues.edit(PartyFoul.owner, PartyFoul.repo, issue['number'], params)
+    end
+  end
+
+  def issue_title
+    line = exception.backtrace.select {|p| p =~ /#{app_root}/ }.first
+    name_and_number = extract_file_name_and_line_number(line)[1]
+    "#{exception} - #{name_and_number}"
+  end
+
+  def fingerprint
+    Digest::SHA1.hexdigest(issue_title)
+  end
+
+  def update_body(body)
+    begin
+      current_count = body.match(/<th>Count<\/th><td>(\d+)<\/td>/)[1].to_i
+      body.sub!("<th>Count</th><td>#{current_count}</td>", "<th>Count</th><td>#{current_count + 1}</td>")
+      body.sub!(/<th>Last Occurance<\/th><td>.+<\/td>/, "<th>Last Occurance</th><td>#{Time.now}</td>")
+      body
+    rescue
+      issue_body
+    end
+  end
+
+  def params
+    if env["action_dispatch.parameter_filter"]
+      parameter_filter = ActionDispatch::Http::ParameterFilter.new(env["action_dispatch.parameter_filter"])
+      parameter_filter.filter(env['action_dispatch.request.path_parameters'])
+    else
+      env['QUERY_STRING']
+    end
+  end
+
+  def issue_body
+    <<-BODY
+<table>
+<tr><th>Count</th><td>1</td></tr>
+<tr><th>Last Occurance</th><td>#{Time.now}</td></tr>
+<tr><th>Params</th><td>#{params}</td></tr>
+<tr><th>Exception</th><td>#{exception}</td></tr>
+</table>
+
+## Stack Trace
+<pre>#{stack_trace}</pre>
+Fingerprint: `#{fingerprint}`
+    BODY
+  end
+
+  private
+
+  def app_root
+    if defined?(Rails)
+      Rails.root
+    else
+      Dir.pwd
+    end
+  end
+
+  def file_and_line_regex
+    /#{app_root}\/((.+?):(\d+))/
+  end
+
+  def extract_file_name_and_line_number(backtrace_line)
+    backtrace_line.match(file_and_line_regex)
+  end
+end

data/lib/party_foul/middleware.rb

@@ -0,0 +1,32 @@
+module PartyFoul
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => captured_exception
+      if allow_handling?(captured_exception)
+        PartyFoul::ExceptionHandler.handle(captured_exception, env)
+      end
+      raise captured_exception
+    end
+
+    private
+
+    def allow_handling?(captured_exception)
+      !PartyFoul.ignored_exceptions.find do |ignored_exception|
+        names = ignored_exception.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+
+        constant === captured_exception
+      end
+    end
+  end
+end

data/lib/party_foul/version.rb

@@ -1,3 +1,3 @@
 module PartyFoul
-  VERSION = "0.0.0"
+  VERSION = '0.1.0'
 end

data/lib/party_foul.rb

@@ -1,2 +1,24 @@
+require 'github_api'
+
 module PartyFoul
+  class << self
+    attr_accessor :github, :oauth_token, :endpoint, :owner, :repo, :ignored_exceptions
+  end
+
+  def self.ignored_exceptions
+    @ignored_exceptions || []
+  end
+
+  def self.configure(&block)
+    yield self
+    _self = self
+    self.github ||= Github.new do |config|
+      %w{endpoint oauth_token}.each do |option|
+        config.send("#{option}=", _self.send(option)) if !_self.send(option).nil?
+      end
+    end
+  end
 end
+
+require 'party_foul/exception_handler'
+require 'party_foul/middleware'

data/test/party_foul/configure_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+describe 'Party Foul Confg' do
+
+  after do
+    clean_up_party
+  end
+
+  it 'sets the proper config variables' do
+    PartyFoul.configure do |config|
+      config.ignored_exceptions = ['StandardError']
+      config.oauth_token        = 'test_token'
+      config.endpoint           = 'test_endpoint'
+      config.owner              = 'test_owner'
+      config.repo               = 'test_repo'
+    end
+
+    PartyFoul.ignored_exceptions.must_equal ['StandardError']
+    PartyFoul.github.must_be_instance_of Github::Client
+    PartyFoul.github.oauth_token.must_equal 'test_token'
+    PartyFoul.github.endpoint.must_equal 'test_endpoint'
+    PartyFoul.owner.must_equal 'test_owner'
+    PartyFoul.repo.must_equal 'test_repo'
+  end
+end

data/test/party_foul/exception_handler_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+require 'active_support/core_ext/object/blank'
+require 'action_dispatch/http/parameter_filter'
+
+describe 'Party Foul Exception Handler' do
+  before do
+    Time.stubs(:now).returns(Time.at(0))
+  end
+
+  describe '#body' do
+    describe 'updating issue body' do
+      before do
+        @handler = PartyFoul::ExceptionHandler.new(nil, nil)
+        @handler.stubs(:fingerprint).returns('abcdefg1234567890')
+        @handler.stubs(:stack_trace)
+        @handler.stubs(:params)
+        @handler.stubs(:exception)
+      end
+
+      it 'updates count and timestamp' do
+        body = <<-BODY
+<table>
+<tr><th>Count</th><td>1</td></tr>
+<tr><th>Last Occurance</th><td>#{Time.now}</td></tr>
+<tr><th>Params</th><td></td></tr>
+<tr><th>Exception</th><td></td></tr>
+</table>
+
+## Stack Trace
+<pre></pre>
+Fingerprint: `abcdefg1234567890`
+    BODY
+
+        Time.stubs(:now).returns(Time.new(1985, 10, 25, 1, 22, 0, '-05:00'))
+
+        expected_body = <<-BODY
+<table>
+<tr><th>Count</th><td>2</td></tr>
+<tr><th>Last Occurance</th><td>#{Time.now}</td></tr>
+<tr><th>Params</th><td></td></tr>
+<tr><th>Exception</th><td></td></tr>
+</table>
+
+## Stack Trace
+<pre></pre>
+Fingerprint: `abcdefg1234567890`
+    BODY
+
+        @handler.update_body(body).must_equal expected_body
+      end
+    end
+
+    describe 'empty body' do
+      before do
+        @handler = PartyFoul::ExceptionHandler.new(nil, nil)
+        @handler.stubs(:fingerprint).returns('abcdefg1234567890')
+        @handler.stubs(:stack_trace)
+        @handler.stubs(:params)
+        @handler.stubs(:exception)
+      end
+
+      it 'resets body' do
+        expected_body = <<-BODY
+<table>
+<tr><th>Count</th><td>1</td></tr>
+<tr><th>Last Occurance</th><td>#{Time.now}</td></tr>
+<tr><th>Params</th><td></td></tr>
+<tr><th>Exception</th><td></td></tr>
+</table>
+
+## Stack Trace
+<pre></pre>
+Fingerprint: `abcdefg1234567890`
+    BODY
+        @handler.update_body(nil).must_equal expected_body
+      end
+    end
+  end
+
+  describe '#params' do
+    context 'with Rails' do
+      before do
+        @handler = PartyFoul::ExceptionHandler.new(nil, {'action_dispatch.parameter_filter' => ['password'], 'action_dispatch.request.path_parameters' => { 'status' => 'ok', 'password' => 'test' }, 'QUERY_STRING' => { 'status' => 'fail' } })
+      end
+
+      it 'returns ok' do
+        @handler.params['status'].must_equal 'ok'
+        @handler.params['password'].must_equal '[FILTERED]'
+      end
+    end
+
+    context 'without Rails' do
+      before do
+        @handler = PartyFoul::ExceptionHandler.new(nil, {'QUERY_STRING' => { 'status' => 'ok' } })
+      end
+
+      it 'returns ok' do
+        @handler.params['status'].must_equal 'ok'
+      end
+    end
+  end
+end

data/test/party_foul/middleware_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+describe 'Party Foul Middleware' do
+  include Rack::Test::Methods
+
+  after do
+    clean_up_party
+  end
+
+  def error_to_raise
+    Exception
+  end
+
+  def app
+    _self = self
+    Rack::Builder.new {
+      map '/' do
+        use PartyFoul::Middleware
+        run lambda { |env| raise _self.error_to_raise }
+      end
+    }
+  end
+
+  before do
+    PartyFoul.configure do |config|
+      config.oauth_token = 'abcdefg1234567890'
+      config.owner       = 'test_owner'
+      config.repo        = 'test_repo'
+    end
+    PartyFoul.github.stubs(:issues).returns(mock('Issues'))
+    PartyFoul.github.stubs(:search).returns(mock('Search'))
+    PartyFoul.github.issues.stubs(:create)
+    PartyFoul.github.issues.stubs(:edit)
+    PartyFoul::ExceptionHandler.any_instance.stubs(:issue_title).returns('Test Title')
+    PartyFoul::ExceptionHandler.any_instance.stubs(:fingerprint).returns('test_fingerprint')
+  end
+
+  context 'when error is new' do
+    it 'will open a new error on Github' do
+      PartyFoul::ExceptionHandler.any_instance.stubs(:issue_body).returns('Test Body')
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: []))
+      PartyFoul.github.issues.expects(:create).with('test_owner', 'test_repo', title: 'Test Title', body: 'Test Body', :labels => ['bug'])
+      lambda {
+        get '/'
+      }.must_raise(Exception)
+    end
+  end
+
+  context 'when error is not new' do
+    before do
+      PartyFoul::ExceptionHandler.any_instance.stubs(:update_body).returns('New Body')
+    end
+
+    context 'and open' do
+      it 'will update the issue' do
+        PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: [{title: 'Test Title', body: 'Test Body', state: 'open', number: 1}]))
+        PartyFoul.github.issues.expects(:edit).with('test_owner', 'test_repo', 1, body: 'New Body', state: 'open')
+        lambda {
+          get '/'
+        }.must_raise(Exception)
+      end
+    end
+
+    context 'and closed' do
+      it 'will update the count on the body and re-open the issue' do
+        PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
+        PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: [{title: 'Test Title', body: 'Test Body', state: 'closed', number: 1}]))
+        PartyFoul.github.issues.expects(:edit).with('test_owner', 'test_repo', 1, body: 'New Body', state: 'open', labels: ['bug', 'regression'])
+        lambda {
+          get '/'
+        }.must_raise(Exception)
+      end
+    end
+  end
+
+  context 'when issue is marked as "wontfix"' do
+    it 'does nothing' do
+      PartyFoul::ExceptionHandler.any_instance.stubs(:issue_body).returns('Test Body')
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: [{title: 'Test Title', body: 'Test Body', state: 'closed', number: 1, 'labels' => ['wontfix']}]))
+      PartyFoul.github.issues.expects(:create).never
+      PartyFoul.github.issues.expects(:edit).never
+      lambda {
+        get '/'
+      }.must_raise(Exception)
+    end
+  end
+
+  context 'filtering based upon exception' do
+    before do
+      PartyFoul.ignored_exceptions = ['StandardError']
+      self.stubs(:error_to_raise).returns(StandardError)
+    end
+
+    it 'does not handle exception' do
+      PartyFoul::ExceptionHandler.any_instance.stubs(:issue_body).returns('Test Body')
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'open').returns(Hashie::Mash.new(issues: []))
+      PartyFoul.github.search.stubs(:issues).with(owner: 'test_owner', repo: 'test_repo', keyword: 'test_fingerprint', state: 'closed').returns(Hashie::Mash.new(issues: []))
+      PartyFoul.github.issues.expects(:create).never
+      lambda {
+        get '/'
+      }.must_raise(StandardError)
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,15 +1,26 @@
-# Configure Rails Environment
-ENV["RAILS_ENV"] = "test"
-
-require File.expand_path("../dummy/config/environment.rb",  __FILE__)
-require "rails/test_help"
+if defined?(M)
+  require 'minitest/spec'
+else
+  require 'minitest/autorun'
+end
+require 'rack/test'
+require 'mocha/setup'
+require 'bourne'
+require 'debugger'
+require 'party_foul'
 
-Rails.backtrace_cleaner.remove_silencers!
+class MiniTest::Spec
+  class << self
+    alias :context :describe
+  end
+end
 
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+module MiniTest::Expectations
+  infect_an_assertion :assert_received, :must_have_received
+end
 
-# Load fixtures from the engine
-if ActiveSupport::TestCase.method_defined?(:fixture_path=)
-  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
+def clean_up_party
+  %w{github oauth_token endpoint owner repo ignored_exceptions}.each do |attr|
+    PartyFoul.send("#{attr}=", nil)
+  end
 end