airbrake 4.3.8 → 5.0.0

data/generators/airbrake/airbrake_generator.rb

@@ -1,94 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/lib/insert_commands.rb")
-require File.expand_path(File.dirname(__FILE__) + "/lib/rake_commands.rb")
-
-class AirbrakeGenerator < Rails::Generator::Base
-  def add_options!(opt)
-    opt.on('-k', '--api-key=key', String, "Your Airbrake API key")                                               { |v| options[:api_key] = v}
-    opt.on('-h', '--heroku',              "Use the Heroku addon to provide your Airbrake API key")               { |v| options[:heroku]  = v}
-    opt.on('-a', '--app=myapp', String,   "Your Heroku app name (only required if deploying to >1 Heroku app)") { |v| options[:app]     = v}
-  end
-
-  def manifest
-    if !api_key_configured? && !options[:api_key] && !options[:heroku]
-      puts "Must pass --api-key or --heroku or create config/initializers/airbrake.rb"
-      exit
-    end
-    if plugin_is_present?
-      puts "You must first remove the airbrake plugin. Please run: script/plugin remove airbrake"
-      exit
-    end
-    record do |m|
-      m.directory 'lib/tasks'
-      m.file 'airbrake_tasks.rake', 'lib/tasks/airbrake_tasks.rake'
-      if ['config/deploy.rb', 'Capfile'].all? { |file| File.exists?(file) }
-        m.append_to 'config/deploy.rb', capistrano_hook
-      end
-      if api_key_expression
-        if use_initializer?
-          m.template 'initializer.rb', 'config/initializers/airbrake.rb',
-            :assigns => {:api_key => api_key_expression}
-        else
-          m.template 'initializer.rb', 'config/airbrake.rb',
-            :assigns => {:api_key => api_key_expression}
-          m.append_to 'config/environment.rb', "require 'config/airbrake'"
-        end
-      end
-      determine_api_key if heroku?
-      m.rake "airbrake:test", :generate_only => true
-    end
-  end
-
-  def api_key_expression
-    s = if options[:api_key]
-      "'#{options[:api_key]}'"
-    elsif options[:heroku]
-      "ENV['HOPTOAD_API_KEY']"
-    end
-  end
-
-  def determine_api_key
-    puts "Attempting to determine your API Key from Heroku..."
-    ENV['HOPTOAD_API_KEY'] = heroku_api_key
-    if ENV['HOPTOAD_API_KEY'] =~ /\S/
-      puts "... Done."
-      puts "Heroku's Airbrake API Key is '#{ENV['HOPTOAD_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 ? "--app #{app_name}" : ''
-    `heroku config #{app} | grep -E "#{var.upcase}" | awk '{ print $3; }'`.strip
-  end
-
-  def heroku_api_key
-    heroku_var("(hoptoad|airbrake)_api_key",options[:app]).split.find {|x| x =~ /\S/ }
-  end
-
-  def heroku?
-    options[:heroku] ||
-      system("grep HOPTOAD_API_KEY config/initializers/airbrake.rb") ||
-      system("grep HOPTOAD_API_KEY config/environment.rb")
-  end
-
-  def use_initializer?
-    ::Rails::VERSION::MAJOR > 1
-  end
-
-  def api_key_configured?
-    File.exists?('config/initializers/airbrake.rb') ||
-      system("grep Airbrake config/environment.rb")
-  end
-
-  def capistrano_hook
-    IO.read(source_path('capistrano_hook.rb'))
-  end
-
-  def plugin_is_present?
-    File.exists?('vendor/plugins/airbrake')
-  end
-end

data/generators/airbrake/lib/insert_commands.rb

@@ -1,34 +0,0 @@
-# Mostly pinched from http://github.com/ryanb/nifty-generators/tree/master
-
-Rails::Generator::Commands::Base.class_eval do
-  def file_contains?(relative_destination, line)
-    File.read(destination_path(relative_destination)).include?(line)
-  end
-end
-
-Rails::Generator::Commands::Create.class_eval do
-  def append_to(file, line)
-    logger.insert "#{line} appended to #{file}"
-    unless options[:pretend] || file_contains?(file, line)
-      File.open(file, "a") do |file|
-        file.puts
-        file.puts line
-      end
-    end
-  end
-end
-
-Rails::Generator::Commands::Destroy.class_eval do
-  def append_to(file, line)
-    logger.remove "#{line} removed from #{file}"
-    unless options[:pretend]
-      gsub_file file, "\n#{line}", ''
-    end
-  end
-end
-
-Rails::Generator::Commands::List.class_eval do
-  def append_to(file, line)
-    logger.insert "#{line} appended to #{file}"
-  end
-end

