snitch_reporting 0.1.0 → 1.0.0

data/app/controllers/snitch_reporting/application_controller.rb

@@ -0,0 +1,4 @@
+module SnitchReporting
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/snitch_reporting/snitch_reports_controller.rb

@@ -0,0 +1,167 @@
+require_dependency "snitch_reporting/application_controller"
+
+class ::SnitchReporting::SnitchReportsController < ApplicationController
+  include ::SnitchReporting::ParamsHelper
+  helper ::SnitchReporting::SnitchReportHelper
+
+  layout "application"
+
+    def index
+      @reports = ::SnitchReporting::SnitchReport.order("last_occurrence_at DESC NULLS LAST").page(params[:page]).per(params[:per] || 25)
+
+      # set_report_preferences
+      filter_reports
+      # sort_reports
+    end
+
+    def show
+      @report = ::SnitchReporting::SnitchReport.find(params[:id])
+      occurrences = @report.occurrences.order(created_at: :asc)
+      @occurrence = occurrences.find_by(id: params[:occurrence]) || occurrences.last
+      occurrence_ids = occurrences.ids
+      occurrence_idx = occurrence_ids.index(@occurrence.id)
+      @paged_ids = {
+        first: occurrence_idx == 0 ? nil : occurrence_ids.first,
+        prev:  occurrence_idx == 0 ? nil : occurrence_ids[occurrence_idx - 1],
+        next:  occurrence_idx == occurrence_ids.length - 1 ? nil : occurrence_ids[occurrence_idx + 1],
+        last:  occurrence_idx == occurrence_ids.length - 1 ? nil : occurrence_ids.last,
+      }
+      # @formatted_occurrence_data = occurrences.staggered_occurrence_data
+      # @comments = @report.comments.order(created_at: :desc)
+    end
+
+
+    def update
+      @report = ::SnitchReporting::SnitchReport.find(params[:id])
+      # @report.acting_user = current_user
+      @report.update(report_params)
+
+      respond_to do |format|
+        format.html { redirect_to @report }
+        format.json
+      end
+    end
+  #
+  #   def comment
+  #     if @report.comments.create(comment_params.merge(author: current_credential).merge(params.permit(:resolved, :ignored)))
+  #       update_report_for(:resolved, comment: false)
+  #       update_report_for(:ignored, comment: false)
+  #
+  #       redirect_to snitch_report_path(@report)
+  #     else
+  #       redirect_to snitch_report_path(@report), alert: "Failed to comment. Please try again."
+  #     end
+  #   end
+  #
+    private
+
+    def report_params
+      params.require(:snitch_report).permit(
+        :ignored,
+        :resolved
+      )
+    end
+  #
+  #   def current_snitch_report
+  #     @report = SnitchReporting::SnitchReport.find(params[:id])
+  #   end
+  #
+  #   def update_report_for(status, comment: true)
+  #     raise "Value not allowed: #{status}" unless status.in?([:resolved, :ignored])
+  #
+  #     if true_param?(status)
+  #       @report.update("#{status}_at": Time.current, "#{status}_by": current_credential)
+  #       # @report.comments.create(author: current_credential, message: ">>> Marked as #{status} <<<", skip_notify: true, status => true) if comment
+  #     elsif params[status].present?
+  #       # @report.comments.create(author: current_credential, message: ">>> Marked as un#{status} <<<", skip_notify: true, status => false) if comment
+  #       @report.update("#{status}_at": nil, "#{status}_by": nil)
+  #     end
+  #   end
+  #
+  #   def report_params
+  #     params.require(:snitch_report).permit(
+  #       :source,
+  #       :severity,
+  #       :assigned_to_id,
+  #       :title,
+  #       :custom_details
+  #     )
+  #   end
+  #
+  #   def comment_params
+  #     params.require(:snitch_comment).permit(:message)
+  #   end
+  #
+  #   def set_report_preferences
+  #     @report_preferences = begin
+  #       preferences = JSON.parse(session[:report_preferences].presence || "{}").symbolize_keys
+  #
+  #       available_preferences = [:level_tags, :severity_tags, :source_tags, :resolved, :ignored]
+  #       available_preferences.each do |pref_key|
+  #         pref_val = params[pref_key]
+  #         preferences[pref_key] = pref_val if pref_val.present?
+  #         preferences.delete(pref_key) if pref_val == "all"
+  #       end
+  #
+  #       session[:report_preferences] = preferences.to_json
+  #       preferences
+  #     end
+  #   end
+    def set_filters
+      @filter_sets = {
+        status: {
+          default: :unresolved,
+          values: [:all, :resolved, :unresolved]
+        },
+        # assignee: {
+        #   default: :any,
+        #   values: [:any, :me, :not_me, :not_assigned]
+        # },
+        # log_level: {
+        #   default: :any,
+        #   values: [:any] + ::SnitchReporting::SnitchReport.log_levels.keys.map(&:to_sym)
+        # },
+        # ignored: {
+        #   default: :not_ignored,
+        #   values: [:all, :ignored, :not_ignored]
+        # }
+      }
+
+      @filters = @filter_sets.each_with_object({set_filters: {}}) do |(filter_name, filter_set), filters|
+        filters[filter_name] = filter_set[:default]
+        filter_in_param = params[filter_name].try(:to_sym)
+        next unless filter_in_param && filter_set[:values].include?(filter_in_param)
+        filters[filter_name] = filter_in_param
+        filters[:set_filters][filter_name] = filter_in_param
+      end
+    end
+
+    def filter_reports
+      set_filters
+
+      @reports = @reports.resolved if @filters[:status] == :resolved
+      @reports = @reports.unresolved if @filters[:status] == :unresolved
+      # @reports = @reports.search(@report_preferences[:by_fuzzy_text]) if @report_preferences[:by_fuzzy_text].present?
+      #
+      # @reports = @reports.by_level(@report_preferences[:level_tags]) if @report_preferences[:level_tags].present?
+      # @reports = @reports.by_severity(@report_preferences[:severity_tags]) if @report_preferences[:severity_tags].present?
+      # @reports = @reports.by_source(@report_preferences[:source_tags]) if @report_preferences[:source_tags].present?
+      #
+      # @reports = @report_preferences[:resolved].present? && truthy?(@report_preferences[:resolved]) ? @reports.resolved : @reports.unresolved
+      # @reports = @report_preferences[:ignored].present? && truthy?(@report_preferences[:ignored]) ? @reports.ignored : @reports.unignored
+    end
+  #
+  #   def sort_reports
+  #     order = sort_order || "desc"
+  #     @reports =
+  #     case params[:sort]
+  #     when "count"
+  #       @reports.order("snitch_reporting_snitch_reports.occurrence_count #{order} NULLS LAST, snitch_reporting_snitch_reports.last_occurrence_at DESC NULLS LAST")
+  #     when "last"
+  #       @reports.order("snitch_reporting_snitch_reports.last_occurrence_at #{order} NULLS LAST")
+  #     else
+  #       @reports.order("snitch_reporting_snitch_reports.last_occurrence_at DESC NULLS LAST")
+  #     end
+  #     @reports = @reports.page(params[:page]).per(params[:per])
+  #   end
+end

