redmine_airbrake_backend 1.2.1 → 1.2.2

data/app/controllers/concerns/airbrake_issue_handling.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+# Handling for creating / updating issues
+module AirbrakeIssueHandling
+  extend ActiveSupport::Concern
+  include AirbrakeAttachments
+
+  private
+
+  def reopen_issue_if_qualifies(issue, notice)
+    return unless issue.persisted?
+    return unless issue.status.is_closed?
+    return unless reopen_issue?(notice)
+
+    reopen_issue(issue, notice)
+  end
+
+  def create_issue!
+    return if @notice.blank?
+    return if @notice.errors.blank?
+
+    @issue = find_or_initialize_issue(@notice)
+
+    set_issue_custom_field_values(@issue, @notice)
+
+    reopen_issue_if_qualifies(@issue, @notice)
+
+    @issue = nil unless @issue.save
+  end
+
+  # Load or initialize issue by project, tracker and airbrake hash
+  def find_or_initialize_issue(notice)
+    issue_ids = CustomValue
+                .where(customized_type: Issue.name, custom_field_id: notice_hash_field.id, value: notice.id)
+                .pluck(:customized_id)
+
+    issue = Issue.find_by(id: issue_ids, project_id: @project.id, tracker_id: @tracker.id)
+
+    return issue if issue.present?
+
+    initialize_issue(notice)
+  end
+
+  def initialize_issue(notice)
+    issue = Issue.new(
+      subject:     notice.subject,
+      project:     @project,
+      tracker:     @tracker,
+      author:      User.current,
+      category:    @category,
+      priority:    @priority,
+      description: render_description(notice),
+      assigned_to: @assignee
+    )
+
+    add_attachments_to_issue(issue, notice)
+
+    issue
+  end
+
+  def update_occurrences(issue, custom_field_values)
+    return if occurrences_field.blank?
+
+    current_value = issue.custom_value_for(occurrences_field.id)
+    current_value = current_value ? current_value.value.to_i : 0
+
+    custom_field_values[occurrences_field.id] = (current_value + 1).to_s
+  end
+
+  def set_issue_custom_field_values(issue, notice)
+    custom_field_values = {}
+
+    # Error ID
+    custom_field_values[notice_hash_field.id] = notice.id if issue.new_record?
+
+    # Update occurrences
+    update_occurrences(issue, custom_field_values)
+
+    issue.custom_field_values = custom_field_values
+  end
+
+  def reopen_issue?(notice)
+    reopen_regexp = project_setting(:reopen_regexp)
+
+    return false if reopen_regexp.blank?
+    return false if notice.environment_name.blank?
+
+    notice.environment_name =~ /#{reopen_regexp}/i
+  end
+
+  def issue_reopen_repeat_description?
+    project_setting(:reopen_repeat_description)
+  end
+
+  def reopen_issue(issue, notice)
+    return if notice.environment_name.blank?
+
+    desc = "*Issue reopened after occurring again in _#{notice.environment_name}_ environment.*"
+    desc << "\n\n#{render_description(notice)}" if issue_reopen_repeat_description?
+
+    issue.status = issue.tracker.default_status
+
+    issue.init_journal(User.current, desc)
+
+    add_attachments_to_issue(issue, notice)
+  end
+end

data/app/controllers/concerns/airbrake_rendering.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Rendering of issue description
+module AirbrakeRendering
+  extend ActiveSupport::Concern
+
+  def render_description(notice)
+    locals = { notice: notice }
+
+    if template_exists?("airbrake/issue_description/#{notice.type}")
+      render_to_string("airbrake/issue_description/#{notice.type}", layout: false, locals: locals)
+    else
+      render_to_string('airbrake/issue_description/default', layout: false, locals: locals)
+    end
+  end
+end

data/app/helpers/airbrake_helper.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Helper methods for rendering airbrake errors
 module AirbrakeHelper
   # Error title
   def airbrake_error_title(error)
@@ -36,21 +39,11 @@ module AirbrakeHelper
   def airbrake_format_backtrace_element(element)
     repository = airbrake_repository_for_backtrace_element(element)
 
