airbrakeV4rails5 4.3.8

data/lib/airbrake/tasks.rb

@@ -0,0 +1,81 @@
+require 'airbrake'
+require File.join(File.dirname(__FILE__), 'shared_tasks')
+
+namespace :airbrake do
+  desc "Verify your gem installation by sending a test exception to the airbrake service"
+  task :test => ['airbrake:log_stdout', :environment] do
+    RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+
+    Dir["app/controllers/application*.rb"].each { |file| require(File.expand_path(file)) }
+
+    class AirbrakeTestingException < RuntimeError; end
+
+    unless Airbrake.configuration.api_key
+      puts "Airbrake needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    Airbrake.configuration.development_environments = []
+
+    catcher = Airbrake::Rails::ActionControllerCatcher
+    in_controller = ApplicationController.included_modules.include?(catcher)
+    in_base = ActionController::Base.included_modules.include?(catcher)
+    if !in_controller || !in_base
+      puts "Rails initialization did not occur"
+      exit
+    end
+
+    puts "Configuration:"
+    Airbrake.configuration.to_hash.each do |key, value|
+      puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
+    end
+
+    unless defined?(ApplicationController)
+      puts "No ApplicationController found"
+      exit
+    end
+
+    puts 'Setting up the Controller.'
+    class ApplicationController
+      # This is to bypass any filters that may prevent access to the action.
+      prepend_before_filter :test_airbrake
+      def test_airbrake
+        puts "Raising '#{exception_class.name}' to simulate application failure."
+        raise exception_class.new, 'Testing airbrake via "rake airbrake:test". If you can see this, it works.'
+      end
+
+      def rescue_action(exception)
+        rescue_action_in_public exception
+      end
+
+      # Ensure we actually have an action to go to.
+      def verify; end
+
+      def consider_all_requests_local
+        false
+      end
+
+      def local_request?
+        false
+      end
+
+      def exception_class
+        exception_name = ENV['EXCEPTION'] || "AirbrakeTestingException"
+        exception_name.split("::").inject(Object){|klass, name| klass.const_get(name)}
+      rescue
+        Object.const_set(exception_name.gsub(/:+/, "_"), Class.new(Exception))
+      end
+
+      def logger
+        nil
+      end
+    end
+    class AirbrakeVerificationController < ApplicationController; end
+
+    puts 'Processing request.'
+    request = ActionController::TestRequest.new("REQUEST_URI" => "/airbrake_verification_controller")
+    response = ActionController::TestResponse.new
+    AirbrakeVerificationController.new.process(request, response)
+  end
+end
+

data/lib/airbrake/tasks/airbrake.cap

@@ -0,0 +1,28 @@
+namespace :airbrake do
+  desc <<-DESC
+    Notify Airbrake of the deployment by running the notification on the REMOTE machine.
+      - Run remotely so we use remote API keys, environment, etc.
+  DESC
+  task :deploy do
+    # update scm state to get the repository information
+    invoke "#{scm}:update"
+    on roles(:all) do
+      within release_path do
+        # XXX: Invoking deploy:set_rails_env would set :rails_env to proper
+        # value, but that would make us depend on capistrano-rails
+        with rails_env: fetch(:rails_env, fetch(:stage)) do
+          # Compose the command notify_command
+          airbrake_env = fetch(:airbrake_env, fetch(:rails_env, fetch(:stage)))
+          notify_command = "airbrake:deploy"
+          notify_command << " TO=#{airbrake_env}"
+          notify_command << " REVISION=#{fetch(:current_revision)} REPO=#{fetch(:repo_url)}"
+          notify_command << " USER=#{local_user.strip.shellescape}"
+
+          info "Notifying Airbrake of Deploy (#{notify_command})"
+          execute :rake, notify_command
+          info "Airbrake Notification Complete."
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/user_informer.rb

@@ -0,0 +1,36 @@
+module Airbrake
+  class UserInformer
+    def initialize(app)
+      @app = app
+    end
+
+    def replacement(with)
+      Airbrake.configuration.user_information.gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      status, headers, body = @app.call(env)
+
+      if env['airbrake.error_id'] && Airbrake.configuration.user_information
+        new_body = []
+        replace  = replacement(env['airbrake.error_id'])
+        body.each do |chunk|
+          new_body << chunk.gsub("<!-- AIRBRAKE ERROR -->", replace)
+        end
+        body.close if body.respond_to?(:close)
+        headers['Content-Length'] = new_body.inject(0){|sum, x| sum + x.bytesize}.to_s
+        body = new_body
+      end
+
+      [status, headers, body]
+
+    ensure
+      body.close if body && body.respond_to?(:close) && $!
+    end
+  end
+end
+

