redmine_airbrake_backend 0.4.3 → 0.5.0

data/lib/redmine_airbrake_backend/request/json.rb

@@ -0,0 +1,73 @@
+require 'redmine_airbrake_backend/request'
+
+module RedmineAirbrakeBackend
+  class Request
+    # Represents a JSON request received by airbrake
+    class JSON < ::RedmineAirbrakeBackend::Request
+      # Creates a request from a parsed json request
+      def self.parse(parsed_json_data)
+        raise Invalid if parsed_json_data.blank?
+
+        context  = parse_plain_section(parsed_json_data[:context])
+        params   = parse_plain_section(parsed_json_data[:params])
+        notifier = parse_plain_section(parsed_json_data[:notifier])
+        request  = parse_plain_section(parsed_json_data[:request])
+        env      = parse_plain_section(parsed_json_data[:environment])
+        config   = parsed_json_data[:key]
+
+        errors = []
+
+        (parsed_json_data[:errors] || []).each do |error_data|
+          error = parse_error(error_data)
+          errors << ::RedmineAirbrakeBackend::Error.new(error) if error.present?
+        end
+
+        report = parse_report(parsed_json_data[:type], parsed_json_data[:report])
+        errors << ::RedmineAirbrakeBackend::Error.new(report) if report.present?
+
+        errors.compact!
+
+        raise Invalid.new('No error or report found') if errors.blank?
+
+        new(config, context: context, params: params, notifier: notifier, errors: errors, request: request, env: env)
+      end
+
+      private
+
+      def self.parse_plain_section(section_data)
+        return {} if section_data.blank?
+
+        section_data.symbolize_keys
+      end
+
+      def self.parse_error(error_data)
+        return nil if error_data.blank?
+
+        error             = {}
+        error[:type]      = error_data[:type]
+        error[:message]   = error_data[:message]
+        error[:backtrace] = error_data[:backtrace].map do |backtrace_element|
+          {
+            line:   backtrace_element[:line].to_i,
+            file:   backtrace_element[:file],
+            method: (backtrace_element[:method] || backtrace_element[:function])
+          }
+        end
+
+        error
+      end
+
+      def self.parse_report(type, report_data)
+        return nil if report_data.blank?
+
+        require "redmine_airbrake_backend/report/#{type}"
+
+        clazz = "RedmineAirbrakeBackend::Report::#{type.to_s.camelize}".constantize rescue nil
+
+        return nil if clazz.blank?
+
+        clazz.parse(report_data)
+      end
+    end
+  end
+end

data/lib/redmine_airbrake_backend/request/xml.rb

