redmine_airbrake_backend 0.6.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd301e3a243a6ff787b2e7ecb17deb82b6fe5cd8
-  data.tar.gz: b4064e02518fcf19aae3d6bd2000ba4d55d20f7b
+  metadata.gz: a4627e9e6862c801b73cf31178ff43d50ba40fae
+  data.tar.gz: 0205349f0793115c48e62bdfd85401903ff94421
 SHA512:
-  metadata.gz: 5e927b9d60973da1f426a3e96f8b8692b2fa802473263dc53c94a8c14220d694eacb2b622eac8997865776c23efa920fcc08ec42976da34ff3c11808d5b18e0a
-  data.tar.gz: 55fb70954b0ca1a8c59da66f13a29a365ee68475c5850bfb97b2af2e4a741b2eba512660e4fbabe6c75735b3b62e92be9d39be2a98e92592f5da9b6464382d60
+  metadata.gz: 8f50e28e27bb16e93c8d1dbf56c24f0d049d7c7e9133f70170d47536c9e0eadd0c2c359c372dc7497c52f2d7d64d95ab47ca302fec5899d42e69566b03d1f844
+  data.tar.gz: 5d086483a614240d063d1cd04617b4aa71733bc731ead73051499011ddced147ce72af47a691fc4cbabdee62e835c4f093b976defe7ea2a962ef1e227d1c3e3f

data/CHANGELOG.md

@@ -1,8 +1,18 @@
 # Changelog
 
+## Unreleased
+### Changes
+  - Add support for new v3 JSON notices
+  - Add support for new v3 JSON iOS reports
+  - Dropped support for old notices and reports APIs
+  - Add permission to use Airbrake API. No longer bound to issue create permission
+  - Added new key *column* in backtrace to ID calculation
+  - Require Redmine >= 3.2.0
+  - Show hashes in table sections (no recursion)
+
 ## 0.6.1 (2015-04-28)
 ### Fixes
-  - Usage as redmine plugin additional to gem
+  - Usage as Redmine plugin additional to gem
 
 ## 0.6.0 (2015-04-22)
 ### Changed

data/README.md

@@ -8,7 +8,7 @@ This plugin provides the necessary API to use Redmine as an Airbrake backend.
 
 ## Installation
 
-Add this line to your Redmine Gemfile:
+Add this line to the Gemfile or Gemfile.local of your Redmine installation:
 ```ruby
 gem 'redmine_airbrake_backend'
 ```
@@ -19,7 +19,7 @@ $ bundle install
 $ rake redmine:plugins:migrate
 ```
 
-### Alternate installation
+### Alternate installation method
 
 Please see http://www.redmine.org/projects/redmine/wiki/Plugins for installation instructions.
 
@@ -30,8 +30,9 @@ Please see http://www.redmine.org/projects/redmine/wiki/Plugins for installation
   * Airbrake hash (String) (required)
   * Number of occurrences (Integer) (optional)
 3. Configure the plugin to use these 2 custom fields (Administration -> Plugins -> Airbrake -> Configure)
-4. Enable the project module (Airbrake) in your project settings (don't forget to add at least the Airbrake hash field to your project)
-5. Configure additional defaults under the settings tab (Airbrake)
+4. Check if the custom fields are assigned to the trackers you want to use with airbrake
+5. Enable the project module (Airbrake) in your project settings (don't forget to add at least the Airbrake notice ID custom field to your project if it is not a global field)
+6. Configure additional defaults under the settings tab per project (Airbrake)
 
 ## Client configuration
 
@@ -40,20 +41,20 @@ For a Rails application add the airbrake gem to your Gemfile:
 gem 'airbrake'
 ```
 