data/lib/airbrake/utils/params_cleaner.rb

@@ -0,0 +1,141 @@
+module Airbrake
+  module Utils
+    class ParamsCleaner
+      attr_writer :blacklist_filters, :whitelist_filters, :to_clean
+      attr_reader :parameters, :cgi_data, :session_data
+
+      # Public: Initialize a new Airbrake::Utils::ParamsCleaner
+      #
+      # opts - The Hash options that contain filters and params (default: {}):
+      #        :blacklist_filters - The Array of param keys that should be filtered
+      #        :whitelist_filters - The Array of param keys that shouldn't be filtered
+      #        :to_clean - The Hash of unfiltered params
+      #        :blacklist_filters take precedence over the :whitelist_filters
+      def initialize(opts = {})
+        @blacklist_filters = (opts[:blacklist_filters] || []).flatten
+        @blacklist_filters.map!{|f| f.is_a?(Symbol) ? f.to_s : f }
+        @whitelist_filters = (opts[:whitelist_filters] || []).flatten
+        @whitelist_filters.map!{|f| f.is_a?(Symbol) ? f.to_s : f }
+        @to_clean = opts[:to_clean]
+      end
+
+      # Public: Takes the params to_clean passed in an initializer
+      #         and filters them out by filters passed.
+      #
+      #         Also normalizes unserializable data.
+      #
+      # Returns self, so that :parameters, :cgi_data, :session_data
+      # could be extracted
+      def clean
+        clean_parameters
+        clean_session_data
+        clean_cgi_data
+        clean_rack_request_data
+
+        self
+      end
+
+      private
+
+        def clean_parameters
+          return unless @to_clean[:parameters]
+
+          @parameters = if any_filters?
+            filter(clean_unserializable_data(@to_clean[:parameters]))
+          else
+            clean_unserializable_data(@to_clean[:parameters])
+          end
+        end
+
+        def clean_cgi_data
+          return unless @to_clean[:cgi_data]
+
+          @cgi_data = if any_filters?
+            filter(clean_unserializable_data(@to_clean[:cgi_data]))
+          else
+            clean_unserializable_data(@to_clean[:cgi_data])
+          end
+        end
+
+        def clean_session_data
+          return unless @to_clean[:session_data]
+
+          @session_data = if any_filters?
+            filter(clean_unserializable_data(@to_clean[:session_data]))
+          else
+            clean_unserializable_data(@to_clean[:session_data])
+          end
+        end
+
+        def clean_rack_request_data
+          if @cgi_data
+            @cgi_data.reject! do |key, val|
+              Airbrake::FILTERED_RACK_VARS.include?(key) || Airbrake::SENSITIVE_ENV_VARS.any?{|re| re.match(key)}
+            end
+          end
+        end
+
+        def any_filters?
+          @blacklist_filters.any? || @whitelist_filters.any?
+        end
+
+        def filter_key?(key)
+          blacklist_key?(key) || !whitelist_key?(key)
+        end
+
+        def blacklist_key?(key)
+          @blacklist_filters.any? do |filter|
+            key == filter || filter.is_a?(Regexp) && filter.match(key)
+          end
+        end
+
+        def whitelist_key?(key)
+          return true if @whitelist_filters.empty?
+          @whitelist_filters.any? do |filter|
+            key == filter || filter.is_a?(Regexp) && filter.match(key)
+          end
+        end
+
+        def filter(hash)
+          return hash unless hash.is_a?(Hash)
+
+          hash.each do |key, value|
+            if filter_key?(key)
+              hash[key] = "[FILTERED]"
+            elsif value.respond_to?(:to_hash)
+              filter(value)
+            elsif value.is_a?(Array)
+              hash[key] = value.map { |item| filter(item) }
+            end
+          end
+        end
+
+        # Removes non-serializable data. Allowed data types are strings, arrays,
+        # and hashes. All other types are converted to strings.
+        def clean_unserializable_data(data, stack = [])
+          return "[possible infinite recursion halted]" if stack.any?{|item| item == data.object_id }
+          if data.is_a?(String)
+            data
+          elsif data.is_a?(Hash)
+            data.inject({}) do |result, (key, value)|
+              result.merge!(key => clean_unserializable_data(value, stack + [data.object_id]))
+            end
+          elsif data.respond_to?(:to_hash)
+            data.to_hash.inject({}) do |result, (key, value)|
+              result.merge!(key => clean_unserializable_data(value, stack + [data.object_id]))
+            end
+          elsif data.respond_to?(:collect) && !data.respond_to?(:readlines)
+            data = data.collect do |value|
+              clean_unserializable_data(value, stack + [data.object_id])
+            end
+          elsif data.respond_to?(:to_ary)
+            data = data.to_ary.collect do |value|
+              clean_unserializable_data(value, stack + [data.object_id])
+            end
+          elsif data.respond_to?(:to_s)
+            data.nil? ? nil : data.to_s
+          end
+        end
+    end
+  end
+end

