celerbrake 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f04c2e12ebb741062851f7f603a5eec5457ab3e5a12a03e6b3ea7d50b934bbb7
+  data.tar.gz: 2d8e37ce50181434ed2b8baf785907d1b5d5d8d46f3e57b7680efcedcdde2604
+SHA512:
+  metadata.gz: 927a1d719d732e119aab50304d69083de97783b590beff37bd270bb2d5277d25a376051f8f344fac27b37800eb3a7584c5c357445672f99ef7b32b12eb085e74
+  data.tar.gz: c8b0b139d4077f2afd93a9414ac7b917e09d0f59ce6e7bb13a66a3cef3bbd8658b8d18f8e11704a03aaac4d40f4d406a0560163abf89b2ca6095aea88dff1972

data/lib/celerbrake/capistrano/capistrano2.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  # The Capistrano v2 integration.
+  module Capistrano
+    # rubocop:disable Metrics/AbcSize
+    def self.load_into(config)
+      config.load do
+        after 'deploy',            'celerbrake:deploy'
+        after 'deploy:migrations', 'celerbrake:deploy'
+        after 'deploy:cold',       'celerbrake:deploy'
+
+        namespace :celerbrake do
+          desc "Notify Celerbrake of the deploy"
+          task :deploy, except: { no_release: true }, on_error: :continue do
+            run(
+              <<-CMD, once: true
+                cd #{config.release_path} && \
+
+                RACK_ENV=#{fetch(:rack_env, nil)} \
+                RAILS_ENV=#{fetch(:rails_env, nil)} \
+
+                bundle exec rake celerbrake:deploy \
+                  USERNAME=#{Shellwords.shellescape(ENV.fetch('USER', nil) || ENV.fetch('USERNAME', nil))} \
+                  ENVIRONMENT=#{fetch(:celerbrake_env, fetch(:rails_env, 'production'))} \
+                  REVISION=#{current_revision.strip} \
+                  REPOSITORY=#{repository} \
+                  VERSION=#{fetch(:app_version, nil)}
+              CMD
+            )
+            logger.info 'Notified Celerbrake of the deploy'
+          end
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end
+
+Celerbrake::Capistrano.load_into(Capistrano::Configuration.instance)

data/lib/celerbrake/capistrano/capistrano3.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+namespace :celerbrake do
+  desc "Notify Celerbrake of the deploy"
+  task :deploy do
+    role = roles(:all, select: :primary).first || roles(:all).first
+    on role do
+      within release_path do
+        with rails_env: fetch(:rails_env, fetch(:stage)) do
+          execute :bundle, :exec, :rake, <<-CMD
+            celerbrake:deploy USERNAME=#{Shellwords.shellescape(local_user)} \
+                            ENVIRONMENT=#{fetch(:celerbrake_env, fetch(:rails_env, fetch(:stage)))} \
+                            REVISION=#{fetch(:current_revision)} \
+                            REPOSITORY=#{fetch(:repo_url)} \
+                            VERSION=#{fetch(:app_version)}
+          CMD
+
+          info 'Notified Celerbrake of the deploy'
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake/capistrano.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+if defined?(Capistrano::VERSION) &&
+   Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+  require 'celerbrake/capistrano/capistrano3'
+else
+  require 'celerbrake/capistrano/capistrano2'
+end

data/lib/celerbrake/delayed_job.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Delayed
+  module Plugins
+    # Provides integration with Delayed Job.
+    # rubocop:disable Metrics/BlockLength
+    class Celerbrake < ::Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, *args, &block|
+          timing = ::Celerbrake::Benchmark.measure do
+            # Forward the call to the next callback in the callback chain
+            block.call(job, *args)
+          end
+        rescue Exception => exception # rubocop:disable Lint/RescueException
+          params = job.as_json
+
+          # If DelayedJob is used through ActiveJob, it contains extra info.
+          if job.payload_object.respond_to?(:job_data)
+            params[:active_job] = job.payload_object.job_data
+            job_class = job.payload_object.job_data['job_class']
+          end
+
+          action = job_class || job.payload_object.class.name
+
+          ::Celerbrake.notify(exception, params) do |notice|
+            notice[:context][:component] = 'delayed_job'
+            notice[:context][:action] = action
+          end
+
+          ::Celerbrake.notify_queue(
+            queue: action,
+            error_count: 1,
+            timing: 0.01,
+          )
+
+          raise exception
+        else
+          ::Celerbrake.notify_queue(
+            queue: job_class || job.payload_object.class.name,
+            error_count: 0,
+            timing: timing,
+          )
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end
+
+if RUBY_ENGINE == 'jruby' && defined?(Delayed::Backend::ActiveRecord::Job)
+  # Workaround against JRuby bug:
+  # https://github.com/jruby/jruby/issues/3338
+  # rubocop:disable Style/ClassAndModuleChildren
+  class Delayed::Backend::ActiveRecord::Job
+    alias old_to_ary to_ary
+
+    def to_ary
+      old_to_ary || [self]
+    end
+  end
+  # rubocop:enable Style/ClassAndModuleChildren
+end
+
+Delayed::Worker.plugins << Delayed::Plugins::Celerbrake