-    if repository.blank?
-      if element.line.blank?
-        markup = "@#{element.file}@"
-      else
-        markup = "@#{element.file}:#{element.line}@"
-      end
-    else
-      filename = airbrake_filename_for_backtrace_element(element)
-
-      if repository.identifier.blank?
-        markup = "source:\"#{filename}#L#{element.line}\""
-      else
-        markup = "source:\"#{repository.identifier}|#{filename}#L#{element.line}\""
-      end
-    end
+    markup = if repository.blank?
+               airbrake_backtrace_element_markup_without_repository(element)
+             else
+               airbrake_backtrace_element_markup_with_repository(repository, element)
+             end
 
     markup + " in ??<notextile>#{element.function}</notextile>??"
   end
@@ -64,6 +57,7 @@ module AirbrakeHelper
   private
 
   def airbrake_repository_for_backtrace_element(element)
+    return nil unless element.file.present?
     return nil unless element.file.start_with?('[PROJECT_ROOT]')
 
     filename = airbrake_filename_for_backtrace_element(element)
@@ -72,20 +66,38 @@ module AirbrakeHelper
   end
 
   def airbrake_repositories_for_backtrace
-    return @_bactrace_repositories unless @_bactrace_repositories.nil?
+    return @bactrace_repositories unless @bactrace_repositories.nil?
 
-    if @repository.present?
-      @_bactrace_repositories = [@repository]
-    else
-      @_bactrace_repositories = @project.repositories.to_a
-    end
+    @bactrace_repositories = if @repository.present?
+                               [@repository]
+                             else
+                               @project.repositories.to_a
+                             end
 
-    @_bactrace_repositories
+    @bactrace_repositories
   end
 
   def airbrake_filename_for_backtrace_element(element)
-    return nil if  element.file.blank?
+    return nil if element.file.blank?
 
     element.file[14..-1]
   end
+
+  def airbrake_backtrace_element_markup_without_repository(element)
+    if element.line.blank?
+      "@#{element.file}@"
+    else
+      "@#{element.file}:#{element.line}@"
+    end
+  end
+
+  def airbrake_backtrace_element_markup_with_repository(repository, element)
+    filename = airbrake_filename_for_backtrace_element(element)
+
+    if repository.identifier.blank?
+      "source:\"#{filename}#L#{element.line}\""
+    else
+      "source:\"#{repository.identifier}|#{filename}#L#{element.line}\""
+    end
+  end
 end

data/app/models/airbrake_project_setting.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Project-specific settings for airbrake
 class AirbrakeProjectSetting < ActiveRecord::Base
   belongs_to :project

data/bin/rails

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
-# This command will automatically be run when you run "rails" with Rails 4 gems installed from the root of your application.
+# frozen_string_literal: true
 
-ENGINE_ROOT = File.expand_path('../..', __FILE__)
-ENGINE_PATH = File.expand_path('../../lib/redmine_airbrake_backend/engine', __FILE__)
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/redmine_airbrake_backend/engine', __dir__)
 
 require 'rails/all'
 require 'rails/engine/commands'

data/config/routes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Rails.application.routes.draw do
   # api
   post '/api/v3/projects/:project_id/notices'     => 'airbrake_notice#notices'

data/db/migrate/20130708102357_create_airbrake_project_settings.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Create airbrake project settings
 class CreateAirbrakeProjectSettings < ActiveRecord::Migration
   def up
     create_table :airbrake_project_settings do |t|

data/db/migrate/20131003151228_add_reopen_repeat_description.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Add repeat description configuration to Airbrake project settings
 class AddReopenRepeatDescription < ActiveRecord::Migration
   def up
     add_column :airbrake_project_settings, :reopen_repeat_description, :boolean

data/lib/redmine_airbrake_backend.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'redmine_airbrake_backend/engine'
 
+# Airbrake backend for Redmine
 module RedmineAirbrakeBackend
   def self.directory
     File.expand_path(File.join(File.dirname(__FILE__), '..'))

data/lib/redmine_airbrake_backend/backtrace_element.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'digest/md5'
 
 module RedmineAirbrakeBackend
@@ -20,15 +22,15 @@ module RedmineAirbrakeBackend
     end
 
     def checksum
-      @_checksum ||= Digest::MD5.hexdigest("#{@file}|#{normalize_function_name(@function)}|#{@line}|#{@column}")
+      @checksum ||= Digest::MD5.hexdigest("#{@file}|#{normalized_function_name}|#{@line}|#{@column}")
     end
 
     private
 
-    def normalize_function_name(function_name)
+    def normalized_function_name
       name = @function