@@ -0,0 +1,121 @@
+require 'json'
+require 'hpricot'
+require 'redmine_airbrake_backend/request'
+
+module RedmineAirbrakeBackend
+  class Request
+    # Represents a XML request received by airbrake
+    class XML < ::RedmineAirbrakeBackend::Request
+      # Supported airbrake api versions
+      SUPPORTED_API_VERSIONS = %w(2.4)
+
+      class UnsupportedVersion < Error; end
+
+      # Creates a notice from an airbrake xml request
+      def self.parse(xml_data)
+        doc = Hpricot::XML(xml_data) rescue nil
+        raise Invalid if doc.blank?
+
+        notice = doc.at('notice')
+        raise Invalid if notice.blank?
+
+        # Version
+        version = notice.attributes['version']
+        raise Invalid.new('No version') if version.blank?
+        raise UnsupportedVersion.new(version) unless SUPPORTED_API_VERSIONS.include?(version)
+
+        error_data = parse_error(notice)
+        raise Invalid.new('No error found') if error_data.blank?
+        error = RedmineAirbrakeBackend::Error.new(error_data)
+
+        notifier = convert_element(notice.at('notifier'))
+        request  = parse_request(notice)
+        env      = convert_element(notice.at('server-environment'))
+        config   = notice.at('api-key').inner_text
+
+        new(config, notifier: notifier, errors: [error], request: request, env: env)
+      end
+
+      private
+
+      def self.parse_error(notice_doc)
+        error = convert_element(notice_doc.at('error'))
+
+        # map class to type
+        error[:type] ||= error[:class]
+        error.delete(:class)
+
+        error[:backtrace] = format_backtrace(error[:backtrace])
+
+        error
+      end
+
+      def self.parse_request(notice_doc)
+        request = convert_element(notice_doc.at('request'))
+
+        if request.present? && request[:session].present?
+          request[:session][:log] = request[:session][:log].present? ? format_session_log(request[:session][:log]) : nil
+        end
+
+        request
+      end
+
+      def self.convert_element(elem)
+        return nil if elem.nil?
+        return elem.children.first.inner_text if !elem.children.nil? && elem.children.count == 1 && elem.children.first.is_a?(Hpricot::Text)
+        return elem.attributes.to_hash.symbolize_keys if elem.children.nil?
+        return convert_var_elements(elem.children) if elem.children.count == elem.children.select { |c| c.name == 'var' }.count
+
+        h = {}
+        elem.children.each do |e|
+          key = format_hash_key(e.name)
+          if h.key?(key)
+            h[key] = [h[key]] unless h[key].is_a?(Array)
+            h[key] << convert_element(e)
+          else
+            h[key] = convert_element(e)
+          end
+        end
+        h.delete_if { |k, v| k.strip.blank? }
+        h.symbolize_keys
+      end
+
+      def self.convert_var_elements(elements)
+        vars = {}
+        elements.each do |elem|
+          vars[format_hash_key(elem.attributes['key'])] = elem.inner_text
+        end
+        vars.delete_if { |k, v| k.strip.blank? }
+        vars.symbolize_keys
+      end
+
+      def self.format_hash_key(key)
+        key.to_s.gsub(/-/, '_')
+      end
+
+      def self.ensure_hash_array(data)
+        return nil if data.blank?
+
+        d = (data.is_a?(Array) ? data : [data]).compact
+        d.reject! { |e| !e.is_a?(Hash) }
+        d.blank? ? nil : d
+      end
+
+      def self.format_backtrace(backtrace)
+        ensure_hash_array(backtrace).first[:line] rescue nil
+      end
+
+      def self.format_session_log(log)
+        log = ::JSON.parse(log) rescue nil
+
+        log = ensure_hash_array(log)
+        return nil if log.blank?
+
+        log.map! { |l| l.symbolize_keys!; l[:time] = (Time.parse(l[:time]) rescue nil); l }
+        log.reject! { |l| l[:time].blank? }
+
+        log.blank? ? nil : log
+      end
+    end
+  end
+end

data/lib/redmine_airbrake_backend/version.rb

@@ -1,3 +1,4 @@
 module RedmineAirbrakeBackend
-  VERSION = '0.4.3'
+  # Version of this gem
+  VERSION = '0.5.0'
 end

data/redmine_airbrake_backend.gemspec

@@ -1,5 +1,5 @@
 # coding: utf-8
