Merge pull request #917 from stevecrozz/mongoid5

Mongoid5 and performance improvements

Merge pull request #917 from stevecrozz/mongoid5
Mongoid5 and performance improvements
Stephen Crosby
2 parents bdf4aa57 17ac3ee5
Showing 53 changed files with 871 additions and 754 deletions Show diff stats
.env.default
.travis.yml
Gemfile
Gemfile.lock
README.md
app/controllers/notices_controller.rb
app/controllers/problems_controller.rb
app/decorators/backtrace_decorator.rb
app/decorators/backtrace_line_decorator.rb
app/decorators/notice_decorator.rb
app/decorators/problem_decorator.rb
app/helpers/backtrace_line_helper.rb
app/interactors/resolved_problem_clearer.rb
app/mailers/mailer.rb
app/models/app.rb
app/models/backtrace.rb
app/models/backtrace_line.rb
app/models/backtrace_line_normalizer.rb
app/models/deploy.rb
app/models/error_report.rb
@@ -15,6 +15,8 @@ ERRBIT_PER_APP_EMAIL_AT_NOTICES=false
 ERRBIT_NOTIFY_AT_NOTICES='[0]'
 ERRBIT_PER_APP_NOTIFY_AT_NOTICES=false
 MONGO_URL='mongodb://localhost'
+ERRBIT_LOG_LEVEL=info
+ERRBIT_LOG_LOCATION=STDOUT
 GITHUB_URL='https://github.com'
 GITHUB_AUTHENTICATION=true
 GITHUB_ACCESS_SCOPE='[repo]'
@@ -9,8 +9,12 @@ env:
   - RAILS_ENV=test COVERAGE=true JRUBY_OPTS=--debug
 sudo: false
 cache: bundler
-services: mongodb
-before_script: bundle exec rake errbit:bootstrap
+before_script:
+  - wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.10.tgz -O /tmp/mongodb.tgz
+  - tar -xvf /tmp/mongodb.tgz
+  - mkdir /tmp/data
+  - ${PWD}/mongodb-linux-x86_64-2.6.10/bin/mongod --dbpath /tmp/data --bind_ip 127.0.0.1 --auth &> /dev/null &
+  - bundle exec rake errbit:bootstrap
 script: bundle exec rspec
 matrix:
   allow_failures:
@@ -8,10 +8,8 @@ gem &#39;actionmailer&#39;, RAILS_VERSION
 gem 'actionpack', RAILS_VERSION
 gem 'railties', RAILS_VERSION
  
-gem 'moped', '~> 2.0.2'
-gem 'mongoid', '~> 4.0.0'
+gem 'mongoid', '5.0.0.beta'
  
-gem 'mongoid_rails_migrations'
 gem 'devise'
 gem 'haml'
 gem 'htmlentities'
@@ -78,7 +76,7 @@ group :development do
 end
  
 group :test do
-  gem 'rspec'
+  gem 'rspec', '~> 3.3'
   gem 'rspec-rails', '~> 3.0', require: false
   gem 'rspec-activemodel-mocks'
   gem 'rspec-its'
@@ -87,7 +85,6 @@ group :test do
   gem 'capybara'
   gem 'poltergeist'
   gem 'launchy'
-  gem 'database_cleaner'
   gem 'email_spec'
   gem 'timecop'
   gem 'test-unit', require: 'test/unit'
@@ -44,8 +44,8 @@ GEM
       rack (>= 0.9.0)
     binding_of_caller (0.7.2)
       debug_inspector (>= 0.0.1)
-    bson (3.1.1)
-    bson (3.1.1-java)
+    bson (3.2.0)
+    bson (3.2.0-java)
     builder (3.2.2)
     byebug (4.0.5)
       columnize (= 0.9.0)
@@ -81,7 +81,6 @@ GEM
     coffee-script-source (1.9.1.1)
     colorize (0.7.7)
     columnize (0.9.0)
-    connection_pool (2.2.0)
     coveralls (0.8.2)
       json (~> 1.8)
       rest-client (>= 1.6.8, < 2)
@@ -90,7 +89,6 @@ GEM
       thor (~> 0.19.1)
     css_parser (1.3.6)
       addressable
-    database_cleaner (1.4.1)
     debug_inspector (0.0.2)
     decent_exposure (2.3.2)
     devise (3.5.1)
@@ -175,25 +173,18 @@ GEM
     mimemagic (0.3.0)
     mini_portile (0.6.2)
     minitest (5.7.0)
-    mongoid (4.0.2)
+    mongo (2.1.0.beta)
+      bson (~> 3.0)
+    mongoid (5.0.0.beta)
       activemodel (~> 4.0)
-      moped (~> 2.0.0)
+      mongo (= 2.1.0.beta)
       origin (~> 2.1)
       tzinfo (>= 0.3.37)
-    mongoid-rspec (2.2.0)
-      mongoid (~> 4.0.0)
+    mongoid-rspec (1.10.0)
+      mongoid (>= 3.0.1)
       rake
-      rspec (~> 3.1)
-    mongoid_rails_migrations (1.0.1)
-      activesupport (>= 3.2.0)
-      bundler (>= 1.0.0)
-      rails (>= 3.2.0)
-      railties (>= 3.2.0)
-    moped (2.0.6)
-      bson (~> 3.0)
-      connection_pool (~> 2.0)
-      optionable (~> 0.2.0)
-    multi_json (1.11.1)
+      rspec (>= 2.14)
+    multi_json (1.11.2)
     multi_xml (0.5.5)
     multipart-post (2.0.0)
     net-scp (1.2.1)
@@ -363,7 +354,7 @@ GEM
     thread_safe (0.3.5-java)
     tilt (1.4.1)
     timecop (0.7.4)
-    tins (1.5.4)
+    tins (1.6.0)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
     uglifier (2.7.1)
@@ -410,7 +401,6 @@ DEPENDENCIES
   capybara
   coffee-rails
   coveralls
-  database_cleaner
   decent_exposure
   devise
   dotenv-rails
@@ -431,10 +421,8 @@ DEPENDENCIES
   kaminari (>= 0.14.1)
   launchy
   meta_request
-  mongoid (~> 4.0.0)
+  mongoid (= 5.0.0.beta)
   mongoid-rspec
-  mongoid_rails_migrations
-  moped (~> 2.0.2)
   omniauth-github
   pjax_rails
   poltergeist
@@ -447,7 +435,7 @@ DEPENDENCIES
   rails_autolink
   railties (~> 4.1.11)
   ri_cal
-  rspec
+  rspec (~> 3.3)
   rspec-activemodel-mocks
   rspec-its
   rspec-rails (~> 3.0)
@@ -71,7 +71,7 @@ updates and notifications.
 The list of requirements to install Errbit are:
  
 * Ruby 2.1.0 or higher
-* MongoDB 2.2.0 or higher
+* MongoDB 2.6.0 or higher
  
 Installation
 ------------
@@ -188,6 +188,8 @@ When upgrading Errbit, please run:
 git pull origin master # assuming origin is the github.com/errbit/errbit repo
 bundle install
 rake db:migrate
