Merge pull request #946 from stevecrozz/configurable_backtraces

configurable notice fingerprinting

Merge pull request #946 from stevecrozz/configurable_backtraces
configurable notice fingerprinting
Stephen Crosby
2 parents 24db1d16 ddb32e10
Showing 32 changed files with 606 additions and 571 deletions Show diff stats
.gitignore
README.md
app/controllers/site_config_controller.rb
app/interactors/notice_refingerprinter.rb
app/interactors/problem_merge.rb
app/interactors/problem_recacher.rb
app/interactors/problem_updater_cache.rb
app/models/app.rb
app/models/error_report.rb
app/models/fingerprint/md5.rb
app/models/fingerprint/sha1.rb
app/models/notice.rb
app/models/notice_fingerprinter.rb
app/models/problem.rb
app/models/site_config.rb
app/views/shared/_navigation.html.haml
app/views/site_config/index.html.haml
config/routes.rb
lib/tasks/errbit/database.rake
spec/controllers/site_config_controller_spec.rb
@@ -20,3 +20,4 @@ bundle
 coverage
 *#
 .ruby-version
+NOTES
@@ -88,6 +88,19 @@ Deployment
 ----------
 See [notes on deployment](docs/deployment.md)
+Notice Grouping
+---------------
+The way Errbit arranges notices into error groups is configurable. By default,
+Errbit uses the notice's error class, error message, complete backtrace,
+component (or controller), action and environment name to generate a unique
+fingerprint for every notice. Notices with identical fingerprints appear in the
+UI as different occurences of the same error and notices with differing
+fingerprints are displayed as separate errors.
+
+Changing the fingerprinter (under the 'config' menu) applies to all apps and
+the change affects only notices that arrive after the change. If you want to
+refingerprint old notices, you can run `rake errbit:notice_refingerprint`.
+
 Authentication
 --------------
 ### Configuring GitHub authentication:
