celerbrake 0.1.0

data/lib/celerbrake/rails/backtrace_cleaner.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # BacktraceCleaner is a wrapper around Rails.backtrace_cleaner.
+    class BacktraceCleaner
+      # @return [Regexp]
+      CELERBRAKE_FRAME_PATTERN = %r{/celerbrake/lib/celerbrake/}.freeze
+
+      def self.clean(backtrace)
+        ::Rails.backtrace_cleaner.clean(backtrace).first(1)
+      end
+    end
+  end
+end
+
+if defined?(Rails)
+  # Silence own frames to let the cleaner proceed to the next line (and probably
+  # find the correct call-site coming from the app code rather this library).
+  Rails.backtrace_cleaner.add_silencer do |line|
+    line =~ Celerbrake::Rails::BacktraceCleaner::CELERBRAKE_FRAME_PATTERN
+  end
+end

data/lib/celerbrake/rails/curb.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # Allows measuring request timing.
+    module CurlEasy
+      def http(verb)
+        Celerbrake::Rack.capture_timing(:http) do
+          super(verb)
+        end
+      end
+
+      def perform(&block)
+        Celerbrake::Rack.capture_timing(:http) do
+          super(&block)
+        end
+      end
+    end
+
+    # Allows measuring request timing.
+    module CurlMulti
+      def http(urls_with_config, multi_options = {}, &block)
+        Celerbrake::Rack.capture_timing(:http) do
+          super(urls_with_config, multi_options, &block)
+        end
+      end
+    end
+  end
+end
+
+Curl::Easy.prepend(Celerbrake::Rails::CurlEasy)
+Curl::Multi.singleton_class.prepend(Celerbrake::Rails::CurlMulti)

data/lib/celerbrake/rails/event.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # Event is a wrapper around ActiveSupport::Notifications::Event.
+    #
+    # @since v9.0.3
+    # @api private
+    class Event
+      # @see https://github.com/rails/rails/issues/8987
+      HTML_RESPONSE_WILDCARD = "*/*"
+
+      # @return [Integer]
+      MILLISECOND = 1000
+
+      include Celerbrake::Loggable
+
+      def initialize(*args)
+        @event = ActiveSupport::Notifications::Event.new(*args)
+        @rails_7_or_greater = ::Rails::VERSION::MAJOR >= 7
+      end
+
+      def method
+        @event.payload[:method]
+      end
+
+      def response_type
+        response_type = @event.payload[:format]
+        response_type == HTML_RESPONSE_WILDCARD ? :html : response_type
+      end
+
+      def params
+        @event.payload[:params]
+      end
+
+      def sql
+        @event.payload[:sql]
+      end
+
+      def db_runtime
+        @db_runtime ||= @event.payload[:db_runtime] || 0
+      end
+
+      def view_runtime
+        @view_runtime ||= @event.payload[:view_runtime] || 0
+      end
+
+      def time
+        # On Rails 7+ `ActiveSupport::Notifications::Event#time` returns an
+        # instance of Float. It represents monotonic time in milliseconds.
+        # Celerbrake Ruby expects that the provided time is in seconds. Hence,
+        # we need to convert it from milliseconds to seconds. In the
+        # versions below Rails 7, time is an instance of Time.
+        #
+        # Relevant commit:
+        # https://github.com/rails/rails/commit/81d0dc90becfe0b8e7f7f26beb66c25d84b8ec7f
+        @rails_7_or_greater ? @event.time / MILLISECOND : @event.time
+      end
+
+      def groups
+        groups = {}
+        groups[:db] = db_runtime if db_runtime > 0
+        groups[:view] = view_runtime if view_runtime > 0
+        groups
+      end
+
+      def status_code
+        return @event.payload[:status] if @event.payload[:status]
+
+        if @event.payload[:exception]
+          status = ActionDispatch::ExceptionWrapper.status_code_for_exception(
+            @event.payload[:exception].first,
+          )
+          status = 500 if status == 0
+
+          return status
+        end
+
+        # The ActiveSupport event doesn't have status only in two cases:
+        #   - an exception was thrown
+        #   - unauthorized access
+        # We have already handled the exception so what's left is unauthorized
+        # access. There's no way to know for sure it's unauthorized access, so
+        # we are rather optimistic here.
+        401
+      end
+
+      def duration
+        @event.duration
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/excon_subscriber.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'celerbrake/rails/event'
+
+module Celerbrake
+  module Rails
+    # @api private
+    # @since v9.2.0
+    class Excon
+      def call(*args)
+        return unless Celerbrake::Config.instance.performance_stats
+
+        routes = Celerbrake::Rack::RequestStore[:routes]
+        return if !routes || routes.none?
+
+        event = Celerbrake::Rails::Event.new(*args)
+
+        routes.each do |_route_path, params|
+          params[:groups][:http] ||= 0
+          params[:groups][:http] += event.duration
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/http.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # Monkey-patch to measure request timing.
+    # @api private
+    # @since v11.0.2
+    module HTTP
+      def perform(request, options)
+        Celerbrake::Rack.capture_timing(:http) do
+          super(request, options)
+        end
+      end
+    end
+  end
+end
+
+HTTP::Client.prepend(Celerbrake::Rails::HTTP)

