airbrake 4.3.8 → 5.0.0

data/lib/airbrake/notice.rb

@@ -1,411 +0,0 @@
-require 'builder'
-require 'socket'
-require 'multi_json'
-
-module Airbrake
-  class Notice
-
-    class << self
-      def attr_reader_with_tracking(*names)
-        attr_readers.concat(names)
-        attr_reader_without_tracking(*names)
-      end
-
-      alias_method :attr_reader_without_tracking, :attr_reader
-      alias_method :attr_reader, :attr_reader_with_tracking
-
-
-      def attr_readers
-        @attr_readers ||= []
-      end
-    end
-
-    # The exception that caused this notice, if any
-    attr_reader :exception
-
-    # The API key for the project to which this notice should be sent
-    attr_reader :api_key
-
-    # The backtrace from the given exception or hash.
-    attr_reader :backtrace
-
-    # The name of the class of error (such as RuntimeError)
-    attr_reader :error_class
-
-    # The name of the server environment (such as "production")
-    attr_reader :environment_name
-
-    # CGI variables such as HTTP_METHOD
-    attr_reader :cgi_data
-
-    # The message from the exception, or a general description of the error
-    attr_reader :error_message
-
-    # See Configuration#backtrace_filters
-    attr_reader :backtrace_filters
-
-    # See Configuration#params_filters
-    attr_reader :params_filters
-
-    # See Configuration#params_whitelist_filters
-    attr_reader :params_whitelist_filters
-
-    # A hash of parameters from the query string or post body.
-    attr_reader :parameters
-    alias_method :params, :parameters
-
-    # The component (if any) which was used in this request (usually the controller)
-    attr_reader :component
-    alias_method :controller, :component
-
-    # The action (if any) that was called in this request
-    attr_reader :action
-
-    # A hash of session data from the request
-    attr_reader :session_data
-
-    # The path to the project that caused the error (usually Rails.root)
-    attr_reader :project_root
-
-    # The URL at which the error occurred (if any)
-    attr_reader :url
-
-    # See Configuration#ignore
-    attr_reader :ignore
-
-    # See Configuration#ignore_by_filters
-    attr_reader :ignore_by_filters
-
-    # The name of the notifier library sending this notice, such as "Airbrake Notifier"
-    attr_reader :notifier_name
-
-    # The version number of the notifier library sending this notice, such as "2.1.3"
-    attr_reader :notifier_version
-
-    # A URL for more information about the notifier library sending this notice
-    attr_reader :notifier_url
-
-    # The host name where this error occurred (if any)
-    attr_reader :hostname
-
-    # Details about the user who experienced the error
-    attr_reader :user
-
-    # Instance that's used for cleaning out data that should be filtered out, should respond to #clean
-    attr_accessor :cleaner
-
-    # An array of the exception classes for this error (including wrapped ones)
-    attr_reader :exception_classes
-
-    public
-
-    def initialize(args)
-      @args             = args
-      @exception        = args[:exception]
-      @api_key          = args[:api_key]
-      @project_root     = args[:project_root]
-      @url              = args[:url] || rack_env(:url)
-      @notifier_name    = args[:notifier_name]
-      @notifier_version = args[:notifier_version]
-      @notifier_url     = args[:notifier_url]
-
-      @ignore                   = args[:ignore]                   || []
-      @ignore_by_filters        = args[:ignore_by_filters]        || []
-      @backtrace_filters        = args[:backtrace_filters]        || []
-      @params_filters           = args[:params_filters]           || []
-      @params_whitelist_filters = args[:params_whitelist_filters] || []
-
-      @parameters          = args[:parameters] ||
-                                   action_dispatch_params ||
-                                   rack_env(:params) ||
-                                   {}
-      @component           = args[:component] || args[:controller] || parameters['controller']
-      @action              = args[:action] || parameters['action']
-
-      @environment_name = args[:environment_name]
-      @cgi_data         = (args[:cgi_data].respond_to?(:to_hash) && args[:cgi_data].to_hash.dup) || args[:rack_env] || {}
-      @backtrace        = Backtrace.parse(exception_attribute(:backtrace, caller), :filters => @backtrace_filters)
-      @error_class      = exception_attribute(:error_class) {|exception| exception.class.name }
-      @error_message    = exception_attribute(:error_message, 'Notification') do |exception|
-        "#{exception.class.name}: #{args[:error_message] || exception.message}"
-      end
-
-      @hostname        = local_hostname
-      @user            = args[:user] || {}
-
-      @exception_classes= Array(args[:exception_classes])
-      if @exception
-        @exception_classes << @exception.class
-      end
-      if @error_class
-        @exception_classes << @error_class
-      end
-
-
-      also_use_rack_params_filters
-      find_session_data
-
-      @cleaner = args[:cleaner] ||
-        Airbrake::Utils::ParamsCleaner.new(:blacklist_filters => params_filters,
-                                           :whitelist_filters => params_whitelist_filters,
-                                           :to_clean => data_to_clean)
-
-      clean_data!
-    end
-
-    # Converts the given notice to XML
-    def to_xml
-      builder = Builder::XmlMarkup.new
-      builder.instruct!
-      xml = builder.notice(:version => Airbrake::API_VERSION) do |notice|
-        notice.tag!("api-key", api_key)
-        notice.notifier do |notifier|
-          notifier.name(notifier_name)
-          notifier.version(notifier_version)
-          notifier.url(notifier_url)
-        end
-        notice.tag!('error') do |error|
-          error.tag!('class', error_class)
-          error.message(error_message)
-          error.backtrace do |backtrace|
-            self.backtrace.lines.each do |line|
-              backtrace.line(
-                :number      => line.number,
-                :file        => line.file,
-                :method      => line.method_name
-              )
-            end
-          end
-        end
-        if request_present?
-          notice.request do |request|
-            request.url(url)
-            request.component(controller)
-            request.action(action)
-            unless parameters.empty?
-              request.params do |params|
-                xml_vars_for(params, parameters)
-              end
-            end
-            unless session_data.empty?
-              request.session do |session|
-                xml_vars_for(session, session_data)
-              end
-            end
-            unless cgi_data.empty?
-              request.tag!("cgi-data") do |cgi_datum|
-                xml_vars_for(cgi_datum, cgi_data)
-              end
-            end
-          end
-        end
-        notice.tag!("server-environment") do |env|
-          env.tag!("project-root", project_root)
-          env.tag!("environment-name", environment_name)
-          env.tag!("hostname", hostname)
-        end
-        unless user.empty?
-          notice.tag!("current-user") do |u|
-            user.each do |attr, value|
-              u.tag!(attr.to_s, value)
-            end
-          end
-        end
-        if framework =~ /\S/
-          notice.tag!("framework", framework)
-        end
-      end
-      xml.to_s
-    end
-
-    def to_json
-      MultiJson.dump({
-        'notifier' => {
-          'name'    => 'airbrake',
-          'version' => Airbrake::VERSION,
-          'url'     => 'https://github.com/airbrake/airbrake'
-          },
-        'errors' => [{
-            'type'       => error_class,
-            'message'    => error_message,
-            'backtrace'  => backtrace.lines.map do |line|
-                {
-                  'file'     => line.file,
-                  'line'     => line.number.to_i,
-                  'function' => line.method_name
-                }
-            end
-          }],
-         'context' => {}.tap do |hash|
-            if request_present?
-              hash['url']           = url
-              hash['component']     = controller
-              hash['action']        = action
-              hash['rootDirectory'] = File.dirname(project_root)
-              hash['environment']   = environment_name
-            end
-           end.tap do |hash|
-            next if user.empty?
-
-            hash['userId']    = user[:id]
-            hash['userName']  = user[:name]
-            hash['userEmail'] = user[:email]
-          end
-
-      }.tap do |hash|
-          hash['environment'] = cgi_data     unless cgi_data.empty?
-          hash['params']      = parameters   unless parameters.empty?
-          hash['session']     = session_data unless session_data.empty?
-      end)
-    end
-
-    # Determines if this notice should be ignored
-    def ignore?
-      exception_classes.each do |klass|
-        if ignored_class_names.include?(klass)
-          return true
-        end
-      end
-
-      ignore_by_filters.any? {|filter| filter.call(self) }
-    end
-
-    # Allows properties to be accessed using a hash-like syntax
-    #
-    # @example
-    #   notice[:error_message]
-    # @param [String] method The given key for an attribute
-    # @return The attribute value, or self if given +:request+
-    def [](method)
-      case method
-      when :request
-        self
-      else
-        send(method)
-      end
-    end
-
-    private
-
-    def request_present?
-      url ||
-        controller ||
-        action ||
-        !parameters.empty? ||
-        !cgi_data.empty? ||
-        !session_data.empty?
-    end
-
-    # Gets a property named +attribute+ of an exception, either from an actual
-    # exception or a hash.
-    #
-    # If an exception is available, #from_exception will be used. Otherwise,
-    # a key named +attribute+ will be used from the #args.
-    #
-    # If no exception or hash key is available, +default+ will be used.
-    def exception_attribute(attribute, default = nil, &block)
-      (exception && from_exception(attribute, &block)) || @args[attribute] || default
-    end
-
-    # Gets a property named +attribute+ from an exception.
-    #
-    # If a block is given, it will be used when getting the property from an
-    # exception. The block should accept and exception and return the value for
-    # the property.
-    #
-    # If no block is given, a method with the same name as +attribute+ will be
-    # invoked for the value.
-    def from_exception(attribute)
-      if block_given?
-        yield(exception)
-      else
-        exception.send(attribute)
-      end
-    end
-
-    # Replaces the contents of params that match params_filters.
-    def clean_data!
-      cleaner.clean.tap do |c|
-        @parameters   = c.parameters
-        @cgi_data     = c.cgi_data
-        @session_data = c.session_data
-      end
-    end
-
-    def data_to_clean
-      {:parameters    => parameters,
-        :cgi_data     => cgi_data,
-        :session_data => session_data}
-    end
-
-    def find_session_data
-      @session_data = @args[:session_data] || @args[:session] || rack_session || {}
-      @session_data = session_data[:data] if session_data[:data]
-    end
-
-    # Converts the mixed class instances and class names into just names
-    # TODO: move this into Configuration or another class
-    def ignored_class_names
-      ignore.collect do |string_or_class|
-        if string_or_class.respond_to?(:name)
-          string_or_class.name
-        else
-          string_or_class
-        end
-      end
-    end
-
-    def xml_vars_for(builder, hash)
-      hash.each do |key, value|
-        if value.respond_to?(:to_hash)
-          builder.var(:key => key){|b| xml_vars_for(b, value.to_hash) }
-        else
-          builder.var(value.to_s, :key => key)
-        end
-      end
-    end
-
-    def rack_env(method)
-      rack_request.send(method) if rack_request
-    rescue
-      {:message => "failed to call #{method} on Rack::Request -- #{$!.message}"}
-    end
-
-    def rack_request
-      @rack_request ||= if @args[:rack_env]
-        ::Rack::Request.new(@args[:rack_env])
-      end
-    end
-
-    def action_dispatch_params
-      @args[:rack_env]['action_dispatch.request.parameters'] if @args[:rack_env]
-    end
-
-    def rack_session
-      @args[:rack_env]['rack.session'] if @args[:rack_env]
-    end
-
-    def also_use_rack_params_filters
-      if cgi_data
-        @params_filters ||= []
-        @params_filters += cgi_data["action_dispatch.parameter_filter"] || []
-      end
-    end
-
-    def local_hostname
-      Socket.gethostname
-    end
-
-    def framework
-      Airbrake.configuration.framework
-    end
-
-    def to_s
-      content = []
-      self.class.attr_readers.each do |attr|
-        content << "  #{attr}: #{send(attr)}"
-      end
-      content.join("\n")
-    end
-  end
-end