data/generators/airbrake/lib/rake_commands.rb

@@ -1,24 +0,0 @@
-Rails::Generator::Commands::Create.class_eval do
-  def rake(cmd, opts = {})
-    logger.rake "rake #{cmd}"
-    unless system("rake #{cmd}")
-      logger.rake "#{cmd} failed. Rolling back"
-      command(:destroy).invoke!
-    end
-  end
-end
-
-Rails::Generator::Commands::Destroy.class_eval do
-  def rake(cmd, opts = {})
-    unless opts[:generate_only]
-      logger.rake "rake #{cmd}"
-      system "rake #{cmd}"
-    end
-  end
-end
-
-Rails::Generator::Commands::List.class_eval do
-  def rake(cmd, opts = {})
-    logger.rake "rake #{cmd}"
-  end
-end

data/generators/airbrake/templates/airbrake_tasks.rake

@@ -1,25 +0,0 @@
-# Don't load anything when running the gems:* tasks.
-# Otherwise, airbrake will be considered a framework gem.
-# https://thoughtbot.lighthouseapp.com/projects/14221/tickets/629
-unless ARGV.any? {|a| a =~ /^gems/}
-
-  Dir[File.join(Rails.root, 'vendor', 'gems', 'airbrake-*')].each do |vendored_notifier|
-    $: << File.join(vendored_notifier, 'lib')
-  end
-
-  begin
-    require 'airbrake/tasks'
-  rescue LoadError => exception
-    namespace :airbrake do
-      %w(deploy test log_stdout).each do |task_name|
-        desc "Missing dependency for airbrake:#{task_name}"
-        task task_name do
-          $stderr.puts "Failed to run airbrake:#{task_name} because of missing dependency."
-          $stderr.puts "You probably need to run `rake gems:install` to install the airbrake gem"
-          abort exception.inspect
-        end
-      end
-    end
-  end
-
-end

data/generators/airbrake/templates/capistrano_hook.rb

@@ -1,6 +0,0 @@
-
-Dir[File.join(File.dirname(__FILE__), '..', 'vendor', 'gems', 'airbrake-*')].each do |vendored_notifier|
-  $: << File.join(vendored_notifier, 'lib')
-end
-
-require 'airbrake/capistrano'

data/generators/airbrake/templates/initializer.rb

@@ -1,4 +0,0 @@
-<% if ::Rails::VERSION::MAJOR < 3 && ::Rails::VERSION::MINOR < 2 -%>
-require 'airbrake/rails'
-<% end -%>
-<%= configuration_output %>

data/install.rb

@@ -1 +0,0 @@
-puts IO.read(File.join(File.dirname(__FILE__), 'INSTALL'))

data/lib/airbrake/backtrace.rb

@@ -1,103 +0,0 @@
-module Airbrake
-  # Front end to parsing the backtrace for each notice
-  class Backtrace
-
-    # Handles backtrace parsing line by line
-    class Line
-
-      # regexp (optionnally allowing leading X: for windows support)
-      INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
-
-      # The file portion of the line (such as app/models/user.rb)
-      attr_reader :file
-
-      # The line number portion of the line
-      attr_reader :number
-
-      # The method_name of the line (such as index)
-      attr_reader :method_name
-
-      # Parses a single line of a given backtrace
-      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
-      # @return [Line] The parsed backtrace line
-      def self.parse(unparsed_line)
-        _, file, number, method_name = unparsed_line.match(INPUT_FORMAT).to_a
-        new(file, number, method_name)
-      end
-
-      def initialize(file, number, method_name)
-        @file   = file
-        @number = number
-        @method_name = method_name
-      end
-
-      # Reconstructs the line in a readable fashion
-      def to_s
-        "#{file}:#{number}:in `#{method_name}'"
-      end
-
-      def ==(other)
-        to_s == other.to_s
-      end
-
-      def inspect
-        "<Line:#{to_s}>"
-      end
-    end
-
-    # holder for an Array of Backtrace::Line instances
-    attr_reader :lines
-
-    def self.parse(ruby_backtrace, opts = {})
-      ruby_lines = split_multiline_backtrace(ruby_backtrace)
-
-      filters = opts[:filters] || []
-      filtered_lines = ruby_lines.to_a.map do |line|
-        filters.inject(line) do |l, proc|
-          proc.call(l)
-        end
-      end.compact
-
-      lines = filtered_lines.collect do |unparsed_line|
-        Line.parse(unparsed_line)
-      end
-
-      new(lines)
-    end
-
-    def initialize(lines)
-      @lines = lines
-    end
-
-    def inspect
-      "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
-    end
-
-    def to_s
-      content = []
-      lines.each do |line|
-        content << line
-      end
-      content.join("\n")
-    end
-
-    def ==(other)
-      if other.respond_to?(:lines)
-        lines == other.lines
-      else
-        false
-      end
-    end
-
-    private
-
-    def self.split_multiline_backtrace(backtrace)
-      backtrace = [backtrace] unless backtrace.respond_to?(:to_a)
-      if backtrace.to_a.size == 1
-        backtrace.to_a.first.split(/\n\s*/)
-      else
-        backtrace
-      end
-    end
-  end
-end

