airbrakeV4rails5 4.3.8

data/lib/airbrake/capistrano3.rb

@@ -0,0 +1,3 @@
+# Defines airbrake:deploy which will send information about the deploy to Airbrake.
+
+load File.expand_path("../tasks/airbrake.cap", __FILE__)

data/lib/airbrake/cli/client.rb

@@ -0,0 +1,76 @@
+require File.expand_path( "../runner", __FILE__)
+
+module Client
+  extend self
+
+  def options
+    Runner.options
+  end
+
+  def fetch_projects
+    uri = URI.parse "http://#{options.account}.airbrake.io"\
+    "/data_api/v1/projects.xml?auth_token=#{options.auth_token}"
+    http = Net::HTTP.new(uri.host,uri.port)
+    request = Net::HTTP::Get.new(uri.request_uri)
+    response = http.request(request)
+    response.body
+  end
+
+  def create_project
+    uri = URI.parse "http://#{options.account}.airbrake.io"\
+    "/data_api/v1/projects.xml"
+    http = Net::HTTP.new(uri.host,uri.port)
+    request = Net::HTTP::Post.new(uri.request_uri)
+    request.set_form_data('project[name]' => options.name,'auth_token' => options.auth_token)
+    response = http.request(request)
+    response.body
+
+    print_project_response(response.body)
+  end
+
+  def create_deploy
+    uri = URI.parse "http://airbrake.io/deploys.txt"
+    http = Net::HTTP.new(uri.host,uri.port)
+    request = Net::HTTP::Post.new(uri.request_uri)
+    opts = { 'api_key' => options.api_key }.merge!(deploy_opts)
+    request.set_form_data(opts)
+    response = http.request(request)
+    puts response.message if response.respond_to?(:message)
+  end
+
+  def deploy_opts
+    opts = {}
+    ['rails_env', 'scm_revision', 'scm_repository', 'local_username'].each do |attr|
+      opts.merge!("deploy[#{attr}]" => options.send(attr))
+    end
+    opts
+  end
+
+  def print_projects
+    factory = ProjectFactory.new
+    projects = fetch_projects
+    factory.create_projects_from_xml(projects)
+    abort "No projects were fetched. Did you provide the correct auth token?" if projects.match(/error/m)
+    puts "\nProjects\n" + "".rjust(63,"#")
+    factory.projects.each do |project|
+      puts project
+    end
+    puts
+  end
+
+  def print_project_response(response)
+    case response
+    when /errors/
+      puts "Error creating project: #{response.gsub("\n","").scan(/.*<error[^>]*>(.*?)<\/error>.*/).last.first.gsub(/\s{1,}/," ")}"
+    when /project/
+      project = Project.new(:id => response[/<id[^>]*>(.*?)<\/id>/,1],
+                            :name => response[/<name[^>]*>(.*?)<\/name>/,1],
+                            :api_key => response[/<api-key[^>]*>(.*?)<\/api-key>/,1])
+      puts "\nProject details\n" + "".rjust(63,"#")
+      puts project
+    else
+      puts "Unexpected error. Please try again!\n"
+      puts response
+    end
+  end
+end

data/lib/airbrake/cli/options.rb

@@ -0,0 +1,45 @@
+class Options
+
+  ATTRIBUTES = [:error, :message, :api_key, :host, :port, :auth_token, :name,
+                :account, :rails_env, :scm_revision, :scm_repository, :local_username]
+
+  ATTRIBUTES.each do |attribute|
+    attr_reader attribute
+  end
+
+  private
+
+  # You should not write to this from outside
+  ATTRIBUTES.each do |attribute|
+    attr_writer attribute
+  end
+
+  public
+
+  # Parses all the options passed and stores them in attributes
+  def initialize(array = [])
+    opts = Hash[*array]
+    self.error          = opts.delete("-e") || opts.delete("--error")   { RuntimeError }
+    self.message        = opts.delete("-m") || opts.delete("--message") { "I've made a huge mistake" }
+    self.api_key        = opts.delete("-k") || opts.delete("--api-key")        || config_from_file.api_key || ENV["AIRBRAKE_API_KEY"]
+    self.host           = opts.delete("-h") || opts.delete("--host")           || config_from_file.host
+    self.port           = opts.delete("-p") || opts.delete("--port")           || config_from_file.port
+    self.auth_token     = opts.delete("-t") || opts.delete("--auth-token")     || ENV["AIRBRAKE_AUTH_TOKEN"]
+    self.name           = opts.delete("-n") || opts.delete("--name")
+    self.account        = opts.delete("-a") || opts.delete("--account")        || ENV["AIRBRAKE_ACCOUNT"]
+    self.rails_env      = opts.delete("-E") || opts.delete("--rails-env")      || ENV["RAILS_ENV"] || "production"
+    self.scm_revision   = opts.delete("-r") || opts.delete("--scm-revision")   || ENV["REVISION"]
+    self.scm_repository = opts.delete("-R") || opts.delete("--scm-repository") || ENV["REPO"]
+    self.local_username = opts.delete("-u") || opts.delete("--local-username") || ENV["USER"]
+    opts
+  end
+
+  # Fallback to read from the initializer
+  def config_from_file
+    begin
+      load "config/initializers/airbrake.rb"
+    rescue LoadError
+    end
+    Airbrake.configuration
+  end
+end

