redmine_airbrake_backend 0.6.2 → 1.0.0

data/lib/redmine_airbrake_backend/request.rb

@@ -1,133 +0,0 @@
-require 'json'
-require 'base64'
-require 'redmine_airbrake_backend/error'
-
-module RedmineAirbrakeBackend
-  # Represents a request received by airbrake
-  class Request
-    class Error < StandardError; end
-    class Invalid < Error; end
-
-    attr_reader :api_key, :project, :tracker, :category, :priority, :assignee, :repository, :type
-    attr_reader :params, :notifier, :errors, :context, :request, :env
-    attr_reader :environment_name
-
-    def initialize(config, data = {})
-      # config
-      @config = self.class.parse_config(config)
-      raise Invalid.new('Encoded configuration in api-key is missing') if @config.blank?
-
-      # API key
-      @api_key = @config[:api_key]
-      raise Invalid.new('No or invalid api-key') if @api_key.blank?
-
-      # Project
-      @project = Project.where(identifier: @config[:project]).first
-      raise Invalid.new('No or invalid project') if @project.blank?
-      raise Invalid.new('Airbrake not enabled for project') if @project.enabled_modules.where(name: :airbrake).empty?
-
-      # Check configuration
-      raise Invalid.new('Custom field for notice hash is not configured!') if notice_hash_field.blank?
-
-      # Tracker
-      @tracker = record_for(@project.trackers, :tracker)
-      raise Invalid.new('No or invalid tracker') if @tracker.blank?
-      raise Invalid.new('Custom field for notice hash not available on selected tracker') if @tracker.custom_fields.where(id: notice_hash_field.id).first.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.where(identifier: (@config[:repository] || '')).first
-
-      # Type
-      @type = @config[:type]
-
-      # Errors
-      @errors = (data[:errors] || [])
-      @errors.each { |e| e.request = self }
-
-      # Environment
-      @env = data[:env]
-
-      # Request
-      @request = data[:request]
-
-      # Context
-      @context = data[:context]
-
-      # Notifier
-      @notifier = data[:notifier]
-
-      # Params
-      @params = data[:params]
-
-      # Environment name
-      @environment_name   = (@env[:environment_name].presence || @env[:name].presence) if @env.present?
-      @environment_name ||= @context[:environment].presence if @context.present?
-    end
-
-    def notice_hash_field
-      custom_field(:hash_field)
-    end
-
-    def occurrences_field
-      custom_field(:occurrences_field)
-    end
-
-    def reopen?
-      reopen_regexp = project_setting(:reopen_regexp)
-
-      return false if environment_name.blank? || reopen_regexp.blank?
-
-      !!(environment_name =~ /#{reopen_regexp}/i)
-    end
-
-    def reopen_repeat_description?
-      !!project_setting(:reopen_repeat_description)
-    end
-
-    private
-
-    def record_for(on, config_key, fields = [:id, :name])
-      fields.each do |field|
-        val = on.where(field => @config[config_key]).first
-        return val if val.present?
-      end
-
-      project_setting(config_key)
-    end
-
-    def project_setting(key)
-      return nil if @project.airbrake_settings.blank?
-
-      @project.airbrake_settings.send(key) if @project.airbrake_settings.respond_to?(key)
-    end
-
-    def custom_field(key)
-      @project.issue_custom_fields.where(id: global_setting(key)).first || CustomField.where(id: global_setting(key), is_for_all: true).first
-    end
-
-    def global_setting(key)
-      Setting.plugin_redmine_airbrake_backend[key]
-    end
-
-    def self.parse_config(api_key_data)
-      config = ::JSON.parse(api_key_data).symbolize_keys rescue nil
-
-      return config.symbolize_keys if config.is_a?(Hash)
-
-      config = ::JSON.parse(Base64.decode64(api_key_data)) rescue nil
-
-      return config.symbolize_keys if config.is_a?(Hash)
-
-      nil
-    end
-  end
-end

data/lib/redmine_airbrake_backend/request/json.rb

@@ -1,85 +0,0 @@
-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  = []
-        errors += parse_errors(parsed_json_data[:errors])
-        errors << parse_report(parsed_json_data[:type], parsed_json_data[:report])
-        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_errors(errors)
-        errors = []
-
-        (errors || []).each do |error_data|
-          error = parse_error(error_data)
-          errors << ::RedmineAirbrakeBackend::Error.new(error) if error.present?
-        end
-
-        errors
-      end
-
-      def self.parse_error(error_data)
-        return nil if error_data.blank?
-
-        error             = {}
-        error[:type]      = secure_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?
-
-        sec_type = secure_type(type)
-
-        require "redmine_airbrake_backend/report/#{sec_type}" rescue nil
-
-        clazz = "RedmineAirbrakeBackend::Report::#{sec_type.camelize}".constantize rescue nil
-
-        return nil if clazz.blank?
-
-        report = clazz.parse(report_data)
-
-        report.present? ? ::RedmineAirbrakeBackend::Error.new(report) : nil
-      end
-
-      def self.secure_type(type)
-        type.to_s.gsub(/[^a-zA-Z0-9_-]/, '')
-      end
-    end
-  end
-end

data/lib/redmine_airbrake_backend/request/xml.rb

@@ -1,122 +0,0 @@
-require 'json'
-require 'nokogiri'
-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 = Nokogiri::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? || version.value.blank?
-        raise UnsupportedVersion.new(version) unless SUPPORTED_API_VERSIONS.include?(version.value)
-
-        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)
-        convert_element(notice_doc.at('//request'))
-      end
-
-      def self.convert_element(elem)
-        return nil if elem.nil?
-
-        return elem.children.first.inner_text if elem.children.count == 1 && elem.children.first.is_a?(Nokogiri::XML::Text)
-        return convert_attributes(elem.attributes) if elem.children.blank?
-        return convert_var_elements(elem.children) if elem.children.count == elem.children.select { |c| c.name == 'var' }.count
-
-        h = convert_children(elem)
-        h.delete_if { |k, v| k.strip.blank? }
-        h.symbolize_keys
-      end
-
-      def self.convert_children(elem)
-        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
-      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.convert_attributes(attributes)
-        attrs = {}
-
-        attributes.each do |k, v|
-          attrs[k] = v.value
-        end
-
-        attrs.symbolize_keys
-      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
-    end
-  end
-end