@@ -230,21 +243,6 @@ Airbrake.setProject(&quot;ERRBIT API KEY&quot;, &quot;ERRBIT API KEY&quot;);
 Airbrake.setHost("http://errbit.yourdomain.com");
 ```
-Using custom fingerprinting methods
------------------------------------
-
-Errbit collates errors into groups using a fingerprinting strategy. If you find
-your errors are not getting grouped the way you would expect, you may need to
-implement your own strategy. A fingerprinting strategy is just a class that
-implements a ::generate class method. See the classes in
-`app/models/fingerprint/` if you need some inspiration. You can install it with
-an initializer like:
-
-```ruby
-# config/initializers/fingerprint.rb
-ErrorReport.fingerprint_strategy = MyStrategy
-```
-
 Plugins and Integrations
 ------------------------
 You can extend Errbit by adding Ruby gems and plugins which are typically gems.
@@ -0,0 +1,27 @@
+class SiteConfigController < ApplicationController
+  before_action :require_admin!
+
+  def index
+    @config = SiteConfig.document
+  end
+
+  def update
+    SiteConfig.document.update_attributes(
+      notice_fingerprinter: filtered_update_params)
+    flash[:success] = 'Updated site config'
+    redirect_to action: :index
+  end
+
+  private def filtered_update_params
+    params
+      .require(:site_config)
+      .require(:notice_fingerprinter_attributes)
+      .permit(
+        :error_class,
+        :message,
+        :backtrace_lines,
+        :component,
+        :action,
+        :environment_name)
+  end
+end
@@ -0,0 +1,38 @@
+class NoticeRefingerprinter
+  LOG_EVERY = 100
+  LOG_ITR = '%.1f%% complete, %i notice(s) remaining'
+  LOG_START = 'Regenerating notice fingerprints for %i notices'
+
+  def self.run
+    count = Notice.count
+    puts format(LOG_START, count)
+
+    Notice.no_timeout.each_with_index do |notice, index|
+      refingerprint(notice)
+
+      next unless (index + 1) % LOG_EVERY == 0
+      puts format(LOG_ITR, (index * 100 / count), count - index)
+    end
+
+    puts 'Finished generating notice fingerprints'
+    puts 'Destroying orphaned err records'
+
+    Err.each { |e| e.destroy if e.notices.size == 0 }
+
+    puts 'Finished destroying orphaned err records'
+  end
+
+  def self.refingerprint(notice)
+    app = notice.app
+    notice.err = app.find_or_create_err!(
+      error_class: notice.error_class,
+      environment: notice.environment_name,
+      fingerprint: app.notice_fingerprinter.generate(app.api_key, notice, notice.backtrace)
+    )
+    notice.save!
+  end
+
+  def self.puts(*args)
+    Rails.logger.info(*args)
+  end
+end
@@ -16,13 +16,7 @@ class ProblemMerge
       problem.reload # deference all associate objet to avoid delete him after
       ProblemDestroy.execute(problem)
     end
-    reset_cached_attributes
+    merged_problem.recache
     merged_problem
   end
-
-  private
-
-  def reset_cached_attributes
-    ProblemUpdaterCache.new(merged_problem).update
-  end
 end
@@ -0,0 +1,24 @@
+class ProblemRecacher
+  LOG_EVERY = 100
+  LOG_ITR = '%.1f%% complete, %i problem(s) remaining'
+  LOG_START = 'Re-caching problem attributes for %i problems'
+
+  def self.run
+    count = Problem.count
+    puts format(LOG_START, count)
+
+    Problem.no_timeout.each_with_index do |problem, index|
+      problem.recache
+      problem.destroy if problem.notices_count == 0
+
+      next unless (index + 1) % LOG_EVERY == 0
+      puts format(LOG_ITR, (index * 100 / count), count - index)
+    end
+
+    puts "Finished re-caching problem attributes"
+  end
+
+  def self.puts(*args)
+    Rails.logger.info(*args)
+  end
+end
@@ -1,88 +0,0 @@
-class ProblemUpdaterCache
-  def initialize(problem, notice=nil)
-    @problem = problem
-    @notice = notice
-  end
-  attr_reader :problem
-
-  ##
-  # Update cache information about child associate to this problem
-  #
-  # update the notices count, and some notice informations
-  #
-  # @return [ Problem ] the problem with this update
-  #
-  def update
-    update_notices_count
-    update_notices_cache
-    problem
-  end
-
-  private
-
-  def update_notices_count
-    if @notice
-      problem.inc(notices_count: 1)
-    else
-      problem.update_attribute(
-        :notices_count, problem.notices.count
-      )
-    end
-  end
-
-  ##
-  # Update problem statistique from some notice information
-  #
-  def update_notices_cache
-    first_notice = notices.first
-    last_notice = notices.last
-    notice ||= @notice || first_notice
-
-    attrs = {}
-    attrs[:first_notice_at] = first_notice.created_at if first_notice
-    attrs[:last_notice_at] = last_notice.created_at if last_notice
-    attrs.merge!(
-      :message     => notice.message,
-      :where       => notice.where,
-      :messages    => attribute_count(:message, messages),
-      :hosts       => attribute_count(:host, hosts),
-      :user_agents => attribute_count(:user_agent_string, user_agents)
-    ) if notice
-    problem.update_attributes!(attrs)
-  end
-
-  def notices
-    @notices ||= @notice ? [@notice].sort(&:created_at) : problem.notices.order_by([:created_at, :asc])
-  end
-
-  def messages
-    @notice ? problem.messages : {}
-  end
-
-  def hosts
-    @notice ? problem.hosts : {}
-  end
-
-  def user_agents
-    @notice ? problem.user_agents : {}
-  end
-
-  private
-
-    def attribute_count(value, init)
-      init.tap do |counts|
-        notices.each do |notice|
-          counts[attribute_index(notice.send(value))] ||= {
-            'value' => notice.send(value),
-            'count' => 0
-          }
-          counts[attribute_index(notice.send(value))]['count'] += 1
-        end
-      end
-    end
-
-    def attribute_index(value)
-      @attributes_index ||= {}
-      @attributes_index[value.to_s] ||= Digest::MD5.hexdigest(value.to_s)
-    end
-end
@@ -27,6 +27,7 @@ class App
   embeds_many :deploys
   embeds_one :issue_tracker, :class_name => 'IssueTracker'
   embeds_one :notification_service
+  embeds_one :notice_fingerprinter, autobuild: true
   has_many :problems, :inverse_of => :app, :dependent => :destroy
@@ -38,6 +39,7 @@ class App
   validates_uniqueness_of :name, :allow_blank => true
   validates_uniqueness_of :api_key, :allow_blank => true
   validates_associated :watchers
+  validates_associated :notice_fingerprinter
   validate :check_issue_tracker
   accepts_nested_attributes_for :watchers, :allow_destroy => true,
@@ -46,6 +48,7 @@ class App
     :reject_if => proc { |attrs| !ErrbitPlugin::Registry.issue_trackers.keys.map(&:to_s).include?(attrs[:type_tracker].to_s) }
   accepts_nested_attributes_for :notification_service, :allow_destroy => true,
     :reject_if => proc { |attrs| !NotificationService.subclasses.map(&:to_s).include?(attrs[:type].to_s) }
+  accepts_nested_attributes_for :notice_fingerprinter
   scope :watched_by, ->(user) do
     where watchers: { "$elemMatch" => { "user_id" => user.id } }
@@ -62,16 +65,15 @@ class App
   # * <tt>:fingerprint</tt> - a unique value identifying the notice
   #
   def find_or_create_err!(attrs)
-    Err.where(
-      :fingerprint => attrs[:fingerprint]
-    ).first || (
-      problem = problems.create!(
-        error_class: attrs[:error_class],
-        environment: attrs[:environment],
-        app_name: name
-      )
-      problem.errs.create!(attrs.slice(:fingerprint, :problem_id))
+    err = Err.where(fingerprint: attrs[:fingerprint]).first
+    return err if err
+
+    problem = problems.create!(
+      error_class: attrs[:error_class],
+      environment: attrs[:environment],
+      app_name: name
     )
+    problem.errs.create!(attrs.slice(:fingerprint, :problem_id))
   end
   # Mongoid Bug: find(id) on association proxies returns an Enumerator
@@ -26,10 +26,6 @@ class ErrorReport
   attr_reader :server_environment
   attr_reader :user_attributes
-  cattr_accessor :fingerprint_strategy do
-    Fingerprint::Sha1
-  end
-
   def initialize(xml_or_attributes)
     @attributes = xml_or_attributes
     @attributes = Hoptoad.parse_xml!(@attributes) if @attributes.is_a? String
@@ -130,9 +126,7 @@ class ErrorReport
     Gem::Version.new(app_version) >= Gem::Version.new(current_version)
   end
-  private
-
   def fingerprint
-    @fingerprint ||= fingerprint_strategy.generate(notice, api_key)
+    app.notice_fingerprinter.generate(api_key, notice, backtrace)
   end
 end
@@ -1,22 +0,0 @@
-require 'digest/md5'
-
-module Fingerprint
-  class MD5 < Sha1
-    def to_s
-      Digest::MD5.hexdigest(fingerprint_source)
-    end
-
-    def fingerprint_source
-      location['method'] &&= sanitized_method_signature
-    end
-
-    private
-    def sanitized_method_signature
-      location['method'].gsub(/[0-9]+|FRAGMENT/, '#').gsub(/_+#/, '_#')
-    end
-
-    def location
-      notice.backtrace.lines.first
-    end
-  end
-end
@@ -1,43 +0,0 @@
-require 'digest/sha1'
-
-module Fingerprint
-  class Sha1
-
-    attr_reader :notice, :api_key
-
-    def self.generate(notice, api_key)
-      self.new(notice, api_key).to_s
-    end
-
-    def initialize(notice, api_key)
-      @notice = notice
-      @api_key = api_key
-    end
-
-    def to_s
-      Digest::SHA1.hexdigest(fingerprint_source.to_s)
-    end
-
-    def fingerprint_source
-      {
-        :file_or_message => file_or_message,
-        :error_class => notice.error_class,
-        :component => notice.component || 'unknown',
-        :action => notice.action,
-        :environment => notice.environment_name || 'development',
-        :api_key => api_key
-      }
-    end
-
-    def file_or_message
-      @file_or_message ||= unified_message + notice.backtrace.fingerprint
-    end
-
-    # filter memory addresses out of object strings
-    # example: "#<Object:0x007fa2b33d9458>" becomes "#<Object>"
-    def unified_message
-      notice.message.gsub(/(#<.+?):[0-9a-f]x[0-9a-f]+(>)/, '\1\2')
-    end
-
-  end
-end
@@ -29,9 +29,7 @@ class Notice
   scope :ordered, ->{ order_by(:created_at.asc) }
   scope :reverse_ordered, ->{ order_by(:created_at.desc) }
   scope :for_errs, Proc.new { |errs|
-    if (ids = errs.all.map(&:id)) && ids.present?
-      where(:err_id.in => ids)
-    end
+    where(:err_id.in => errs.all.map(&:id))
   }
   def user_agent
@@ -48,7 +46,8 @@ class Notice
   end
   def environment_name
-    server_environment['server-environment'] || server_environment['environment-name']
+    n = server_environment['server-environment'] || server_environment['environment-name']
+    n.blank? ? 'development' : n
   end
   def component
@@ -119,6 +118,12 @@ class Notice
     end
   end
+  # filter memory addresses out of object strings
+  # example: "#<Object:0x007fa2b33d9458>" becomes "#<Object>"
+  def filtered_message
+    message.gsub(/(#<.+?):[0-9a-f]x[0-9a-f]+(>)/, '\1\2')
+  end
+
   protected
   def problem_recache
@@ -0,0 +1,32 @@
+class NoticeFingerprinter
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  field :error_class, default: true, type: Boolean
+  field :message, default: true, type: Boolean
+  field :backtrace_lines, default: -1, type: Integer
+  field :component, default: true, type: Boolean
+  field :action, default: true, type: Boolean
+  field :environment_name, default: true, type: Boolean
+  field :source, type: String
+
+  embedded_in :app
+  embedded_in :site_config
+
+  def generate(api_key, notice, backtrace)
+    material = [ api_key ]
+    material << notice.error_class if error_class
+    material << notice.filtered_message if message
+    material << notice.component if component
+    material << notice.action if action
+    material << notice.environment_name if environment_name
+
+    if backtrace_lines < 0
+      material << backtrace.lines
+    else
+      material << backtrace.lines.slice(0, backtrace_lines)
+    end
+
+    Digest::MD5.hexdigest(material.reduce('') { |c, m| c << m.to_s; c })
+  end
+end
@@ -142,16 +142,22 @@ class Problem
         { "$match" => { err_id: { "$in" => err_ids } } },
         { "$group" => { _id: "$#{v}", count: {"$sum" => 1} } }
       ]).each do |agg|
-        next if agg[:_id] == nil
-
-        send(k)[Digest::MD5.hexdigest(agg[:_id])] = {
-          value: agg[:_id],
-          count: agg[:count]
+        send(k)[Digest::MD5.hexdigest(agg[:_id] || 'N/A')] = {
+          'value' => agg[:_id] || 'N/A',
+          'count' => agg[:count]
         }
       end
     end
-    self.notices_count = Notice.where({ err_id: { "$in" => err_ids }}).count
+    first_notice = notices.order_by([:created_at, :asc]).first
+    last_notice = notices.order_by([:created_at, :desc]).first
+
+    self.notices_count = notices.count
+    self.first_notice_at = first_notice.created_at if first_notice
+    self.message = first_notice.message if first_notice
+    self.where = first_notice.where if first_notice
+    self.last_notice_at = last_notice.created_at if last_notice
+
     save
   end
@@ -0,0 +1,36 @@
+class SiteConfig
+  CONFIG_SOURCE_SITE = 'site'.freeze
+  CONFIG_SOURCE_APP = 'app'.freeze
+
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  before_save :denormalize
+
+  embeds_one :notice_fingerprinter, autobuild: true
+  validates_associated :notice_fingerprinter
+  accepts_nested_attributes_for :notice_fingerprinter
+
+  # Get the one and only SiteConfig document
+  def self.document
+    first || create
+  end
+
+  # Denormalize SiteConfig onto individual apps so that this record doesn't
+  # need to be accessed when inserting new error notices
+  def denormalize
+    notice_fingerprinter_attributes = notice_fingerprinter.attributes.tap do |attrs|
+      attrs.delete('_id')
+      attrs[:source] = :site
+    end
+
+    App.each do |app|
+      f = app.notice_fingerprinter
+
+      if !f || f.source == CONFIG_SOURCE_SITE
+        app.update_attributes(
+          notice_fingerprinter: notice_fingerprinter_attributes)
+      end
+    end
+  end
+end
@@ -13,4 +13,8 @@
         = link_to users_path do
           %i.fa.fa-users
           = t('.users')
+      %li{:class => active_if_here(:site_config)}
+        = link_to site_config_index_path do
+          %i.fa.fa-wrench
+          = t('.config')
   %div.clear
@@ -0,0 +1,39 @@
+- content_for :title, 'Config'
+
+- content_for :action_bar, link_to('cancel', users_path, :class => 'button')
+
+= form_for @config, url: site_config_index_path, method: 'put' do |f|
+  = errors_for @config
+
+  %fieldset
+    %legend Notice Fingerprinter
+    %p
+      The notice fingerprinter governs how error notifications are grouped.
+      Each item counts toward an error's uniqueness if enabled.
+
+    = f.fields_for :notice_fingerprinter do |g|
+      .checkbox
+        = g.check_box :error_class
+        = g.label :error_class, 'Error class'
+
+      .checkbox
+        = g.check_box :message
+        = g.label :message, 'Error message'
+
+      %div
+        = g.label :backtrace_lines, 'Number of backtrace lines (-1 for unlimited)'
+        = g.text_field :backtrace_lines
+
+      .checkbox
+        = g.check_box :component
+        = g.label :component, 'Component (or controller)'
+
+      .checkbox
+        = g.check_box :action
+        = g.label :action, 'Action'
+
+      .checkbox
+        = g.check_box :environment_name
+        = g.label :environment_name, 'Environment name'
+
+  %div.buttons= f.submit 'Update Config'
@@ -14,7 +14,14 @@ Rails.application.routes.draw do
       delete :unlink_github
     end
   end
-  resources :problems,      :only => [:index] do
+
+  resources :site_config, :only => [:index] do
+    collection do
+      put :update
+    end
+  end
+
+  resources :problems,    :only => [:index] do
     collection do
       post :destroy_several
       post :resolve_several
-require 'digest/sha1'
-
 namespace :errbit do
-  namespace :db do
-
-    desc "Updates cached attributes on Problem"
-    task :update_problem_attrs => :environment do
-      puts "Updating problems"
-      Problem.no_timeout.all.each do |problem|
-        ProblemUpdaterCache.new(problem).update
-      end
-    end
-
-    desc "Updates Problem#notices_count"
-    task :update_notices_count => :environment do
-      puts "Updating problem.notices_count"
-      Problem.no_timeout.all.each do |pr|
-        pr.update_attributes(:notices_count => pr.notices.count)
-      end
-    end
-
-    desc "Delete resolved errors from the database. (Useful for limited heroku databases)"
-    task :clear_resolved => :environment do
-      require 'resolved_problem_clearer'
-      puts "=== Cleared #{ResolvedProblemClearer.new.execute} resolved errors from the database."
-    end
-
-    desc "Regenerate fingerprints"
-    task :regenerate_fingerprints => :environment do
-
-      def normalize_backtrace(backtrace)
-        backtrace[0...3].map do |trace|
-          trace.merge 'method' => trace['method'].to_s.gsub(/[0-9_]{10,}+/, "__FRAGMENT__")
-        end
-      end
+  desc "Updates cached attributes on Problem"
+  task :problem_recache => :environment do
+    ProblemRecacher.run
+  end
-      def fingerprint(source)
-        Digest::SHA1.hexdigest(source.to_s)
-      end
+  desc "Delete resolved errors from the database. (Useful for limited heroku databases)"
+  task :clear_resolved => :environment do
+    require 'resolved_problem_clearer'
+    puts "=== Cleared #{ResolvedProblemClearer.new.execute} resolved errors from the database."
+  end
-      puts "Regenerating Err fingerprints"
-      Err.create_indexes
-      Err.all.each do |err|
-        next if err.notices.count == 0
-        source = {
-          :backtrace => normalize_backtrace(err.notices.first.backtrace).to_s,
-          :error_class => err.error_class,
-          :component => err.component,
-          :action => err.action,
-          :environment => err.environment,
-          :api_key => err.app.api_key
-        }
-        err.update_attributes(:fingerprint => fingerprint(source))
-      end
-    end
+  desc "Regenerate fingerprints"
+  task :notice_refingerprint => :environment do
+    NoticeRefingerprinter.run
+    ProblemRecacher.run
+  end
-    desc "Remove notices in batch"
-    task :notices_delete, [ :problem_id ] => [ :environment ] do
-      BATCH_SIZE = 1000
-      if args[:problem_id]
-        item_count = Problem.find(args[:problem_id]).notices.count
-        removed_count = 0
-        puts "Notices to remove: #{item_count}"
-        while item_count > 0
-          Problem.find(args[:problem_id]).notices.limit(BATCH_SIZE).each do |notice|
-            notice.remove
-            removed_count += 1
-          end
-          item_count -= BATCH_SIZE
-          puts "Removed #{removed_count} notices"
+  desc "Remove notices in batch"
+  task :notices_delete, [ :problem_id ] => [ :environment ] do
+    BATCH_SIZE = 1000
+    if args[:problem_id]
+      item_count = Problem.find(args[:problem_id]).notices.count
+      removed_count = 0
+      puts "Notices to remove: #{item_count}"
+      while item_count > 0
+        Problem.find(args[:problem_id]).notices.limit(BATCH_SIZE).each do |notice|
+          notice.remove
+          removed_count += 1
         end
+        item_count -= BATCH_SIZE
+        puts "Removed #{removed_count} notices"
       end
     end
   end
@@ -0,0 +1,48 @@
+describe SiteConfigController, type: 'controller' do
+  it_requires_admin_privileges for: {
+    index: :get,
+    update: :put
+  }
+
+  let(:admin) { Fabricate(:admin) }
+
+  before { sign_in admin }
+
+  describe '#index' do
+    it 'has an index action' do
+      get :index
+    end
+  end
+
+  describe '#update' do
+    it 'updates' do
+      put :update, site_config: {
+        notice_fingerprinter_attributes: {
+          backtrace_lines: 3,
+          environment_name: false
+        }
+      }
+
+      fingerprinter = SiteConfig.document.notice_fingerprinter
+
+      expect(fingerprinter.environment_name).to be false
+      expect(fingerprinter.backtrace_lines).to be 3
+    end
+
+    it 'redirects to the index' do
+      put :update, site_config: {
+        notice_fingerprinter_attributes: { error_class: true }
+      }
+
+      expect(response).to redirect_to(site_config_index_path)
+    end
+
+    it 'flashes a confirmation' do
+      put :update, site_config: {
+        notice_fingerprinter_attributes: { error_class: true }
+      }
+
+      expect(request.flash[:success]).to eq 'Updated site config'
+    end
+  end
+end
@@ -0,0 +1,9 @@
+Fabricator :backtrace do
+  lines(:count => 99) do
+    {
+      number: rand(999),
+      file: "/path/to/file/#{SecureRandom.hex(4)}.rb",
+      method: ActiveSupport.methods.shuffle.first
+    }
+  end
+end
@@ -2,28 +2,3 @@ Fabricator :err do
   problem
   fingerprint 'some-finger-print'
 end
-
-Fabricator :notice do
-  app
-  err
-  message             'FooError: Too Much Bar'
-  backtrace
-  server_environment  { {'environment-name' => 'production'} }
-  request             {{ 'component' => 'foo', 'action' => 'bar' }}
-  notifier            {{ 'name' => 'Notifier', 'version' => '1', 'url' => 'http://toad.com' }}
-
-  after_create do
-    Problem.cache_notice(err.problem_id, self)
-    problem.reload
-  end
-end
-
-Fabricator :backtrace do
-  lines(:count => 99) do
-    {
-      number: rand(999),
-      file: "/path/to/file/#{SecureRandom.hex(4)}.rb",
-      method: ActiveSupport.methods.shuffle.first
-    }
-  end
-end
@@ -0,0 +1,15 @@
+Fabricator :notice do
+  app
+  err
+  error_class         'FooError'
+  message             'Too Much Bar'
+  backtrace
+  server_environment  {{ 'environment-name' => 'production' }}
+  request             {{ 'component' => 'foo', 'action' => 'bar' }}
+  notifier            {{ 'name' => 'Notifier', 'version' => '1', 'url' => 'http://toad.com' }}
+
+  after_create do
+    Problem.cache_notice(err.problem_id, self)
+    problem.reload
+  end
+end
@@ -0,0 +1,52 @@
+describe NoticeRefingerprinter do
+  let(:app) { Fabricate(:app) }
+  let(:backtrace) do
+    Fabricate(:backtrace)
+  end
+
+  before do
+    notices
+  end
+
+  context 'identical backtraces' do
+    let(:notices) do
+      5.times.map do
+        notice = Fabricate(:notice, backtrace: backtrace, app: app)
+        notice.save!
+        notice
+      end
+    end
+
+    it 'has only one err' do
+      described_class.run
+      expect(Err.count).to eq(1)
+    end
+  end
+
+  context 'minor backtrace differences' do
+    let(:notices) do
+      line_numbers = [1, 1, 2, 2, 3]
+      5.times.map do
+        b = backtrace.clone
+        b.lines[5][:number] = line_numbers.shift
+        b.save!
+        notice = Fabricate(:notice, backtrace: b, app: app)
+        notice.save!
+      end
+    end
+
+    it 'has three errs with default fingerprinter' do
+      described_class.run
+      expect(Err.count).to eq(3)
+    end
+
+    it 'has one err when limiting backtrace line count' do
+      fingerprinter = app.notice_fingerprinter
+      fingerprinter.backtrace_lines = 4
+      fingerprinter.save!
+
+      described_class.run
+      expect(Err.count).to eq(1)
+    end
+  end
+end
@@ -47,7 +47,7 @@ describe ProblemMerge do
     end
     it 'update problem cache' do
-      expect(ProblemUpdaterCache).to receive(:new).with(problem).and_return(double(:update => true))
+      expect(problem).to receive(:recache)
       problem_merge.merge
     end
@@ -0,0 +1,38 @@
+describe ProblemRecacher do
+  let(:app) { Fabricate(:app) }
+  let(:backtrace) do
+    Fabricate(:backtrace)
+  end
+
+  before do
+    notices
+
+    NoticeRefingerprinter.run
+    described_class.run
+  end
+
+  context 'minor backtrace differences' do
+    let(:notices) do
+      line_numbers = [1, 1, 2, 2, 3]
+      5.times.map do
+        b = backtrace.clone
+        b.lines[5][:number] = line_numbers.shift
+        b.save!
+        notice = Fabricate(:notice, backtrace: b, app: app)
+        notice.save!
+        notice
+      end
+    end
+
+    it 'has three problems for the five notices' do
+      expect(Notice.count).to eq(5)
+      expect(Problem.count).to eq(3)
+    end
+
+    it 'the problems have the right cached attributes' do
+      problem = notices.first.reload.problem
+
+      expect(problem.notices_count).to eq(2)
+    end
+  end
+end
@@ -1,145 +0,0 @@
-describe ProblemUpdaterCache do
-  let(:problem) { Fabricate(:problem_with_errs) }
-  let(:first_errs) { problem.errs }
-  let!(:notice) { Fabricate(:notice, :err => first_errs.first) }
-
-  describe "#update" do
-    context "without notice pass args" do
-      before do
-        problem.update_attribute(:notices_count, 0)
-      end
-
-      it 'update the notice_count' do
-        expect {
-          ProblemUpdaterCache.new(problem).update
-        }.to change{
-          problem.notices_count
-        }.from(0).to(1)
-      end
-
-      context "with only one notice" do
-        before do
-          problem.update_attributes!(:messages => {})
-          ProblemUpdaterCache.new(problem).update
-        end
-
-        it 'update information about this notice' do
-          expect(problem.message).to eq notice.message
-          expect(problem.where).to eq notice.where
-        end
-
-        it 'update first_notice_at' do
-          expect(problem.first_notice_at).to eq notice.reload.created_at
-        end
-
-        it 'update last_notice_at' do
-          expect(problem.last_notice_at).to eq notice.reload.created_at
-        end
-
-        it 'update stats messages' do
-          expect(problem.messages).to eq({
-            Digest::MD5.hexdigest(notice.message) => {'value' => notice.message, 'count' => 1}
-          })
-        end
-
-        it 'update stats hosts' do
-          expect(problem.hosts).to eq({
-            Digest::MD5.hexdigest(notice.host) => {'value' => notice.host, 'count' => 1}
-          })
-        end
-
-        it 'update stats user_agents' do
-          expect(problem.user_agents).to eq({
-            Digest::MD5.hexdigest(notice.user_agent_string) => {'value' => notice.user_agent_string, 'count' => 1}
-          })
-        end
-      end
-
-      context "with several notices" do
-        let!(:notice_2) { Fabricate(:notice, :err => first_errs.first) }
-        let!(:notice_3) { Fabricate(:notice, :err => first_errs.first) }
-        before do
-          problem.update_attributes!(:messages => {})
-          ProblemUpdaterCache.new(problem).update
-        end
-        it 'update information about this notice' do
-          expect(problem.message).to eq notice.message
-          expect(problem.where).to eq notice.where
-        end
-
-        it 'update first_notice_at' do
-          expect(problem.first_notice_at.to_i).to be_within(2).of(notice.created_at.to_i)
-        end
-
-        it 'update last_notice_at' do
-          expect(problem.last_notice_at.to_i).to be_within(2).of(notice.created_at.to_i)
-        end
-
-        it 'update stats messages' do
-          expect(problem.messages).to eq({
-            Digest::MD5.hexdigest(notice.message) => {'value' => notice.message, 'count' => 3}
-          })
-        end
-
-        it 'update stats hosts' do
-          expect(problem.hosts).to eq({
-            Digest::MD5.hexdigest(notice.host) => {'value' => notice.host, 'count' => 3}
-          })
-        end
-
-        it 'update stats user_agents' do
-          expect(problem.user_agents).to eq({
-            Digest::MD5.hexdigest(notice.user_agent_string) => {'value' => notice.user_agent_string, 'count' => 3}
-          })
-        end
-
-      end
-    end
-
-    context "with notice pass in args" do
-
-      before do
-        ProblemUpdaterCache.new(problem, notice).update
-      end
-
-      it 'increase notices_count by 1' do
-        expect {
-          ProblemUpdaterCache.new(problem, notice).update
-        }.to change{
-          problem.notices_count
-        }.by(1)
-      end
-
-      it 'update information about this notice' do
-        expect(problem.message).to eq notice.message
-        expect(problem.where).to eq notice.where
-      end
-
-      it 'update first_notice_at' do
-        expect(problem.first_notice_at).to eq notice.created_at
-      end
-
-      it 'update last_notice_at' do
-        expect(problem.last_notice_at).to eq notice.created_at
-      end
-
-      it 'inc stats messages' do
-        expect(problem.messages).to eq({
-          Digest::MD5.hexdigest(notice.message) => {'value' => notice.message, 'count' => 2}
-        })
-      end
-
-      it 'inc stats hosts' do
-        expect(problem.hosts).to eq({
-          Digest::MD5.hexdigest(notice.host) => {'value' => notice.host, 'count' => 2}
-        })
-      end
-
-      it 'inc stats user_agents' do
-        expect(problem.user_agents).to eq({
-          Digest::MD5.hexdigest(notice.user_agent_string) => {'value' => notice.user_agent_string, 'count' => 2}
-        })
-      end
-    end
-  end
-end
@@ -42,20 +42,6 @@ describe ErrorReport do
     end
   end
-  describe "#fingerprint_strategy" do
-    it "should be possible to change how fingerprints are generated" do
-      def error_report.fingerprint_strategy
-        Class.new do
-          def self.generate(*args)
-            'fingerprintzzz'
-          end
-        end
-      end
-
-      expect(error_report.error.fingerprint).to eq('fingerprintzzz')
-    end
-  end
-
   describe "#generate_notice!" do
     it "save a notice" do
       expect {
@@ -1,39 +0,0 @@
-describe Fingerprint::MD5, type: 'model' do
-  context 'being created' do
-    let(:backtrace) do
-      Backtrace.find_or_create([
-        {
-          "number"=>"17",
-          "file"=>"[GEM_ROOT]/gems/activesupport/lib/active_support/callbacks.rb",
-          "method"=>"_run__2497084960985961383__process_action__2062871603614456254__callbacks"
-        }
-      ])
-    end
-    let(:notice1) { Fabricate.build(:notice, :backtrace => backtrace) }
-    let(:notice2) { Fabricate.build(:notice, :backtrace => backtrace_2) }
-
-    context "with same backtrace" do
-      let(:backtrace_2) do
-        new_lines = backtrace.lines.dup
-        new_lines.last[:method] = '_run__FRAGMENT__process_action__FRAGMENT__callbacks'
-        Backtrace.find_or_create(new_lines)
-      end
-
-      it "normalizes the fingerprint of generated methods" do
-        expect(Fingerprint::MD5.generate(notice1, "api key")).to eql Fingerprint::MD5.generate(notice2, "api key")
-      end
-    end
-
-    context "with same backtrace where FRAGMENT has not been extracted" do
-      let(:backtrace_2) do
-        new_lines = backtrace.lines.dup
-        new_lines.last[:method] =  '_run__998857585768765__process_action__1231231312321313__callbacks'
-        Backtrace.find_or_create(new_lines)
-      end
-
-      it "normalizes the fingerprint of generated methods" do
-        expect(Fingerprint::MD5.generate(notice1, "api key")).to eql Fingerprint::MD5.generate(notice2, "api key")
-      end
-    end
-  end
-end
@@ -1,79 +0,0 @@
-describe Fingerprint::Sha1, type: 'model' do
-  context '#generate' do
-    let(:backtrace) {
-      Backtrace.find_or_create([
-        {"number"=>"425", "file"=>"[GEM_ROOT]/gems/activesupport-3.0.0.rc/lib/active_support/callbacks.rb", "method"=>"_run__2115867319__process_action__262109504__callbacks"},
-        {"number"=>"404", "file"=>"[GEM_ROOT]/gems/activesupport-3.0.0.rc/lib/active_support/callbacks.rb", "method"=>"send"},
-        {"number"=>"404", "file"=>"[GEM_ROOT]/gems/activesupport-3.0.0.rc/lib/active_support/callbacks.rb", "method"=>"_run_process_action_callbacks"}
-      ])
-    }
-    let(:notice1) { Fabricate.build(:notice, :backtrace => backtrace) }
-    let(:notice2) { Fabricate.build(:notice, :backtrace => backtrace_2) }
-
-    context "with same backtrace" do
-      let(:backtrace_2) { backtrace }
-      it 'should create the same fingerprint for two notices' do
-        expect(Fingerprint::Sha1.generate(notice1, "api key")).to eq  Fingerprint::Sha1.generate(notice2, "api key")
-      end
-    end
-
-    context "with different backtrace with only last line change" do
-      let(:backtrace_2) {
-        new_lines = backtrace.lines.dup
-        new_lines.last[:number] = 401
-        Backtrace.find_or_create backtrace.lines
-      }
-      it 'should not same fingerprint' do
-        expect(
-          Fingerprint::Sha1.generate(notice1, "api key")
-        ).not_to eql Fingerprint::Sha1.generate(notice2, "api key")
-      end
-    end
-
-    context 'with messages differing in object string memory addresses' do
-      let(:backtrace_2) { backtrace }
-
-      before do
-        notice1.message = "NoMethodError: undefined method `foo' for #<ActiveSupport::HashWithIndifferentAccess:0x007f6bfe3287e8>"
-        notice2.message = "NoMethodError: undefined method `foo' for #<ActiveSupport::HashWithIndifferentAccess:0x007f6bfd9f5338>"
-      end
-
-      its 'fingerprints should be equal' do
-        expect(Fingerprint::Sha1.generate(notice1, 'api key')).to eq Fingerprint::Sha1.generate(notice2, 'api key')
-      end
-    end
-
-    context 'with different messages at same stacktrace' do
-      let(:backtrace_2) { backtrace }
-
-      before do
-        notice1.message = "NoMethodError: undefined method `bar' for #<ActiveSupport::HashWithIndifferentAccess:0x007f6bfe3287e8>"
-        notice2.message = "NoMethodError: undefined method `bar' for nil:NilClass"
-      end
-
-      its 'fingerprints should not be equal' do
-        expect(Fingerprint::Sha1.generate(notice1, 'api key')).to_not eq Fingerprint::Sha1.generate(notice2, 'api key')
-      end
-    end
-  end
-
-  describe '#unified_message' do
-    subject{ Fingerprint::Sha1.new(double('notice', message: message), 'api key').unified_message }
-
-    context "full error message" do
-      let(:message) { "NoMethodError: undefined method `foo' for #<ActiveSupport::HashWithIndifferentAccess:0x007f6bfe3287e8>" }
-
-      it 'removes memory address from object strings' do
-        is_expected.to eq "NoMethodError: undefined method `foo' for #<ActiveSupport::HashWithIndifferentAccess>"
-      end
-    end
-
-    context "multiple object strings in message" do
-      let(:message) { "#<ActiveSupport::HashWithIndifferentAccess:0x007f6bfe3287e8> #<Object:0x007fa2b33d9458>" }
-
-      it 'removes memory addresses globally' do
-        is_expected.to eq "#<ActiveSupport::HashWithIndifferentAccess> #<Object>"
-      end
-    end
-  end
-end
@@ -0,0 +1,64 @@
+describe NoticeFingerprinter, type: 'model' do
+  let(:fingerprinter) { described_class.new }
+  let(:notice) { Fabricate(:notice) }
+  let(:backtrace) { Fabricate(:backtrace) }
+
+  context '#generate' do
+    it 'generates the same fingerprint for the same notice' do
+      f1 = fingerprinter.generate('123', notice, backtrace)
+      f2 = fingerprinter.generate('123', notice, backtrace)
+      expect(f1).to eq(f2)
+    end
+
+    %w(error_class message component action environment_name).each do |i|
+      it "affects the fingerprint when #{i} is false" do
+        f1 = fingerprinter.generate('123', notice, backtrace)
+        f2 = fingerprinter.generate('123', notice, backtrace)
+
+        fingerprinter.send((i << '=').to_sym, false)
+        f3 = fingerprinter.generate('123', notice, backtrace)
+
+        expect(f1).to eq(f2)
+        expect(f1).to_not eq(f3)
+      end
+    end
+
+    it 'affects the fingerprint with different backtrace_lines config' do
+      f1 = fingerprinter.generate('123', notice, backtrace)
+      f2 = fingerprinter.generate('123', notice, backtrace)
+
+      fingerprinter.backtrace_lines = 2
+      f3 = fingerprinter.generate('123', notice, backtrace)
+
+      expect(f1).to eq(f2)
+      expect(f1).to_not eq(f3)
+    end
+
+    context 'two backtraces have the same first two lines' do
+      let(:backtrace1) { Fabricate(:backtrace) }
+      let(:backtrace2) { Fabricate(:backtrace) }
+
+      before do
+        backtrace1.lines[0] = backtrace2.lines[0]
+        backtrace1.lines[1] = backtrace2.lines[1]
+        backtrace1.lines[2] = { number: 1, file: 'a', method: :b }
+      end
+
+      it 'has the same fingerprint when only considering two lines' do
+        fingerprinter.backtrace_lines = 2
+        f1 = fingerprinter.generate('123', notice, backtrace1)
+        f2 = fingerprinter.generate('123', notice, backtrace2)
+
+        expect(f1).to eq(f2)
+      end
+
+      it 'has a different fingerprint when considering three lines' do
+        fingerprinter.backtrace_lines = 3
+        f1 = fingerprinter.generate('123', notice, backtrace1)
+        f2 = fingerprinter.generate('123', notice, backtrace2)
+
+        expect(f1).to_not eq(f2)
+      end
+    end
+  end
+end
@@ -397,4 +397,100 @@ describe Problem, type: &#39;model&#39; do
       end
     end
   end