data/lib/airbrake/cli/printer.rb

@@ -0,0 +1,33 @@
+module Printer
+  def self.print(collection)
+    collection.each do |element|
+      puts element
+    end
+  end
+
+  def self.print_usage
+    puts <<-USAGE
+Usage: airbrake [COMMAND] [OPTION]...
+Commands:
+  raise                          # Raise an exception specified by ERROR and MESSAGE.
+  list                           # List all the projects for given AUTH_TOKEN and ACCOUNT.
+  create                         # Create a project with the given NAME.
+  deploy                         # Send a new deployment notification to a project that matches the API_KEY.
+
+Options:
+  -e, [--error=ERROR]            # Error class to raise. Default:  RuntimeError
+  -m, [--message=MESSAGE]        # Error message. Default: "I've made a huge mistake"
+  -k, [--api-key=API_KEY]        # Api key of your Airbrake application
+  -h, [--host=HOST]              # URL of the Airbrake API server. Default: api.airbrake.io
+  -p, [--port=PORT]              # Port of the Airbrake API server. Default: 80
+  -t, [--auth-token=AUTH_TOKEN]  # The auth token used for API requests
+  -a, [--account=ACCOUNT]        # The account used for API requests
+  -n, [--name=NAME]              # The name of the project you're trying to create
+  -E, [--rails-env=NAME]         # The name of the environment you're deploying to. Default: production
+  -r, [--scm-revision=REVISION]  # SCM revision for deployment info
+  -R, [--scm-repository=REPO]    # SCM repository for deployment info
+  -u, [--local-username=USER]    # The name of the user who is deploying
+  -h, [--help]                   # Show this usage
+   USAGE
+  end
+end

data/lib/airbrake/cli/project.rb

@@ -0,0 +1,17 @@
+class Project
+  attr_writer :name, :id, :api_key
+
+  def initialize(attributes = {})
+    attributes.keys.each do |key|
+      instance_variable_set("@#{key}",attributes[key])
+    end
+  end
+
+  def to_s
+    "#{@name}".rjust(20) + "(#{@id}):".rjust(10) + " #{@api_key}"
+  end
+
+  def valid?
+    @name && @id && @api_key
+  end
+end

data/lib/airbrake/cli/project_factory.rb

@@ -0,0 +1,33 @@
+require File.expand_path( "../project", __FILE__)
+# Responsible for creating projects when needed.
+# Creates them from XML received.
+class ProjectFactory
+  attr_reader :project, :projects
+
+  def initialize
+    @project = Project.new
+    @projects = []
+  end
+
+  def create_projects_from_xml(xml)
+    xml.split("\n").each do |line|
+      /<name[^>]*>(.*)<\/name>/ =~ line
+      name = $1
+      project.name    = name.capitalize if name
+      /<id[^>]*>(.*)<\/id>/ =~ line
+      id = $1
+      project.id      = id              if id
+      /<api-key[^>]*>(.*)<\/api-key>/ =~ line
+      api_key = $1
+      project.api_key = api_key         if api_key
+      check_project
+    end
+  end
+
+  def check_project
+    if @project.valid?
+      projects << @project
+      @project = Project.new
+    end
+  end
+end

data/lib/airbrake/cli/runner.rb