data/lib/celerbrake/logger.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'delegate'
+
+module Celerbrake
+  # Decorator for +Logger+ from stdlib. Endows loggers the ability to both log
+  # and report errors to Celerbrake.
+  #
+  # @example
+  #   # Create a logger like you normally do and decorate it.
+  #   logger = Celerbrake::CelerbrakeLogger.new(Logger.new($stdout))
+  #
+  #   # Just use the logger like you normally do.
+  #   logger.fatal('oops')
+  class CelerbrakeLogger < SimpleDelegator
+    # @example
+    #   # Assign a custom Celerbrake notifier
+    #   logger.celerbrake_notifier = Celerbrake::NoticeNotifier.new
+    # @return [Celerbrake::Notifier] notifier to be used to send notices
+    attr_accessor :celerbrake_notifier
+
+    # @return [Integer]
+    attr_reader :celerbrake_level
+
+    def initialize(logger)
+      super
+
+      __setobj__(logger)
+      @celerbrake_notifier = Celerbrake
+      self.level = logger.level
+    end
+
+    # @see Logger#warn
+    def warn(progname = nil, &block)
+      notify_celerbrake(Logger::WARN, progname)
+      super
+    end
+
+    # @see Logger#error
+    def error(progname = nil, &block)
+      notify_celerbrake(Logger::ERROR, progname)
+      super
+    end
+
+    # @see Logger#fatal
+    def fatal(progname = nil, &block)
+      notify_celerbrake(Logger::FATAL, progname)
+      super
+    end
+
+    # @see Logger#unknown
+    def unknown(progname = nil, &block)
+      notify_celerbrake(Logger::UNKNOWN, progname)
+      super
+    end
+
+    # @see Logger#level=
+    def level=(value)
+      self.celerbrake_level = value < Logger::WARN ? Logger::WARN : value
+      super
+    end
+
+    # Sets celerbrake severity level. Does not permit values below `Logger::WARN`.
+    #
+    # @example
+    #   logger.celerbrake_level = Logger::FATAL
+    # @return [void]
+    def celerbrake_level=(level)
+      if level < Logger::WARN
+        raise "Celerbrake severity level #{level} is not allowed. " \
+              "Minimum allowed level is #{Logger::WARN}"
+      end
+      @celerbrake_level = level
+    end
+
+    private
+
+    def notify_celerbrake(severity, progname)
+      return if severity < @celerbrake_level || !@celerbrake_notifier
+
+      @celerbrake_notifier.notify(progname) do |notice|
+        # Get rid of unwanted internal Logger frames. Examples:
+        # * /ruby-2.4.0/lib/ruby/2.4.0/logger.rb
+        # * /gems/activesupport-4.2.7.1/lib/active_support/logger.rb
+        backtrace = notice[:errors].first[:backtrace]
+        notice[:errors].first[:backtrace] =
+          backtrace.drop_while { |frame| frame[:file] =~ %r{/logger.rb\z} }
+
+        notice[:context][:component] = 'log'
+        notice[:context][:severity] = normalize_severity(severity)
+      end
+    end
+
+    def normalize_severity(severity)
+      (case severity
+       when Logger::WARN then 'warning'
+       when Logger::ERROR, Logger::UNKNOWN then 'error'
+       when Logger::FATAL then 'critical'
+       else
+         raise "Unknown celerbrake severity: #{severity}"
+       end).freeze
+    end
+  end
+end