+
+  describe '#recache' do
+    let(:problem) { Fabricate(:problem_with_errs) }
+    let(:first_errs) { problem.errs }
+    let!(:notice) { Fabricate(:notice, :err => first_errs.first) }
+
+    before do
+      problem.update_attribute(:notices_count, 0)
+    end
+
+    it 'update the notice_count' do
+      expect {
+        problem.recache
+      }.to change{
+        problem.notices_count
+      }.from(0).to(1)
+    end
+
+    context "with only one notice" do
+      before do
+        problem.update_attributes!(:messages => {})
+        problem.recache
+      end
+
+      it 'update information about this notice' do
+        expect(problem.message).to eq notice.message
+        expect(problem.where).to eq notice.where
+      end
+
+      it 'update first_notice_at' do
+        expect(problem.first_notice_at).to eq notice.reload.created_at
+      end
+
+      it 'update last_notice_at' do
+        expect(problem.last_notice_at).to eq notice.reload.created_at
+      end
+
+      it 'update stats messages' do
+        expect(problem.messages).to eq({
+          Digest::MD5.hexdigest(notice.message) => {'value' => notice.message, 'count' => 1}
+        })
+      end
+
+      it 'update stats hosts' do
+        expect(problem.hosts).to eq({
+          Digest::MD5.hexdigest(notice.host) => {'value' => notice.host, 'count' => 1}
+        })
+      end
+
+      it 'update stats user_agents' do
+        expect(problem.user_agents).to eq({
+          Digest::MD5.hexdigest(notice.user_agent_string) => {'value' => notice.user_agent_string, 'count' => 1}
+        })
+      end
+    end
+
+    context "with several notices" do
+      let!(:notice_2) { Fabricate(:notice, :err => first_errs.first) }
+      let!(:notice_3) { Fabricate(:notice, :err => first_errs.first) }
+      before do
+        problem.update_attributes!(:messages => {})
+        problem.recache
+      end
+
+      it 'update information about this notice' do
+        expect(problem.message).to eq notice.message
+        expect(problem.where).to eq notice.where
+      end
+
+      it 'update first_notice_at' do
+        expect(problem.first_notice_at.to_i).to be_within(2).of(notice.created_at.to_i)
+      end
+
+      it 'update last_notice_at' do
+        expect(problem.last_notice_at.to_i).to be_within(2).of(notice.created_at.to_i)
+      end
+
+      it 'update stats messages' do
+        expect(problem.messages).to eq({
+          Digest::MD5.hexdigest(notice.message) => {'value' => notice.message, 'count' => 3}
+        })
+      end
+
+      it 'update stats hosts' do
+        expect(problem.hosts).to eq({
+          Digest::MD5.hexdigest(notice.host) => {'value' => notice.host, 'count' => 3}
+        })
+      end
+
+      it 'update stats user_agents' do
+        expect(problem.user_agents).to eq({
+          Digest::MD5.hexdigest(notice.user_agent_string) => {'value' => notice.user_agent_string, 'count' => 3}
+        })
+      end
+    end
+  end
 end
	@@ -20,3 +20,4 @@ bundle		@@ -20,3 +20,4 @@ bundle
