airbrake 4.3.8 → 5.0.0.rc.1

data/lib/airbrake/tasks.rb

@@ -1,81 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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_tasks.rb

@@ -1,62 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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