data/app/helpers/snitch_reporting/params_helper.rb

@@ -0,0 +1,38 @@
+module ::SnitchReporting::ParamsHelper
+  def sort_order
+    params[:order] == "desc" ? "desc" : "asc"
+  end
+
+  def toggled_sort_order
+    params[:order] == "desc" ? "asc" : "desc"
+  end
+
+  def truthy?(val)
+    val.to_s.downcase.in?(["true", "t", "1"])
+  end
+
+  def true_param?(*param_keys)
+    truthy?(params&.dig(*param_keys))
+  end
+
+  def svg(img, opts={})
+    ""
+  end
+
+  def sortable(link_text, param_string, options={})
+    if param_string.nil?
+      return link_to link_text.html_safe, options[:additional_params] || {}, class: "sortable #{options[:class]}" # rubocop:disable Rails/OutputSafety - We're certain this is safe because we're in control of all of the elements.
+    end
+    if params[:sort] == param_string
+      sorted_class = "sorted sortable-#{toggled_sort_order}"
+      default_order = toggled_sort_order
+    end
+
+    additional_params = options[:additional_params] || {}
+    additional_params = additional_params.permit!.to_h if additional_params.is_a?(ActionController::Parameters)
+    # rubocop:disable Rails/OutputSafety - We're certain this is safe because we're in control of all of the elements.
+    link_html = "#{link_text}<div class=\"sortable-arrows\">#{svg('icons/UpChevron.svg', class: 'desc')}#{svg('icons/DownChevron.svg', class: 'asc')}</div>".html_safe
+    # rubocop:enable Rails/OutputSafety
+    link_to link_html, { sort: param_string, order: default_order || "desc" }.reverse_merge(additional_params), class: "sortable #{sorted_class} #{options[:class]}"
+  end
+end