data/lib/celerbrake/rails/http_client.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # Allows measuring request timing.
+    module HTTPClient
+      def do_get_block(request, proxy, connection, &block)
+        Celerbrake::Rack.capture_timing(:http) do
+          super(request, proxy, connection, &block)
+        end
+      end
+    end
+  end
+end
+
+HTTPClient.prepend(Celerbrake::Rails::HTTPClient)

data/lib/celerbrake/rails/net_http.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # Monkey-patch Net::HTTP to benchmark it.
+    # @api private
+    # @since v10.0.2
+    module NetHttp
+      def request(request, *args, &block)
+        Celerbrake::Rack.capture_timing(:http) do
+          super(request, *args, &block)
+        end
+      end
+    end
+  end
+end
+
+Net::HTTP.prepend(Celerbrake::Rails::NetHttp)

data/lib/celerbrake/rails/railtie.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # This railtie works for any Rails application that supports railties (Rails
+    # 3.2+ apps). It makes Celerbrake Ruby work with Rails and report errors
+    # occurring in the application automatically.
+    class Railtie < ::Rails::Railtie
+      initializer('celerbrake.middleware') do |app|
+        require 'celerbrake/rails/railties/middleware_tie'
+        Railties::MiddlewareTie.new(app).call
+      end
+
+      rake_tasks do
+        # Report exceptions occurring in Rake tasks.
+        require 'celerbrake/rake'
+
+        # Defines tasks such as `celerbrake:test` & `celerbrake:deploy`.
+        require 'celerbrake/rake/tasks'
+      end
+
+      initializer('celerbrake.action_controller') do
+        require 'celerbrake/rails/railties/action_controller_tie'
+        Railties::ActionControllerTie.new.call
+      end
+
+      initializer('celerbrake.active_record') do
+        require 'celerbrake/rails/railties/active_record_tie'
+        Railties::ActiveRecordTie.new.call
+      end
+
+      initializer('celerbrake.active_job') do
+        ActiveSupport.on_load(:active_job, run_once: true) do
+          # Reports exceptions occurring in ActiveJob jobs.
+          require 'celerbrake/rails/active_job'
+          include Celerbrake::Rails::ActiveJob
+        end
+      end
+
+      initializer('celerbrake.action_cable') do
+        ActiveSupport.on_load(:action_cable, run_once: true) do
+          # Reports exceptions occurring in ActionCable connections.
+          require 'celerbrake/rails/action_cable'
+        end
+      end
+
+      runner do
+        at_exit do
+          Celerbrake.notify_sync($ERROR_INFO) if $ERROR_INFO
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/railties/action_controller_tie.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'celerbrake/rails/action_controller'
+require 'celerbrake/rails/action_controller_route_subscriber'
+require 'celerbrake/rails/action_controller_notify_subscriber'
+require 'celerbrake/rails/action_controller_performance_breakdown_subscriber'
+
+module Celerbrake
+  module Rails
+    module Railties
+      # Ties Celerbrake APM (routes) and HTTP clients with Rails.
+      #
+      # @api private
+      # @since v13.0.1
+      class ActionControllerTie
+        def initialize
+          @route_subscriber = Celerbrake::Rails::ActionControllerRouteSubscriber.new
+          @notify_subscriber = Celerbrake::Rails::ActionControllerNotifySubscriber.new
+          @performance_breakdown_subscriber =
+            Celerbrake::Rails::ActionControllerPerformanceBreakdownSubscriber.new
+        end
+
+        def call
+          ActiveSupport.on_load(:action_controller, run_once: true, yield: self) do
+            # Patches ActionController with methods that allow us to retrieve
+            # interesting request data. Appends that information to notices.
+            ::ActionController::Base.include(Celerbrake::Rails::ActionController)
+
+            tie_routes_apm
+            tie_http_integrations
+          end
+        end
+
+        private
+
+        def tie_routes_apm
+          [
+            # Cache route information for the duration of the request.
+            ['start_processing.action_controller', @route_subscriber],
+
+            # Send route stats.
+            ['process_action.action_controller', @notify_subscriber],
+
+            # Send performance breakdown: where a request spends its time.
+            ['process_action.action_controller', @performance_breakdown_subscriber],
+          ].each do |(event, callback)|
+            ActiveSupport::Notifications.subscribe(event, callback)
+          end
+        end
+
+        def tie_http_integrations
+          tie_net_http
+          tie_curl
+          tie_http
+          tie_http_client
+          tie_typhoeus
+          tie_excon
+        end
+
+        def tie_net_http
+          require 'celerbrake/rails/net_http' if defined?(Net) && defined?(Net::HTTP)
+        end
+
+        def tie_curl
+          require 'celerbrake/rails/curb' if defined?(Curl) && defined?(Curl::CURB_VERSION)
+        end
+
+        def tie_http
+          require 'celerbrake/rails/http' if defined?(HTTP) && defined?(HTTP::Client)
+        end
+
+        def tie_http_client
+          require 'celerbrake/rails/http_client' if defined?(HTTPClient)
+        end
+
+        def tie_typhoeus
+          require 'celerbrake/rails/typhoeus' if defined?(Typhoeus)
+        end
+
+        def tie_excon
+          return unless defined?(Excon)
+
+          require 'celerbrake/rails/excon_subscriber'
+          ActiveSupport::Notifications.subscribe(/excon/, Celerbrake::Rails::Excon.new)
+          ::Excon.defaults[:instrumentor] = ActiveSupport::Notifications
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/railties/active_record_tie.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'celerbrake/rails/active_record'
+require 'celerbrake/rails/active_record_subscriber'
+
+module Celerbrake
+  module Rails
+    module Railties
+      # Ties Celerbrake APM (queries) with Rails.
+      #
+      # @api private
+      # @since v13.0.1
+      class ActiveRecordTie
+        def initialize
+          @active_record_subscriber = Celerbrake::Rails::ActiveRecordSubscriber.new
+        end
+
+        def call
+          ActiveSupport.on_load(:active_record, run_once: true, yield: self) do
+            tie_activerecord_callback_fix
+            tie_activerecord_apm
+          end
+        end
+
+        private
+
+        def tie_activerecord_callback_fix
+          # Reports exceptions occurring in some bugged ActiveRecord callbacks.
+          # Applicable only to the versions of Rails lower than 4.2.
+          return unless defined?(::Rails)
+          return if Gem::Version.new(::Rails.version) > Gem::Version.new('4.2')
+
+          ActiveRecord::Base.include(Celerbrake::Rails::ActiveRecord)
+        end
+
+        def tie_activerecord_apm
+          # Some Rails apps don't use ActiveRecord.
+          return unless defined?(::ActiveRecord)
+
+          # However, some dependencies might still require it, so we need an
+          # extra check. Apps that don't need ActiveRecord will likely have no
+          # AR configurations defined. We will skip APM integration in that
+          # case. See: https://github.com/celerbrake/celerbrake/issues/1222
+          configurations = ::ActiveRecord::Base.configurations
+          return unless configurations.any?
+
+          # Send SQL queries.
+          ActiveSupport::Notifications.subscribe(
+            'sql.active_record',
+            @active_record_subscriber,
+          )
+
+          # Filter out parameters from SQL body.
+          sql_filter = Celerbrake::Filters::SqlFilter.new(
+            detect_activerecord_adapter(configurations),
+          )
+          Celerbrake.add_performance_filter(sql_filter)
+        end
+
+        # Rails 6+ introduces the `configs_for` API instead of the deprecated
+        # `#[]`, so we need an updated call.
+        def detect_activerecord_adapter(configurations)
+          unless configurations.respond_to?(:configs_for)
+            return configurations[::Rails.env]['adapter']
+          end
+
+          cfg = configurations.configs_for(env_name: ::Rails.env).first
+          # Rails 7+ API : Rails 6 API.
+          cfg.respond_to?(:adapter) ? cfg.adapter : cfg.config['adapter']
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/railties/middleware_tie.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    module Railties
+      # Ties Celerbrake Rails Middleware with Rails (error sending).
+      #
+      # Since Rails 3.2 the ActionDispatch::DebugExceptions middleware is
+      # responsible for logging exceptions and showing a debugging page in case
+      # the request is local. We want to insert our middleware after
+      # DebugExceptions, so we don't notify Celerbrake about local requests.
+      #
+      # @api private
+      # @since v13.0.1
+      class MiddlewareTie
+        def initialize(app)
+          @app = app
+          @middleware = app.config.middleware
+        end
+
+        def call
+          return tie_rails_5_or_above if ::Rails.version.to_i >= 5
+
+          if defined?(::ActiveRecord::ConnectionAdapters::ConnectionManagement)
+            return tie_rails_4_or_below_with_active_record
+          end
+
+          tie_rails_4_or_below_with_active_record
+        end
+
+        private
+
+        # Avoid the warning about deprecated strings.
+        # Insert after DebugExceptions, since ConnectionManagement doesn't
+        # exist in Rails 5 anymore.
+        def tie_rails_5_or_above
+          @middleware.insert_after(
+            ActionDispatch::DebugExceptions,
+            Celerbrake::Rack::Middleware,
+          )
+        end
+
+        # Insert after ConnectionManagement to avoid DB connection leakage:
+        # https://github.com/celerbrake/celerbrake/pull/568
+        def tie_rails_4_or_below_with_active_record
+          @middleware.insert_after(
+            ::ActiveRecord::ConnectionAdapters::ConnectionManagement,
+            'Celerbrake::Rack::Middleware',
+          )
+        end
+
+        # Insert after DebugExceptions for apps without ActiveRecord.
+        def tie_rails_4_or_below_without_active_record
+          @middleware.insert_after(
+            ActionDispatch::DebugExceptions,
+            'Celerbrake::Rack::Middleware',
+          )
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake/rails/typhoeus.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Celerbrake
+  module Rails
+    # Allow measuring request timing.
+    module TyphoeusRequest
+      def run
+        Celerbrake::Rack.capture_timing(:http) do
+          super
+        end
+      end
+    end
+  end
+end
+
+Typhoeus::Request.prepend(Celerbrake::Rails::TyphoeusRequest)