-$:.push File.expand_path('../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
 
 require 'redmine_airbrake_backend/version'
 
@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = RedmineAirbrakeBackend::VERSION
   spec.authors       = ['Florian Schwab']
   spec.email         = ['me@ydkn.de']
-  spec.description   = %q{Plugin which adds Airbrake support to Redmine}
-  spec.summary       = %q{This plugin provides the necessary API to use Redmine as a Airbrake backend}
+  spec.description   = %q(Plugin which adds Airbrake support to Redmine)
+  spec.summary       = %q(This plugin provides the necessary API to use Redmine as a Airbrake backend)
   spec.homepage      = 'https://github.com/ydkn/redmine_airbrake_backend'
   spec.license       = 'MIT'
 

data/test/unit/notice_test.rb

@@ -1,7 +1,6 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 class NoticeTest < ActiveSupport::TestCase
-
   test 'parse' do
     api_key = {
       api_key: 'foobar',
@@ -48,7 +47,6 @@ class NoticeTest < ActiveSupport::TestCase
   private
 
   def prepare_xml(xml_data)
-    xml_data.split("\n").map{|l| l.strip}.join('')
+    xml_data.split("\n").map { |l| l.strip }.join('')
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redmine_airbrake_backend
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Florian Schwab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-20 00:00:00.000000000 Z
+date: 2014-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -89,14 +89,17 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - Gemfile
+- Gemfile.lock
 - MIT-LICENSE
 - README.md
 - Rakefile
 - app/controllers/airbrake_controller.rb
+- app/controllers/airbrake_notice_controller.rb
 - app/controllers/airbrake_project_settings_controller.rb
+- app/controllers/airbrake_report_controller.rb
 - app/helpers/airbrake_helper.rb
 - app/models/airbrake_project_setting.rb
-- app/views/airbrake/_issue_description.erb
+- app/views/airbrake/issue_description/default.erb
 - app/views/projects/settings/_airbrake.html.erb
 - app/views/settings/_airbrake.html.erb
 - bin/rails
@@ -107,12 +110,16 @@ files:
 - db/migrate/20131003151228_add_reopen_repeat_description.rb
 - lib/redmine_airbrake_backend.rb
 - lib/redmine_airbrake_backend/engine.rb
-- lib/redmine_airbrake_backend/notice.rb
+- lib/redmine_airbrake_backend/error.rb
 - lib/redmine_airbrake_backend/patches/issue_category.rb
 - lib/redmine_airbrake_backend/patches/issue_priority.rb
 - lib/redmine_airbrake_backend/patches/project.rb
 - lib/redmine_airbrake_backend/patches/projects_helper.rb
 - lib/redmine_airbrake_backend/patches/tracker.rb
+- lib/redmine_airbrake_backend/report/ios.rb
+- lib/redmine_airbrake_backend/request.rb
+- lib/redmine_airbrake_backend/request/json.rb
+- lib/redmine_airbrake_backend/request/xml.rb
 - lib/redmine_airbrake_backend/version.rb
 - lib/tasks/test.rake
 - redmine_airbrake_backend.gemspec

data/app/views/airbrake/_issue_description.erb

@@ -1,50 +0,0 @@
-h1. <%= @notice.error[:message] %>
-
-<% if @notice.error.present? && @notice.error[:backtrace].present? %>
-h2. Stacktrace:
-
-p((. <%=raw @notice.error[:backtrace].collect{|e| format_backtrace_element(e)}.join("\n") %>
-<% end %>
-
-<% if @notice.request.present? %>
-h2. Request:
-
-<%=format_list_item('URL', @notice.request[:url]) %>
-<%=format_list_item('Component', @notice.request[:component]) %>
-<%=format_list_item('Action', @notice.request[:action]) %>
-
-<% if @notice.request[:params].present? %>
-h2. Parameters:
-
-<%=format_table(@notice.request[:params]) %>
-<% end %>
-
-<% if @notice.request[:cgi_data].present? %>
-h2. Headers:
-
-<%=format_table(@notice.request[:cgi_data]) %>
-<% end %>
-
-<% log = @notice.request[:session].delete(:log) if @notice.request[:session].present? %>
-<% if @notice.request[:session].present? %>
-h2. Session:
-
-<%=format_table(@notice.request[:session]) %>
-<% end %>
-
-<% if log.present? %>
-h2. Log:
-
-<pre>
-<%=format_log(log) %>
-</pre>
-<% end %>
-<% end %>
-
-<% if @notice.env.present? %>
-h2. Environment
-
-<%=format_list_item('Name', @notice.env[:environment_name]) %>
-<%=format_list_item('Directory', @notice.env[:project_root]) %>
-<%=format_list_item('Hostname', @notice.env[:hostname]) %>
-<% end %>

data/lib/redmine_airbrake_backend/notice.rb

@@ -1,109 +0,0 @@
-require 'json'
-require 'hpricot'
-require 'htmlentities'
-
-module RedmineAirbrakeBackend
-  class Notice
-    SUPPORTED_API_VERSIONS = %w(2.4)
-
-    class NoticeInvalid < StandardError; end
-    class UnsupportedVersion < StandardError; end
-
-    attr_reader :version, :params, :notifier, :error, :request, :env
-
-    def initialize(version, params, notifier, options={})
-      @version = version
-      @params = params
-      @notifier = notifier
-
-      @error = options.delete(:error)
-      @request = options.delete(:request)
-      @env = options.delete(:env)
-    end
-
-    def self.parse(xml_data)
-      doc = Hpricot::XML(xml_data)
-
-      raise NoticeInvalid if (notice = doc.at('notice')).blank?
-      raise NoticeInvalid.new('no version') if (version = notice.attributes['version']).blank?
-      raise UnsupportedVersion.new(version) unless SUPPORTED_API_VERSIONS.include?(version)
-
-      params = JSON.parse(notice.at('api-key').inner_text).symbolize_keys rescue nil
-      raise NoticeInvalid.new('no or invalid api-key') if params.blank?
-
-      raise NoticeInvalid.new('no notifier') if (notifier = convert_element(notice.at('notifier'))).blank?
-
-      raise NoticeInvalid.new('no error') if (error = convert_element(notice.at('error'))).blank?
-      raise NoticeInvalid.new('no message') if error[:message].blank?
-
-      error[:backtrace] = format_backtrace(error[:backtrace])
-
-      request = convert_element(notice.at('request'))
-      if request.present? && request[:session].present?
-        request[:session][:log] = request[:session][:log].present? ? format_session_log(request[:session][:log]) : nil
-      end
-
-      env = convert_element(notice.at('server-environment'))
-
-      new(version, params, notifier, error: error, request: request, env: env)
-    end
-
-    private
-
-    def self.convert_element(elem)
-      return nil if elem.nil?
-      return elem.children.first.inner_text if !elem.children.nil? && elem.children.count == 1 && elem.children.first.is_a?(Hpricot::Text)
-      return elem.attributes.to_hash.symbolize_keys if elem.children.nil?
-      return convert_var_elements(elem.children) if elem.children.count == elem.children.select{|c| c.name == 'var'}.count
-
-      h = {}
-      elem.children.each do |e|
-        key = format_hash_key(e.name)
-        if h.key?(key)
-          h[key] = [h[key]] unless h[key].is_a?(Array)
-          h[key] << convert_element(e)
-        else
-          h[key] = convert_element(e)
-        end
-      end
-      h.delete_if{|k,v| k.strip.blank?}
-      h.symbolize_keys
-    end
-
-    def self.convert_var_elements(elements)
-      vars = {}
-      elements.each do |elem|
-        vars[format_hash_key(elem.attributes['key'])] = elem.inner_text
-      end
-      vars.delete_if{|k,v| k.strip.blank?}
-      vars.symbolize_keys
-    end
-
-    def self.format_hash_key(key)
-      key.to_s.gsub(/-/, '_')
-    end
-
-    def self.ensure_hash_array(data)
-      return nil if data.blank?
-
-      d = (data.is_a?(Array) ? data : [data]).compact
-      d.reject!{|e| !e.is_a?(Hash)}
-      d.blank? ? nil : d
-    end
-
-    def self.format_backtrace(backtrace)
-      ensure_hash_array(backtrace).first[:line] rescue nil
-    end
-
-    def self.format_session_log(log)
-      log = JSON.parse(log) rescue nil
-      return nil unless log = ensure_hash_array(log)
-
-      log.map!{|l| l.symbolize_keys!; l[:time] = (Time.parse(l[:time]) rescue nil); l}
-      log.reject!{|l| l[:time].blank?}
-
-      log.blank? ? nil : log
-    end
-
-  end
-end