data/app/helpers/snitch_reporting/snitch_report_helper.rb

@@ -0,0 +1,2 @@
+module ::SnitchReporting::SnitchReportHelper
+end

data/app/models/snitch_reporting/service/json_wrapper.rb

@@ -0,0 +1,5 @@
+class ::SnitchReporting::Service::JSONWrapper
+  # Allows directly setting pre-stringified JSON.
+  def self.dump(obj); obj.is_a?(String) ? obj : JSON.dump(obj); end
+  def self.load(str); str.present? ? JSON.parse(str) : str; end
+end

data/app/models/snitch_reporting/snitch_comment.rb

@@ -0,0 +1,7 @@
+# belongs_to :snitch_report
+# belongs_to :author
+# text :body
+class SnitchReporting::SnitchComment < ApplicationRecord
+  belongs_to :report, class_name: "SnitchReporting::SnitchReport"
+  belongs_to :author, optional: true
+end

data/app/models/snitch_reporting/snitch_history.rb

@@ -0,0 +1,7 @@
+# belongs_to :snitch_report
+# belongs_to :user
+# text :text
+class SnitchReporting::SnitchHistory < ApplicationRecord
+  belongs_to :report, class_name: "SnitchReporting::SnitchReport"
+  belongs_to :user, optional: true
+end

data/app/models/snitch_reporting/snitch_occurrence.rb