data/lib/airbrake/capistrano.rb

@@ -1,103 +0,0 @@
-# Defines deploy:notify_airbrake which will send information about the deploy to Airbrake.
-require 'capistrano'
-
-module Airbrake
-  module Capistrano
-    # What follows is a copy-paste backport of the shellescape method
-    # included in Ruby 1.9 and greater. The FSF's guidance on a snippet
-    # of this size indicates that such a small function is not subject
-    # to copyright and as such there is no risk of a license conflict:
-    # See www.gnu.org/prep/maintain/maintain.html#Legally-Significant
-    #
-    # Escapes a string so that it can be safely used in a Bourne shell
-    # command line.  +str+ can be a non-string object that responds to
-    # +to_s+.
-    #
-    # Note that a resulted string should be used unquoted and is not
-    # intended for use in double quotes nor in single quotes.
-    #
-    #   argv = Shellwords.escape("It's better to give than to receive")
-    #   argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
-    #
-    # String#shellescape is a shorthand for this function.
-    #
-    #   argv = "It's better to give than to receive".shellescape
-    #   argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
-    #
-    #   # Search files in lib for method definitions
-    #   pattern = "^[ \t]*def "
-    #   open("| grep -Ern #{pattern.shellescape} lib") { |grep|
-    #     grep.each_line { |line|
-    #       file, lineno, matched_line = line.split(':', 3)
-    #       # ...
-    #     }
-    #   }
-    #
-    # It is the caller's responsibility to encode the string in the right
-    # encoding for the shell environment where this string is used.
-    #
-    # Multibyte characters are treated as multibyte characters, not bytes.
-    #
-    # Returns an empty quoted String if +str+ has a length of zero.
-    def self.shellescape(str)
-      str = str.to_s
-
-      # An empty argument will be skipped, so return empty quotes.
-      return "''" if str.empty?
-
-      str = str.dup
-
-      # Treat multibyte characters as is.  It is caller's responsibility
-      # to encode the string in the right encoding for the shell
-      # environment.
-      str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/, "\\\\\\1")
-
-      # A LF cannot be escaped with a backslash because a backslash + LF
-      # combo is regarded as line continuation and simply ignored.
-      str.gsub!(/\n/, "'\n'")
-
-      return str
-    end
-
-    def self.load_into(configuration)
-      configuration.load do
-        after "deploy",            "airbrake:deploy"
-        after "deploy:migrations", "airbrake:deploy"
-        after "deploy:cold",       "airbrake:deploy"
-
-        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, :except => { :no_release => true } do
-            rack_env = fetch(:rack_env, nil)
-            rails_env = fetch(:rails_env, nil)
-            airbrake_env = fetch(:airbrake_env, rack_env || rails_env || "production")
-            local_user = ENV['USER'] || ENV['USERNAME']
-            executable = RUBY_PLATFORM.downcase.include?('mswin') ? fetch(:rake, 'rake.bat') : fetch(:rake, 'bundle exec rake ')
-            directory = configuration.release_path
-            notify_command = "cd #{directory}; #{executable}"
-            notify_command << " RACK_ENV=#{rack_env}" if rack_env
-            notify_command << " RAILS_ENV=#{rails_env}" if rails_env
-            notify_command << " airbrake:deploy TO=#{airbrake_env} REVISION=#{current_revision} REPO=#{repository} USER=#{Airbrake::Capistrano::shellescape(local_user)}"
-            notify_command << " DRY_RUN=true" if dry_run
-            logger.info "Notifying Airbrake of Deploy (#{notify_command})"
-            if configuration.dry_run
-              logger.info "DRY RUN: Notification not actually run."
-            else
-              result = ""
-              run(notify_command, :once => true) { |ch, stream, data| result << data }
-              # TODO: Check if SSL is active on account via result content.
-            end
-            logger.info "Airbrake Notification Complete."
-          end
-        end
-      end
-    end
-  end
-end
-
-if Capistrano::Configuration.instance
-  Airbrake::Capistrano.load_into(Capistrano::Configuration.instance)
-end

data/lib/airbrake/capistrano3.rb

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

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

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

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

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

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

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

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