data/lib/airbrake/utils/rack_filters.rb

@@ -0,0 +1,45 @@
+module Airbrake
+  SENSITIVE_RACK_VARS = %w(
+      HTTP_X_CSRF_TOKEN
+      HTTP_COOKIE
+      HTTP_AUTHORIZATION
+
+      action_dispatch.request.unsigned_session_cookie
+      action_dispatch.cookies
+      action_dispatch.unsigned_session_cookie
+      action_dispatch.secret_key_base
+      action_dispatch.signed_cookie_salt
+      action_dispatch.encrypted_cookie_salt
+      action_dispatch.encrypted_signed_cookie_salt
+      action_dispatch.http_auth_salt
+      action_dispatch.secret_token
+
+      rack.request.cookie_hash
+      rack.request.cookie_string
+      rack.request.form_vars
+
+      rack.session
+      rack.session.options
+  )
+
+  RACK_VARS_CONTAINING_INSTANCES = %w(
+      action_controller.instance
+
+      action_dispatch.backtrace_cleaner
+      action_dispatch.routes
+      action_dispatch.logger
+      action_dispatch.key_generator
+
+      rack-cache.storage
+
+      rack.errors
+      rack.input
+  )
+
+  SENSITIVE_ENV_VARS = [
+      /secret/i,
+      /password/i
+  ]
+
+  FILTERED_RACK_VARS = SENSITIVE_RACK_VARS + SENSITIVE_ENV_VARS + RACK_VARS_CONTAINING_INSTANCES
+end

data/lib/airbrake/version.rb

@@ -0,0 +1,3 @@
+module Airbrake
+  VERSION = "4.3.8".freeze
+end

data/lib/airbrake_tasks.rb

@@ -0,0 +1,62 @@
+require 'net/http'
+require 'uri'
+
+# Capistrano tasks for notifying Airbrake of deploys
+module AirbrakeTasks
+
+  # Alerts Airbrake of a deploy.
+  #
+  # @param [Hash] opts Data about the deploy that is set to Airbrake
+  #
+  # @option opts [String] :rails_env Environment of the deploy (production, staging)
+  # @option opts [String] :scm_revision The given revision/sha that is being deployed
+  # @option opts [String] :scm_repository Address of your repository to help with code lookups
+  # @option opts [String] :local_username Who is deploying
+  def self.deploy(opts = {})
+    unless Airbrake.configuration.api_key =~ /\S/
+      puts "I don't seem to be configured with an API key. Please check your configuration."
+      return false
+    end
+
+    unless opts[:rails_env] =~ /\S/
+      puts "I don't know to which Rails environment you are deploying (use the TO=production option)."
+      return false
+    end
+
+    dry_run = opts.delete(:dry_run)
+    params = {'api_key' => Airbrake.configuration.api_key}
+    opts.each {|k,v| params["deploy[#{k}]"] = v }
+
+    host = Airbrake.configuration.host || 'api.airbrake.io'
+    port = Airbrake.configuration.port
+
+    proxy = Net::HTTP.Proxy(Airbrake.configuration.proxy_host,
+                            Airbrake.configuration.proxy_port,
+                            Airbrake.configuration.proxy_user,
+                            Airbrake.configuration.proxy_pass)
+    http = proxy.new(host, port)
+
+
+
+    # Handle Security
+    if Airbrake.configuration.secure?
+      http.use_ssl      = true
+      http.ca_file      = Airbrake.configuration.ca_bundle_path
+      http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+    end
+
+    post = Net::HTTP::Post.new("/deploys.txt")
+    post.set_form_data(params)
+
+    if dry_run
+      puts http.inspect, params.inspect
+      return true
+    else
+      response = http.request(post)
+
+      puts response.body
+      return Net::HTTPSuccess === response
+    end
+  end
+end
+

data/lib/rails/generators/airbrake/airbrake_generator.rb