+rake db:mongoid:create_indexes
+rake db:mongoid:remove_undefined_indexes
 rake assets:precompile
 ```
  
@@ -2,7 +2,8 @@ class NoticesController &lt; ApplicationController
  
   class ParamsError < StandardError; end
  
-  skip_before_action :authenticate_user!, :only => :create
+  skip_before_action :authenticate_user!, only: :create
+  skip_before_filter :verify_authenticity_token, only: :create
  
   rescue_from ParamsError, :with => :bad_params
  
@@ -22,7 +22,7 @@ class ProblemsController &lt; ApplicationController
   }
  
   expose(:problem) {
-    app.problems.find(params[:id])
+    ProblemDecorator.new app.problems.find(params[:id])
   }
  
   expose(:all_errs) {
@@ -50,8 +50,9 @@ class ProblemsController &lt; ApplicationController
   def index; end
  
   def show
-    @notices  = problem.notices.reverse_ordered.page(params[:notice]).per(1)
-    @notice   = @notices.first
+    @notices = problem.object.notices.reverse_ordered
+      .page(params[:notice]).per(1)
+    @notice  = NoticeDecorator.new @notices.first
     @comment = Comment.new
   end
  
@@ -0,0 +1,5 @@
+class BacktraceDecorator < Draper::Decorator
+  def lines
+    @lines ||= object.lines.map { |line| BacktraceLineDecorator.new line }
+  end
+end
@@ -0,0 +1,88 @@
+class BacktraceLineDecorator < Draper::Decorator
+  EMPTY_STRING = ''.freeze
+
+  def in_app?
+    object[:file].match Backtrace::IN_APP_PATH
+  end
+
+  def number
+    object[:number]
+  end
+
+  def column
+    object[:column]
+  end
+
+  def file
+    object[:file]
+  end
+
+  def method
+    object[:method]
+  end
+
+  def file_relative
+    file.to_s.sub(Backtrace::IN_APP_PATH, EMPTY_STRING)
+  end
+
+  def file_name
+    File.basename file
+  end
+
+  def to_s
+    column = object.try(:[], :column)
+    "#{file_relative}:#{number}#{column.present? ? ":#{column}" : ''}"
+  end
+
+  def link_to_source_file(app, &block)
+    text = h.capture_haml(&block)
+    link_to_in_app_source_file(app, text) || text
+  end
+
+  def path
+    File.dirname(object[:file]).gsub(/^\.$/, '') + "/"
+  end
+
+  def decorated_path
+    file_relative.sub(Backtrace::GEMS_PATH, "<strong>\\1</strong>")
+  end
+
+  private
+  def link_to_in_app_source_file(app, text)
+    return unless in_app?
+    if file_name =~ /\.js$/
+      link_to_hosted_javascript(app, text)
+    else
+      link_to_repo_source_file(app, text) ||
+      link_to_issue_tracker_file(app, text)
+    end
+  end
+
+  def link_to_repo_source_file(app, text)
+    link_to_github(app, text) || link_to_bitbucket(app, text)
+  end
+
+  def link_to_hosted_javascript(app, text)
+    if app.asset_host?
+      h.link_to(text, "#{app.asset_host}/#{file_relative}", :target => '_blank')
+    end
+  end
+
+  def link_to_github(app, text = nil)
+    return unless app.github_repo?
+    href = "%s#L%s" % [app.github_url_to_file(decorated_path + file_name), number]
+    h.link_to(text || file_name, href, :target => '_blank')
+  end
+
+  def link_to_bitbucket(app, text = nil)
+    return unless app.bitbucket_repo?
+    href = "%s#cl-%s" % [app.bitbucket_url_to_file(decorated_path + file_name), number]
+    h.link_to(text || file_name, href, :target => '_blank')
+  end
+
+  def link_to_issue_tracker_file(app, text = nil)
+    return unless app.issue_tracker && app.issue_tracker.respond_to?(:url_to_file)
+    href = app.issue_tracker.url_to_file(file_relative, number)
+    h.link_to(text || file_name, href, :target => '_blank')
+  end
+end
@@ -0,0 +1,4 @@
+class NoticeDecorator < Draper::Decorator
+  decorates_association :backtrace
+  delegate_all
+end
@@ -0,0 +1,4 @@
+class ProblemDecorator < Draper::Decorator
+  decorates_association :notices
+  delegate_all
+end
 module BacktraceLineHelper
-  def link_to_source_file(line, &block)
+  def link_to_source_file(line, app, &block)
     text = capture_haml(&block)
-     link_to_in_app_source_file(line, text) || link_to_external_source_file(text)
+    link_to_in_app_source_file(line, app, text) || text
   end
  
   private
-  def link_to_in_app_source_file(line, text)
+  def link_to_in_app_source_file(line, app, text)
     return unless line.in_app?
     if line.file_name =~ /\.js$/
-      link_to_hosted_javascript(line, text)
+      link_to_hosted_javascript(line, app, text)
     else
-      link_to_repo_source_file(line, text) ||
-      link_to_issue_tracker_file(line, text)
+      link_to_repo_source_file(line, app, text) ||
+      link_to_issue_tracker_file(line, app, text)
     end
   end
  
-  def link_to_repo_source_file(line, text)
-    link_to_github(line, text) || link_to_bitbucket(line, text)
+  def link_to_repo_source_file(line, app, text)
+    link_to_github(line, app, text) || link_to_bitbucket(line, app, text)
   end
  
-  def link_to_hosted_javascript(line, text)
-    if line.app.asset_host?
-      link_to(text, "#{line.app.asset_host}/#{line.file_relative}", :target => '_blank')
+  def link_to_hosted_javascript(line, app, text)
+    if app.asset_host?
+      link_to(text, "#{app.asset_host}/#{line.file_relative}", :target => '_blank')
     end
   end
  
-  def link_to_external_source_file(text)
-    text
-  end
-
-  def link_to_github(line, text = nil)
-    return unless line.app.github_repo?
-    href = "%s#L%s" % [line.app.github_url_to_file(line.decorated_path + line.file_name), line.number]
+  def link_to_github(line, app, text = nil)
+    return unless app.github_repo?
+    href = "%s#L%s" % [app.github_url_to_file(line.decorated_path + line.file_name), line.number]
     link_to(text || line.file_name, href, :target => '_blank')
   end
  
-  def link_to_bitbucket(line, text = nil)
-    return unless line.app.bitbucket_repo?
-    href = "%s#cl-%s" % [line.app.bitbucket_url_to_file(line.decorated_path + line.file_name), line.number]
+  def link_to_bitbucket(line, app, text = nil)
+    return unless app.bitbucket_repo?
+    href = "%s#cl-%s" % [app.bitbucket_url_to_file(line.decorated_path + line.file_name), line.number]
     link_to(text || line.file_name, href, :target => '_blank')
   end
  
-  def link_to_issue_tracker_file(line, text = nil)
-    return unless line.app.issue_tracker && line.app.issue_tracker.respond_to?(:url_to_file)
-    href = line.app.issue_tracker.url_to_file(line.file_relative, line.number)
+  def link_to_issue_tracker_file(line, app, text = nil)
+    return unless app.issue_tracker && app.issue_tracker.respond_to?(:url_to_file)
+    href = app.issue_tracker.url_to_file(line.file_relative, line.number)
     link_to(text || line.file_name, href, :target => '_blank')
   end
  
@@ -27,6 +27,6 @@ class ResolvedProblemClearer
   end
  
   def repair_database
-    Mongoid.default_session.command :repairDatabase => 1
+    Mongoid.default_client.command :repairDatabase => 1
   end
 end
@@ -13,11 +13,11 @@ class Mailer &lt; ActionMailer::Base
           'Precedence' => 'bulk',
           'Auto-Submitted' => 'auto-generated'
  
-  def err_notification(notice)
-    @notice   = notice
-    @app      = notice.app
+  def err_notification(error_report)
+    @notice   = NoticeDecorator.new error_report.notice
+    @app      = AppDecorator.new error_report.app
  
-    count = @notice.similar_count
+    count = error_report.problem.notices_count
     count = count > 1 ? "(#{count}) " : ""
  
     errbit_headers 'App' => @app.name,
@@ -30,7 +30,7 @@ class Mailer &lt; ActionMailer::Base
  
   def deploy_notification(deploy)
     @deploy   = deploy
-    @app  = deploy.app
+    @app  = AppDecorator.new deploy.app
  
     errbit_headers 'App' => @app.name,
                    'Environment' => @deploy.environment,
@@ -44,7 +44,7 @@ class Mailer &lt; ActionMailer::Base
   def comment_notification(comment)
     @comment  = comment
     @user     = comment.user
-    @problem  = comment.err
+    @problem  = ProblemDecorator.new comment.err
     @notice   = @problem.notices.first
     @app      = @problem.app
  
@@ -57,8 +57,14 @@ class App
   def find_or_create_err!(attrs)
     Err.where(
       :fingerprint => attrs[:fingerprint]
-    ).first ||
-      problems.create!(attrs.slice(:error_class, :environment)).errs.create!(attrs.slice(:fingerprint, :problem_id))
+    ).first || (
+      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
@@ -178,7 +184,9 @@ class App
   protected
  
     def store_cached_attributes_on_problems
-      problems.each(&:cache_app_attributes)
+      Problem.where(:app_id => id).update_all(
+        app_name: name
+      )
     end
  
     def generate_api_key
@@ -2,35 +2,28 @@ class Backtrace
   include Mongoid::Document
   include Mongoid::Timestamps
  
-  field :fingerprint
-  index :fingerprint => 1
-
-  has_many :notices
-  has_one :notice
-
-  embeds_many :lines, :class_name => "BacktraceLine"
+  IN_APP_PATH = %r{^\[PROJECT_ROOT\](?!(\/vendor))/?}
+  GEMS_PATH = %r{\[GEM_ROOT\]\/gems\/([^\/]+)}
  
-  after_initialize :generate_fingerprint
+  field :fingerprint
+  field :lines
  
-  delegate :app, :to => :notice
+  index :fingerprint => 1
  
-  def self.find_or_create(attributes = {})
-    new(attributes).similar || create(attributes)
-  end
+  def self.find_or_create(lines)
+    fingerprint = generate_fingerprint(lines)
  
-  def similar
-    Backtrace.where(:fingerprint => fingerprint).first
+    where(fingerprint: fingerprint).find_one_and_update(
+      { '$setOnInsert' => { fingerprint: fingerprint, lines: lines } },
+      { return_document: :after, upsert: true })
   end
  
-  def raw=(raw)
-    raw.compact.each do |raw_line|
-      lines << BacktraceLine.new(BacktraceLineNormalizer.new(raw_line).call)
-    end
+  def self.generate_fingerprint(lines)
+    Digest::SHA1.hexdigest(lines.map(&:to_s).join)
   end
  
   private
   def generate_fingerprint
-    self.fingerprint = Digest::SHA1.hexdigest(lines.map(&:to_s).join)
+    self.fingerprint = self.class.generate_fingerprint(lines)
   end
-
 end
@@ -1,42 +0,0 @@
-class BacktraceLine
-  include Mongoid::Document
-  IN_APP_PATH = %r{^\[PROJECT_ROOT\](?!(\/vendor))/?}
-  GEMS_PATH   = %r{\[GEM_ROOT\]\/gems\/([^\/]+)}
-
-  field :number, :type => Integer
-  field :column, :type => Integer
-  field :file
-  field :method
-
-  embedded_in :backtrace
-
-  scope :in_app, ->{ where(:file => IN_APP_PATH) }
-
-  delegate :app, :to => :backtrace
-
-  def to_s
-    "#{file_relative}:#{number}" << (column.present? ? ":#{column}" : "")
-  end
-
-  def in_app?
-    !!(file =~ IN_APP_PATH)
-  end
-
-  def path
-    File.dirname(file).gsub(/^\.$/, '') + "/"
-  end
-
-  def file_relative
-    file.to_s.sub(IN_APP_PATH, '')
-  end
-
-  def file_name
-    File.basename file
-  end
-
-  def decorated_path
-    path.sub(BacktraceLine::IN_APP_PATH, '').
-      sub(BacktraceLine::GEMS_PATH, "<strong>\\1</strong>")
-  end
-
-end
@@ -1,32 +0,0 @@
-class BacktraceLineNormalizer
-  def initialize(raw_line)
-    @raw_line = raw_line || {}
-  end
-
-  def call
-    @raw_line.merge 'file' => normalized_file, 'method' => normalized_method
-  end
-
-  private
-  def normalized_file
-    if @raw_line['file'].blank?
-      "[unknown source]"
-    else
-      file = @raw_line['file'].to_s
-      # Detect lines from gem
-      file.gsub!(/\[PROJECT_ROOT\]\/.*\/ruby\/[0-9.]+\/gems/, '[GEM_ROOT]/gems')
-      # Strip any query strings
-      file.gsub!(/\?[^\?]*$/, '')
-      @raw_line['file'] = file
-    end
-  end
-
-  def normalized_method
-    if @raw_line['method'].blank?
-      "[unknown method]"
-    else
-      @raw_line['method'].to_s.gsub(/[0-9_]{10,}+/, "__FRAGMENT__")
-    end
-  end
-
-end
@@ -33,7 +33,9 @@ class Deploy
     end
  
     def store_cached_attributes_on_problems
-      Problem.where(:app_id => app.id).each(&:cache_app_attributes)
+      Problem.where(:app_id => app.id).update_all(
+        last_deploy_at: created_at
+      )
     end
  
     def deliver_email
@@ -15,8 +15,16 @@ require &#39;hoptoad_notifier&#39;
 # * <tt>:notifier</tt> - information to identify the source of the error report
 #
 class ErrorReport
-  attr_reader :error_class, :message, :request, :server_environment, :api_key,
-              :notifier, :user_attributes, :framework, :notice
+  attr_reader :api_key
+  attr_reader :error_class
+  attr_reader :framework
+  attr_reader :message
+  attr_reader :notice
+  attr_reader :notifier
+  attr_reader :problem
+  attr_reader :request
+  attr_reader :server_environment
+  attr_reader :user_attributes
  
   cattr_accessor :fingerprint_strategy do
     Fingerprint::Sha1
@@ -40,24 +48,59 @@ class ErrorReport
   end
  
   def backtrace
-    @normalized_backtrace ||= Backtrace.find_or_create(raw: @backtrace)
+    @normalized_backtrace ||= Backtrace.find_or_create(@backtrace)
   end
  
   def generate_notice!
     return unless valid?
     return @notice if @notice
+
+    make_notice
+    error.notices << @notice
+    cache_attributes_on_problem
+    email_notification
+    services_notification
+    @notice
+  end
+
+  def make_notice
     @notice = Notice.new(
       message: message,
       error_class: error_class,
-      backtrace_id: backtrace.id,
+      backtrace: backtrace,
       request: request,
       server_environment: server_environment,
       notifier: notifier,
       user_attributes: user_attributes,
       framework: framework
     )
-    error.notices << @notice
-    @notice
+  end
+
+  # Update problem cache with information about this notice
+  def cache_attributes_on_problem
+    @problem = Problem.cache_notice(@error.problem_id, @notice)
+  end
+
+  # Send email notification if needed
+  def email_notification
+    return false unless app.emailable?
+    return false unless app.email_at_notices.include?(@problem.notices_count)
+    Mailer.err_notification(self).deliver
+  rescue => e
+    HoptoadNotifier.notify(e)
+  end
+
+  def should_notify?
+    app.notification_service.notify_at_notices.include?(0) ||
+      app.notification_service.notify_at_notices.include?(@problem.notices_count)
+  end
+
+  # Launch all notification define on the app associate to this notice
+  def services_notification
+    return true unless app.notification_service_configured? and should_notify?
+    app.notification_service.create_notification(problem)
+  rescue => e
+    HoptoadNotifier.notify(e)
   end
  
   ##
@@ -20,13 +20,10 @@ class Notice
   index(:created_at => 1)
   index(:err_id => 1, :created_at => 1, :_id => 1)
  
-  after_create :cache_attributes_on_problem, :unresolve_problem
-  after_create :email_notification
-  after_create :services_notification
   before_save :sanitize
-  before_destroy :decrease_counter_cache, :remove_cached_attributes_from_problem
+  before_destroy :problem_recache
  
-  validates_presence_of :backtrace, :server_environment, :notifier
+  validates_presence_of :backtrace_id, :server_environment, :notifier
  
   scope :ordered, ->{ order_by(:created_at.asc) }
   scope :reverse_ordered, ->{ order_by(:created_at.desc) }
@@ -106,26 +103,6 @@ class Notice
     request['session'] || {}
   end
  
-  def in_app_backtrace_lines
-    backtrace_lines.in_app
-  end
-
-  def similar_count
-    problem.notices_count
-  end
-
-  def emailable?
-    app.email_at_notices.include?(similar_count)
-  end
-
-  def should_email?
-    app.emailable? && emailable?
-  end
-
-  def should_notify?
-    app.notification_service.notify_at_notices.include?(0) || app.notification_service.notify_at_notices.include?(similar_count)
-  end
-
   ##
   # TODO: Move on decorator maybe
   #
@@ -143,20 +120,8 @@ class Notice
  
   protected
  
-  def decrease_counter_cache
-    problem.inc(notices_count: -1) if err
-  end
-
-  def remove_cached_attributes_from_problem
-    problem.remove_cached_notice_attributes(self) if err
-  end
-
-  def unresolve_problem
-    problem.update_attributes!(:resolved => false, :resolved_at => nil, :notices_count => 1) if problem.resolved?
-  end
-
-  def cache_attributes_on_problem
-    ProblemUpdaterCache.new(problem, self).update
+  def problem_recache
+    problem.uncache_notice(self)
   end
  
   def sanitize
@@ -165,7 +130,6 @@ class Notice
     end
   end
  
-
   def sanitize_hash(h)
     h.recurse do |h|
       h.inject({}) do |h,(k,v)|
@@ -178,25 +142,4 @@ class Notice
       end
     end
   end
-
-  private
-
-  ##
-  # Send email notification if needed
-  def email_notification
-    return true unless should_email?
-    Mailer.err_notification(self).deliver
-  rescue => e
-    HoptoadNotifier.notify(e)
-  end
-
-  ##
-  # Launch all notification define on the app associate to this notice
-  def services_notification
-    return true unless app.notification_service_configured? and should_notify?
-    app.notification_service.create_notification(problem)
-  rescue => e
-    HoptoadNotifier.notify(e)
-  end
-
 end
@@ -26,7 +26,7 @@ class NotificationService
   else
     Fields = []
   end
-       
+
   def notify_at_notices
     Errbit::Config.per_app_notify_at_notices ? super : Errbit::Config.notify_at_notices
   end
@@ -6,8 +6,15 @@ class Problem
   include Mongoid::Document
   include Mongoid::Timestamps
  
-  field :last_notice_at, :type => DateTime, :default => Proc.new { Time.now }
-  field :first_notice_at, :type => DateTime, :default => Proc.new { Time.now }
+  CACHED_NOTICE_ATTRIBUTES = {
+    messages: :message,
+    hosts: :host,
+    user_agents: :user_agent_string
+  }.freeze
+
+
+  field :last_notice_at, :type => ActiveSupport::TimeWithZone, :default => Proc.new { Time.now }
+  field :first_notice_at, :type => ActiveSupport::TimeWithZone, :default => Proc.new { Time.now }
   field :last_deploy_at, :type => Time
   field :resolved, :type => Boolean, :default => false
   field :resolved_at, :type => Time
@@ -35,6 +42,14 @@ class Problem
   index :resolved_at => 1
   index :notices_count => 1
  
+  index({
+    error_class: "text",
+    where: "text",
+    message: "text",
+    app_name: "text",
+    environment: "text"
+  }, default_language: "english")
+
   belongs_to :app
   has_many :errs, :inverse_of => :problem, :dependent => :destroy
   has_many :comments, :inverse_of => :err, :dependent => :destroy
@@ -63,6 +78,83 @@ class Problem
     env.present? ? where(:environment => env) : scoped
   end
  
+  def self.cache_notice(id, notice)
+    # increment notice count
+    message_digest = Digest::MD5.hexdigest(notice.message)
+    host_digest = Digest::MD5.hexdigest(notice.host)
+    user_agent_digest = Digest::MD5.hexdigest(notice.user_agent_string)
+
+    Problem.where('_id' => id).find_one_and_update({
+      '$set' => {
+        'environment' => notice.environment_name,
+        'error_class' => notice.error_class,
+        'last_notice_at' => notice.created_at.utc,
+        'message' => notice.message,
+        'resolved' => false,
+        'resolved_at' => nil,
+        'where' => notice.where,
+        "messages.#{message_digest}.value" => notice.message,
+        "hosts.#{host_digest}.value" => notice.host,
+        "user_agents.#{user_agent_digest}.value" => notice.user_agent_string,
+      },
+      '$inc' => {
+        'notices_count' => 1,
+        "messages.#{message_digest}.count" => 1,
+        "hosts.#{host_digest}.count" => 1,
+        "user_agents.#{user_agent_digest}.count" => 1,
+      }
+    }, return_document: :after)
+  end
+
+  def uncache_notice(notice)
+    last_notice = notices.last
+
+    atomically do |doc|
+      doc.set(
+        'environment' => last_notice.environment_name,
+        'error_class' => last_notice.error_class,
+        'last_notice_at' => last_notice.created_at,
+        'message' => last_notice.message,
+        'where' => last_notice.where,
+        'notices_count' => notices_count.to_i > 1 ? notices_count - 1 : 0
+      )
+
+      CACHED_NOTICE_ATTRIBUTES.each do |k,v|
+        digest = Digest::MD5.hexdigest(notice.send(v))
+        field = "#{k}.#{digest}"
+
+        if (doc[k].try(:[], digest).try(:[], :count)).to_i > 1
+          doc.inc("#{field}.count" => -1)
+        else
+          doc.unset(field)
+        end
+      end
+    end
+  end
+
+  def recache
+    CACHED_NOTICE_ATTRIBUTES.each do |k,v|
+      # clear all cached attributes
+      send("#{k}=", {})
+
+      # find only notices related to this problem
+      Notice.collection.find.aggregate([
+        { "$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]
+        }
+      end
+    end
+
+    self.notices_count = Notice.where({ err_id: { "$in" => err_ids }}).count
+    save
+  end
+
   def url
     Rails.application.routes.url_helpers.app_problem_url(app, self,
       :host => Errbit::Config.host,
@@ -98,16 +190,21 @@ class Problem
   def unmerge!
     attrs = {:error_class => error_class, :environment => environment}
     problem_errs = errs.to_a
-    problem_errs.shift
-    [self] + problem_errs.map(&:id).map do |err_id|
-      err = Err.find(err_id)
-      app.problems.create(attrs).tap do |new_problem|
-        err.update_attribute(:problem_id, new_problem.id)
-        new_problem.reset_cached_attributes
-      end
+
+    # associate and return all the problems
+    new_problems = [self]
+
+    # create new problems for each err that needs one
+    (problem_errs[1..-1] || []).each do |err|
+      new_problems << app.problems.create(attrs)
+      err.update_attribute(:problem, new_problems.last)
     end
-  end
  
+    # recache each new problem
+    new_problems.each(&:recache)
+
+    new_problems
+  end
  
   def self.ordered_by(sort, order)
     case sort
@@ -124,20 +221,10 @@ class Problem
     where(:first_notice_at.lte => date_range.end).where("$or" => [{:resolved_at => nil}, {:resolved_at.gte => date_range.begin}])
   end
  
-
-  def reset_cached_attributes
-    ProblemUpdaterCache.new(self).update
-  end
-
   def cache_app_attributes
     if app
       self.app_name = app.name
-      self.last_deploy_at = if (last_deploy = app.deploys.where(:environment => self.environment).last)
-        last_deploy.created_at.utc
-      end
-      collection.find('_id' => self.id)
-                .update({'$set' => {'app_name' => self.app_name,
-                          'last_deploy_at' => self.last_deploy_at.try(:utc)}})
+      self.last_deploy_at = app.last_deploy_at
     end
   end
  
@@ -145,14 +232,6 @@ class Problem
     self.message = self.message[0, 1000] if self.message
   end
  
-  def remove_cached_notice_attributes(notice)
-    update_attributes!(
-      :messages    => attribute_count_descrease(:messages, notice.message),
-      :hosts       => attribute_count_descrease(:hosts, notice.host),
-      :user_agents => attribute_count_descrease(:user_agents, notice.user_agent_string)
-    )
-  end
-
   def issue_type
     # Return issue_type if configured, but fall back to detecting app's issue tracker
     attributes['issue_type'] ||=
@@ -160,13 +239,7 @@ class Problem
   end
  
   def self.search(value)
-    any_of(
-      {:error_class => /#{value}/i},
-      {:where => /#{value}/i},
-      {:message => /#{value}/i},
-      {:app_name => /#{value}/i},
-      {:environment => /#{value}/i}
-    )
+    Problem.where({'$text' => {'$search' => value}})
   end
  
   private
@@ -27,7 +27,7 @@
  
 ## Backtrace ##
 ~~~
-<% notice.backtrace_lines.each do |line| %><%= line.number %>:  <%= line.file_relative %> -> **<%= line.method %>**
+<% notice.backtrace.lines.each do |line| %><%= line.number %>:  <%= line.file_relative %> -> **<%= line.method %>**
 <% end %>
 ~~~
  
@@ -16,6 +16,6 @@ Env:     &lt;%= pretty_hash notice.env_vars %&gt;
  
 Backtrace
 ---------
-<% notice.backtrace_lines.each do |line| %><%= sprintf('%5d: %s **%s', line.number, line.file_relative, line.method) %>
+<% notice.backtrace.lines.each do |line| %><%= sprintf('%5d: %s **%s', line.number, line.file_relative, line.method) %>
 <% end %>
 <% end %>
@@ -21,8 +21,8 @@ WHERE:
  
 <%= @notice.where %>
  
-<% @notice.in_app_backtrace_lines.each do |line| %>
-  <%= line %>
+<% @notice.backtrace.lines.each do |line| %>
+  <% next unless line.in_app? %><%= line %>
 <% end %>
  
  
@@ -27,9 +27,10 @@
               %p.heading WHERE:
               %p.monospace
                 = @notice.where
-              - @notice.in_app_backtrace_lines.each do |line|
+              - @notice.backtrace.lines.each do |line|
+                - next unless line.in_app?
                 %p.backtrace
-                  = link_to_source_file(line) do
+                  = line.link_to_source_file(@app) do
                     = line.to_s
               %br
               - if @notice.app_version.present?
@@ -59,11 +60,11 @@
                       %td(style="text-align: right; padding-right: 10px; color: #6a6a6a;")= key.to_s.titleize + ":"
                       %td= auto_link(value.to_s)
                 %br
-              - if @notice.backtrace_lines.any?
+              - if @notice.backtrace.lines.any?
                 %br
                 %p.heading FULL BACKTRACE:
-                - @notice.backtrace_lines.each do |line|
+                - @notice.backtrace.lines.each do |line|
                   %p.backtrace
-                    = link_to_source_file(line) do
+                    = link_to_source_file(line, @app) do
                       = line.to_s
                 %br
@@ -14,7 +14,8 @@ WHERE:
  
 <%= @notice.where %>
  
-<% @notice.in_app_backtrace_lines.each do |line| %>
+<% @notice.backtrace.lines.each do |line| %>
+  <% next unless line.in_app? %>
   <%= line %>
 <% end %>
  
@@ -51,7 +52,7 @@ USER:
  
 BACKTRACE:
  
-<% @notice.backtrace_lines.each do |line| %>
+<% @notice.backtrace.lines.each do |line| %>
   <%= line %>
 <% end %>
  
 %tr{:class => defined?(row_class) && row_class}
   %td.line{:class => line.in_app? && 'in-app' }
-    = link_to_source_file(line) do
+    = line.link_to_source_file(app) do
       %span.path>= raw line.decorated_path
       %span.file>= line.file_name
       - if line.number.present?
@@ -68,7 +68,7 @@
  
   #backtrace
     %h3 Backtrace
-    = render 'notices/backtrace', :lines => @notice.backtrace_lines
+    = render 'notices/backtrace', :lines => @notice.backtrace.lines
  
   - if @notice.user_attributes.present?
     #user_attributes
@@ -2,7 +2,7 @@ require File.expand_path(&#39;../boot&#39;, __FILE__)
  
 require 'action_controller/railtie'
 require 'action_mailer/railtie'
-require 'mongoid/railtie'
+# require 'mongoid/railtie'
 require 'sprockets/railtie'
  
 # Require the gems listed in Gemfile, including any gems
@@ -19,9 +19,6 @@ module Errbit
     config.autoload_paths += [Rails.root.join('lib')]
  
     config.before_initialize do
-      # Load up Errbit::Config with values from the environment
-      require Rails.root.join('config/load')
-
       config.secret_key_base = Errbit::Config.secret_key_base
       config.serve_static_assets = Errbit::Config.serve_static_assets
     end
 # Load the Rails application.
 require File.expand_path('../application', __FILE__)
  
+# Load up Errbit::Config with values from the environment
+require Rails.root.join('config/load')
+
+if Errbit::Config.log_location == 'STDOUT'
+  Rails.logger = ActiveSupport::Logger.new STDOUT
+else
+  Rails.logger = ActiveSupport::Logger.new Errbit::Config.log_location
+end
+
+Rails.logger.level = Errbit::Config.log_level.to_sym
+
 # Initialize the Rails application.
 Rails.application.initialize!
 # load default ENV values (without overwriting any existing value)
 Dotenv.load('.env.default')
  
+require_relative '../lib/configurator'
+
 # map config keys to environment variables
 #
 # We use the first non-nil environment variable in the list. If the last array
@@ -19,6 +21,8 @@ Errbit::Config = Configurator.run({
   per_app_email_at_notices:  ['ERRBIT_PER_APP_EMAIL_AT_NOTICES'],
   notify_at_notices:         ['ERRBIT_NOTIFY_AT_NOTICES'],
   per_app_notify_at_notices: ['ERRBIT_PER_APP_NOTIFY_AT_NOTICES'],
+  log_location:              ['ERRBIT_LOG_LOCATION'],
+  log_level:                 ['ERRBIT_LOG_LEVEL'],
  
   serve_static_assets:       ['SERVE_STATIC_ASSETS'],
   secret_key_base:           ['SECRET_KEY_BASE'],
+log_level = Logger.const_get Errbit::Config.log_level.upcase
+
+Mongoid.logger.level = log_level
+Mongo::Logger.level = log_level
+
 Mongoid.configure do |config|
   uri = if Errbit::Config.mongo_url == 'mongodb://localhost'
           "mongodb://localhost/errbit_#{Rails.env}"
@@ -6,7 +11,7 @@ Mongoid.configure do |config|
         end
  
   config.load_configuration({
-    sessions: {
+    clients: {
       default: {
         uri: uri
       }
@@ -52,8 +52,8 @@ feature &quot;Create an application&quot; do
     fill_in 'app_name', :with => 'My new app'
     click_on I18n.t('apps.new.add_app')
     page.has_content?(I18n.t('controllers.apps.flash.create.success'))
-    expect(App.where(:name => 'My new app').count).to eql 1
-    expect(App.where(:name => 'My new app 2').count).to eql 0
+    expect(App.where(:name => 'My new app').count).to eq 1
+    expect(App.where(:name => 'My new app 2').count).to eq 0
  
  
     click_on I18n.t('shared.navigation.apps')
@@ -62,8 +62,8 @@ feature &quot;Create an application&quot; do
     fill_in 'app_name', :with => 'My new app 2'
     click_on I18n.t('apps.edit.update')
     page.has_content?(I18n.t('controllers.apps.flash.update.success'))
-    expect(App.where(:name => 'My new app').count).to eql 0
-    expect(App.where(:name => 'My new app 2').count).to eql 1
+    expect(App.where(:name => 'My new app').count).to eq 0
+    expect(App.where(:name => 'My new app 2').count).to eq 1
  
   end
  
@@ -138,15 +138,13 @@ describe ProblemsController, type: &#39;controller&#39; do
     end
  
     it "searches problems for given string" do
-      get :search, :search => "Most important"
+      get :search, :search => "\"Most important\""
       expect(controller.problems).to include(@problem1)
       expect(controller.problems).to_not include(@problem2)
     end
   end
  
   describe "GET /apps/:app_id/problems/:id" do
-    #render_views
-
     context 'when logged in as an admin' do
       before do
         sign_in admin
@@ -250,8 +248,8 @@ describe ProblemsController, type: &#39;controller&#39; do
     before { sign_in admin }
  
     context "when app has a issue tracker" do
-      let(:notice) { Fabricate :notice }
-      let(:problem) { notice.problem }
+      let(:notice) { NoticeDecorator.new(Fabricate :notice) }
+      let(:problem) { ProblemDecorator.new(notice.problem) }
       let(:issue_tracker) do
         Fabricate(:issue_tracker).tap do |t|
           t.instance_variable_set(:@tracker, ErrbitPlugin::MockIssueTracker.new(t.options))
@@ -10,15 +10,19 @@ Fabricator :notice do
   server_environment  { {'environment-name' => 'production'} }
   request             {{ 'component' => 'foo', 'action' => 'bar' }}
   notifier            {{ 'name' => 'Notifier', 'version' => '1', 'url' => 'http://toad.com' }}
-end
  
-Fabricator :backtrace do
-  lines(:count => 99) { Fabricate.build(:backtrace_line) }
+  after_create do
+    Problem.cache_notice(err.problem_id, self)
+    problem.reload
+  end
 end
  
-Fabricator :backtrace_line do
-  number { rand(999) }
-  file { "/path/to/file/#{SecureRandom.hex(4)}.rb" }
-  method(:method) { ActiveSupport.methods.shuffle.first }
+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
-
@@ -23,8 +23,7 @@ end
  
 Fabricator(:problem_resolved, :from => :problem) do
   after_create do |pr|
-    Fabricate(:notice,
-              :err => Fabricate(:err, :problem => pr))
+    Fabricate(:notice, :err => Fabricate(:err, :problem => pr))
     pr.resolve!
   end
 end
@@ -19,16 +19,16 @@ describe ResolvedProblemClearer do
         }
       end
       it 'not repair database' do
-        allow(Mongoid.default_session).to receive(:command).and_call_original
-        expect(Mongoid.default_session).to_not receive(:command).with({:repairDatabase => 1})
+        allow(Mongoid.default_client).to receive(:command).and_call_original
+        expect(Mongoid.default_client).to_not receive(:command).with({:repairDatabase => 1})
         resolved_problem_clearer.execute
       end
     end
  
     context "with problem resolve" do
       before do
-        allow(Mongoid.default_session).to receive(:command).and_call_original
-        allow(Mongoid.default_session).to receive(:command).with({:repairDatabase => 1})
+        allow(Mongoid.default_client).to receive(:command).and_call_original
+        allow(Mongoid.default_client).to receive(:command).with({:repairDatabase => 1})
         problems.first.resolve!
         problems.second.resolve!
       end
@@ -44,7 +44,7 @@ describe ResolvedProblemClearer do
       end
  
       it 'repair database' do
-        expect(Mongoid.default_session).to receive(:command).with({:repairDatabase => 1})
+        expect(Mongoid.default_client).to receive(:command).with({:repairDatabase => 1})
         resolved_problem_clearer.execute
       end
     end
 shared_examples "a notification email" do
   it "should have X-Mailer header" do
-    expect(@email).to have_header('X-Mailer', 'Errbit')
+    expect(email).to have_header('X-Mailer', 'Errbit')
   end
  
   it "should have X-Errbit-Host header" do
-    expect(@email).to have_header('X-Errbit-Host', Errbit::Config.host)
+    expect(email).to have_header('X-Errbit-Host', Errbit::Config.host)
   end
  
   it "should have Precedence header" do
-    expect(@email).to have_header('Precedence', 'bulk')
+    expect(email).to have_header('Precedence', 'bulk')
   end
  
   it "should have Auto-Submitted header" do
-    expect(@email).to have_header('Auto-Submitted', 'auto-generated')
+    expect(email).to have_header('Auto-Submitted', 'auto-generated')
   end
  
   it "should have X-Auto-Response-Suppress header" do
     # http://msdn.microsoft.com/en-us/library/ee219609(v=EXCHG.80).aspx
-    expect(@email).to have_header('X-Auto-Response-Suppress', 'OOF, AutoReply')
+    expect(email).to have_header('X-Auto-Response-Suppress', 'OOF, AutoReply')
   end
  
   it "should send the email" do
+    email
     expect(ActionMailer::Base.deliveries.size).to eq 1
   end
 end
@@ -30,44 +31,63 @@ describe Mailer do
     include EmailSpec::Helpers
     include EmailSpec::Matchers
  
-    let(:notice)  { Fabricate(:notice, :message => "class < ActionController::Base") }
-    let!(:user)   { Fabricate(:admin) }
+    let(:notice) do
+      n = Fabricate(:notice, message: "class < ActionController::Base")
+      n.backtrace.lines.last[:file] = '[PROJECT_ROOT]/path/to/file.js'
+      # notice.backtrace.update_attributes(lines: lines)
+      n
+    end
  
-    before do
-      ActionMailer::Base.deliveries = []
-      notice.backtrace.lines.last.update_attributes(:file => "[PROJECT_ROOT]/path/to/file.js")
-      notice.app.update_attributes(
+    let(:app) do
+      a = notice.app
+      a.update_attributes(
         :asset_host => "http://example.com",
         :notify_all_users => true
       )
-      notice.problem.update_attributes :notices_count => 3
-
-      @email = Mailer.err_notification(notice).deliver
+      a
+    end
+    let(:problem) do
+      p = notice.problem
+      p.notices_count = 3
+      p
+    end
+    let!(:user)   { Fabricate(:admin) }
+    let(:error_report) do
+      instance_double(
+        'ErrorReport',
+        notice: notice,
+        app: app,
+        problem: problem
+      )
+    end
+    let(:email) do
+      Mailer.err_notification(error_report).deliver
     end
  
-    it_should_behave_like "a notification email"
+    before { email }
  
+    it_should_behave_like "a notification email"
  
     it "should html-escape the notice's message for the html part" do
-      expect(@email).to have_body_text("class &lt; ActionController::Base")
+      expect(email).to have_body_text("class &lt; ActionController::Base")
     end
  
     it "should have inline css" do
-      expect(@email).to have_body_text('<p class="backtrace" style="')
+      expect(email).to have_body_text('<p class="backtrace" style="')
     end
  
     it "should have links to source files" do
-      expect(@email).to have_body_text('<a href="http://example.com/path/to/file.js" target="_blank">path/to/file.js')
+      expect(email).to have_body_text('<a href="http://example.com/path/to/file.js" target="_blank">path/to/file.js')
     end
  
     it "should have the error count in the subject" do
-      expect(@email.subject).to match( /^\(3\) / )
+      expect(email.subject).to match( /^\(3\) / )
     end
  
     context 'with a very long message' do
       let(:notice)  { Fabricate(:notice, :message => 6.times.collect{|a| "0123456789" }.join('')) }
       it "should truncate the long message" do
-        expect(@email.subject).to match( / \d{47}\.{3}$/ )
+        expect(email.subject).to match( / \d{47}\.{3}$/ )
       end
     end
   end
@@ -1,25 +0,0 @@
-describe BacktraceLineNormalizer, type: 'model' do
-  subject { described_class.new(raw_line).call }
-
-  describe "sanitize" do
-    context "unknown file and method" do
-      let(:raw_line) { { 'number' => rand(999), 'file' => nil, 'method' => nil } }
-
-      it "should replace nil file with [unknown source]" do
-        expect(subject['file']).to eq "[unknown source]"
-      end
-
-      it "should replace nil method with [unknown method]" do
-        expect(subject['method']).to eq "[unknown method]"
-      end
-    end
-
-    context "in app file" do
-      let(:raw_line) { { 'number' => rand(999), 'file' => "[PROJECT_ROOT]/assets/file.js?body=1", 'method' => nil } }
-
-      it "should strip query strings from files" do
-        expect(subject['file']).to eq "[PROJECT_ROOT]/assets/file.js"
-      end
-    end
-  end
-end
@@ -1,10 +0,0 @@
-describe BacktraceLine, type: 'model' do
-  subject { described_class.new(raw_line) }
-
-  describe "root at the start of decorated filename" do
-    let(:raw_line) { { 'number' => rand(999), 'file' => '[PROJECT_ROOT]/app/controllers/pages_controller.rb', 'method' => ActiveSupport.methods.shuffle.first.to_s } }
-    it "should leave leading root symbol in filepath" do
-      expect(subject.decorated_path).to eq 'app/controllers/'
-    end
-  end
-end
 describe Backtrace, type: 'model' do
-  subject { described_class.new }
-
-  its(:fingerprint) { should be_present }
-
-  describe "#similar" do
-    context "no similar backtrace" do
-      its(:similar) { should be_nil }
+  describe '.find_or_create' do
+    let(:lines) do
+      [
+        { 'number' => '123', 'file' => '/some/path/to.rb', 'method' => 'abc' },
+        { 'number' => '345', 'file' => '/path/to.rb', 'method' => 'dowhat' }
+      ]
     end
+    let(:fingerprint) { Backtrace.generate_fingerprint(lines) }
  
-    context "similar backtrace exist" do
-      let!(:similar_backtrace) {
-        b =  Fabricate(:backtrace)
-        b.fingerprint = fingerprint
-        b.save!
-        b
-      }
-      let(:fingerprint) { "fingerprint" }
-
-      before { allow(subject).to receive(:fingerprint).and_return(fingerprint) }
-
-      its(:similar) { should == similar_backtrace }
-    end
-  end
-
-  describe "find_or_create" do
-    subject { described_class.find_or_create(attributes) }
-    let(:attributes) { double :attributes }
-    let(:backtrace) { double :backtrace }
-
-    before { allow(described_class).to receive(:new).and_return(backtrace) }
-
-    context "no similar backtrace" do
-      before { allow(backtrace).to receive(:similar).and_return(nil) }
-      it "create new backtrace" do
-        expect(described_class).to receive(:create).with(attributes)
+    it 'create new backtrace' do
+      backtrace = described_class.find_or_create(lines)
  
-        described_class.find_or_create(attributes)
-      end
+      expect(backtrace.lines).to eq(lines)
+      expect(backtrace.fingerprint).to eq(fingerprint)
     end
  
-    context "similar backtrace exist" do
-      let(:similar_backtrace) { double :similar_backtrace }
-      before { allow(backtrace).to receive(:similar).and_return(similar_backtrace) }
+    it 'creates one backtrace for two identical ones' do
+      described_class.find_or_create(lines)
+      described_class.find_or_create(lines)
  
-      it { should == similar_backtrace }
+      expect(Backtrace.where(fingerprint: fingerprint).count).to eq(1)
     end
   end
 end
@@ -17,259 +17,310 @@ module Airbrake
 end
  
 describe ErrorReport do
-  context "with notice without line of backtrace" do
-    let(:xml){
-      Rails.root.join('spec','fixtures','hoptoad_test_notice.xml').read
-    }
-
-    let(:error_report) {
-      ErrorReport.new(xml)
-    }
-
-    let!(:app) {
-      Fabricate(
-        :app,
-        :api_key => 'APIKEY'
-      )
-    }
-
-    describe "#app" do
-      it 'find the good app' do
-        expect(error_report.app).to eq app
-      end
+  let(:xml){
+    Rails.root.join('spec','fixtures','hoptoad_test_notice.xml').read
+  }
+
+  let(:error_report) { ErrorReport.new(xml) }
+
+  let!(:app) {
+    Fabricate(
+      :app,
+      :api_key => 'APIKEY'
+    )
+  }
+
+  describe "#app" do
+    it 'find the good app' do
+      expect(error_report.app).to eq app
     end
+  end
  
-    describe "#backtrace" do
-      it 'should have valid backtrace' do
-        expect(error_report.backtrace).to be_valid
-      end
+  describe "#backtrace" do
+    it 'should have valid backtrace' do
+      expect(error_report.backtrace).to be_valid
     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
+  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
-
-        expect(error_report.error.fingerprint).to eq('fingerprintzzz')
       end
+
+      expect(error_report.error.fingerprint).to eq('fingerprintzzz')
     end
+  end
  
-    describe "#generate_notice!" do
-      it "save a notice" do
+  describe "#generate_notice!" do
+    it "save a notice" do
+      expect {
+        error_report.generate_notice!
+      }.to change {
+        app.reload.problems.count
+      }.by(1)
+    end
+
+    context "with notice generate by Airbrake gem" do
+      let(:xml) { Airbrake::Notice.new(
+        :exception => Exception.new,
+        :api_key => 'APIKEY',
+        :project_root => Rails.root
+      ).to_xml }
+      it 'save a notice' do
         expect {
           error_report.generate_notice!
         }.to change {
           app.reload.problems.count
         }.by(1)
       end
+    end
  
-      context "with notice generate by Airbrake gem" do
-        let(:xml) { Airbrake::Notice.new(
-          :exception => Exception.new,
-          :api_key => 'APIKEY',
-          :project_root => Rails.root
-        ).to_xml }
-        it 'save a notice' do
-          expect {
-            error_report.generate_notice!
-          }.to change {
-            app.reload.problems.count
-          }.by(1)
-        end
-      end
+    describe "notice create" do
+      before { error_report.generate_notice! }
+      subject { error_report.notice }
+      its(:message) { 'HoptoadTestingException: Testing hoptoad via "rake hoptoad:test". If you can see this, it works.' }
+      its(:framework) { should == 'Rails: 3.2.11' }
  
-      describe "notice create" do
-        before { error_report.generate_notice! }
-        subject { error_report.notice }
-        its(:message) { 'HoptoadTestingException: Testing hoptoad via "rake hoptoad:test". If you can see this, it works.' }
-        its(:framework) { should == 'Rails: 3.2.11' }
+      it 'has complete backtrace' do
+        expect(subject.backtrace_lines.size).to eq 73
+        expect(subject.backtrace_lines.last['file']).to eq '[GEM_ROOT]/bin/rake'
+      end
  
-        it 'has complete backtrace' do
-          expect(subject.backtrace_lines.size).to eq 73
-          expect(subject.backtrace_lines.last['file']).to eq '[GEM_ROOT]/bin/rake'
-        end
-        it 'has server_environement' do
-          expect(subject.server_environment['environment-name']).to eq 'development'
-        end
+      it 'has server_environement' do
+        expect(subject.server_environment['environment-name']).to eq 'development'
+      end
  
-        it 'has request' do
-          expect(subject.request['url']).to eq 'http://example.org/verify/cupcake=fistfight&lovebird=doomsayer'
-          expect(subject.request['params']['controller']).to eq 'application'
-        end
+      it 'has request' do
+        expect(subject.request['url']).to eq 'http://example.org/verify/cupcake=fistfight&lovebird=doomsayer'
+        expect(subject.request['params']['controller']).to eq 'application'
+      end
  
-        it 'has notifier' do
-          expect(subject.notifier['name']).to eq 'Hoptoad Notifier'
-        end
+      it 'has notifier' do
+        expect(subject.notifier['name']).to eq 'Hoptoad Notifier'
+      end
  
-        it 'get user_attributes' do
-          expect(subject.user_attributes['id']).to eq '123'
-          expect(subject.user_attributes['name']).to eq 'Mr. Bean'
-          expect(subject.user_attributes['email']).to eq 'mr.bean@example.com'
-          expect(subject.user_attributes['username']).to eq 'mrbean'
-        end
+      it 'get user_attributes' do
+        expect(subject.user_attributes['id']).to eq '123'
+        expect(subject.user_attributes['name']).to eq 'Mr. Bean'
+        expect(subject.user_attributes['email']).to eq 'mr.bean@example.com'
+        expect(subject.user_attributes['username']).to eq 'mrbean'
+      end
  
-        it 'valid env_vars' do
-          # XML: <var key="SCRIPT_NAME"/>
-          expect(subject.env_vars).to have_key('SCRIPT_NAME')
-          expect(subject.env_vars['SCRIPT_NAME']).to be_nil # blank ends up nil
-
-          # XML representation:
-          # <var key="rack.session.options">
-          #   <var key="secure">false</var>
-          #   <var key="httponly">true</var>
-          #   <var key="path">/</var>
-          #   <var key="expire_after"/>
-          #   <var key="domain"/>
-          #   <var key="id"/>
-          # </var>
-          expected = {
-            'secure'        => 'false',
-            'httponly'      => 'true',
-            'path'          => '/',
-            'expire_after'  => nil,
-            'domain'        => nil,
-            'id'            => nil
-          }
-          expect(subject.env_vars).to have_key('rack_session_options')
-          expect(subject.env_vars['rack_session_options']).to eql(expected)
-        end
+      it 'valid env_vars' do
+        # XML: <var key="SCRIPT_NAME"/>
+        expect(subject.env_vars).to have_key('SCRIPT_NAME')
+        expect(subject.env_vars['SCRIPT_NAME']).to be_nil # blank ends up nil
+
+        # XML representation:
+        # <var key="rack.session.options">
+        #   <var key="secure">false</var>
+        #   <var key="httponly">true</var>
+        #   <var key="path">/</var>
+        #   <var key="expire_after"/>
+        #   <var key="domain"/>
+        #   <var key="id"/>
+        # </var>
+        expected = {
+          'secure'        => 'false',
+          'httponly'      => 'true',
+          'path'          => '/',
+          'expire_after'  => nil,
+          'domain'        => nil,
+          'id'            => nil
+        }
+        expect(subject.env_vars).to have_key('rack_session_options')
+        expect(subject.env_vars['rack_session_options']).to eql(expected)
       end
     end
+  end
  
-    it 'save a notice assignes to err' do
+  describe '#cache_attributes_on_problem' do
+    it 'sets the latest notice properties on the problem' do
       error_report.generate_notice!
-      expect(error_report.notice.err).to be_a(Err)
+      problem = error_report.problem.reload
+      notice = error_report.notice.reload
+
+      expect(problem.environment).to eq('development')
+      expect(problem.error_class).to eq('HoptoadTestingException')
+      expect(problem.last_notice_at).to eq(notice.created_at)
+      expect(problem.message).to eq(notice.message)
+      expect(problem.where).to eq(notice.where)
     end
  
-    it 'memoize the notice' do
-      expect {
-        error_report.generate_notice!
-        error_report.generate_notice!
-      }.to change {
-        Notice.count
-      }.by(1)
+    it 'unresolves the problem' do
+      error_report.generate_notice!
+      problem = error_report.problem
+      problem.update(
+        resolved_at: Time.now,
+        resolved: true
+      )
+
+      error_report = ErrorReport.new(xml)
+      error_report.generate_notice!
+      problem.reload
+
+      expect(problem.resolved_at).to be(nil)
+      expect(problem.resolved).to be(false)
     end
  
-    it 'find the correct err for the notice' do
-      err = Fabricate(:err, :problem => Fabricate(:problem, :resolved => true))
+    it 'caches notice counts' do
+      error_report.generate_notice!
+      problem = error_report.problem
+      problem.reload
+
+      expect(problem.notices_count).to be(1)
+      expect(problem.user_agents['382b0f5185773fa0f67a8ed8056c7759']['count']).to be(1)
+      expect(problem.messages['9449f087eee0499e2d9029ae3dacaf53']['count']).to be(1)
+      expect(problem.hosts['1bdf72e04d6b50c82a48c7e4dd38cc69']['count']).to be(1)
+    end
  
-      allow(error_report).to receive(:fingerprint).and_return(err.fingerprint)
+    it 'increments notice counts' do
+      error_report.generate_notice!
+      error_report = ErrorReport.new(xml)
+      error_report.generate_notice!
+      problem = error_report.problem
+      problem.reload
  
-      expect {
-        error_report.generate_notice!
-      }.to change {
-        error_report.error.resolved?
-      }.from(true).to(false)
+      expect(problem.notices_count).to be(2)
+      expect(problem.user_agents['382b0f5185773fa0f67a8ed8056c7759']['count']).to be(2)
+      expect(problem.messages['9449f087eee0499e2d9029ae3dacaf53']['count']).to be(2)
+      expect(problem.hosts['1bdf72e04d6b50c82a48c7e4dd38cc69']['count']).to be(2)
     end
+  end
  
-    context "with notification service configured" do
-      before do
-        app.notify_on_errs = true
-        app.watchers.build(:email => 'foo@example.com')
-        app.save
-      end
-      it 'send email' do
-        notice = error_report.generate_notice!
-        email = ActionMailer::Base.deliveries.last
-        expect(email.to).to include(app.watchers.first.email)
-        expect(email.subject).to include(notice.message.truncate(50))
-        expect(email.subject).to include("[#{app.name}]")
-        expect(email.subject).to include("[#{notice.environment_name}]")
-      end
+  it 'save a notice assignes to err' do
+    error_report.generate_notice!
+    expect(error_report.notice.err).to be_a(Err)
+  end
  
-      context "with xml without request section" do
-        let(:xml){
-          Rails.root.join('spec','fixtures','hoptoad_test_notice_without_request_section.xml').read
-        }
-        it "save a notice" do
-          expect {
-            error_report.generate_notice!
-          }.to change {
-            app.reload.problems.count
-          }.by(1)
-        end
+  it 'memoize the notice' do
+    expect {
+      error_report.generate_notice!
+      error_report.generate_notice!
+    }.to change {
+      Notice.count
+    }.by(1)
+  end
+
+  it 'find the correct err for the notice' do
+    error_report.generate_notice!
+    error_report.problem.resolve!
+
+    expect {
+      ErrorReport.new(xml).generate_notice!
+    }.to change {
+      error_report.problem.reload.resolved?
+    }.from(true).to(false)
+  end
+
+  context "with notification service configured" do
+    before do
+      app.notify_on_errs = true
+      app.watchers.build(:email => 'foo@example.com')
+      app.save
+    end
+
+    it 'send email' do
+      notice = error_report.generate_notice!
+      email = ActionMailer::Base.deliveries.last
+      expect(email.to).to include(app.watchers.first.email)
+      expect(email.subject).to include(notice.message.truncate(50))
+      expect(email.subject).to include("[#{app.name}]")
+      expect(email.subject).to include("[#{notice.environment_name}]")
+    end
+
+    context "with xml without request section" do
+      let(:xml){
+        Rails.root.join('spec','fixtures','hoptoad_test_notice_without_request_section.xml').read
+      }
+      it "save a notice" do
+        expect {
+          error_report.generate_notice!
+        }.to change {
+          app.reload.problems.count
+        }.by(1)
       end
+    end
  
-      context "with xml with only a single line of backtrace" do
-        let(:xml){
-          Rails.root.join('spec','fixtures','hoptoad_test_notice_with_one_line_of_backtrace.xml').read
-        }
-        it "save a notice" do
-          expect {
-            error_report.generate_notice!
-          }.to change {
-            app.reload.problems.count
-          }.by(1)
-        end
+    context "with xml with only a single line of backtrace" do
+      let(:xml){
+        Rails.root.join('spec','fixtures','hoptoad_test_notice_with_one_line_of_backtrace.xml').read
+      }
+      it "save a notice" do
+        expect {
+          error_report.generate_notice!
+        }.to change {
+          app.reload.problems.count
+        }.by(1)
       end
     end
+  end
  
-    describe "#valid?" do
-      context "with valid error report" do
-        it "return true" do
-          expect(error_report.valid?).to be true
-        end
+  describe "#valid?" do
+    context "with valid error report" do
+      it "return true" do
+        expect(error_report.valid?).to be true
       end
-      context "with not valid api_key" do
-        before do
-          App.where(:api_key => app.api_key).delete_all
-        end
-        it "return false" do
-          expect(error_report.valid?).to be false
-        end
+    end
+    context "with not valid api_key" do
+      before do
+        App.where(:api_key => app.api_key).delete_all
+      end
+      it "return false" do
+        expect(error_report.valid?).to be false
       end
     end
+  end
  
-    describe "#notice" do
-      context "before generate_notice!" do
-        it 'return nil' do
-          expect(error_report.notice).to be nil
-        end
+  describe "#notice" do
+    context "before generate_notice!" do
+      it 'return nil' do
+        expect(error_report.notice).to be nil
       end
+    end
  
-      context "after generate_notice!" do
-        before do
-          error_report.generate_notice!
-        end
-
-        it 'return the notice' do
-          expect(error_report.notice).to be_a Notice
-        end
+    context "after generate_notice!" do
+      before do
+        error_report.generate_notice!
+      end
  
+      it 'return the notice' do
+        expect(error_report.notice).to be_a Notice
       end
+
     end
+  end
  
-    describe "#should_keep?" do
-      context "with current app version not set" do
-        before do
-          error_report.app.current_app_version = nil
-          error_report.server_environment['app-version'] = '1.0'
-        end
+  describe "#should_keep?" do
+    context "with current app version not set" do
+      before do
+        error_report.app.current_app_version = nil
+        error_report.server_environment['app-version'] = '1.0'
+      end
  
-        it "return true" do
-          expect(error_report.should_keep?).to be true
-        end
+      it "return true" do
+        expect(error_report.should_keep?).to be true
       end
+    end
  
-      context "with current app version set" do
-        before do
-          error_report.app.current_app_version = '1.0'
-        end
+    context "with current app version set" do
+      before do
+        error_report.app.current_app_version = '1.0'
+      end
  
-        it "return true if current or newer" do
-          error_report.server_environment['app-version'] = '1.0'
-          expect(error_report.should_keep?).to be true
-        end
+      it "return true if current or newer" do
+        error_report.server_environment['app-version'] = '1.0'
+        expect(error_report.should_keep?).to be true
+      end
  
-        it "return false if older" do
-          error_report.server_environment['app-version'] = '0.9'
-          expect(error_report.should_keep?).to be false
-        end
+      it "return false if older" do
+        error_report.server_environment['app-version'] = '0.9'
+        expect(error_report.should_keep?).to be false
       end
     end
   end
 describe Fingerprint::MD5, type: 'model' do
   context 'being created' do
     let(:backtrace) do
-      Backtrace.create(:raw => [
+      Backtrace.find_or_create([
         {
           "number"=>"17",
           "file"=>"[GEM_ROOT]/gems/activesupport/lib/active_support/callbacks.rb",
@@ -14,10 +14,9 @@ describe Fingerprint::MD5, type: &#39;model&#39; do
  
     context "with same backtrace" do
       let(:backtrace_2) do
-        backtrace
-        backtrace.lines.last.method =  '_run__FRAGMENT__process_action__FRAGMENT__callbacks'
-        backtrace.save
-        backtrace
+        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
@@ -27,10 +26,9 @@ describe Fingerprint::MD5, type: &#39;model&#39; do
  
     context "with same backtrace where FRAGMENT has not been extracted" do
       let(:backtrace_2) do
-        backtrace
-        backtrace.lines.last.method =  '_run__998857585768765__process_action__1231231312321313__callbacks'
-        backtrace.save
-        backtrace
+        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
 describe Fingerprint::Sha1, type: 'model' do
   context '#generate' do
     let(:backtrace) {
-      Backtrace.create(:raw => [
+      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"}
@@ -19,11 +19,9 @@ describe Fingerprint::Sha1, type: &#39;model&#39; do
  
     context "with different backtrace with only last line change" do
       let(:backtrace_2) {
-        backtrace
-        backtrace.lines.last.number = 401
-        backtrace.send(:generate_fingerprint)
-        backtrace.save
-        backtrace
+        new_lines = backtrace.lines.dup
+        new_lines.last[:number] = 401
+        Backtrace.find_or_create backtrace.lines
       }
       it 'should not same fingerprint' do
         expect(
 describe "Callback on Notice", type: 'model' do
-  describe "email notifications (configured individually for each app)" do
+  let(:notice_attrs_for) do
+    ->(api_key) do
+      {
+        error_class: "HoptoadTestingException",
+        message: "some message",
+        backtrace: [
+          {
+            "number"=>"425",
+            "file"=>"[GEM_ROOT]/callbacks.rb",
+            "method"=>"__callbacks"
+          }
+        ],
+        request: { "component" => "application" },
+        server_environment: {
+          "project-root" => "/path/to/sample/project",
+          "environment-name" => "development"
+        },
+        api_key: api_key,
+        notifier: {
+          "name"=>"Hoptoad Notifier",
+          "version"=>"2.3.2",
+          "url"=>"http://hoptoadapp.com"
+        },
+        framework: "Rails: 3.2.11"
+      }
+    end
+  end
+
+  describe 'email notifications (configured individually for each app)' do
+    let(:notice_attrs) { notice_attrs_for.call(app.api_key) }
     custom_thresholds = [2, 4, 8, 16, 32, 64]
+    let(:app) do
+      Fabricate(:app_with_watcher, email_at_notices: custom_thresholds)
+    end
  
     before do
       Errbit::Config.per_app_email_at_notices = true
-      @app = Fabricate(:app_with_watcher, :email_at_notices => custom_thresholds)
-      @err = Fabricate(:err, :problem => Fabricate(:problem, :app => @app))
+      error_report = ErrorReport.new(notice_attrs)
+      error_report.generate_notice!
+      @problem = error_report.notice.err.problem
     end
  
-    after do
-      Errbit::Config.per_app_email_at_notices = false
-    end
+    after { Errbit::Config.per_app_email_at_notices = false }
  
     custom_thresholds.each do |threshold|
       it "sends an email notification after #{threshold} notice(s)" do
-        allow(@err.problem).to receive(:notices_count).and_return(threshold)
+        # set to just before the threshold
+        @problem.update_attributes notices_count: threshold - 1
+
         expect(Mailer).to receive(:err_notification).
           and_return(double('email', :deliver => true))
-        Fabricate(:notice, :err => @err)
+
+        error_report = ErrorReport.new(notice_attrs)
+        error_report.generate_notice!
       end
     end
-  end
  
-  describe "email notifications for a resolved issue" do
-    before do
-      Errbit::Config.per_app_email_at_notices = true
-      @app = Fabricate(:app_with_watcher, :email_at_notices => [1])
-      @err = Fabricate(:err, :problem => Fabricate(:problem, :app => @app, :notices_count => 100))
-    end
+    it "doesn't email after 5 notices" do
+      @problem.update_attributes notices_count: 5
  
-    after do
-      Errbit::Config.per_app_email_at_notices = false
-    end
+      expect(Mailer).to_not receive(:err_notification)
  
-    it "should send email notification after 1 notice since an error has been resolved" do
-      @err.problem.resolve!
-      expect(Mailer).to receive(:err_notification).
-        and_return(double('email', :deliver => true))
-      Fabricate(:notice, :err => @err)
+      error_report = ErrorReport.new(notice_attrs)
+      error_report.generate_notice!
     end
-    it 'self notify if mailer failed' do
-      @err.problem.resolve!
-      expect(Mailer).to receive(:err_notification).
-        and_raise(ArgumentError)
+
+    it 'notify self if mailer fails' do
+      expect(Mailer).to receive(:err_notification).and_raise(ArgumentError)
       expect(HoptoadNotifier).to receive(:notify)
-      Fabricate(:notice, :err => @err)
+      ErrorReport.new(notice_attrs).generate_notice!
     end
   end
  
-  describe "should send a notification if a notification service is configured with defaults" do
-    let(:app) { Fabricate(:app, :email_at_notices => [1], :notification_service => Fabricate(:campfire_notification_service))}
-    let(:err) { Fabricate(:err, :problem => Fabricate(:problem, :app => app, :notices_count => 100)) }
-    let(:backtrace) { Fabricate(:backtrace) }
-
-    before do
-      Errbit::Config.per_app_email_at_notices = true
+  describe 'email notifications for resolved issues' do
+    let(:notification_service) { Fabricate(:campfire_notification_service) }
+    let(:app) do
+      Fabricate(
+        :app_with_watcher,
+        notify_on_errs: true,
+        email_at_notices: [1,100]
+      )
     end
+    let(:notice_attrs) { notice_attrs_for.call(app.api_key) }
  
-    after do
-      Errbit::Config.per_app_email_at_notices = false
-    end
+    before { Errbit::Config.per_app_email_at_notices = true }
+    after { Errbit::Config.per_app_email_at_notices = false }
  
-    it "should create a campfire notification" do
-      expect(app.notification_service).to receive(:create_notification)
+    it 'sends email the first time after the error is resolved' do
+      error_report = ErrorReport.new(notice_attrs)
+      error_report.generate_notice!
+      err = error_report.notice.err
  
-      Notice.create!(:err => err, :message => 'FooError: Too Much Bar', :server_environment => {'environment-name' => 'production'},
-                     :backtrace => backtrace, :notifier => { 'name' => 'Notifier', 'version' => '1', 'url' => 'http://toad.com' })
-    end
-  end
+      err.problem.update_attributes notices_count: 99
+      err.problem.resolve!
  
-  describe "send a notification if a notification service is configured with defaults but failed" do
-    let(:app) { Fabricate(:app_with_watcher,
-                          :notify_on_errs => true,
-                          :email_at_notices => [1, 100], :notification_service => Fabricate(:campfire_notification_service))}
-    let(:err) { Fabricate(:err, :problem => Fabricate(:problem, :app => app, :notices_count => 99)) }
-    let(:backtrace) { Fabricate(:backtrace) }
+      expect(Mailer).to receive(:err_notification)
+        .and_return(double('email', :deliver => true))
  
-    before do
-      Errbit::Config.per_app_email_at_notices = true
+      ErrorReport.new(notice_attrs).generate_notice!
     end
+  end
  
-    after do
-      Errbit::Config.per_app_email_at_notices = false
+  describe 'send email when notification service is configured but fails' do
+    let(:notification_service) {Fabricate(:campfire_notification_service)}
+    let(:app) do
+      Fabricate(
+        :app_with_watcher,
+        notify_on_errs: true,
+        notification_service: notification_service
+      )
     end
+    let(:notice_attrs) { notice_attrs_for.call(app.api_key) }
+
+    before { Errbit::Config.per_app_notify_at_notices = true }
+    after { Errbit::Config.per_app_notify_at_notices = false }
+
+    it 'sends email' do
+      error_report = ErrorReport.new(notice_attrs)
  
-    it "send email" do
-      expect(app.notification_service).to receive(:create_notification).and_raise(ArgumentError)
-      expect(Mailer).to receive(:err_notification).and_return(double(:deliver => true))
+      expect(error_report.app.notification_service)
+        .to receive(:create_notification).and_raise(ArgumentError)
+      expect(Mailer)
+        .to receive(:err_notification).and_return(double(:deliver => true))
  
-      Notice.create!(:err => err, :message => 'FooError: Too Much Bar', :server_environment => {'environment-name' => 'production'},
-                     :backtrace => backtrace, :notifier => { 'name' => 'Notifier', 'version' => '1', 'url' => 'http://toad.com' })
+      error_report.generate_notice!
     end
   end
  
-  describe "should not send a notification if a notification service is not configured" do
-    let(:app) { Fabricate(:app, :email_at_notices => [1], :notification_service => Fabricate(:notification_service))}
-    let(:err) { Fabricate(:err, :problem => Fabricate(:problem, :app => app, :notices_count => 100)) }
-    let(:backtrace) { Fabricate(:backtrace) }
+  describe 'should not send a notification if a notification service is not' \
+           'configured' do
  
-    before do
-      Errbit::Config.per_app_email_at_notices = true
-    end
+    let(:notification_service) { Fabricate(:notification_service) }
+    let(:app) { Fabricate(:app, notification_service: notification_service )}
+    let(:notice_attrs) { notice_attrs_for.call(app.api_key) }
  
-    after do
-      Errbit::Config.per_app_email_at_notices = false
-    end
+    before { Errbit::Config.per_app_notify_at_notices = true }
+    after { Errbit::Config.per_app_notify_at_notices = false }
  
     it "should not create a campfire notification" do
-      expect(app.notification_service).to_not receive(:create_notification)
-
-      Notice.create!(:err => err, :message => 'FooError: Too Much Bar', :server_environment => {'environment-name' => 'production'},
-                     :backtrace => backtrace, :notifier => { 'name' => 'Notifier', 'version' => '1', 'url' => 'http://toad.com' })
+      error_report = ErrorReport.new(notice_attrs)
+      expect(error_report.app.notification_service).to_not receive(:create_notification)
+      error_report.generate_notice!
     end
   end
  
   describe 'hipcat notifications' do
-    let(:app) { Fabricate(:app, :email_at_notices => [1], :notification_service => Fabricate(:hipchat_notification_service))}
-    let(:err) { Fabricate(:err, :problem => Fabricate(:problem, :app => app, :notices_count => 100)) }
+    let(:notification_service) { Fabricate(:hipchat_notification_service) }
+    let(:notice_attrs) { notice_attrs_for.call(app.api_key) }
+    let(:app) { Fabricate(:app, notification_service: notification_service) }
  
-    before do
-      Errbit::Config.per_app_email_at_notices = true
-    end
-
-    after do
-      Errbit::Config.per_app_email_at_notices = false
-    end
+    before { Errbit::Config.per_app_notify_at_notices = true }
+    after { Errbit::Config.per_app_notify_at_notices = false }
  
     it 'creates a hipchat notification' do
-      expect(app.notification_service).to receive(:create_notification)
-
-      Fabricate(:notice, :err => err)
+      error_report = ErrorReport.new(notice_attrs)
+      expect(error_report.app.notification_service)
+        .to receive(:create_notification)
+      error_report.generate_notice!
     end
   end
  
   describe "should send a notification at desired intervals" do
-    let(:app) { Fabricate(:app, :email_at_notices => [1], :notification_service => Fabricate(:campfire_notification_service, :notify_at_notices => [1,2]))}
-    let(:backtrace) { Fabricate(:backtrace) }
-
-    before do
-      Errbit::Config.per_app_email_at_notices = true
+    let(:notification_service) do
+      Fabricate(:campfire_notification_service, notify_at_notices: [1,2])
     end
+    let(:app) { Fabricate(:app, notification_service: notification_service) }
+    let(:notice_attrs) { notice_attrs_for.call(app.api_key) }
  
-    after do
-      Errbit::Config.per_app_email_at_notices = false
-    end
+    before { Errbit::Config.per_app_notify_at_notices = true }
+    after { Errbit::Config.per_app_notify_at_notices = false }
  
     it "should create a campfire notification on first notice" do
-      err = Fabricate(:err, :problem => Fabricate(:problem, :app => app, :notices_count => 1))
-      expect(app.notification_service).to receive(:create_notification)
-
-      Notice.create!(:err => err, :message => 'FooError: Too Much Bar', :server_environment => {'environment-name' => 'production'},
-                     :backtrace => backtrace, :notifier => { 'name' => 'Notifier', 'version' => '1', 'url' => 'http://toad.com' })
+      error_report = ErrorReport.new(notice_attrs)
+      expect(error_report.app.notification_service)
+        .to receive(:create_notification)
+      error_report.generate_notice! # one
     end
  
     it "should create a campfire notification on second notice" do
-      err = Fabricate(:err, :problem => Fabricate(:problem, :app => app, :notices_count => 1))
-      expect(app.notification_service).to receive(:create_notification)
-
-      Notice.create!(:err => err, :message => 'FooError: Too Much Bar', :server_environment => {'environment-name' => 'production'},
-                     :backtrace => backtrace, :notifier => { 'name' => 'Notifier', 'version' => '1', 'url' => 'http://toad.com' })
+      ErrorReport.new(notice_attrs).generate_notice! # one
+      error_report = ErrorReport.new(notice_attrs)
+      expect(error_report.app.notification_service)
+        .to receive(:create_notification)
+      error_report.generate_notice! # two
     end
  
     it "should not create a campfire notification on third notice" do
-      err = Fabricate(:err, :problem => Fabricate(:problem, :app => app, :notices_count => 1))
-      expect(app.notification_service).to receive(:create_notification)
-
-      Notice.create!(:err => err, :message => 'FooError: Too Much Bar', :server_environment => {'environment-name' => 'production'},
-                     :backtrace => backtrace, :notifier => { 'name' => 'Notifier', 'version' => '1', 'url' => 'http://toad.com' })
+      ErrorReport.new(notice_attrs).generate_notice! # one
+      ErrorReport.new(notice_attrs).generate_notice! # two
+      error_report = ErrorReport.new(notice_attrs)
+      expect(error_report.app.notification_service)
+        .to_not receive(:create_notification)
+      error_report.generate_notice! # three
     end
   end
 end
@@ -3,7 +3,7 @@ describe Notice, type: &#39;model&#39; do
     it 'requires a backtrace' do
       notice = Fabricate.build(:notice, :backtrace => nil)
       expect(notice).to_not be_valid
-      expect(notice.errors[:backtrace]).to include("can't be blank")
+      expect(notice.errors[:backtrace_id]).to include("can't be blank")
     end
  
     it 'requires the server_environment' do
@@ -40,10 +40,10 @@ describe Problem, type: &#39;model&#39; do
       expect(problem).to_not be_nil
  
       notice1 = Fabricate(:notice, :err => err)
-      expect(problem.last_notice_at).to eq notice1.created_at
+      expect(problem.last_notice_at).to eq notice1.reload.created_at
  
       notice2 = Fabricate(:notice, :err => err)
-      expect(problem.last_notice_at).to eq notice2.created_at
+      expect(problem.last_notice_at).to eq notice2.reload.created_at
     end
   end
  
@@ -266,12 +266,6 @@ describe Problem, type: &#39;model&#39; do
       expect(@problem.messages).to eq ({})
     end
  
-    it "adding a notice adds a string to #messages" do
-      expect {
-        Fabricate(:notice, :err => @err, :message => 'ERR 1')
-      }.to change(@problem, :messages).from({}).to({Digest::MD5.hexdigest('ERR 1') => {'value' => 'ERR 1', 'count' => 1}})
-    end
-
     it "removing a notice removes string from #messages" do
       Fabricate(:notice, :err => @err, :message => 'ERR 1')
       expect {
@@ -299,12 +293,6 @@ describe Problem, type: &#39;model&#39; do
       expect(@problem.hosts).to eq ({})
     end
  
-    it "adding a notice adds a string to #hosts" do
-      expect {
-        Fabricate(:notice, :err => @err, :request => {'url' => "http://example.com/resource/12"})
-      }.to change(@problem, :hosts).from({}).to({Digest::MD5.hexdigest('example.com') => {'value' => 'example.com', 'count' => 1}})
-    end
-
     it "removing a notice removes string from #hosts" do
       Fabricate(:notice, :err => @err, :request => {'url' => "http://example.com/resource/12"})
       expect {
@@ -325,12 +313,6 @@ describe Problem, type: &#39;model&#39; do
       expect(@problem.user_agents).to eq ({})
     end
  
-    it "adding a notice adds a string to #user_agents" do
-      expect {
-        Fabricate(:notice, :err => @err, :request => {'cgi-data' => {'HTTP_USER_AGENT' => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_7; en-US) AppleWebKit/534.16 (KHTML, like Gecko) Chrome/10.0.648.204 Safari/534.16'}})
-      }.to change(@problem, :user_agents).from({}).to({Digest::MD5.hexdigest('Chrome 10.0.648.204 (OS X 10.6.7)') => {'value' => 'Chrome 10.0.648.204 (OS X 10.6.7)', 'count' => 1}})
-    end
-
     it "removing a notice removes string from #user_agents" do
       Fabricate(:notice, :err => @err, :request => {'cgi-data' => {'HTTP_USER_AGENT' => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_7; en-US) AppleWebKit/534.16 (KHTML, like Gecko) Chrome/10.0.648.204 Safari/534.16'}})
       expect {
 # This file is copied to ~/spec when you run 'ruby script/generate rspec'
 # from the project root directory.
-ENV["RAILS_ENV"] ||= 'test'
+ENV["RAILS_ENV"] = 'test'
+ENV["ERRBIT_LOG_LEVEL"] = 'fatal'
  
 if ENV['COVERAGE']
   require 'coveralls'
@@ -21,7 +22,6 @@ require File.expand_path(&quot;../../config/environment&quot;, __FILE__)
 require 'rspec/rails'
 require 'rspec/its'
 require 'email_spec'
-require 'database_cleaner'
 require 'xmpp4r'
 require 'xmpp4r/muc'
 require 'mongoid-rspec'
@@ -31,6 +31,8 @@ require &#39;errbit_plugin/mock_issue_tracker&#39;
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+Mongoid::Config.truncate!
+Mongoid::Tasks::Database.create_indexes
  
 RSpec.configure do |config|
   config.include Devise::TestHelpers, :type => :controller
@@ -38,8 +40,7 @@ RSpec.configure do |config|
   config.alias_example_to :fit, :focused => true
  
   config.before(:each) do
-    DatabaseCleaner[:mongoid].strategy = :truncation
-    DatabaseCleaner.clean
+    Mongoid::Config.truncate!
   end
  
   config.include Haml, type: :helper
@@ -6,7 +6,7 @@ describe &quot;issue_trackers/issue.md.erb&quot;, type: &#39;view&#39; do
   }
  
   before do
-    allow(view).to receive(:problem).and_return(problem)
+    allow(view).to receive(:problem).and_return(ProblemDecorator.new(problem))
   end
  
   it "has the problem url" do
@@ -6,7 +6,8 @@ describe &quot;issue_trackers/issue.txt.erb&quot;, type: &#39;view&#39; do
   }
  
   before do
-    allow(view).to receive(:problem).and_return(problem)
+    allow(view).to receive(:problem).and_return(
+      ProblemDecorator.new(problem))
   end
  
   it "has the problem url" do
...	...	@@ -15,6 +15,8 @@ ERRBIT_PER_APP_EMAIL_AT_NOTICES=false
15	15	ERRBIT_NOTIFY_AT_NOTICES='[0]'
16	16	ERRBIT_PER_APP_NOTIFY_AT_NOTICES=false
17	17	MONGO_URL='mongodb://localhost'
	18	+ERRBIT_LOG_LEVEL=info
	19	+ERRBIT_LOG_LOCATION=STDOUT
18	20	GITHUB_URL='https://github.com'
19	21	GITHUB_AUTHENTICATION=true
20	22	GITHUB_ACCESS_SCOPE='[repo]'
...	...
...	...	@@ -9,8 +9,12 @@ env:
9	9	- RAILS_ENV=test COVERAGE=true JRUBY_OPTS=--debug
10	10	sudo: false
11	11	cache: bundler
12		-services: mongodb
13		-before_script: bundle exec rake errbit:bootstrap
	12	+before_script:
	13	+ - wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.10.tgz -O /tmp/mongodb.tgz
	14	+ - tar -xvf /tmp/mongodb.tgz
	15	+ - mkdir /tmp/data
	16	+ - ${PWD}/mongodb-linux-x86_64-2.6.10/bin/mongod --dbpath /tmp/data --bind_ip 127.0.0.1 --auth &> /dev/null &
	17	+ - bundle exec rake errbit:bootstrap
14	18	script: bundle exec rspec
15	19	matrix:
16	20	allow_failures:
...	...
...	...	@@ -8,10 +8,8 @@ gem 'actionmailer', RAILS_VERSION
8	8	gem 'actionpack', RAILS_VERSION
9	9	gem 'railties', RAILS_VERSION
10	10
11		-gem 'moped', '~> 2.0.2'
12		-gem 'mongoid', '~> 4.0.0'
	11	+gem 'mongoid', '5.0.0.beta'
13	12
14		-gem 'mongoid_rails_migrations'
15	13	gem 'devise'
16	14	gem 'haml'
17	15	gem 'htmlentities'
...	...	@@ -78,7 +76,7 @@ group :development do
78	76	end
79	77
80	78	group :test do
81		- gem 'rspec'
	79	+ gem 'rspec', '~> 3.3'
82	80	gem 'rspec-rails', '~> 3.0', require: false
83	81	gem 'rspec-activemodel-mocks'
84	82	gem 'rspec-its'
...	...	@@ -87,7 +85,6 @@ group :test do
87	85	gem 'capybara'
88	86	gem 'poltergeist'
89	87	gem 'launchy'
90		- gem 'database_cleaner'
91	88	gem 'email_spec'
92	89	gem 'timecop'
93	90	gem 'test-unit', require: 'test/unit'
...	...
...	...	@@ -44,8 +44,8 @@ GEM
44	44	rack (>= 0.9.0)
45	45	binding_of_caller (0.7.2)
46	46	debug_inspector (>= 0.0.1)
47		- bson (3.1.1)
48		- bson (3.1.1-java)
	47	+ bson (3.2.0)
	48	+ bson (3.2.0-java)
49	49	builder (3.2.2)
50	50	byebug (4.0.5)
51	51	columnize (= 0.9.0)
...	...	@@ -81,7 +81,6 @@ GEM
81	81	coffee-script-source (1.9.1.1)
82	82	colorize (0.7.7)
83	83	columnize (0.9.0)
84		- connection_pool (2.2.0)
85	84	coveralls (0.8.2)
86	85	json (~> 1.8)
87	86	rest-client (>= 1.6.8, < 2)
...	...	@@ -90,7 +89,6 @@ GEM
90	89	thor (~> 0.19.1)
91	90	css_parser (1.3.6)
92	91	addressable
93		- database_cleaner (1.4.1)
94	92	debug_inspector (0.0.2)
95	93	decent_exposure (2.3.2)
96	94	devise (3.5.1)
...	...	@@ -175,25 +173,18 @@ GEM
175	173	mimemagic (0.3.0)
176	174	mini_portile (0.6.2)
177	175	minitest (5.7.0)
178		- mongoid (4.0.2)
	176	+ mongo (2.1.0.beta)
	177	+ bson (~> 3.0)
	178	+ mongoid (5.0.0.beta)
179	179	activemodel (~> 4.0)
180		- moped (~> 2.0.0)
	180	+ mongo (= 2.1.0.beta)
181	181	origin (~> 2.1)
182	182	tzinfo (>= 0.3.37)
183		- mongoid-rspec (2.2.0)
184		- mongoid (~> 4.0.0)
	183	+ mongoid-rspec (1.10.0)
	184	+ mongoid (>= 3.0.1)
185	185	rake
186		- rspec (~> 3.1)
187		- mongoid_rails_migrations (1.0.1)
188		- activesupport (>= 3.2.0)
189		- bundler (>= 1.0.0)
190		- rails (>= 3.2.0)
191		- railties (>= 3.2.0)
192		- moped (2.0.6)
193		- bson (~> 3.0)
194		- connection_pool (~> 2.0)
195		- optionable (~> 0.2.0)
196		- multi_json (1.11.1)
	186	+ rspec (>= 2.14)
	187	+ multi_json (1.11.2)
197	188	multi_xml (0.5.5)
198	189	multipart-post (2.0.0)
199	190	net-scp (1.2.1)
...	...	@@ -363,7 +354,7 @@ GEM
363	354	thread_safe (0.3.5-java)
364	355	tilt (1.4.1)
365	356	timecop (0.7.4)
366		- tins (1.5.4)
	357	+ tins (1.6.0)
367	358	tzinfo (1.2.2)
368	359	thread_safe (~> 0.1)
369	360	uglifier (2.7.1)
...	...	@@ -410,7 +401,6 @@ DEPENDENCIES
410	401	capybara
411	402	coffee-rails
412	403	coveralls
413		- database_cleaner
414	404	decent_exposure
415	405	devise
416	406	dotenv-rails
...	...	@@ -431,10 +421,8 @@ DEPENDENCIES
431	421	kaminari (>= 0.14.1)
432	422	launchy
433	423	meta_request
434		- mongoid (~> 4.0.0)
	424	+ mongoid (= 5.0.0.beta)
435	425	mongoid-rspec
436		- mongoid_rails_migrations
437		- moped (~> 2.0.2)
438	426	omniauth-github
439	427	pjax_rails
440	428	poltergeist
...	...	@@ -447,7 +435,7 @@ DEPENDENCIES
447	435	rails_autolink
448	436	railties (~> 4.1.11)
449	437	ri_cal
450		- rspec
	438	+ rspec (~> 3.3)
451	439	rspec-activemodel-mocks
452	440	rspec-its
453	441	rspec-rails (~> 3.0)
...	...
...	...	@@ -71,7 +71,7 @@ updates and notifications.
71	71	The list of requirements to install Errbit are:
72	72
73	73	* Ruby 2.1.0 or higher
74		-* MongoDB 2.2.0 or higher
	74	+* MongoDB 2.6.0 or higher
75	75
76	76	Installation
77	77	------------
...	...	@@ -188,6 +188,8 @@ When upgrading Errbit, please run:
188	188	git pull origin master # assuming origin is the github.com/errbit/errbit repo
189	189	bundle install
190	190	rake db:migrate
	191	+rake db:mongoid:create_indexes
	192	+rake db:mongoid:remove_undefined_indexes
191	193	rake assets:precompile
192	194	```
193	195
...	...
...	...	@@ -2,7 +2,8 @@ class NoticesController < ApplicationController
2	2
3	3	class ParamsError < StandardError; end
4	4
5		- skip_before_action :authenticate_user!, :only => :create
	5	+ skip_before_action :authenticate_user!, only: :create
	6	+ skip_before_filter :verify_authenticity_token, only: :create