@@ -0,0 +1,183 @@
+# belongs_to :snitch_report
+# string :http_method
+# string :url
+# text :user_agent
+# text :backtrace
+# text :context
+# text :params
+# text :headers
+
+class SnitchReporting::SnitchOccurrence < ApplicationRecord
+  attr_accessor :always_notify, :acting_user, :should_notify
+
+  belongs_to :report, class_name: "SnitchReporting::SnitchReport"
+
+  after_create :mark_occurrence
+
+  serialize :backtrace_data, ::SnitchReporting::Service::JSONWrapper
+  serialize :backtrace,      ::SnitchReporting::Service::JSONWrapper
+  serialize :context,        ::SnitchReporting::Service::JSONWrapper
+  serialize :params,         ::SnitchReporting::Service::JSONWrapper
+  serialize :headers,        ::SnitchReporting::Service::JSONWrapper
+
+  # def self.staggered_occurrence_data
+  #   data = {}
+  #   occurrence_data_keys = all.map { |occurrence| occurrence.details.try(:keys) }.compact
+  #   longest_key_array = occurrence_data_keys.max_by(&:length) # Need the longest because `zip` removes any objects longer than the initial.
+  #   staggered_keys = longest_key_array&.zip(*occurrence_data_keys)&.flatten(1)&.compact&.uniq || []
+  #
+  #   data[:keys] = staggered_keys
+  #   data[:details] = all.map do |occurrence|
+  #     detail_hash = {
+  #       id: occurrence.id,
+  #       details: []
+  #     }
+  #     occurrence_details = occurrence.details
+  #     data[:keys].each_with_index do |detail_key, idx|
+  #       occurrence_detail = occurrence_details[detail_key]
+  #       detail_hash[:details][idx] =
+  #         if occurrence_detail.is_a?(Array)
+  #           occurrence_detail.join("\n")
+  #         else
+  #           occurrence_detail.to_s
+  #         end
+  #     end
+  #     detail_hash
+  #   end
+  #
+  #   data
+  # end
+  #
+  # def from_data=(details_hash)
+  #   self.details = flatten_hash(details_hash)
+  # end
+
+  def backtrace=(trace_lines)
+    already_traced = []
+    self.backtrace_data = trace_lines.map do |trace_line|
+      next unless trace_line.include?("/app/") # && trace_line.exclude?("app/models/snitch_reporting")
+
+      joined_path = file_lines_from_backtrace(trace_line)
+      next if joined_path.include?(joined_path)
+      already_traced << joined_path
+
+      file_path, line_number = joined_path.split(":", 2)
+      {
+        file_path: remove_project_root(file_path),
+        line_number: line_number,
+        snippet: snippet_for_line(trace_line)
+      }
+    end.compact
+    super(trace_lines.map { |trace_line| remove_project_root(trace_line) })
+  end
+
+  def filtered_backtrace
+    backtrace_data&.map { |data| data&.dig(:file_path) }.compact
+  end
+
+  def remove_project_root(row)
+    row.gsub(Rails.root.to_s, "[PROJECT_ROOT]")
+  end
+
+  def file_lines_from_backtrace(backtrace_line)
+    backtrace_line[/(\/?\w+\/?)+(\.\w+)+:?\d*/]
+  end
+
+  def snippet_for_line(backtrace_line, line_count: 5)
+    file, num = backtrace_line.split(":")
+    first_line_number = num.to_i
+    offset_line_numbers = (line_count - 1) / 2
+    line_numbers = (first_line_number - offset_line_numbers - 1)..(first_line_number + offset_line_numbers - 1)
+
+    lines = File.open(file).read.split("\n").map.with_index { |line, idx| [line, idx + 1] }[line_numbers] rescue nil
+
+    whitespace_count = lines.map { |line, _idx| line[/\s*/].length }.min
+
+    lines.each_with_object({}) do |(line, idx), data|
+      data[idx] = line[whitespace_count..-1]
+    end
+  end
+  #
+  # def title
+  #   super.presence || "#{report.title} | Occurrence ##{id}"
+  # end
+  #
+  # def details
+  #   temp_details = super
+  #
+  #   temp_details.each do |detail_key, detail_val|
+  #     next unless detail_val.to_s.first.in?(["[", "{"])
+  #
+  #     begin
+  #       temp_details[detail_key] = JSON.parse(detail_val)
+  #     rescue JSON::ParserError
+  #       nil
+  #     end
+  #   end
+  #
+  #   temp_details
+  # end
+
+  def notify?
+    @should_notify ||= always_notify || report.resolved? || report.occurrence_count == 1
+  end
+
+  private
+
+  def mark_occurrence
+    notify? # Store ivar
+    report_updates = { last_occurrence_at: Time.current, resolved_at: nil }
+    report_updates[:first_occurrence_at] = Time.current if report.first_occurrence_at.nil?
+    report_updates[:occurrence_count] = report.occurrence_count.to_i + 1
+
+    report.update(report_updates)
+
+    tracker = report.tracker_for_date
+    now = Time.current
+    todays_occurrences = report.occurrences.where(created_at: now.beginning_of_day..now.end_of_day)
+    tracker.update(count: todays_occurrences.count + 1)
+  end
+
+  # def to_slack_attachment
+  #   details ||= {}
+  #   description = details[:description] || details[:error_description] || details[:error] || details[:explanation]
+  #   source = report.source.to_s.titleize
+  #   level = report.log_level.to_sym
+  #
+  #   color =
+  #     case level
+  #     when :debug   then "#F5F5F5"
+  #     when :info    then "#209CEE"
+  #     when :warn    then "#FFDD57"
+  #     when :error   then "#FF945B"
+  #     when :fatal   then "#FF1F35"
+  #     when :unknown then "#000000"
+  #     end
+  #   fields = []
+  #   fields << { title: "Level",       value: level,       short: true }  if level.present?
+  #   fields << { title: "Source",      value: source,      short: true }  if source.present?
+  #   fields << { title: "Description", value: description, short: false } if description.present?
+  #
+  #   {
+  #     pretext: report.resolved? ? "A previously resolved #{level} level error has occurred again:" : "A new #{level} level error has occurred:",
+  #     title: title,
+  #     fallback: "```#{filtered_backtrace.present? ? filtered_backtrace.first(5).join("\n") : description}```",
+  #     color: color,
+  #     title_link: custom_url_for(:helix, :bug_report_path, report_id),
+  #     text: filtered_backtrace.present? ? filtered_backtrace.first(10).join("\n") : description,
+  #     fields: fields,
+  #     footer: "Last occurred:",
+  #     ts: created_at.to_i
+  #   }
+  # end
+  #
+  # def flatten_hash(hash_to_flatten, hash_memo={}, ancestor_key_str=nil)
+  #   hash_to_flatten = hash_to_flatten[0] if hash_to_flatten.is_a?(Array) && hash_to_flatten.first.is_a?(Hash)
+  #   return hash_memo.merge!(ancestor_key_str => hash_to_flatten.to_s) unless hash_to_flatten.is_a?(Hash)
+  #   # If the current object is not a hash, we don't need to continue nesting, so set the current ancestor string as the final key.
+  #   hash_to_flatten.each { |key, hash_values| flatten_hash(hash_values, hash_memo, [ancestor_key_str, key].compact.join(".")) }
+  #   # Iterate through the hash, and pass each key as the ancestor into the current method to flatten lower level hashes.
+  #   hash_memo
+  #   # Return the current hash for memoization.
+  # end
+end

