airbrake 3.1.6 → 11.0.0

data/lib/airbrake/rack.rb

@@ -1,54 +1,39 @@
-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'
-  #   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
-    end
+# frozen_string_literal: true
 
-    def ignored_user_agent?(env)
-      true if Airbrake.
-        configuration.
-        ignore_user_agent.
-        flatten.
-        any? { |ua| ua === env['HTTP_USER_AGENT'] }
-    end
+require 'airbrake/rack/user'
+require 'airbrake/rack/user_filter'
+require 'airbrake/rack/context_filter'
+require 'airbrake/rack/session_filter'
+require 'airbrake/rack/http_params_filter'
+require 'airbrake/rack/http_headers_filter'
+require 'airbrake/rack/request_body_filter'
+require 'airbrake/rack/route_filter'
+require 'airbrake/rack/middleware'
+require 'airbrake/rack/request_store'
+require 'airbrake/rack/instrumentable'
 
-    def notify_airbrake(exception,env)
-      Airbrake.notify_or_ignore(exception,:rack_env => env) unless ignored_user_agent?(env)
-    end
+module Airbrake
+  # Rack is a namespace for all Rack-related code.
+  module Rack
+    # @since v9.2.0
+    # @api public
+    def self.capture_timing(label)
+      return yield unless Airbrake::Config.instance.performance_stats
 
-    def call(env)
-      begin
-        response = @app.call(env)
-      rescue Exception => raised
-        env['airbrake.error_id'] = notify_airbrake(raised,env)
-        raise
-      end
+      routes = Airbrake::Rack::RequestStore[:routes]
+      if !routes || routes.none?
+        result = yield
+      else
+        timed_trace = Airbrake::TimedTrace.span(label) do
+          result = yield
+        end
 
-      if env['rack.exception']
-        env['airbrake.error_id'] = notify_airbrake(env['rack.exception'],env)
+        routes.each do |_route_path, params|
+          params[:groups].merge!(timed_trace.spans)
+        end
       end
 
-      response
+      result
     end
   end
 end

data/lib/airbrake/rack/context_filter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rack
+    # Adds context (URL, User-Agent, framework version, controller and more).
+    #
+    # @since v5.7.0
+    class ContextFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 99
+      end
+
+      # @see Airbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        context = notice[:context]
+
+        context[:url] = request.url
+        context[:userAddr] =
+          if request.respond_to?(:remote_ip)
+            request.remote_ip
+          else
+            request.ip
+          end
+        context[:userAgent] = request.user_agent
+
+        add_framework_version(context)
+
+        controller = request.env['action_controller.instance']
+        return unless controller
+
+        context[:component] = controller.controller_name
+        context[:action] = controller.action_name
+      end
+
+      private
+
+      def add_framework_version(context)
+        if context.key?(:versions)
+          context[:versions].merge!(framework_version)
+        else
+          context[:versions] = framework_version
+        end
+      end
+
+      def framework_version
+        @framework_version ||=
+          if defined?(::Rails) && ::Rails.respond_to?(:version)
+            { 'rails' => ::Rails.version }
+          elsif defined?(::Sinatra)
+            { 'sinatra' => Sinatra::VERSION }
+          else
+            {
+              'rack_version' => ::Rack.version,
+              'rack_release' => ::Rack.release,
+            }
+          end
+      end
+    end
+  end
+end

data/lib/airbrake/rack/http_headers_filter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rack
+    # Adds HTTP request parameters.
+    #
+    # @since v5.7.0
+    class HttpHeadersFilter
+      # @return [Array<String>] the prefixes of the majority of HTTP headers in
+      #   Rack (some prefixes match the header names for simplicity)
+      HTTP_HEADER_PREFIXES = %w[
+        HTTP_
+        CONTENT_TYPE
+        CONTENT_LENGTH
+      ].freeze
+
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 98
+      end
+
+      # @see Airbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        http_headers = request.env.map.with_object({}) do |(key, value), headers|
+          if HTTP_HEADER_PREFIXES.any? { |prefix| key.to_s.start_with?(prefix) }
+            headers[key] = value
+          end
+
+          headers
+        end
+
+        notice[:context].merge!(
+          httpMethod: request.request_method,
+          referer: request.referer,
+          headers: http_headers,
+        )
+      end
+    end
+  end
+end