20	coverage	20	coverage
21	*#	21	*#
22	.ruby-version	22	.ruby-version
		23	+NOTES
@@ -0,0 +1,27 @@		@@ -0,0 +1,27 @@
	1	+class SiteConfigController < ApplicationController
	2	+ before_action :require_admin!
	3	+
	4	+ def index
	5	+ @config = SiteConfig.document
	6	+ end
	7	+
	8	+ def update
	9	+ SiteConfig.document.update_attributes(
	10	+ notice_fingerprinter: filtered_update_params)
	11	+ flash[:success] = 'Updated site config'
	12	+ redirect_to action: :index
	13	+ end
	14	+
	15	+ private def filtered_update_params
	16	+ params
	17	+ .require(:site_config)
	18	+ .require(:notice_fingerprinter_attributes)
	19	+ .permit(
	20	+ :error_class,
	21	+ :message,
	22	+ :backtrace_lines,
	23	+ :component,
	24	+ :action,
	25	+ :environment_name)
	26	+ end
	27	+end
@@ -0,0 +1,38 @@		@@ -0,0 +1,38 @@
	1	+class NoticeRefingerprinter
	2	+ LOG_EVERY = 100
	3	+ LOG_ITR = '%.1f%% complete, %i notice(s) remaining'
	4	+ LOG_START = 'Regenerating notice fingerprints for %i notices'
	5	+
	6	+ def self.run
	7	+ count = Notice.count
	8	+ puts format(LOG_START, count)
	9	+
	10	+ Notice.no_timeout.each_with_index do \|notice, index\|
	11	+ refingerprint(notice)
	12	+
	13	+ next unless (index + 1) % LOG_EVERY == 0
	14	+ puts format(LOG_ITR, (index * 100 / count), count - index)
	15	+ end
	16	+
	17	+ puts 'Finished generating notice fingerprints'
	18	+ puts 'Destroying orphaned err records'
	19	+
	20	+ Err.each { \|e\| e.destroy if e.notices.size == 0 }
	21	+
	22	+ puts 'Finished destroying orphaned err records'
	23	+ end
	24	+
	25	+ def self.refingerprint(notice)
	26	+ app = notice.app
	27	+ notice.err = app.find_or_create_err!(
	28	+ error_class: notice.error_class,
	29	+ environment: notice.environment_name,
	30	+ fingerprint: app.notice_fingerprinter.generate(app.api_key, notice, notice.backtrace)
	31	+ )
	32	+ notice.save!
	33	+ end
	34	+
	35	+ def self.puts(*args)
	36	+ Rails.logger.info(*args)
	37	+ end
	38	+end