@@ -0,0 +1,49 @@
+require File.expand_path( "../project_factory", __FILE__)
+require File.expand_path( "../options", __FILE__)
+require File.expand_path( "../validator", __FILE__)
+require File.expand_path( "../printer", __FILE__)
+require File.expand_path( "../client", __FILE__)
+
+module Runner
+  extend Validator
+
+  extend self
+
+  attr_accessor :options
+
+  def run!(command, cli_options = {})
+
+    self.options = Options.new(cli_options)
+
+    case command
+    when 'raise'
+      validates :api_key
+      Airbrake.configure do |c|
+        c.api_key = options.api_key
+        c.host    = options.host if options.host
+        c.port    = options.port if options.port
+        c.secure  = options.port.to_i == 443
+      end
+      exception_id = Airbrake.notify(:error_class   => options.error,
+                                     :error_message => "#{options.error}: #{options.message}",
+                                     :cgi_data      => ENV)
+      abort "Error sending exception to Airbrake server. Try again later." unless exception_id
+      puts "Exception sent successfully: http://airbrake.io/locate/#{exception_id}"
+
+    when "list"
+      validates :auth_token, :account
+      Client.print_projects
+
+    when "create"
+      validates :auth_token, :account
+      Client.create_project
+
+    when "deploy"
+      validates :api_key
+      Client.create_deploy
+
+    else
+      Printer.print_usage
+    end
+  end
+end

data/lib/airbrake/cli/validator.rb

@@ -0,0 +1,8 @@
+module Validator
+  def validates(*attributes)
+    attributes.each do |attribute|
+      abort "You didn't provide #{attribute.to_s.upcase}"\
+        " so no API request was made." unless Runner.options.send(attribute)
+    end
+  end
+end

data/lib/airbrake/configuration.rb