data/app/models/snitch_reporting/snitch_report.rb

@@ -0,0 +1,301 @@
+# text :error
+# text :message
+# integer :log_level
+# string :klass
+# string :action
+# text :tags
+# datetime :first_occurrence_at
+# datetime :last_occurrence_at
+# bigint :occurrence_count
+# belongs_to :assigned_to
+# datetime :resolved_at
+# belongs_to :resolved_by
+# datetime :ignored_at
+# belongs_to :ignored_by
+
+class SnitchReporting::SnitchReport < ApplicationRecord
+  attr_accessor :acting_user
+  has_many :occurrences, class_name: "SnitchReporting::SnitchOccurrence", foreign_key: :report_id
+  has_many :trackers, class_name: "SnitchReporting::SnitchTracker", foreign_key: :report_id
+  has_many :histories, class_name: "SnitchReporting::SnitchHistory", foreign_key: :report_id
+
+  # belongs_to :assigned_to
+  def assigned_to; end
+  # belongs_to :resolved_by
+  # belongs_to :ignored_by
+
+  scope :resolved,      -> { where.not(resolved_at: nil) }
+  scope :unresolved,    -> { where(resolved_at: nil) }
+  scope :ignored,       -> { where.not(ignored_at: nil) }
+  scope :unignored,     -> { where(ignored_at: nil) }
+  scope :by_level,      ->(*level_tags) { where(log_level: level_tags) }
+
+  enum log_level: {
+    debug:   1,
+    info:    2,
+    warn:    3,
+    error:   4,
+    fatal:   5,
+    unknown: 6
+  }
+
+  class << self
+    def debug(*args);   report(:debug,   args); end
+    def info(*args);    report(:info,    args); end
+    def warn(*args);    report(:warn,    args); end
+    def error(*args);   report(:error,   args); end
+    def fatal(*args);   report(:fatal,   args); end
+    def unknown(*args); report(:unknown, args); end
+
+    def report(log_level, *args)
+      exceptions, arg_hash, arg_values = format_args(args)
+      env, klass, base_exception = extract_base_variables(exceptions, arg_hash, arg_values)
+      always_notify = arg_hash.delete(:always_notify)
+
+      report_title = retrieve_report_title(base_exception, arg_hash)
+      report = retrieve_or_create_existing_report(log_level, santize_title(report_title), env, base_exception, arg_hash)
+      return SnitchReporting::SnitchReport.error("Failed to save report.", report.errors.full_messages) unless report.persisted?
+
+      report_data = gather_report_data(env, exceptions, arg_hash, arg_values)
+
+      occurrence = report.occurrences.create(
+        http_method: env[:REQUEST_METHOD],
+        url:         env[:REQUEST_URI],
+        user_agent:  env[:HTTP_USER_AGENT],
+        backtrace:   trace_from_exception(base_exception),
+        context:     report_data,
+        params:      env&.dig(:"action_controller.instance")&.params&.permit!&.to_h&.except(:action, :controller),
+        headers:     env&.reject { |k, v| k.to_s.include?(".") || !v.is_a?(String) },
+        always_notify: always_notify
+      )
+      return SnitchReporting::SnitchReport.error("Failed to save occurrence.", occurrence.errors.full_messages) unless occurrence.persisted?
+      occurrence
+    rescue StandardError => ex
+      env ||= {}
+      SnitchReporting::SnitchReport.fatal("Failed to create report. (#{ex.class})", env, ex)
+    end
+
+    def format_args(args)
+      args = [args].flatten.compact
+
+      exceptions = args.select { |arg| arg.is_a?(Exception) }
+      reduced_arrays = args.select { |arg| arg.is_a?(Array) }.reduce([], :concat)
+      reduced_values = args.select { |arg| [Array, Exception, Hash].all? { |klass| !arg.is_a?(klass) } }
+      arg_values = reduced_arrays + reduced_values
+
+      arg_hash = (args.select { |arg| arg.is_a?(Hash) }.inject(&:merge) || {}).deep_symbolize_keys
+      # This will remove duplicate keys in the case there are multiple hashes
+      #   passed in for some reason. I don't foresee this being an issue, but
+      #   if it ever proves to be, this is the spot to refactor.
+      [exceptions, arg_hash, arg_values]
+    end
+
+    def extract_base_variables(exceptions, arg_hash, _arg_values)
+      exceptions << arg_hash.delete(:exception) if arg_hash[:exception].present?
+      base_exception = exceptions.first || {} # TODO: Deal with other exceptions here
+      klass = arg_hash[:klass] || arg_hash[:class]
+      env = arg_hash.delete(:env) || {}
+
+      [env, klass, base_exception]
+    end
+
+    def trace_from_exception(exception)
+      trace = exception.try(:backtrace).presence
+      return trace if trace.present?
+      trace = caller.dup
+      trace.shift until trace.first.exclude?("snitch_reporting")
+      trace
+    end
+
+    def extract_relevant_ivars(report_data, kontroller)
+      set_user_vars_from_source(report_data, kontroller)
+    end
+
+    def set_user_vars_from_source(report_data, source)
+      user_vars = source.try(:instance_variables)&.select { |ivar_key| ivar_key.to_s.starts_with?("@current_") } || []
+      user_vars.each do |user_var|
+        begin
+          ivar = source.instance_variable_get(user_var)
+          next if ivar.blank?
+
+          report_data[user_var] = get_details_from_ivar(ivar)
+        rescue StandardError => ex
+          report_data[user_var] = "!-- Failed to retrieve data from user #{user_var}: #{ivar.try(:class).try(:name)} (#{ex.class}) --!"
+        end
+      end
+    end
+
+    def get_details_from_ivar(ivar)
+      return ivar.class.name if ivar.class.name.include?("Abilit")
+      case ivar.class.name
+      when "String", "Array", "Hash" then ivar
+      when "ActionController::Parameters" then ivar.to_json
+      when "ActiveRecord::Relation"
+        "#{ivar.klass} ids: [#{ivar.pluck(:id).join(', ')}]"
+      else
+        ivar.try(:to_data) || ivar.try(:to_json) || ivar.to_s.presence
+      end
+    end
+
+    def add_controller_data_to_report(report_data, env)
+      kontroller = env&.dig(:"action_controller.instance")
+      return if kontroller.blank?
+
+      extract_relevant_ivars(report_data, kontroller)
+
+      kontroller.instance_variables.each do |ivar_key|
+        begin
+          next if ivar_key.to_s.starts_with?("@current_") # Already extracted these in the above method
+          next if ivar_key.in?(ignored_kontroller_ivars)
+
+          ivar = kontroller.instance_variable_get(ivar_key)
+          next if ivar.blank?
+
+          report_data[ivar_key] = get_details_from_ivar(ivar)
+        rescue StandardError => ex
+          report_data[ivar_key] = "!-- Failed to retrieve data from variable #{ivar_key}: #{ivar.try(:class).try(:name)} (#{ex.class}) --!"
+        end
+      end
+    end
+
+    def retrieve_report_title(exception, arg_hash)
+      report_title = arg_hash[:title].presence
+      report_title ||= exception.try(:message).presence
+      report_title ||= exception.try(:body).presence
+      report_title ||= exception.try(:class).presence
+      report_title ||= (arg_hash[:klass] || arg_hash[:class]).presence
+      report_title ||= trace_from_exception(exception).find { |row| row.include?("/app/") }
+      report_title
+    end
+
+    def add_leftover_objects_to_report_data(report_data, exceptions, arg_hash, arg_values)
+      report_data[:exceptions] = exceptions.map { |ex| "#{ex.try(:class)}: #{ex.try(:message)}" } if exceptions.present?
+      report_data.merge!(arg_hash)
+      report_data[:details] = arg_values if arg_values.present?
+    end
+
+    def add_sanitized_env_information_to_report_data(report_data, env)
+      report_data[:env] = env.slice(*relevant_env_keys) if env.present?
+    end
+
+    def santize_title(report_title)
+      regex_find_numbers_and_words_with_numbers = /\w*\d[\d\w]*/
+      # We remove all numbers and words that have numbers in them so that we can
+      #   more easily group similar errors together, but often times errors have
+      #   unique ids, so we strip those out.
+      report_title.to_s.gsub(regex_find_numbers_and_words_with_numbers, "").presence
+    end
+
+    def retrieve_or_create_existing_report(log_level, sanitized_title, env, exception, arg_hash)
+      report_identifiable_data = {
+        error:     (exception.try(:class) || sanitized_title.presence).to_s,
+        message:   sanitized_title.presence,
+        log_level: log_level,
+        klass:     env&.dig(:"action_controller.instance").try(:class).to_s.split("::").last&.gsub("Controller", ""),
+        action:    env&.dig(:"action_controller.instance").try(:action_name)
+      }
+
+      report = find_by(report_identifiable_data) if sanitized_title.present?
+      # Not using find or create because the slug might be `nil`- in these
+      #   cases, we want to create a new report so that we don't falsely group
+      #   unrelated errors together.
+      report || create(report_identifiable_data)
+    end
+
+    def gather_report_data(env, exceptions, arg_hash, arg_values)
+      report_data = {}
+
+      add_controller_data_to_report(report_data, env)
+      add_leftover_objects_to_report_data(report_data, exceptions, arg_hash, arg_values)
+      add_sanitized_env_information_to_report_data(report_data, env)
+
+      report_data
+    end
+
+    def ignored_kontroller_ivars
+      [
+        :@_request,
+        :@_response,
+        :@_response,
+        :@_lookup_context,
+        :@_authorized,
+        :@_main_app,
+        :@_view_renderer,
+        :@_view_context_class,
+        :@_db_runtime,
+        :@marked_for_same_origin_verification
+      ]
+    end
+
+    def relevant_env_keys
+      [
+        :REQUEST_URI,
+        :REQUEST_METHOD,
+        :HTTP_REFERER,
+        :HTTP_USER_AGENT,
+        :PATH_INFO,
+        :HTTP_CONNECTION,
+        :REMOTE_USER,
+        :SERVER_NAME,
+        :QUERY_STRING,
+        :REMOTE_HOST,
+        :SERVER_PORT,
+        :HTTP_ACCEPT_ENCODING,
+        :HTTP_USER_AGENT,
+        :SERVER_PROTOCOL,
+        :HTTP_CACHE_CONTROL,
+        :HTTP_ACCEPT_LANGUAGE,
+        :HTTP_HOST,
+        :REMOTE_ADDR,
+        :SERVER_SOFTWARE,
+        :HTTP_KEEP_ALIVE,
+        :HTTP_REFERER,
+        :HTTP_ACCEPT_CHARSET,
+        :GATEWAY_INTERFACE,
+        :HTTP_ACCEPT,
+        :HTTP_COOKIE
+      ]
+    end
+  end
+
+  def tracker_for_date(date=Date.today)
+    trackers.tracker_for_date(date)
+  end
+
+  def resolved?; resolved_at?; end
+  def ignored?; ignored_at?; end
+
+  def ignored=(bool)
+    if bool.to_s.downcase.in?(["t", "true", "1", "y", "yes"])
+      self.ignored_at ||= Time.current
+      # self.ignored_by ||= acting_user
+    else
+      self.ignored_at = nil
+      # self.ignored_by = nil
+    end
+  end
+
+  def resolved=(bool)
+    if bool.to_s.downcase.in?(["t", "true", "1", "y", "yes"])
+      self.resolved_at ||= Time.current
+      # self.resolved_by ||= acting_user
+    else
+      self.resolved_at = nil
+      # self.resolved_by = nil
+    end
+  end
+
+  # def title
+  #   super.presence || slug.presence || "Report ##{id}"
+  # end
+  #
+  # def timeago
+  #   "Not implemented"
+  #   # timeago_in_words(last_occurrence_at)
+  # end
+  #
+  # def slack_channel
+  #   "Not implemented"
+  #   # "error-reporting"
+  # end
+end