-        .downcase
-        .gsub(/([\d_]+$)?/, '') # ruby blocks
+             .downcase
+             .gsub(/([\d_]+$)?/, '') # ruby blocks
 
       RedmineAirbrakeBackend.filter_hex_values(name)
     end

data/lib/redmine_airbrake_backend/engine.rb

@@ -1,51 +1,53 @@
+# frozen_string_literal: true
+
 require 'redmine_airbrake_backend/version'
 
 module RedmineAirbrakeBackend
+  # Engine for Airbrake integration into Redmine
   class Engine < ::Rails::Engine
-    initializer 'redmine_airbrake_backend.register_redmine_plugin', after: 'load_config_initializers' do |app|
-      register_redmine_plugin
+    initializer 'airbrake_backend.register_redmine_plugin', after: 'load_config_initializers' do |_|
+      RedmineAirbrakeBackend::Engine.register_redmine_plugin
     end
 
-    initializer 'redmine_airbrake_backend.apply_patches', after: 'redmine_airbrake_backend.register_redmine_plugin' do |app|
+    initializer 'airbrake_backend.apply_patches', after: 'airbrake_backend.register_redmine_plugin' do |_|
       ActionDispatch::Callbacks.to_prepare do
-        require_dependency 'redmine_airbrake_backend/patches/project' unless defined?(RedmineAirbrakeBackend::Patches::Project)
-        require_dependency 'redmine_airbrake_backend/patches/tracker' unless defined?(RedmineAirbrakeBackend::Patches::Tracker)
-        require_dependency 'redmine_airbrake_backend/patches/issue_category' unless defined?(RedmineAirbrakeBackend::Patches::IssueCategory)
-        require_dependency 'redmine_airbrake_backend/patches/issue_priority' unless defined?(RedmineAirbrakeBackend::Patches::IssuePriority)
-        require_dependency 'redmine_airbrake_backend/patches/projects_helper' unless defined?(RedmineAirbrakeBackend::Patches::ProjectsHelper)
-
-        RedmineAirbrakeBackend::Engine.apply_patch(Project, RedmineAirbrakeBackend::Patches::Project)
-        RedmineAirbrakeBackend::Engine.apply_patch(Tracker, RedmineAirbrakeBackend::Patches::Tracker)
-        RedmineAirbrakeBackend::Engine.apply_patch(IssueCategory, RedmineAirbrakeBackend::Patches::IssueCategory)
-        RedmineAirbrakeBackend::Engine.apply_patch(IssuePriority, RedmineAirbrakeBackend::Patches::IssuePriority)
-        RedmineAirbrakeBackend::Engine.apply_patch(ProjectsHelper, RedmineAirbrakeBackend::Patches::ProjectsHelper)
+        RedmineAirbrakeBackend::Engine.add_redmine_patch('Project')
+        RedmineAirbrakeBackend::Engine.add_redmine_patch('Tracker')
+        RedmineAirbrakeBackend::Engine.add_redmine_patch('IssueCategory')
+        RedmineAirbrakeBackend::Engine.add_redmine_patch('IssuePriority')
+        RedmineAirbrakeBackend::Engine.add_redmine_patch('ProjectsHelper')
       end
     end
 
-    def apply_patch(clazz, patch)
-      clazz.send(:include, patch) unless clazz.included_modules.include?(patch)
-    end
-
-    private
-
     def register_redmine_plugin
       Redmine::Plugin.register :redmine_airbrake_backend do
         name             'Airbrake Backend'
         author           'Florian Schwab'
-        author_url       'https://github.com/ydkn'
+        author_url       'https://ydkn.de'
         description      'Airbrake Backend for Redmine'
-        url              'https://github.com/ydkn/redmine_airbrake_backend'
+        url              'https://gitlab.com/ydkn/redmine_airbrake_backend'
         version          ::RedmineAirbrakeBackend::VERSION
-        requires_redmine version_or_higher: '3.2.0'
+        requires_redmine version_or_higher: '3.4.0'
         directory        RedmineAirbrakeBackend.directory
 
         project_module :airbrake do