data/lib/celerbrake/rack/context_filter.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  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 Celerbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+
+        context = notice[:context]
+
+        context[:url] = request.url
+        context[:userAgent] = request.user_agent
+
+        add_ip(context, request)
+        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
+
+      def add_ip(context, request)
+        context[:userAddr] =
+          if request.respond_to?(:remote_ip)
+            request.remote_ip
+          else
+            request.ip
+          end
+      end
+    end
+  end
+end

data/lib/celerbrake/rack/http_headers_filter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  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 Celerbrake::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/celerbrake/rack/http_params_filter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rack
+    # Adds HTTP request parameters.
+    #
+    # @since v5.7.0
+    class HttpParamsFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 97
+      end
+
+      # @see Celerbrake::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/celerbrake/rack/instrumentable.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rack
+    # Instrumentable holds methods that simplify instrumenting Rack apps.
+    # @example
+    #   class UsersController
+    #     extend Celerbrake::Rack::Instrumentable
+    #
+    #     def index
+    #       # ...
+    #     end
+    #     celerbrake_capture_timing :index
+    #   end
+    #
+    # @api public
+    # @since v9.2.0
+    module Instrumentable
+      def celerbrake_capture_timing(method_name, label: method_name.to_s)
+        instrumentable = ::Celerbrake::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 __celerbrake_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.
+        @__celerbrake_capture_timing_module__ ||= ::Module.new
+      end
+      private :__celerbrake_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 = __celerbrake_capture_timing_module__
+          mod.module_exec do
+            # rubocop:disable Style/DocumentDynamicEvalDefinition
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method_name}(#{args})
+                Celerbrake::Rack.capture_timing(#{label.to_s.inspect}) do
+                  super
+                end
+              end
+              #{visibility} :#{method_name}
+            RUBY
+            # rubocop:enable Style/DocumentDynamicEvalDefinition
+          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_celerbrake#{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
+          # rubocop:disable Style/DocumentDynamicEvalDefinition
+          module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method_name}(#{args})
+              Celerbrake::Rack.capture_timing(#{label.to_s.inspect}) do
+                __send__("#{aliased}_without_celerbrake#{punctuation}", #{args})
+              end
+            end
+            #{visibility} :#{method_name}
+          RUBY
+          # rubocop:enable Style/DocumentDynamicEvalDefinition
+        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/celerbrake/rack/middleware.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rack
+    # Celerbrake Rack middleware for Rails and Sinatra applications (or any other
+    # Rack-compliant app). Any errors raised by the upstream application will be
+    # delivered to Celerbrake 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/celerbrake/celerbrake/issues/904
+      def call(env)
+        dup.call!(env)
+      end
+
+      # Rescues any exceptions, sends them to Celerbrake 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_celerbrake(ex)
+          raise ex
+        end
+
+        exception = framework_exception(env)
+        notify_celerbrake(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_celerbrake(exception)
+        notice = Celerbrake.build_notice(exception)
+        return unless notice
+
+        # ActionDispatch::Request correctly captures server port when using SSL:
+        # See: https://github.com/celerbrake/celerbrake/issues/802
+        notice.stash[:rack_request] = RequestStore[:request]
+
+        Celerbrake.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
+
+[
+  Celerbrake::Rack::ContextFilter,
+  Celerbrake::Rack::UserFilter,
+  Celerbrake::Rack::SessionFilter,
+  Celerbrake::Rack::HttpParamsFilter,
+  Celerbrake::Rack::HttpHeadersFilter,
+  Celerbrake::Rack::RouteFilter,
+].each do |filter|
+  Celerbrake.add_filter(filter.new)
+end

data/lib/celerbrake/rack/request_body_filter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rack
+    # A filter that appends Rack request body to the notice.
+    #
+    # @example
+    #   # Read and append up to 512 bytes from Rack request's body.
+    #   Celerbrake.add_filter(Celerbrake::Rack::RequestBodyFilter.new(512))
+    #
+    # @since v5.7.0
+    # @note This filter is *not* used by default.
+    class RequestBodyFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      # @param [Integer] length The maximum number of bytes to read
+      def initialize(length = 4096)
+        @length = length
+        @weight = 95
+      end
+
+      # @see Celerbrake::FilterChain#refine
+      def call(notice)
+        return unless (request = notice.stash[:rack_request])
+        return unless request.body
+
+        notice[:environment][:body] = request.body.read(@length)
+        request.body.rewind
+      end
+    end
+  end
+end