data/lib/airbrake/rack/http_params_filter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rack
+    # Adds HTTP request parameters.
+    #
+    # @since v5.7.0
+    class HttpParamsFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 97
+      end
+
+      # @see Airbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        notice[:params].merge!(request.params)
+
+        rails_params = request.env['action_dispatch.request.parameters']
+        notice[:params].merge!(rails_params) if rails_params
+      end
+    end
+  end
+end

data/lib/airbrake/rack/instrumentable.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rack
+    # Instrumentable holds methods that simplify instrumenting Rack apps.
+    # @example
+    #   class UsersController
+    #     extend Airbrake::Rack::Instrumentable
+    #
+    #     def index
+    #       # ...
+    #     end
+    #     airbrake_capture_timing :index
+    #   end
+    #
+    # @api public
+    # @since v9.2.0
+    module Instrumentable
+      def airbrake_capture_timing(method_name, label: method_name.to_s)
+        instrumentable = ::Airbrake::Rack::Instrumentable
+        if instrumentable.should_prepend?(self, method_name)
+          instrumentable.prepend_capture_timing(self, method_name, label)
+        else
+          instrumentable.chain_capture_timing(self, method_name, label)
+        end
+        method_name
+      end
+
+      # @api private
+      def __airbrake_capture_timing_module__
+        # Module used to store prepended wrapper methods, saved as an instance
+        # variable so each target class/module gets its own module. This just
+        # a convenience to avoid prepending a lot of anonymous modules.
+        @__airbrake_capture_timing_module__ ||= ::Module.new
+      end
+      private :__airbrake_capture_timing_module__
+
+      # Using api private self methods so they don't get defined in the target
+      # class or module, but can still be called by the above method.
+
+      # @api private
+      def self.should_prepend?(klass, method_name)
+        # Don't chain already-prepended or operator methods.
+        klass.module_exec do
+          self_class_idx = ancestors.index(self)
+          method_owner_idx = ancestors.index(instance_method(method_name).owner)
+          method_owner_idx < self_class_idx || !(/\A\W/ =~ method_name).nil?
+        end
+      end
+
+      # @api private
+      def self.prepend_capture_timing(klass, method_name, label)
+        args = method_signature
+        visibility = method_visibility(klass, method_name)
+
+        # Generate the wrapper method.
+        klass.module_exec do
+          mod = __airbrake_capture_timing_module__
+          mod.module_exec do
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method_name}(#{args})
+                Airbrake::Rack.capture_timing(#{label.to_s.inspect}) do
+                  super
+                end
+              end
+              #{visibility} :#{method_name}
+            RUBY
+          end
+          prepend mod
+        end
+      end
+
+      # @api private
+      def self.chain_capture_timing(klass, method_name, label)
+        args = method_signature
+        visibility = method_visibility(klass, method_name)
+
+        # Generate the wrapper method.
+        aliased = method_name.to_s.sub(/([?!=])$/, '')
+        punctuation = Regexp.last_match(1)
+        wrapped_method_name = "#{aliased}_without_airbrake#{punctuation}"
+        needs_removal = method_needs_removal(klass, method_name)
+        klass.module_exec do
+          alias_method wrapped_method_name, method_name
+          remove_method method_name if needs_removal
+          module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method_name}(#{args})
+              Airbrake::Rack.capture_timing(#{label.to_s.inspect}) do
+                __send__("#{aliased}_without_airbrake#{punctuation}", #{args})
+              end
+            end
+            #{visibility} :#{method_name}
+          RUBY
+        end
+      end
+
+      # @api private
+      def self.method_visibility(klass, method_name)
+        klass.module_exec do
+          if protected_method_defined?(method_name)
+            "protected"
+          elsif private_method_defined?(method_name)
+            "private"
+          else
+            "public"
+          end
+        end
+      end
+
+      # @api private
+      # A method instead of a constant so it isn't accessible in the target.
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7")
+        def self.method_signature
+          "*args, **kw_args, &block"
+        end
+      else
+        def self.method_signature
+          "*args, &block"
+        end
+      end
+
+      # @api private
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6")
+        def self.method_needs_removal(klass, method_name)
+          klass.method_defined?(method_name, false) ||
+            klass.private_method_defined?(method_name, false)
+        end
+      else
+        def self.method_needs_removal(klass, method_name)
+          klass.instance_methods(false).include?(method_name) ||
+            klass.private_instance_methods(false).include?(method_name)
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rack/middleware.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rack
+    # Airbrake Rack middleware for Rails and Sinatra applications (or any other
+    # Rack-compliant app). Any errors raised by the upstream application will be
+    # delivered to Airbrake and re-raised.
+    #
+    # The middleware automatically sends information about the framework that
+    # uses it (name and version).
+    #
+    # For Rails apps the middleware collects route performance statistics.
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      # Thread-safe {call!}.
+      #
+      # @param [Hash] env the Rack environment
+      # @see https://github.com/airbrake/airbrake/issues/904
+      def call(env)
+        dup.call!(env)
+      end
+
+      # Rescues any exceptions, sends them to Airbrake and re-raises the
+      # exception. We also duplicate middleware to guarantee thread-safety.
+      #
+      # @param [Hash] env the Rack environment
+      def call!(env)
+        before_call(env)
+
+        begin
+          response = @app.call(env)
+        rescue Exception => ex # rubocop:disable Lint/RescueException
+          notify_airbrake(ex)
+          raise ex
+        end
+
+        exception = framework_exception(env)
+        notify_airbrake(exception) if exception
+
+        response
+      ensure
+        # Clear routes for the next request.
+        RequestStore.clear
+      end
+
+      private
+
+      def before_call(env)
+        # Rails hooks such as ActionControllerRouteSubscriber rely on this.
+        RequestStore[:routes] = {}
+        RequestStore[:request] = find_request(env)
+      end
+
+      def find_request(env)
+        if defined?(ActionDispatch::Request)
+          ActionDispatch::Request.new(env)
+        elsif defined?(Sinatra::Request)
+          Sinatra::Request.new(env)
+        else
+          ::Rack::Request.new(env)
+        end
+      end
+
+      def notify_airbrake(exception)
+        notice = Airbrake.build_notice(exception)
+        return unless notice
+
+        # ActionDispatch::Request correctly captures server port when using SSL:
+        # See: https://github.com/airbrake/airbrake/issues/802
+        notice.stash[:rack_request] = RequestStore[:request]
+
+        Airbrake.notify(notice)
+      end
+
+      # Web framework middlewares often store rescued exceptions inside the
+      # Rack env, but Rack doesn't have a standard key for it:
+      #
+      # - Rails uses action_dispatch.exception: https://goo.gl/Kd694n
+      # - Sinatra uses sinatra.error: https://goo.gl/LLkVL9
+      # - Goliath uses rack.exception: https://goo.gl/i7e1nA
+      def framework_exception(env)
+        env['action_dispatch.exception'] ||
+          env['sinatra.error'] ||
+          env['rack.exception']
+      end
+    end
+  end
+end
+
+[
+  Airbrake::Rack::ContextFilter,
+  Airbrake::Rack::UserFilter,
+  Airbrake::Rack::SessionFilter,
+  Airbrake::Rack::HttpParamsFilter,
+  Airbrake::Rack::HttpHeadersFilter,
+  Airbrake::Rack::RouteFilter,
+].each do |filter|
+  Airbrake.add_filter(filter.new)
+end