-          permission :airbrake, { airbrake_notice: [:notices], airbrake_report: [:ios_reports] }
-          permission :manage_airbrake, { airbrake: [:update] }
+          permission :airbrake, airbrake_notice: [:notices], airbrake_report: [:ios_reports]
+          permission :manage_airbrake, airbrake: [:update]
         end
 
         settings default: { hash_field: '', occurrences_field: '' }, partial: 'settings/airbrake'
       end
     end
+
+    def add_redmine_patch(clazz_name)
+      require_dependency "redmine_airbrake_backend/patches/#{clazz_name.underscore}"
+
+      clazz       = "::#{clazz_name}".constantize
+      patch_clazz = "::RedmineAirbrakeBackend::Patches::#{clazz_name}".constantize
+
+      return if clazz.included_modules.include?(patch_clazz)
+
+      clazz.send(:include, patch_clazz)
+    end
   end
 end

data/lib/redmine_airbrake_backend/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'digest/md5'
 require 'redmine_airbrake_backend/backtrace_element'
 

data/lib/redmine_airbrake_backend/ios_report.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'redmine_airbrake_backend/notice'
 
 module RedmineAirbrakeBackend
@@ -6,16 +8,15 @@ module RedmineAirbrakeBackend
     def initialize(options)
       error, application, attachments = self.class.parse(options[:report])
 
-      super({
-          errors:      [Error.new(error)],
-          context:     options[:context],
-          application: application,
-          attachments: attachments
-        })
+      super(
+        errors:      [Error.new(error)],
+        context:     options[:context],
+        application: application,
+        attachments: attachments
+      )
     end
 
-    private
-
+    # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
     def self.parse(data)
       error       = { backtrace: [] }
       application = {}
@@ -27,7 +28,9 @@ module RedmineAirbrakeBackend
       indicent_identifier  = nil
 
       data.split("\n").each do |line|
-        header_finished = true if line =~ /^(Application Specific Information|Last Exception Backtrace|Thread \d+( Crashed)?):$/
+        if line.match?(/^(Application Specific Information|Last Exception Backtrace|Thread \d+( Crashed)?):$/)
+          header_finished = true
+        end
 
         unless header_finished
           ii = parse_header_line(line, error, application)
@@ -47,26 +50,22 @@ module RedmineAirbrakeBackend
           error[:backtrace] << backtrace if backtrace
         end
 
-        crashed_thread = true if error[:backtrace].compact.blank? && line =~ /^(Last Exception Backtrace|Thread \d+ Crashed):$/
+        if error[:backtrace].compact.blank? && line.match?(/^(Last Exception Backtrace|Thread \d+ Crashed):$/)
+          crashed_thread = true
+        end
 
         next_line_is_message = true if line =~ /^Application Specific Information:$/
       end
 
       return nil if error.blank?
 
-      attachments << {
-        filename: "#{indicent_identifier}.crash",
-        data:     data
-      } if indicent_identifier.present?
+      attachments << { filename: "#{indicent_identifier}.crash", data: data } if indicent_identifier.present?
 
       [error, application, attachments]
     end
+    # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
 
-    def self.parse_header_line(line, error, application)
-      key, value = line.split(':', 2).map { |s| s.strip }
-
-      return nil if key.blank? || value.blank?
-
+    def self.handle_header(key, value, error, application)
       case key
       when 'Exception Type'
         error[:type] = value
@@ -83,6 +82,14 @@ module RedmineAirbrakeBackend
       nil
     end
 
+    def self.parse_header_line(line, error, application)
+      key, value = line.split(':', 2).map(&:strip)
+
+      return nil if key.blank? || value.blank?
+
+      handle_header(key, value, error, application)
+    end
+
     def self.parse_message(line, error)
       error[:message] = line
 
@@ -95,15 +102,13 @@ module RedmineAirbrakeBackend
     end
 
     def self.parse_backtrace_element(line)
-      if line =~ /^(\d+)\s+([^\s]+)\s+(0x[0-9a-f]+)\s+(.+) \+ (\d+)$/
-        {
-          file:     Regexp.last_match(2),
-          function: Regexp.last_match(4),
-          line:     Regexp.last_match(5)
-        }
-      else
-        nil
-      end
+      return nil unless line =~ /^(\d+)\s+([^\s]+)\s+(0x[0-9a-f]+)\s+(.+) \+ (\d+)$/
+
+      {
+        file:     Regexp.last_match(2),
+        function: Regexp.last_match(4),
+        line:     Regexp.last_match(5)
+      }
     end
   end
 end