@@ -0,0 +1,24 @@		@@ -0,0 +1,24 @@
	1	+class ProblemRecacher
	2	+ LOG_EVERY = 100
	3	+ LOG_ITR = '%.1f%% complete, %i problem(s) remaining'
	4	+ LOG_START = 'Re-caching problem attributes for %i problems'
	5	+
	6	+ def self.run
	7	+ count = Problem.count
	8	+ puts format(LOG_START, count)
	9	+
	10	+ Problem.no_timeout.each_with_index do \|problem, index\|
	11	+ problem.recache
	12	+ problem.destroy if problem.notices_count == 0
	13	+
	14	+ next unless (index + 1) % LOG_EVERY == 0
	15	+ puts format(LOG_ITR, (index * 100 / count), count - index)
	16	+ end
	17	+
	18	+ puts "Finished re-caching problem attributes"
	19	+ end
	20	+
	21	+ def self.puts(*args)
	22	+ Rails.logger.info(*args)
	23	+ end
	24	+end
	@@ -1,88 +0,0 @@	@@ -1,88 +0,0 @@
1	-class ProblemUpdaterCache
2	- def initialize(problem, notice=nil)
3	- @problem = problem
4	- @notice = notice
5	- end
6	- attr_reader :problem
7	-
8	- ##
9	- # Update cache information about child associate to this problem
10	- #
11	- # update the notices count, and some notice informations
12	- #
13	- # @return [ Problem ] the problem with this update
14	- #
15	- def update
16	- update_notices_count
17	- update_notices_cache
18	- problem
19	- end
20	-
21	- private
22	-
23	- def update_notices_count
24	- if @notice
25	- problem.inc(notices_count: 1)
26	- else
27	- problem.update_attribute(
28	- :notices_count, problem.notices.count
29	- )
30	- end
31	- end
32	-
33	- ##
34	- # Update problem statistique from some notice information
35	- #
36	- def update_notices_cache
37	- first_notice = notices.first
38	- last_notice = notices.last
39	- notice \|\|= @notice \|\| first_notice
40	-
41	- attrs = {}
42	- attrs[:first_notice_at] = first_notice.created_at if first_notice
43	- attrs[:last_notice_at] = last_notice.created_at if last_notice
44	- attrs.merge!(
45	- :message => notice.message,
46	- :where => notice.where,
47	- :messages => attribute_count(:message, messages),
48	- :hosts => attribute_count(:host, hosts),
49	- :user_agents => attribute_count(:user_agent_string, user_agents)
50	- ) if notice
51	- problem.update_attributes!(attrs)
52	- end
53	-
54	- def notices
55	- @notices \|\|= @notice ? [@notice].sort(&:created_at) : problem.notices.order_by([:created_at, :asc])
56	- end
57	-
58	- def messages
59	- @notice ? problem.messages : {}
60	- end
61	-
62	- def hosts
63	- @notice ? problem.hosts : {}
64	- end
65	-
66	- def user_agents
67	- @notice ? problem.user_agents : {}
68	- end
69	-
70	- private
71	-
72	- def attribute_count(value, init)
73	- init.tap do \|counts\|
74	- notices.each do \|notice\|
75	- counts[attribute_index(notice.send(value))] \|\|= {
76	- 'value' => notice.send(value),
77	- 'count' => 0
78	- }
79	- counts[attribute_index(notice.send(value))]['count'] += 1
80	- end
81	- end
82	- end
83	-
84	- def attribute_index(value)
85	- @attributes_index \|\|= {}
86	- @attributes_index[value.to_s] \|\|= Digest::MD5.hexdigest(value.to_s)
87	- end
88	-end
	@@ -1,22 +0,0 @@	@@ -1,22 +0,0 @@