data/lib/airbrake/rack.rb

@@ -1,64 +0,0 @@
-module Airbrake
-  # Middleware for Rack applications. Any errors raised by the upstream
-  # application will be delivered to Airbrake and re-raised.
-  #
-  # Synopsis:
-  #
-  #   require 'rack'
-  #   require 'airbrake'
-  #
-  #   Airbrake.configure do |config|
-  #     config.api_key = 'my_api_key'
-  #     #can also set the environment over here
-  #     config.environment_name = ENV['RACK_ENV'] || "development"
-  #   end
-  #
-  #   app = Rack::Builder.app do
-  #     run lambda { |env| raise "Rack down" }
-  #   end
-  #
-  #   use Airbrake::Rack
-  #   run app
-  #
-  # Use a standard Airbrake.configure call to configure your api key.
-  class Rack
-    def initialize(app)
-      @app = app
-      Airbrake.configuration.framework = "Rack: #{::Rack.release}"
-    end
-
-    def ignored_user_agent?(env)
-      true if Airbrake.
-        configuration.
-        ignore_user_agent.
-        flatten.
-        any? { |ua| ua === env['HTTP_USER_AGENT'] }
-    end
-
-    def notify_airbrake(exception, env)
-      unless ignored_user_agent?(env)
-        Airbrake.notify_or_ignore(exception, :rack_env => env)
-      end
-    end
-
-    def call(env)
-      begin
-        response = @app.call(env)
-      rescue Exception => raised
-        env['airbrake.error_id'] = notify_airbrake(raised, env)
-        raise raised
-      end
-
-      if framework_exception(env)
-        env['airbrake.error_id'] = notify_airbrake(framework_exception(env), env)
-      end
-
-      response
-    end
-
-    def framework_exception(env)
-      env['rack.exception'] || env['sinatra.error']
-    end
-
-  end
-end