@@ -0,0 +1,155 @@
+require 'rails/generators'
+
+class AirbrakeGenerator < Rails::Generators::Base
+  desc "Creates the Airbrake initializer file at config/initializers/airbrake.rb"
+
+  class_option :api_key, :aliases => "-k", :type => :string,
+    :desc => "Your Airbrake API key"
+
+  class_option :heroku, :type => :boolean,
+    :desc => "Use the Heroku addon to provide your Airbrake API key"
+
+  class_option :app, :aliases => "-a", :type => :string,
+    :desc => "Your Heroku app name (only required if deploying to >1 Heroku app)"
+
+  class_option :secure, :type => :boolean,
+    :desc => "Use SSL connection"
+
+  class_option :test_mode, :aliases => "-t", :type => :boolean,
+    :desc => "Use Airbrake in test mode"
+
+  def self.source_root
+    @_airbrake_source_root ||= File.expand_path("../../../../../generators/airbrake/templates", __FILE__)
+  end
+
+  def install
+    ensure_api_key_was_configured
+    ensure_plugin_is_not_present
+    append_capistrano_hook if capistrano_present?
+    generate_initializer unless api_key_configured?
+    determine_api_key if heroku?
+    test_airbrake
+  end
+
+  private
+
+  def ensure_api_key_was_configured
+    if !options[:api_key] && !options[:heroku] && !api_key_configured?
+      puts "Must pass --api-key or --heroku or create config/initializers/airbrake.rb"
+      exit
+    end
+  end
+
+  def ensure_plugin_is_not_present
+    if plugin_is_present?
+      puts "You must first remove the airbrake plugin. Please run: script/plugin remove airbrake"
+      exit
+    end
+  end
+
+  def capistrano_present?
+    !Gem.loaded_specs['capistrano'].nil? &&
+      File.exists?('config/deploy.rb') &&
+      File.exists?('Capfile')
+  end
+
+  def append_capistrano_hook
+    if capistrano_version < Gem::Version.new('3')
+      append_file('config/deploy.rb', capistrano2_hook)
+    else
+      append_file('config/deploy.rb', capistrano3_hook)
+    end
+  end
+
+  def capistrano_version
+    Gem.loaded_specs['capistrano'].version
+  end
+
+  def capistrano2_hook
+    <<-HOOK
+
+require './config/boot'
+require 'airbrake/capistrano'
+    HOOK
+  end
+
+  def capistrano3_hook
+    <<-HOOK
+
+require 'airbrake/capistrano3'
+after "deploy:finished", "airbrake:deploy"
+    HOOK
+  end
+
+  def api_key_expression
+    if options[:api_key]
+      "'#{options[:api_key]}'"
+    elsif options[:heroku]
+      "ENV['AIRBRAKE_API_KEY']"
+    end
+  end
+
+  def generate_initializer
+    template 'initializer.rb', 'config/initializers/airbrake.rb'
+  end
+
+  def determine_api_key
+    puts "Attempting to determine your API Key from Heroku..."
+    ENV['AIRBRAKE_API_KEY'] = heroku_api_key
+    if ENV['AIRBRAKE_API_KEY'] =~ /\S/
+      puts "... Done."
+      puts "Heroku's Airbrake API Key is '#{ENV['AIRBRAKE_API_KEY']}'"
+    else
+      puts "... Failed."
+      puts "WARNING: We were unable to detect the Airbrake API Key from your Heroku environment."
+      puts "Your Heroku application environment may not be configured correctly."
+      exit 1
+    end
+  end
+
+  def heroku_var(var,app_name = nil)
+    app = app_name ? "-a #{app_name}" : ''
+    `heroku config:get #{var} #{app}`
+  end
+
+  def heroku_api_key
+    heroku_var("AIRBRAKE_API_KEY",options[:app]).split.find {|x| x if x =~ /\S/}
+  end
+
+  def secure?
+    options[:secure]
+  end
+
+  def test_mode?
+    options[:test_mode]
+  end
+
+  def heroku?
+    options[:heroku] ||
+      system("grep AIRBRAKE_API_KEY config/initializers/airbrake.rb") ||
+      system("grep AIRBRAKE_API_KEY config/environment.rb")
+  end
+
+  def api_key_configured?
+    File.exists?('config/initializers/airbrake.rb')
+  end
+
+  def test_airbrake
+    puts run("rake airbrake:test")
+  end
+
+  def plugin_is_present?
+    File.exists?('vendor/plugins/airbrake')
+  end
+
+  def configuration_output
+    output = <<-eos
+Airbrake.configure do |config|
+  config.api_key = #{api_key_expression}
+    eos
+
+    output << "  config.secure = true\n" if secure?
+    output << "  config.test_mode = true\n" if test_mode?
+    output << "end"
+  end
+end