-And configure it, e.g. with a initializer `config/initializers/airbrake.rb`:
+And configure it, e.g. with an initializer `config/initializers/airbrake.rb`:
 ```ruby
-Airbrake.configure do |config|
-  config.api_key = {
-      project: 'redmine_project_identifier',    # the identifier you specified for your project in Redmine
-      api_key: 'redmine_api_key',               # the api key for a user which has permission to create issues in the project specified in the previous step
-      tracker: 'Bug',                           # the name or id of your desired tracker (optional if default is configured)
-      category: 'Development',                  # the name or id of a ticket category, optional
-      priority: 5,                              # the name or id of the priority for new tickets, optional.
-      assignee: 'admin'                         # the login or id of a user the ticket should get assigned to by default, optional
+Airbrake.configure do |c|
+  c.project_id     = 'redmine_project_identifier'
+  c.project_key    = {
+      key:      'redmine_api_key', # the api key for a user which has permission to create issues in the project specified in the previous step
+      tracker:  'Bug',             # the name or id of your desired tracker (optional if default is configured)
+      category: 'Development',     # the name or id of a ticket category, optional
+      priority: 5,                 # the name or id of the priority for new tickets, optional.
+      assignee: 'admin'            # the login or id of a user the ticket should get assigned to by default, optional
     }.to_json
-  config.host = 'my_redmine_host.com'           # the hostname your Redmine runs at
-  config.port = 443                             # the port your Redmine runs at
-  config.secure = true                          # sends data to your server using SSL, optional
+  c.host           = 'https://redmine.example.com/'
+  c.root_directory = Rails.root
+  c.environment    = 'production'
 end
 ```
 

data/app/controllers/airbrake_controller.rb

@@ -1,148 +1,191 @@
 require 'tempfile'
-require 'redmine_airbrake_backend/request/xml'
-require 'redmine_airbrake_backend/request/json'
+require 'redmine_airbrake_backend/error'
+
 
 # Controller with airbrake related stuff
 class AirbrakeController < ::ApplicationController
-  skip_before_filter :verify_authenticity_token
+  class InvalidRequest < StandardError; end
 
-  before_filter :authorize_airbrake
-  before_filter :handle_request
+  skip_before_action :verify_authenticity_token
 
-  after_filter :cleanup_tempfiles
+  prepend_before_action :parse_key
+  prepend_before_action :find_project
+  before_action :set_environment
+  before_action :authorize
 
-  rescue_from RedmineAirbrakeBackend::Request::Error, with: :render_bad_request
+  after_action :cleanup_tempfiles
 
-  private
+  rescue_from InvalidRequest, with: :render_bad_request
 
-  def authorize_airbrake
-    @project = @request.project
+  private
 
-    authorize(:issues, :create)
+  def find_project
+    @project = Project.find(params[:project_id])
   end
 
-  def render_bad_request(error)
-    ::Rails.logger.warn(error.message) if error.is_a?(RedmineAirbrakeBackend::Request::Invalid)
+  def parse_key
+    @key = JSON.parse(params[:key]).symbolize_keys #rescue nil
 
-    render text: error.message, status: :bad_request
+    # API key
+    raise InvalidRequest.new('No or invalid API key') if @key.blank? || @key[:key].blank?
+    params[:key] = @key[:key]
+
+    # Tracker
+    @tracker = record_for(@project.trackers, :tracker)
+    raise InvalidRequest.new('No or invalid tracker') if @tracker.blank?
+
+    # Notice ID field
+    raise InvalidRequest.new('Custom field for notice hash not available on selected tracker') if @tracker.custom_fields.find_by(id: notice_hash_field.id).blank?
+
+    # Category
+    @category = record_for(@project.issue_categories, :category)
+
+    # Priority
+    @priority = record_for(IssuePriority, :priority) || IssuePriority.default
+
+    # Assignee
+    @assignee = record_for(@project.users, :assignee, [:id, :login])
+
+    # Repository
+    @repository = @project.repositories.find_by(identifier: (@key[:repository] || ''))
+
+    # Type
+    @type = @key[:type] || (params[:context][:language].split('/', 2).first.downcase rescue nil)
   end
 
-  def parse_xml_request
-    request.body.rewind
+  def set_environment
+    @environment = params[:context][:environment].presence rescue nil
+  end
 