data/lib/airbrake/rails/action_controller_catcher.rb

@@ -1,32 +0,0 @@
-module Airbrake
-  module Rails
-    module ActionControllerCatcher
-
-      # Sets up an alias chain to catch exceptions for Rails 2
-      def self.included(base) #:nodoc:
-        if base.method_defined?(:rescue_action_in_public)
-          base.send(:alias_method, :rescue_action_in_public_without_airbrake, :rescue_action_in_public)
-          base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_airbrake)
-        end
-      end
-
-      private
-
-      # Overrides the rescue_action method in ActionController::Base, but does not inhibit
-      # any custom processing that is defined with Rails 2's exception helpers.
-      def rescue_action_in_public_with_airbrake(exception)
-        unless airbrake_ignore_user_agent?
-          error_id = Airbrake.notify_or_ignore(exception, airbrake_request_data)
-          request.env['airbrake.error_id'] = error_id
-        end
-        rescue_action_in_public_without_airbrake(exception)
-      end
-
-      def airbrake_ignore_user_agent? #:nodoc:
-        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
-        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
-        Airbrake.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
-      end
-    end
-  end
-end

data/lib/airbrake/rails/controller_methods.rb

@@ -1,146 +0,0 @@
-module Airbrake
-  module Rails
-    module ControllerMethods
-
-      SLASH = "/"
-
-      def airbrake_request_data
-        {
-          :parameters       => airbrake_filter_if_filtering(to_hash(params)),
-          :session_data     => airbrake_filter_if_filtering(airbrake_session_data),
-          :controller       => params[:controller],
-          :action           => params[:action],
-          :url              => airbrake_request_url,
-          :cgi_data         => airbrake_filter_if_filtering(request.env),
-          :user             => airbrake_current_user
-        }
-      end
-
-      private
-
-      def to_hash(params)
-        # Rails <= 4
-        return params.to_hash if params.respond_to?(:to_hash)
-
-        # Rails >= 5
-        params.to_unsafe_h
-      end
-
-      # This method should be used for sending manual notifications while you are still
-      # inside the controller. Otherwise it works like Airbrake.notify.
-      def notify_airbrake(hash_or_exception)
-        unless airbrake_local_request?
-          Airbrake.notify_or_ignore(hash_or_exception, airbrake_request_data)
-        end
-      end
-
-      def airbrake_local_request?
-        if defined?(::Rails.application.config)
-          ::Rails.application.config.consider_all_requests_local || (request.local? && (!request.env["HTTP_X_FORWARDED_FOR"]))
-        else
-          consider_all_requests_local || (local_request? && (!request.env["HTTP_X_FORWARDED_FOR"]))
-        end
-      end
-
-      def airbrake_ignore_user_agent? #:nodoc:
-        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
-        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
-        Airbrake.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
-      end
-
-
-      def airbrake_filter_if_filtering(hash)
-        return hash if ! hash.is_a?(Hash)
-
-        if respond_to?(:filter_parameters) # Rails 2
-          filter_parameters(hash)
-        elsif rails_3_or_4?
-          filter_rails3_parameters(hash)
-        else
-          hash
-        end
-      end
-
-      def rails_3_or_4?
-        defined?(::Rails.version) && ::Rails.version =~ /\A[34]/
-      end
-
-      def filter_rails3_parameters(hash)
-        ActionDispatch::Http::ParameterFilter.new(
-          ::Rails.application.config.filter_parameters
-        ).filter(recursive_stringify_keys(hash))
-      end
-
-      def recursive_stringify_keys(hash)
-        hash = hash.stringify_keys
-        hash.each do |k, v|
-          if v.is_a?(Hash)
-            hash[k] = v.respond_to?(:stringify_keys) ? recursive_stringify_keys(v) : nil # Rack::Session::Abstract::SessionHash has a stringify_keys method we should not call
-          end
-        end
-        hash
-      end
-
-      def airbrake_session_data
-        if session
-          if session.respond_to?(:to_hash)
-            session.to_hash
-          else
-            session.data
-          end
-        else
-          {:session => 'no session found'}
-        end
-      end
-
-      def airbrake_request_url
-        url = "#{request.protocol}#{request.host}"
-
-        unless [80, 443].include?(request.port)
-          url << ":#{request.port}"
-        end
-
-        unless request.fullpath[0] == SLASH
-          url << SLASH
-        end
-
-        url << request.fullpath
-      end
-
-      def airbrake_current_user
-        user = fetch_user
-
-        if user
-          Airbrake.configuration.user_attributes.map(&:to_sym).inject({}) do |hsh, attr|
-            begin
-              hsh[attr] = user.send(attr) if user.respond_to? attr
-              hsh
-            rescue
-              hsh
-            end
-          end
-        else
-          {}
-        end
-      end
-
-      def fetch_user
-        if defined?(current_user)
-          current_user
-        elsif defined?(current_member)
-          current_member
-        else
-          nil
-        end
-      rescue
-        nil
-      ensure
-        # The Airbrake middleware is first in the chain, before ActiveRecord::ConnectionAdapters::ConnectionManagement
-        # kicks in to do its thing. This can cause the connection pool to run out of connections.
-        if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:clear_active_connections!)
-          ActiveRecord::Base.clear_active_connections!
-        end
-      end
-    end
-  end
-end

data/lib/airbrake/rails/error_lookup.rb

@@ -1,35 +0,0 @@
-module Airbrake
-  module Rails
-    module ErrorLookup
-
-      # Sets up an alias chain to catch exceptions when Rails does
-      def self.included(base) #:nodoc:
-        if base.method_defined?(:rescue_action_locally)
-          base.send(:alias_method, :rescue_action_locally_without_airbrake, :rescue_action_locally)
-          base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_airbrake)
-        end
-      end
-
-      private
-
-      def rescue_action_locally_with_airbrake(exception)
-        result = rescue_action_locally_without_airbrake(exception)
-
-        if Airbrake.configuration.development_lookup
-          path   = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'rescue.erb')
-          notice = Airbrake.build_lookup_hash_for(exception, airbrake_request_data)
-
-          result << @template.render(
-            :file          => path,
-            :use_full_path => false,
-            :locals        => { :host    => Airbrake.configuration.host,
-                                :api_key => Airbrake.configuration.api_key,
-                                :notice  => notice })
-        end
-
-        result
-      end
-    end
-  end
-end
-