party_fouls 1.5.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 24bb7632ea8be8c278cd4583225f4f7d5dfbf4fb
+  data.tar.gz: ad2655ec1e1f1b26d46355941b2a77f0ab7b2a19
+SHA512:
+  metadata.gz: 0eb1eaea0c9d6a0beed7ae74c16cee3e485daeb01cb41f9fb11f0b66069d641b95d59bd9b5746db2eeb0392bc323459a2210e26aa9ed08849b50c7180e0a5670
+  data.tar.gz: da6149b6f020abd7f5f9e3f1f5d2a63a531b90b933b40932ce62bba6f87e0841045b069d79b5cca5a93206e22b766281dc6a1bd1fb0624003932866e5a7ca33a

data/README.md

@@ -0,0 +1,268 @@
+# PartyFoul #
+
+Rails exceptions automatically opened as issues on GitHub
+
+# This is a fork, released as the `party_fouls` gem
+
+## Looking for help? ##
+
+If it is a bug [please open an issue on
+GitHub](https://github.com/dockyard/party_foul/issues).
+
+## About ##
+
+`PartyFoul` captures exceptions in your application and does the
+following:
+
+1. Attempt to find a matching issue in your GitHub repo
+2. If no matching issue is found, a new issue is created with a
+   unique title, session information, and stack trace. The issue is
+tagged as a `bug`. A new comment is added with relevant data on the
+application state.
+3. If an open issue is found, the occurrence count and time stamp is
+   updated. A new comment is added with relevant data on the
+application state.
+4. If a closed issue is found, the occurrence count and time stamp is
+   updated. The issue is reopened and a `regression` tag is
+added. A new comment is added with relevant data on the
+application state.
+5. If the issue is marked as `wontfix` the issue is not updated nor is
+   a new issue created. No comments are added.
+
+## 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 is 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.
+
+```
+rails g party_foul:install
+```
+
+This prompts you for the GitHub credentials of the account that is
+opening the issues. The OAuth token for that account is 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.use('PartyFoul::Middleware')
+```
+### Other ###
+
+You need to initialize `PartyFoul`, use the following:
+
+```ruby
+PartyFoul.configure do |config|
+  # The collection of exceptions PartyFoul should not be allowed to handle
+  # The constants here *must* be represented as strings
+  config.blacklisted_exceptions = ['ActiveRecord::RecordNotFound', 'ActionController::RoutingError']
+
+  # The OAuth token for the account that is 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.api_endpoint           = 'https://api.github.com'
+
+  # The Web URL for GitHub. Unless you are hosting a private
+  # instance of Enterprise GitHub you do not need to include this
+  config.web_url                = 'https://github.com'
+
+  # The organization or user that owns the target repository
+  config.owner                  = 'owner_name'
+
+  # The repository for this application
+  config.repo                   = 'repo_name'
+
+  # The branch for your deployed code
+  # config.branch               = 'master'
+
+  # Additional labels to add to issues created
+  # config.additional_labels    = ['production']
+  # or
+  # config.additional_labels    = Proc.new do |exception, env|
+  #   []
+  # end
+
+  # Limit the number of comments per issue
+  # config.comment_limit        = 10
+
+  # Setting your title prefix can help with
+  # distinguising the issue between environments
+  # config.title_prefix         = Rails.env
+end
+```
+
+You can
+[create an OAuth token](https://help.github.com/articles/creating-an-access-token-for-command-line-use/)
+or generate an OAuth token via the
+[OAuth Authorizations API](http://developer.github.com/v3/oauth/#oauth-authorizations-api) with cURL:
+
+```bash
+curl -u <github_login> -i -d "{ \"scopes\": [\"repo\"], \"note\":[\"Test\"] }" \
+https://api.github.com/authorizations
+```
+
+## Customization ##
+
+### Labels ###
+
+You can specify an additional array of labels that will be applied to the issues PartyFoul creates.
+
+```ruby
+PartyFoul.configure do |config|
+  config.additional_labels = ['front-end']
+end
+```
+
+You can also provide a Proc that is passed the exception and the environment.
+
+```ruby
+PartyFoul.configure do |config|
+  config.additional_labels = Proc.new do |exception, env|
+    labels = if env["HTTP_HOST"] =~ /beta\./
+      ['beta']
+    else
+      ['production']
+    end
+    if exception.message =~ /PG::Error/
+      labels << 'database'
+    end
+    labels
+  end
+end
+```
+
+### Background Processing ###
+
+You can specify the adapter with which the exceptions should be
+handled. By default, PartyFoul includes the
+[`PartyFoul::Processors::Sync`](https://github.com/dockyard/party_foul/tree/master/lib/party_foul/processors/sync.rb)
+which handles the exception synchronously. To use your own adapter,
+include the following in your `PartyFoul.configure` block:
+
+```ruby
+PartyFoul.configure do |config|
+  config.processor = PartyFoul::Processors::MyBackgroundProcessor
+end
+
+class PartyFoul::Processors::MyBackgroundProcessor
+  def self.handle(exception, env)
+    # Enqueue the exception, then in your worker, call
+    # PartyFoul::ExceptionHandler.new(exception, env).run
+  end
+end
+
+```
+
+`PartyFoul` comes with the following background processing adapters:
+
+* [PartyFoul::Processors::Sidekiq](https://github.com/dockyard/party_foul/blob/master/lib/party_foul/processors/sidekiq.rb)
+* [PartyFoul::Processors::Resque](https://github.com/dockyard/party_foul/blob/master/lib/party_foul/processors/resque.rb)
+* [PartyFoul::Processors::DelayedJob](https://github.com/dockyard/party_foul/blob/master/lib/party_foul/processors/delayed_job.rb)
+
+These adapters are not loaded by default. You must explicitly require if
+you want to use:
+
+```ruby
+require 'party_foul/processors/sidekiq'
+
+PartyFoul.configure do |config|
+  config.processor = PartyFoul::Processors::Sidekiq
+end
+```
+
+### Limiting Comments
+
+You can specify a limit on the number of comments added to each issue. The main issue will still be updated
+with a count and time for each occurrence, regardless of the limit.
+
+```ruby
+PartyFoul.configure do |config|
+  config.comment_limit = 10
+end
+```
+
+## Tracking errors outside of an HTTP request
+
+You may want to track errors outside of a regular HTTP stack. In that
+case you will need to make sure of the
+`PartyFoul::RacklessExceptionHandler`.
+
+The code that you want to handle should be wrapped like so:
+
+```ruby
+begin
+  ... # some code that might raise an error
+rescue => error
+  PartyFoul::RacklessExceptionHandler.handle(error, class: class_name, method: method_name, params: message)
+  raise error
+end
+```
+
+### Tracking errors in a Sidekiq worker
+In order to use PartyFoul for exception handling with Sidekiq you will need to create an initializer with some middleware configuration. The following example is based on using [Sidekiq with another exception notifier server](https://github.com/bugsnag/bugsnag-ruby/blob/master/lib/bugsnag/sidekiq.rb).
+
+File: config/initializers/partyfoul_sidekiq.rb
+
+```ruby
+module PartyFoul
+  class Sidekiq
+    def call(worker, msg, queue)
+      begin
+        yield
+      rescue => error
+        PartyFoul::RacklessExceptionHandler.handle(error, {class: worker.class.name, method: queue, params: msg})
+        raise error
+      end
+    end
+  end
+end
+
+::Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add ::PartyFoul::Sidekiq
+  end
+end
+```
+
+This will pass the worker class name and queue as well as all worker-related parameters off to PartyFoul before passing on the exception.
+
+## Authors ##
+
+* [Brian Cardarella](http://twitter.com/bcardarella)
+* [Dan McClain](http://twitter.com/_danmcclain)
+
+[We are very thankful for the many contributors](https://github.com/dockyard/party_foul/graphs/contributors)
+
+## Versioning ##
+
+This gem follows [Semantic Versioning](http://semver.org)
+
+## Want to help? ##
+
+Please do! We are always looking to improve this gem. Please see our
+[Contribution Guidelines](https://github.com/dockyard/party_foul/blob/master/CONTRIBUTING.md)
+on how to properly submit issues and pull requests.
+
+## Legal ##
+
+[DockYard](http://dockyard.com), LLC &copy; 2013
+
+[@dockyard](http://twitter.com/dockyard)
+
+[Licensed under the MIT license](http://www.opensource.org/licenses/mit-license.php)

data/Rakefile

@@ -0,0 +1,19 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/lib/generators/party_foul/install_generator.rb

@@ -0,0 +1,38 @@
+require 'rails/generators'
+require 'net/http'
+
+module PartyFoul
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_initializer_file
+      login         = ask 'GitHub login:'
+      password      = ask 'GitHub password:'
+      @owner        = ask_with_default "\nRepository owner:", login
+      @repo         = ask 'Repository name:'
+      @api_endpoint = ask_with_default 'Api Endpoint:', 'https://api.github.com'
+      @web_url      = ask_with_default 'Web URL:', 'https://github.com'
+
+      begin
+        octokit      = Octokit::Client.new :login => login, :password => password, :api_endpoint => @api_endpoint
+        @oauth_token = octokit.create_authorization(scopes: ['repo'], note: "PartyFoul #{@owner}/#{@repo}", note_url: "#{@web_url}/#{@owner}/#{@repo}").token
+        template 'party_foul.rb', 'config/initializers/party_foul.rb'
+      rescue Octokit::Unauthorized
+        say 'There was an error retrieving your GitHub OAuth token'
+      end
+    end
+
+    private
+
+    def self.installation_message
+      'Generates the initializer'
+    end
+
+    desc installation_message
+
+    def ask_with_default(prompt, default)
+      value = ask("#{prompt} [#{default}]")
+      value.blank? ? default : value
+    end
+  end
+end

data/lib/generators/party_foul/templates/party_foul.rb

@@ -0,0 +1,39 @@
+PartyFoul.configure do |config|
+  # The collection of exceptions PartyFoul should not be allowed to handle
+  # The constants here *must* be represented as strings
+  config.blacklisted_exceptions = ['ActiveRecord::RecordNotFound', 'ActionController::RoutingError']
+
+  # The OAuth token for the account that is 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.api_endpoint           = '<%= @api_endpoint %>'
+
+  # The Web URL for GitHub. Unless you are hosting a private
+  # instance of Enterprise GitHub you do not need to include this
+  config.web_url                = '<%= @web_url %>'
+
+  # The organization or user that owns the target repository
+  config.owner                  = '<%= @owner %>'
+
+  # The repository for this application
+  config.repo                   = '<%= @repo %>'
+
+  # The branch for your deployed code
+  # config.branch               = 'master'
+
+  # Additional labels to add to issues created
+  # config.additional_labels    = ['production']
+  # or
+  # config.additional_labels    = Proc.new do |exception, env|
+  #   []
+  # end
+
+  # Limit the number of comments per issue
+  # config.comment_limit        = 10
+
+  # Setting your title prefix can help with
+  # distinguishing the issue between environments
+  # config.title_prefix         = Rails.env
+end

data/lib/party_foul/exception_handler.rb

@@ -0,0 +1,106 @@
+class PartyFoul::ExceptionHandler
+  attr_accessor :rendered_issue
+
+  # This handler will pass the exception and env from Rack off to a processor.
+  # The default PartyFoul processor will work synchronously. Processor adapters can be written
+  # to push this logic to a background job if desired.
+  #
+  # @param [Exception, Hash]
+  def self.handle(exception, env)
+    PartyFoul.processor.handle(exception, clean_env(env))
+  end
+
+  # Makes an attempt to determine what framework is being used and will use the proper
+  # IssueRenderer.
+  #
+  # @param [Exception, Hash]
+  def initialize(exception, env)
+    renderer_klass = if defined?(Rails)
+                       PartyFoul::IssueRenderers::Rails
+                     else
+                       PartyFoul::IssueRenderers::Rack
+                     end
+
+    self.rendered_issue = renderer_klass.new(exception, env)
+  end
+
+  # Begins to process the exception for GitHub Issues. Makes an attempt
+  # to find the issue. If found will update the issue. If not found will create a new issue.
+  def run
+    if issue = find_issue
+      update_issue(issue)
+    else
+      create_issue
+    end
+  end
+
+  # Hits the GitHub API to find the matching issue using the fingerprint.
+  def find_issue
+    find_first_issue('open') || find_first_issue('closed')
+  end
+
+  # Will create a new issue and a comment with the proper details. All issues are labeled as 'bug'.
+  def create_issue
+    self.sha = PartyFoul.github.references(PartyFoul.repo_path, "heads/#{PartyFoul.branch}").object.sha
+    issue = PartyFoul.github.create_issue(PartyFoul.repo_path, rendered_issue.title, rendered_issue.body, labels: ['bug'] + rendered_issue.labels)
+    PartyFoul.github.add_comment(PartyFoul.repo_path, issue[:number], rendered_issue.comment)
+  end
+
+  # Updates the given issue. If the issue is labeled as 'wontfix' nothing is done. If the issue is closed the issue is reopened and labeled as 'regression'.
+  #
+  # @param [Sawyer::Resource]
+  def update_issue(issue)
+    label_names = issue.key?(:labels) ? issue[:labels].map {|label| label[:name] } : []
+
+    unless label_names.include?('wontfix')
+      body = rendered_issue.update_body(issue[:body])
+      params = {state: 'open'}
+
+      if issue[:state] == 'closed'
+        params[:labels] = (['bug', 'regression'] + label_names).uniq
+      end
+
+      self.sha = PartyFoul.github.references(PartyFoul.repo_path, "heads/#{PartyFoul.branch}").object.sha
+      PartyFoul.github.update_issue(PartyFoul.repo_path, issue[:number], issue.title, body, params)
+
+      unless comment_limit_met?(issue[:body])
+        PartyFoul.github.add_comment(PartyFoul.repo_path, issue[:number], rendered_issue.comment)
+      end
+    end
+  end
+
+  private
+
+  def self.clean_env(env)
+    env.select do |key, value|
+      begin
+        Marshal.dump(value)
+      rescue TypeError
+        true
+      rescue
+        false
+      end
+    end
+  end
+
+  def fingerprint
+    rendered_issue.fingerprint
+  end
+
+  def sha=(sha)
+    rendered_issue.sha = sha
+  end
+
+  def occurrence_count(body)
+    result = body.match(/<th>Count<\/th><td>(\d+)<\/td>/)
+    result.nil? ? 0 : result[1].to_i
+  end
+
+  def comment_limit_met?(body)
+    !!PartyFoul.comment_limit && PartyFoul.comment_limit <= occurrence_count(body)
+  end
+
+  def find_first_issue(state)
+    PartyFoul.github.search_issues("#{fingerprint} repo:#{PartyFoul.repo_path} state:#{state}").items.first
+  end
+end

data/lib/party_foul/issue_renderers/base.rb

@@ -0,0 +1,187 @@
+require 'cgi'
+
+class PartyFoul::IssueRenderers::Base
+  attr_accessor :exception, :env, :sha
+
+  # A new renderer instance for GitHub issues
+  #
+  # @param [Exception, Hash]
+  def initialize(exception, env)
+    self.exception = exception
+    self.env       = env
+  end
+
+  # Title of the issue with any object ids masked
+  #
+  # @return [String]
+  def title
+    _title = if PartyFoul.title_prefix
+      "[#{PartyFoul.title_prefix}] #{masked_title}"
+    else
+      masked_title
+    end
+
+    _title[0..255]
+  end
+
+  # Renders the issue body
+  #
+  # Customize by overriding {#body_options}
+  #
+  # @return [String]
+  def body
+    @body ||= <<-BODY
+#{build_table_from_hash(body_options)}
+
+## Stack Trace
+<pre>#{stack_trace}</pre>
+Fingerprint: `#{fingerprint}`
+BODY
+  end
+
+  # Renderes the issue comment
+  #
+  # Customize by overriding {#comment_options}
+  #
+  def comment
+    build_table_from_hash(comment_options)
+  end
+
+  # Compiles the stack trace for use in the issue body. Lines in the
+  # stack trace that are part of the application will be rendered as
+  # links to the relative file and line on GitHub based upon
+  # {PartyFoul.web_url}, {PartyFoul.owner}, {PartyFoul.repo}, and
+  # {PartyFoul.branch}. The branch will be used at the time the
+  # exception happens to grab the SHA for that branch at that time for
+  # the purpose of linking.
+  #
+  # @return [String]
+  def stack_trace
+    exception.backtrace.map do |line|
+      if from_bundler?(line)
+        format_line(line)
+      elsif (matches = extract_file_name_and_line_number(line))
+        "<a href='#{PartyFoul.repo_url}/blob/#{sha}/#{matches[2]}#L#{matches[3]}'>#{format_line(line)}</a>"
+      else
+        format_line(line)
+      end
+    end.join("\n")
+  end
+
+  # A SHA1 hex digested representation of the title. The fingerprint is
+  # used to create a unique value in the issue body. This value is used
+  # for seraching when matching issues happen again in the future.
+  #
+  # @return [String]
+  def fingerprint
+    Digest::SHA1.hexdigest(title)
+  end
+
+  # Will update the issue body. The count and the time stamp will both
+  # be updated. If the format of the issue body fails to match for
+  # whatever reason the issue body will be reset.
+  #
+  # @return [String]
+  def update_body(old_body)
+    begin
+      current_count = old_body.match(/<th>Count<\/th><td>(\d+)<\/td>/)[1].to_i
+      old_body.sub!("<th>Count</th><td>#{current_count}</td>", "<th>Count</th><td>#{current_count + 1}</td>")
+      old_body.sub!(/<th>Last Occurrence<\/th><td>.+?<\/td>/, "<th>Last Occurrence</th><td>#{occurred_at}</td>")
+      old_body
+    rescue
+      self.body
+    end
+  end
+
+  # The timestamp when the exception occurred.
+  #
+  # @return [String]
+  def occurred_at
+    @occurred_at ||= Time.now.strftime('%B %d, %Y %H:%M:%S %z')
+  end
+
+  # The hash used for building the table in issue body
+  #
+  # @return [Hash]
+  def body_options(count = 0)
+    { Exception: exception, 'Last Occurrence' => occurred_at, Count: count + 1 }
+  end
+
+  # The hash used for building the table in the comment body
+  #
+  # @return [Hash]
+  def comment_options
+    { 'Occurred At' => occurred_at }
+  end
+
+  # Builds an HTML table from hash
+  #
+  # @return [String]
+  def build_table_from_hash(hash)
+    "<table>#{rows_for_table_from_hash(hash)}</table>"
+  end
+
+  # Builds the rows of an HTML table from hash.
+  # Keys as Headers cells and Values as Data cells
+  # If the Value is a Hash it will be rendered as a table
+  #
+  # @return [String]
+  def rows_for_table_from_hash(hash)
+    hash.inject('') do |rows, row|
+      key, value = row
+      if row[1].kind_of?(Hash)
+        value = build_table_from_hash(row[1])
+      else
+        value = CGI.escapeHTML(value.to_s)
+      end
+      rows << "<tr><th>#{key}</th><td>#{value}</td></tr>"
+    end
+  end
+
+  # Provides additional labels using the configured options
+  #
+  # @return [Array]
+  def labels
+    if PartyFoul.additional_labels.respond_to? :call
+      PartyFoul.additional_labels.call(self.exception, self.env) || []
+    else
+      PartyFoul.additional_labels || []
+    end
+  end
+
+  private
+
+  def app_root
+    Dir.pwd
+  end
+
+  def bundle_root
+    Bundler.bundle_path.to_s if defined?(Bundler)
+  end
+
+  def from_bundler?(line)
+    if bundle_root
+      line.match(bundle_root)
+    end
+  end
+
+  def extract_file_name_and_line_number(line)
+    line.match(/#{app_root}\/((.+?):(\d+))/)
+  end
+
+  def raw_title
+    raise NotImplementedError
+  end
+
+  def masked_title
+    raw_title.gsub(/0x(\w+)/, "0xXXXXXX")
+  end
+
+  def format_line(line)
+    if from_bundler?(line)
+      line.sub(bundle_root, '[bundle]...')
+    else
+      line.sub(app_root, '[app]...')
+    end
+  end
+end