-    @request  = RedmineAirbrakeBackend::Request::XML.parse(request.body)
+  def render_bad_request(error)
+    ::Rails.logger.warn(error.message)
 
-    params[:key] = @request.api_key
+    render text: error.message, status: :bad_request
   end
 
-  def parse_json_request
-    @request  = RedmineAirbrakeBackend::Request::JSON.parse(params)
+  def record_for(on, key, fields = [:id, :name])
+    fields.each do |field|
+      val = on.find_by(field => @key[key])
+      return val if val.present?
+    end
 
-    params[:key] = @request.api_key
+    project_setting(key)
   end
 
-  def handle_request
-    @tempfiles = []
+  def global_setting(key)
+    Setting.plugin_redmine_airbrake_backend[key]
+  end
 
-    @results = []
+  def project_setting(key)
+    return nil if @project.airbrake_settings.blank?
 
-    @request.errors.each do |error|
-      issue = find_or_initialize_issue(error)
+    @project.airbrake_settings.send(key) if @project.airbrake_settings.respond_to?(key)
+  end
 
-      set_custom_field_values(issue, @request, error.airbrake_hash)
+  def custom_field(key)
+    @project.issue_custom_fields.find_by(id: global_setting(key)) || CustomField.find_by(id: global_setting(key), is_for_all: true)
+  end
 
-      reopen_issue(issue, error) if @request.reopen? && issue.status.is_closed?
+  def notice_hash_field
+    custom_field(:hash_field)
+  end
 
-      if issue.save
-        @results << {
-          issue: issue,
-          hash:  error.airbrake_hash
-        }
-      end
-    end
+  def occurrences_field
+    custom_field(:occurrences_field)
   end
 
   # Load or initialize issue by project, tracker and airbrake hash
   def find_or_initialize_issue(error)
-    issue_ids = CustomValue.where(customized_type: Issue.name, custom_field_id: @request.notice_hash_field.id, value: error.airbrake_hash).pluck(:customized_id)
+    issue_ids = CustomValue.where(customized_type: Issue.name, custom_field_id: notice_hash_field.id, value: error.id).pluck(:customized_id)
 
-    issue = Issue.where(id: issue_ids, project_id: @request.project.id, tracker_id: @request.tracker.id).first
+    issue = Issue.find_by(id: issue_ids, project_id: @project.id, tracker_id: @tracker.id)
 
     return issue if issue.present?
 
-    issue = initialize_issue(error)
-
-    add_error_attachments_to_issue(issue, error)
-
-    issue
+    initialize_issue(error)
   end
 
   def initialize_issue(error)