1	-require 'digest/md5'
2	-
3	-module Fingerprint
4	- class MD5 < Sha1
5	- def to_s
6	- Digest::MD5.hexdigest(fingerprint_source)
7	- end
8	-
9	- def fingerprint_source
10	- location['method'] &&= sanitized_method_signature
11	- end
12	-
13	- private
14	- def sanitized_method_signature
15	- location['method'].gsub(/[0-9]+\|FRAGMENT/, '#').gsub(/_+#/, '_#')
16	- end
17	-
18	- def location
19	- notice.backtrace.lines.first
20	- end
21	- end
22	-end
	@@ -1,43 +0,0 @@	@@ -1,43 +0,0 @@
1	-require 'digest/sha1'
2	-
3	-module Fingerprint
4	- class Sha1
5	-
6	- attr_reader :notice, :api_key
7	-
8	- def self.generate(notice, api_key)
9	- self.new(notice, api_key).to_s
10	- end
11	-
12	- def initialize(notice, api_key)
13	- @notice = notice
14	- @api_key = api_key
15	- end
16	-
17	- def to_s
18	- Digest::SHA1.hexdigest(fingerprint_source.to_s)
19	- end
20	-
21	- def fingerprint_source
22	- {
23	- :file_or_message => file_or_message,
24	- :error_class => notice.error_class,
25	- :component => notice.component \|\| 'unknown',
26	- :action => notice.action,
27	- :environment => notice.environment_name \|\| 'development',
28	- :api_key => api_key
29	- }
30	- end
31	-
32	- def file_or_message
33	- @file_or_message \|\|= unified_message + notice.backtrace.fingerprint
34	- end
35	-
36	- # filter memory addresses out of object strings
37	- # example: "#<Object:0x007fa2b33d9458>" becomes "#<Object>"
38	- def unified_message
39	- notice.message.gsub(/(#<.+?):[0-9a-f]x[0-9a-f]+(>)/, '\1\2')
40	- end
41	-
42	- end
43	-end
@@ -0,0 +1,32 @@		@@ -0,0 +1,32 @@
	1	+class NoticeFingerprinter
	2	+ include Mongoid::Document
	3	+ include Mongoid::Timestamps
	4	+
	5	+ field :error_class, default: true, type: Boolean
	6	+ field :message, default: true, type: Boolean
	7	+ field :backtrace_lines, default: -1, type: Integer
	8	+ field :component, default: true, type: Boolean
	9	+ field :action, default: true, type: Boolean
	10	+ field :environment_name, default: true, type: Boolean
	11	+ field :source, type: String
	12	+
	13	+ embedded_in :app
	14	+ embedded_in :site_config
	15	+
	16	+ def generate(api_key, notice, backtrace)
	17	+ material = [ api_key ]
	18	+ material << notice.error_class if error_class
	19	+ material << notice.filtered_message if message
	20	+ material << notice.component if component
	21	+ material << notice.action if action
	22	+ material << notice.environment_name if environment_name
	23	+
	24	+ if backtrace_lines < 0
	25	+ material << backtrace.lines
	26	+ else
	27	+ material << backtrace.lines.slice(0, backtrace_lines)
	28	+ end
	29	+
	30	+ Digest::MD5.hexdigest(material.reduce('') { \|c, m\| c << m.to_s; c })
	31	+ end
	32	+end
@@ -0,0 +1,36 @@		@@ -0,0 +1,36 @@
	1	+class SiteConfig
	2	+ CONFIG_SOURCE_SITE = 'site'.freeze
	3	+ CONFIG_SOURCE_APP = 'app'.freeze
	4	+
	5	+ include Mongoid::Document
	6	+ include Mongoid::Timestamps
	7	+
	8	+ before_save :denormalize
	9	+
	10	+ embeds_one :notice_fingerprinter, autobuild: true
	11	+ validates_associated :notice_fingerprinter
	12	+ accepts_nested_attributes_for :notice_fingerprinter
	13	+
	14	+ # Get the one and only SiteConfig document
	15	+ def self.document
	16	+ first \|\| create
	17	+ end
	18	+
	19	+ # Denormalize SiteConfig onto individual apps so that this record doesn't
	20	+ # need to be accessed when inserting new error notices
	21	+ def denormalize
	22	+ notice_fingerprinter_attributes = notice_fingerprinter.attributes.tap do \|attrs\|
	23	+ attrs.delete('_id')
	24	+ attrs[:source] = :site
	25	+ end
	26	+
	27	+ App.each do \|app\|
	28	+ f = app.notice_fingerprinter
	29	+
	30	+ if !f \|\| f.source == CONFIG_SOURCE_SITE
	31	+ app.update_attributes(
	32	+ notice_fingerprinter: notice_fingerprinter_attributes)
	33	+ end
	34	+ end
	35	+ end
	36	+end
	@@ -13,4 +13,8 @@		@@ -13,4 +13,8 @@
13	= link_to users_path do	13	= link_to users_path do
14	%i.fa.fa-users	14	%i.fa.fa-users
15	= t('.users')	15	= t('.users')
		16	+ %li{:class => active_if_here(:site_config)}
		17	+ = link_to site_config_index_path do
		18	+ %i.fa.fa-wrench
		19	+ = t('.config')
16	%div.clear	20	%div.clear