data/lib/celerbrake/rails.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'celerbrake/rails/railtie'
+
+module Celerbrake
+  # Rails namespace holds all Rails-related functionality.
+  module Rails
+    def self.logger
+      # Rails.logger is not set in some Rake tasks such as
+      # 'celerbrake:deploy'. In this case we use a sensible fallback.
+      level = (::Rails.logger ? ::Rails.logger.level : Logger::ERROR)
+
+      if ENV['RAILS_LOG_TO_STDOUT'].present?
+        Logger.new($stdout, level: level)
+      else
+        Logger.new(::Rails.root.join('log', 'celerbrake.log'), level: level)
+      end
+    end
+  end
+end
+
+if defined?(ActionController::Metal)
+  require 'celerbrake/rails/action_controller'
+  module ActionController
+    # Adds support for Rails API/Metal for Rails < 5. Rails 5+ uses standard
+    # hooks.
+    # @see https://github.com/celerbrake/celerbrake/issues/821
+    class Metal
+      include Celerbrake::Rails::ActionController
+    end
+  end
+end

data/lib/celerbrake/rake/tasks.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'celerbrake-ruby'
+
+namespace :celerbrake do
+  desc 'Verify your gem installation by sending a test exception'
+  task test: (:environment if defined?(Rails)) do
+    raise Celerbrake::Error, 'celerbrake-ruby is not configured' unless Celerbrake.configured?
+
+    require 'pp'
+
+    response = Celerbrake.notify_sync('Exception from the test Rake task')
+    if response['error']
+      puts "Error: #{response['error']}"
+    elsif response.nil? || response['code']
+      puts <<-ERROR.gsub(/^\s+\|/, '')
+        |#{response['type']}: #{response['message']} (#{response['code']})
+        |
+        |Possible problems:
+        |  1. Project id/key is incorrect
+        |  2. Custom filters ignore the exception we try to send
+        |  3. Environment this task runs in is ignored (see `ignored_environments`)
+        |
+        |If nothing works, please file an issue at: https://github.com/celerbrake/celerbrake/issues
+      ERROR
+    elsif response['url']
+      puts <<-SUCCESS.gsub(/^\s+\|/, '')
+        |A test exception was sent to Celerbrake.
+        |Find it here: #{response['url']}
+      SUCCESS
+    else
+      puts <<-ERROR.gsub(/^\s+\|/, '')
+        |Unexpected error occurred. Response from Celerbrake:
+        |#{response}
+      ERROR
+    end
+  end
+
+  desc 'Notify Celerbrake of a new deploy'
+  task :deploy do
+    if defined?(Rails)
+      initializer = Rails.root.join('config', 'initializers', 'celerbrake.rb')
+
+      # Avoid loading the environment to speed up the deploy task and try guess
+      # the initializer file location.
+      if initializer.exist? && !Celerbrake.configured?
+        load(initializer)
+      else
+        Rake::Task[:environment].invoke
+      end
+    end
+
+    raise Celerbrake::Error, 'celerbrake-ruby is not configured' unless Celerbrake.configured?
+
+    deploy_params = {
+      environment: ENV.fetch('ENVIRONMENT', nil),
+      username: ENV.fetch('USERNAME', nil),
+      revision: ENV.fetch('REVISION', nil),
+      repository: ENV.fetch('REPOSITORY', nil),
+      version: ENV.fetch('VERSION', nil),
+    }
+    promise = Celerbrake.notify_deploy(deploy_params)
+    promise.then do
+      puts "The #{deploy_params[:environment]} environment was deployed."
+    end
+    promise.rescue { |error| abort(error) }
+  end
+
+  desc 'Install a Heroku deploy hook to notify Celerbrake of deploys'
+  task :install_heroku_deploy_hook do
+    app = ENV.fetch('HEROKU_APP', nil)
+
+    config = Bundler.with_clean_env do
+      `heroku config --shell#{" --app #{app}" if app}`
+    end
+
+    heroku_env = config.each_line.with_object({}) do |line, h|
+      h.merge!(Hash[*line.rstrip.split("\n").flat_map { |v| v.split('=', 2) }])
+    end
+
+    id = heroku_env['CELERBRAKE_PROJECT_ID']
+    key = heroku_env['CELERBRAKE_API_KEY']
+
+    exit!(1) if [id, key].any?(&:nil?)
+
+    unless (env = heroku_env['RAILS_ENV'])
+      env = 'production'
+      puts "Celerbrake couldn't identify your app's environment, so the '#{env}'" \
+           " environment will be used."
+    end
+
+    unless (repo = ENV.fetch('REPOSITORY_URL', nil))
+      repo = `git remote get-url origin 2>/dev/null`.chomp
+      if repo.empty?
+        puts "Celerbrake couldn't identify your app's repository."
+      else
+        puts "Celerbrake couldn't identify your app's repository, so the " \
+             "'origin' remote url '#{repo}' will be used."
+      end
+    end
+
+    url = ["https://celerbrake.com/api/v3/projects/#{id}/heroku-deploys?key=#{key}"]
+    url << "&environment=#{env}"
+    url << "&repository=#{repo}" unless repo.empty?
+
+    command = [%(heroku addons:create deployhooks:http --url="#{url.join}")]
+    command << " --app #{app}" if app
+
+    puts "$ #{command.join}"
+    Bundler.with_clean_env { puts `#{command}` }
+  end
+end