-    Issue.new(
+    issue = Issue.new(
         subject: error.subject,
-        project: @request.project,
-        tracker: @request.tracker,
+        project: @project,
+        tracker: @tracker,
         author: User.current,
-        category: @request.category,
-        priority: @request.priority,
+        category: @category,
+        priority: @priority,
         description: render_description(error),
-        assigned_to: @request.assignee
+        assigned_to: @assignee
       )
+
+    add_attachments_to_issue(issue, error)
+
+    issue
   end
 
-  def set_custom_field_values(issue, request, airbrake_hash)
+  def set_issue_custom_field_values(issue, error)
     custom_field_values = {}
 
-    # Error hash
-    custom_field_values[request.notice_hash_field.id] = airbrake_hash if issue.new_record?
+    # Error ID
+    custom_field_values[notice_hash_field.id] = error.id if issue.new_record?
 
     # Update occurrences
-    if request.occurrences_field.present?
-      occurrences_value = issue.custom_value_for(request.occurrences_field.id)
-      custom_field_values[request.occurrences_field.id] = ((occurrences_value ? occurrences_value.value.to_i : 0) + 1).to_s
+    if occurrences_field.present?
+      occurrences_value = issue.custom_value_for(occurrences_field.id)
+      custom_field_values[occurrences_field.id] = ((occurrences_value ? occurrences_value.value.to_i : 0) + 1).to_s
     end
 
     issue.custom_field_values = custom_field_values
   end
 
-  def add_error_attachments_to_issue(issue, error)
+  def add_attachments_to_issue(issue, error)
     return if error.attachments.blank?
 
-    error.attachments.each do |attachment_data|
-      filename = attachment_data[:filename].presence || Redmine::Utils.random_hex(16)
+    @tempfiles ||= []
+
+    error.attachments.each do |data|
+      filename = data[:filename].presence || Redmine::Utils.random_hex(16)
 
       file = Tempfile.new(filename)
       @tempfiles << file
 
-      file.write(attachment_data[:data])
+      file.write(data[:data])
       file.rewind
 
-      attachment          = Attachment.new(file: file)
-      attachment.author   = User.current
-      attachment.filename = filename
-
-      issue.attachments << attachment
+      issue.attachments << Attachment.new(file: file, author: User.current, filename: filename)
     end
   end
 
+  def reopen_issue?
+    reopen_regexp = project_setting(:reopen_regexp)
+
+    return false if reopen_regexp.blank?
+    return false if @environment.blank?
+
+    !!(@environment =~ /#{reopen_regexp}/i)
+  end
+
+  def issue_reopen_repeat_description?
+    !!project_setting(:reopen_repeat_description)
+  end
+
   def reopen_issue(issue, error)
-    return if @request.environment_name.blank?
+    return if @environment.blank?
 
-    desc = "*Issue reopened after occurring again in _#{@request.environment_name}_ environment.*"
-    desc << "\n\n#{render_description(error)}" if @request.reopen_repeat_description?
+    desc = "*Issue reopened after occurring again in _#{@environment}_ environment.*"
+    desc << "\n\n#{render_description(error)}" if issue_reopen_repeat_description?
 
     issue.status = issue.tracker.default_status
 
     issue.init_journal(User.current, desc)
 
-    add_error_attachments_to_issue(issue, error)
+    add_attachments_to_issue(issue, error)
   end
 
   def render_description(error)
-    locals = { request: @request, error: error }
+    locals = { error: error }
 
-    if template_exists?("airbrake/issue_description/#{@request.type}")
-      render_to_string("airbrake/issue_description/#{@request.type}", layout: false, locals: locals)
+    if template_exists?("airbrake/issue_description/#{@type}")
+      render_to_string("airbrake/issue_description/#{@type}", layout: false, locals: locals)
     else
       render_to_string('airbrake/issue_description/default', layout: false, locals: locals)
     end

data/app/controllers/airbrake_notice_controller.rb

@@ -1,25 +1,30 @@
 # Controller for airbrake notices
 class AirbrakeNoticeController < ::AirbrakeController
-  prepend_before_filter :parse_xml_request,  only: [:notice_xml]
-  prepend_before_filter :parse_json_request, only: [:notice_json]
+  accept_api_auth :notices
 
-  accept_api_auth :notice_xml, :notice_json
+  # Handle airbrake notices
+  def notices
+    @issue = nil
 
-  # Handle airbrake XML notices
-  def notice_xml
-    render xml: {
-      notice: {
-        id: (@results.first[:hash] rescue nil)
-      }
-    }
-  end
+    params[:errors].each do |e|
+      error = RedmineAirbrakeBackend::Error.new(e)
+
+      issue = find_or_initialize_issue(error)
+
+      set_issue_custom_field_values(issue, error)
+
+      reopen_issue(issue, error) if issue.persisted? && issue.status.is_closed? && reopen_issue?
+
+      @issue ||= issue if issue.save
+    end
 
-  # Handle airbrake JSON notices
-  def notice_json
-    render json: {
-      notice: {
-        id: (@results.first[:hash] rescue nil)
+    if @issue.present?
+      render json: {
+        id:  (CustomValue.find_by(customized_type: Issue.name, customized_id: @issue.id, custom_field_id: notice_hash_field.id).value rescue nil),
+        url: issue_url(@issue)
       }
-    }
+    else
+      render json: {}
+    end
   end
 end

data/app/controllers/airbrake_report_controller.rb

@@ -1,15 +1,29 @@
-# Controller for airbrake notices
+require 'redmine_airbrake_backend/ios_report'
+
+
+# Controller for airbrake reports
 class AirbrakeReportController < ::AirbrakeController
-  prepend_before_filter :parse_json_request
+  accept_api_auth :ios_reports
+
+  # Handle airbrake iOS reports
+  def ios_reports
+    error = RedmineAirbrakeBackend::IosReport.new(params[:report])
+
+    @issue = find_or_initialize_issue(error)
+
+    set_issue_custom_field_values(@issue, error)
+
+    reopen_issue(@issue, error) if @issue.persisted? && @issue.status.is_closed? && reopen_issue?
+
+    unless @issue.save
+      render json: {}
 
-  accept_api_auth :report
+      return
+    end
 
-  # Handle airbrake reports
-  def report
     render json: {
-      report: {
-        id: (@results.first[:hash] rescue nil)
-      }
+      id:  (CustomValue.find_by(customized_type: Issue.name, customized_id: @issue.id, custom_field_id: notice_hash_field.id).value rescue nil),
+      url: issue_url(@issue)
     }
   end
 end

data/app/helpers/airbrake_helper.rb

@@ -3,18 +3,13 @@ module AirbrakeHelper
   def format_table(data)
     lines = []
     data.each do |key, value|
-      next unless value.is_a?(String)
-      lines << "|@#{key}@|#{value.strip.blank? ? value : "@#{value}@"}|"
-    end
-    lines.join("\n")
-  end
+      next if value.blank?
 
-  # Wiki markup for logs
-  def format_log(data)
-    lines = []
-    data.each do |log|
-      next unless log.is_a?(Hash)
-      lines << "[#{log[:time].strftime('%F %T')}] #{log[:line]}"
+      if value.is_a?(String)
+        lines << "|@#{key}@|@#{value}@|"
+      elsif value.is_a?(Hash)
+        lines << "|@#{key}@|@#{value.map { |k, v| "#{k}: #{v}"}.join(',')}@|"
+      end
     end
     lines.join("\n")
   end
@@ -31,28 +26,28 @@ module AirbrakeHelper
     repository = repository_for_backtrace_element(element)
 
     if repository.blank?
-      if element[:number].blank?
-        markup = "@#{element[:file]}@"
+      if element.line.blank?
+        markup = "@#{element.file}@"
       else
-        markup = "@#{element[:file]}:#{element[:number]}@"
+        markup = "@#{element.file}:#{element.line}@"
       end
     else
       filename = filename_for_backtrace_element(element)
 
       if repository.identifier.blank?
-        markup = "source:\"#{filename}#L#{element[:number]}\""
+        markup = "source:\"#{filename}#L#{element.line}\""
       else
-        markup = "source:\"#{repository.identifier}|#{filename}#L#{element[:number]}\""
+        markup = "source:\"#{repository.identifier}|#{filename}#L#{element.line}\""
       end
     end
 
-    markup + " in ??<notextile>#{element[:method]}</notextile>??"
+    markup + " in ??<notextile>#{element.function}</notextile>??"
   end
 
   private
 
   def repository_for_backtrace_element(element)
-    return nil unless element[:file].start_with?('[PROJECT_ROOT]')
+    return nil unless element.file.start_with?('[PROJECT_ROOT]')
 
     filename = filename_for_backtrace_element(element)
 
@@ -62,18 +57,18 @@ module AirbrakeHelper
   def repositories_for_backtrace
     return @_bactrace_repositories unless @_bactrace_repositories.nil?
 
-    if @request.repository.present?
-      @_bactrace_repositories = [@request.repository]
+    if @repository.present?
+      @_bactrace_repositories = [@repository]
     else
-      @_bactrace_repositories = @request.project.repositories.to_a
+      @_bactrace_repositories = @project.repositories.to_a
     end
 
     @_bactrace_repositories
   end
 
   def filename_for_backtrace_element(element)
-    return nil if  element[:file].blank?
+    return nil if  element.file.blank?
 
-    element[:file][14..-1]
+    element.file[14..-1]
   end
 end