6	7
7	8	rescue_from ParamsError, :with => :bad_params
8	9
...	...
...	...	@@ -22,7 +22,7 @@ class ProblemsController < ApplicationController
22	22	}
23	23
24	24	expose(:problem) {
25		- app.problems.find(params[:id])
	25	+ ProblemDecorator.new app.problems.find(params[:id])
26	26	}
27	27
28	28	expose(:all_errs) {
...	...	@@ -50,8 +50,9 @@ class ProblemsController < ApplicationController
50	50	def index; end
51	51
52	52	def show
53		- @notices = problem.notices.reverse_ordered.page(params[:notice]).per(1)
54		- @notice = @notices.first
	53	+ @notices = problem.object.notices.reverse_ordered
	54	+ .page(params[:notice]).per(1)
	55	+ @notice = NoticeDecorator.new @notices.first
55	56	@comment = Comment.new
56	57	end
57	58
...	...
...	...	@@ -0,0 +1,5 @@
	1	+class BacktraceDecorator < Draper::Decorator
	2	+ def lines
	3	+ @lines \|\|= object.lines.map { \|line\| BacktraceLineDecorator.new line }
	4	+ end
	5	+end
...	...
...	...	@@ -0,0 +1,88 @@
	1	+class BacktraceLineDecorator < Draper::Decorator
	2	+ EMPTY_STRING = ''.freeze
	3	+
	4	+ def in_app?
	5	+ object[:file].match Backtrace::IN_APP_PATH
	6	+ end
	7	+
	8	+ def number
	9	+ object[:number]
	10	+ end
	11	+
	12	+ def column
	13	+ object[:column]
	14	+ end
	15	+
	16	+ def file
	17	+ object[:file]
	18	+ end
	19	+
	20	+ def method
	21	+ object[:method]
	22	+ end
	23	+
	24	+ def file_relative
	25	+ file.to_s.sub(Backtrace::IN_APP_PATH, EMPTY_STRING)
	26	+ end
	27	+
	28	+ def file_name
	29	+ File.basename file
	30	+ end
	31	+
	32	+ def to_s
	33	+ column = object.try(:[], :column)
	34	+ "#{file_relative}:#{number}#{column.present? ? ":#{column}" : ''}"
	35	+ end
	36	+
	37	+ def link_to_source_file(app, &block)
	38	+ text = h.capture_haml(&block)
	39	+ link_to_in_app_source_file(app, text) \|\| text
	40	+ end
	41	+
	42	+ def path
	43	+ File.dirname(object[:file]).gsub(/^\.$/, '') + "/"
	44	+ end
	45	+
	46	+ def decorated_path
	47	+ file_relative.sub(Backtrace::GEMS_PATH, "<strong>\\1</strong>")
	48	+ end
	49	+
	50	+ private
	51	+ def link_to_in_app_source_file(app, text)
	52	+ return unless in_app?
	53	+ if file_name =~ /\.js$/
	54	+ link_to_hosted_javascript(app, text)
	55	+ else
	56	+ link_to_repo_source_file(app, text) \|\|
	57	+ link_to_issue_tracker_file(app, text)
	58	+ end
	59	+ end
	60	+
	61	+ def link_to_repo_source_file(app, text)
	62	+ link_to_github(app, text) \|\| link_to_bitbucket(app, text)
	63	+ end
	64	+
	65	+ def link_to_hosted_javascript(app, text)
	66	+ if app.asset_host?
	67	+ h.link_to(text, "#{app.asset_host}/#{file_relative}", :target => '_blank')
	68	+ end
	69	+ end
	70	+
	71	+ def link_to_github(app, text = nil)
	72	+ return unless app.github_repo?
	73	+ href = "%s#L%s" % [app.github_url_to_file(decorated_path + file_name), number]
	74	+ h.link_to(text \|\| file_name, href, :target => '_blank')
	75	+ end
	76	+
	77	+ def link_to_bitbucket(app, text = nil)
	78	+ return unless app.bitbucket_repo?
	79	+ href = "%s#cl-%s" % [app.bitbucket_url_to_file(decorated_path + file_name), number]
	80	+ h.link_to(text \|\| file_name, href, :target => '_blank')
	81	+ end
	82	+
	83	+ def link_to_issue_tracker_file(app, text = nil)
	84	+ return unless app.issue_tracker && app.issue_tracker.respond_to?(:url_to_file)
	85	+ href = app.issue_tracker.url_to_file(file_relative, number)
	86	+ h.link_to(text \|\| file_name, href, :target => '_blank')
	87	+ end
	88	+end
...	...
...	...	@@ -0,0 +1,4 @@
	1	+class NoticeDecorator < Draper::Decorator
	2	+ decorates_association :backtrace
	3	+ delegate_all
	4	+end
...	...