@@ -0,0 +1,366 @@
+module Airbrake
+  # Used to set up and modify settings for the notifier.
+  class Configuration
+
+    OPTIONS = [:api_key, :backtrace_filters, :development_environments,
+        :development_lookup, :environment_name, :host,
+        :http_open_timeout, :http_read_timeout, :ignore, :ignore_by_filters,
+        :ignore_user_agent, :notifier_name, :notifier_url, :notifier_version,
+        :params_filters, :params_whitelist_filters, :project_root, :port, :protocol, :proxy_host,
+        :proxy_pass, :proxy_port, :proxy_user, :secure, :use_system_ssl_cert_chain,
+        :framework, :user_information, :rescue_rake_exceptions, :rake_environment_filters,
+        :test_mode].freeze
+
+    # The API key for your project, found on the project edit form.
+    attr_accessor :api_key
+
+    # The host to connect to (defaults to airbrake.io).
+    attr_accessor :host
+
+    # The port on which your Airbrake server runs (defaults to 443 for secure
+    # connections, 80 for insecure connections).
+    attr_writer :port
+
+    # +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+
+    # +true+ to use whatever CAs OpenSSL has installed on your system. +false+ to use the ca-bundle.crt file included in Airbrake itself (reccomended and default)
+    attr_accessor :use_system_ssl_cert_chain
+
+    # The HTTP open timeout in seconds (defaults to 2).
+    attr_accessor :http_open_timeout
+
+    # The HTTP read timeout in seconds (defaults to 5).
+    attr_accessor :http_read_timeout
+
+    # The hostname of your proxy server (if using a proxy)
+    attr_accessor :proxy_host
+
+    # The port of your proxy server (if using a proxy)
+    attr_accessor :proxy_port
+
+    # The username to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_user
+
+    # The password to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_pass
+
+    # A list of parameters that should be filtered out of what is sent to Airbrake.
+    # By default, all "password" attributes will have their contents replaced.
+    attr_accessor :params_filters
+
+    # A list of whitelisted parameters that will be sent to Airbrake.
+    # All other parameters will be filtered and their content replaced.
+    # By default this list is empty (all parameters are whitelisted).
+    attr_accessor :params_whitelist_filters
+
+    # A list of filters for cleaning and pruning the backtrace. See #filter_backtrace.
+    attr_reader :backtrace_filters
+
+    # A list of filters for ignoring exceptions. See #ignore_by_filter.
+    attr_reader :ignore_by_filters
+
+    # A list of environment keys that will be ignored from what is sent to Airbrake server
+    # Empty by default and used only in rake handler
+    attr_reader :rake_environment_filters
+
+    # A list of exception classes to ignore during server requests. The array can be appended to.
+    attr_reader :ignore
+
+    # A list of exception classes to ignore during Rake tasks. The array can be appended to.
+    attr_reader :ignore_rake
+
+    # A list of user agents that are being ignored. The array can be appended to.
+    attr_reader :ignore_user_agent
+
+    # A list of environments in which notifications should not be sent.
+    attr_accessor :development_environments
+
+    # +true+ if you want to check for production errors matching development errors, +false+ otherwise.
+    attr_accessor :development_lookup
+
+    # The name of the environment the application is running in
+    attr_accessor :environment_name
+
+    # The path to the project in which the error occurred, such as the Rails.root
+    attr_accessor :project_root
+
+    # The name of the notifier library being used to send notifications (such as "Airbrake Notifier")
+    attr_accessor :notifier_name
+
+    # The version of the notifier library being used to send notifications (such as "1.0.2")
+    attr_accessor :notifier_version
+
+    # The url of the notifier library being used to send notifications
+    attr_accessor :notifier_url
+
+    # The logger used by Airbrake
+    attr_accessor :logger
+
+    # The text that the placeholder is replaced with. {{error_id}} is the actual error number.
+    attr_accessor :user_information
+
+    # The framework Airbrake is configured to use
+    attr_accessor :framework
+
+    # Should Airbrake catch exceptions from Rake tasks?
+    # (boolean or nil; set to nil to catch exceptions when rake isn't running from a terminal; default is nil)
+    attr_accessor :rescue_rake_exceptions
+    alias_method :rescue_rake_exceptions?, :rescue_rake_exceptions
+
+    # User attributes that are being captured
+    attr_reader :user_attributes
+
+    # Only used for JSON API
+    attr_reader :project_id
+
+    # Setting this to true will use the CollectingSender instead of
+    # the default one which will cause storing the last notice locally
+    attr_accessor :test_mode
+    alias_method :test_mode?, :test_mode
+
+    DEFAULT_PARAMS_FILTERS  = %w(password password_confirmation).freeze
+    DEFAULT_PARAMS_WHITELIST_FILTERS = [].freeze
+
+    DEFAULT_USER_ATTRIBUTES = %w(id).freeze
+
+    VALID_USER_ATTRIBUTES   = %w(id name username email).freeze
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line|
+        if defined?(Airbrake.configuration.project_root) && Airbrake.configuration.project_root.to_s != ''
+          line.sub(/#{Airbrake.configuration.project_root}/, "[PROJECT_ROOT]")
+        else
+          line
+        end
+      },
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        Gem.path.each{ |path| line.sub!(/#{path}/, "[GEM_ROOT]") unless path.to_s.strip.empty? } if defined?(Gem)
+        line
+      },
+      lambda { |line| line if line !~ %r{lib/airbrake} }
+    ].freeze
+
+    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                      'ActionController::RoutingError',
+                      'ActionController::InvalidAuthenticityToken',
+                      'CGI::Session::CookieStore::TamperedWithCookie',
+                      'ActionController::UnknownHttpMethod',
+                      'ActionController::UnknownAction',
+                      'AbstractController::ActionNotFound',
+                      'Mongoid::Errors::DocumentNotFound',
+                      'ActionController::UnknownFormat']
+
+    alias_method :secure?, :secure
+    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
+
+    def initialize
+      @secure                   = false
+      @use_system_ssl_cert_chain= false
+      @host                     = 'api.airbrake.io'
+      @port                     = nil
+      @http_open_timeout        = 2
+      @http_read_timeout        = 5
+      @params_filters           = DEFAULT_PARAMS_FILTERS.dup
+      @params_whitelist_filters = DEFAULT_PARAMS_WHITELIST_FILTERS.dup
+      @backtrace_filters        = DEFAULT_BACKTRACE_FILTERS.dup
+      @ignore_by_filters        = []  # These filters are applied to both server requests and Rake tasks
+      @ignore                   = IGNORE_DEFAULT.dup
+      @ignore_rake              = []  # Rake tasks don't ignore any exception classes by default
+      @ignore_user_agent        = []
+      @development_environments = %w(development test cucumber)
+      @development_lookup       = true
+      @notifier_name            = 'Airbrake Notifier'
+      @notifier_version         = VERSION
+      @notifier_url             = 'https://github.com/airbrake/airbrake'
+      @framework                = 'Standalone'
+      @user_information         = 'Airbrake Error {{error_id}}'
+      @rescue_rake_exceptions   = nil
+      @user_attributes          = DEFAULT_USER_ATTRIBUTES.dup
+      @rake_environment_filters = []
+      @async                    = nil
+    end
+
+    # Takes a block and adds it to the list of backtrace filters. When the filters
+    # run, the block will be handed each line of the backtrace and can modify
+    # it as necessary.
+    #
+    # @example
+    #   config.filter_bracktrace do |line|
+    #     line.gsub(/^#{Rails.root}/, "[Rails.root]")
+    #   end
+    #
+    # @param [Proc] block The new backtrace filter.
+    # @yieldparam [String] line A line in the backtrace.
+    def filter_backtrace(&block)
+      self.backtrace_filters << block
+    end
+
+    # Takes a block and adds it to the list of ignore filters.
+    # When the filters run, the block will be handed the exception.
+    # @example
+    #   config.ignore_by_filter do |exception_data|
+    #     true if exception_data[:error_class] == "RuntimeError"
+    #   end
+    #
+    # @param [Proc] block The new ignore filter
+    # @yieldparam [Hash] data The exception data given to +Airbrake.notify+
+    # @yieldreturn [Boolean] If the block returns true the exception will be ignored, otherwise it will be processed by airbrake.
+    def ignore_by_filter(&block)
+      self.ignore_by_filters << block
+    end
+
+    # Overrides the list of default ignored errors.
+    #
+    # @param [Array<Exception>] names A list of exceptions to ignore.
+    def ignore_only=(names)
+      @ignore = [names].flatten
+    end
+
+    # Overrides the list of default ignored errors during Rake tasks.
+    #
+    # @param [Array<Exception>] names A list of rake exceptions to ignore.
+    def ignore_rake_only=(names)
+      @ignore_rake = [names].flatten
+    end
+
+    # Overrides the list of default ignored user agents
+    #
+    # @param [Array<String>] A list of user agents to ignore
+    def ignore_user_agent_only=(names)
+      @ignore_user_agent = [names].flatten
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash[option.to_sym] = self.send(option)
+        hash
+      end
+    end
+
+    # Returns a hash of all configurable options merged with +hash+
+    #
+    # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+    # Determines if the notifier will send notices.
+    # @return [Boolean] Returns +true+ if an api string exists, +false+ otherwise.
+    def configured?
+      !api_key.nil? && !api_key.empty?
+    end
+
+    # Determines if the notifier will send notices.
+    # @return [Boolean] Returns +false+ if in a development environment, +true+ otherwise.
+    def public?
+      @public ||= !development_environments.include?(environment_name)
+    end
+
+    def port
+      @port || default_port
+    end
+
+    # Determines whether protocol should be "http" or "https".
+    # @return [String] Returns +"http"+ if you've set secure to +false+ in
+    # configuration, and +"https"+ otherwise.
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    def user_attributes=(user_attributes)
+      @user_attributes = validate_user_attributes user_attributes
+    end
+
+    # Should Airbrake send notifications asynchronously
+    # (boolean, nil or callable; default is nil).
+    # Can be used as callable-setter when block provided.
+    def async(&block)
+      if block_given?
+        @async = block
+      end
+      @async
+    end
+    alias_method :async?, :async
+
+    def async=(use_default_or_this)
+      @async = use_default_or_this == true ?
+        default_async_processor :
+        use_default_or_this
+    end
+
+    def rescue_rake_exceptions=(val)
+      if val && !defined?(Airbrake::RakeHandler)
+        raise LoadError, "you must require 'airbrake/rake_handler' to rescue from rake exceptions"
+      end
+      @rescue_rake_exceptions = val
+    end
+
+    def ca_bundle_path
+      if use_system_ssl_cert_chain?
+        OpenSSL::X509::DEFAULT_CERT_FILE if File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
+      else
+        local_cert_path # ca-bundle.crt built from source, see resources/README.md
+      end
+    end
+
+    def local_cert_path
+      File.expand_path(File.join("..", "..", "..", "resources", "ca-bundle.crt"), __FILE__)
+    end
+
+    def project_id=(project_id)
+      @project_id = "#{project_id}"
+    end
+
+  private
+    # Determines what port should we use for sending notices.
+    # @return [Fixnum] Returns 443 if you've set secure to true in your
+    # configuration, and 80 otherwise.
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+
+    # Async notice delivery defaults to girl friday
+    def default_async_processor
+      if defined?(SuckerPunch)
+        lambda {|notice| SendJob.new.async.perform(notice)}
+      elsif defined?(GirlFriday)
+        queue = GirlFriday::WorkQueue.new(nil, :size => 3) do |notice|
+          Airbrake.sender.send_to_airbrake(notice)
+        end
+        lambda {|notice| queue << notice}
+      else
+        warn "[AIRBRAKE] You can't use the default async handler without sucker_punch or girl_friday."\
+        " Please make sure you have sucker_punch or girl_friday installed (sucker_punch is recommended)."
+      end
+    end
+
+    def validate_user_attributes(user_attributes)
+      user_attributes.reject do |attribute|
+        unless VALID_USER_ATTRIBUTES.include? attribute.to_s
+          warn "[AIRBRAKE] Unsupported user attribute: '#{attribute}'. "\
+            "This attribute will not be shown in the Airbrake UI. "\
+            "Check http://git.io/h6YRpA for more info."
+          true
+        end
+      end
+    end
+  end
+end