airbrakeV4rails5 4.3.8

data/generators/airbrake/lib/insert_commands.rb

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

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

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

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

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

data/install.rb

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

data/lib/airbrake.rb

@@ -0,0 +1,191 @@
+begin
+  require "girl_friday"
+rescue LoadError
+end
+
+begin
+  require "sucker_punch"
+rescue LoadError
+end
+
+require 'net/http'
+require 'net/https'
+require 'rubygems'
+require 'logger'
+
+require 'airbrake/version'
+require 'airbrake/jobs/send_job'
+require 'airbrake/utils/rack_filters'
+require 'airbrake/utils/params_cleaner'
+require 'airbrake/configuration'
+require 'airbrake/notice'
+require 'airbrake/sender'
+require 'airbrake/response'
+require 'airbrake/backtrace'
+require 'airbrake/rack'
+require 'airbrake/sinatra'
+require 'airbrake/user_informer'
+
+begin
+  require 'airbrake/sidekiq'
+rescue LoadError
+end
+
+require 'airbrake/railtie' if defined?(Rails::Railtie)
+
+module Airbrake
+  API_VERSION = "2.4"
+  LOG_PREFIX = "** [Airbrake] "
+
+  class << self
+    # The sender object is responsible for delivering formatted data to the Airbrake server.
+    # Must respond to #send_to_airbrake. See Airbrake::Sender.
+    attr_accessor :sender
+
+    # A Airbrake configuration object. Must act like a hash and return sensible
+    # values for all Airbrake configuration options. See Airbrake::Configuration.
+    attr_writer :configuration
+
+    # Tell the log that the Notifier is good to go
+    def report_ready
+      write_verbose_log("Notifier #{VERSION} ready to catch errors")
+    end
+
+    # Prints out the environment info to the log for debugging help
+    def report_environment_info
+      write_verbose_log("Environment Info: #{environment_info}")
+    end
+
+    # Prints out the response body from Airbrake for debugging help
+    def report_response_body(response)
+      write_verbose_log("Response from Airbrake: \n#{Response.pretty_format(response)}")
+    end
+
+    # Prints out the details about the notice that wasn't sent to server
+    def report_notice(notice)
+      write_verbose_log("Notice details: \n#{notice}")
+    end
+
+    def report_notice_not_sent_for_configuration
+      write_verbose_log("Notice was not sent due to configuration: \
+        \n  Environment Monitored? #{configuration.public?} \
+        \n  API key set? #{configuration.configured?}")
+    end
+
+    # Returns the Ruby version, Rails version, and current Rails environment
+    def environment_info
+      info = "[Ruby: #{RUBY_VERSION}]"
+      info << " [#{configuration.framework}]" if configuration.framework
+      info << " [Env: #{configuration.environment_name}]" if configuration.environment_name
+      info
+    end
+
+    # Writes out the given message to the #logger
+    def write_verbose_log(message)
+      logger.debug LOG_PREFIX + message if logger
+    end
+
+    # Look for the Rails logger currently defined
+    def logger
+      self.configuration.logger ||
+        Logger.new(nil)
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Airbrake.configure do |config|
+    #     config.api_key = '1234567890abcdef'
+    #     config.secure  = false
+    #   end
+    def configure(silent = false)
+      yield(configuration)
+      self.sender = if configuration.test_mode?
+                      CollectingSender.new(configuration)
+                    else
+                      Sender.new(configuration)
+                    end
+
+      report_ready unless silent
+      self.sender
+    end
+
+    # The configuration object.
+    # @see Airbrake.configure
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Sends an exception manually using this method, even when you are not in a controller.
+    #
+    # @param [Exception] exception The exception you want to notify Airbrake about.
+    # @param [Hash] opts Data that will be sent to Airbrake.
+    #
+    # @option opts [String] :api_key The API key for this project. The API key is a unique identifier that Airbrake uses for identification.
+    # @option opts [String] :error_message The error returned by the exception (or the message you want to log).
+    # @option opts [String] :backtrace A backtrace, usually obtained with +caller+.
+    # @option opts [String] :rack_env The Rack environment.
+    # @option opts [String] :session The contents of the user's session.
+    # @option opts [String] :environment_name The application environment name.
+    # @option opts [String] :parameters Additional parameters.
+    def notify(exception, opts = {})
+      send_notice(build_notice_for(exception, opts))
+    end
+
+    # Sends the notice unless it is one of the default ignored exceptions
+    # @see Airbrake.notify
+    def notify_or_ignore(exception, opts = {})
+      notice = build_notice_for(exception, opts)
+      send_notice(notice) unless notice.ignore?
+    end
+
+    def build_lookup_hash_for(exception, options = {})
+      notice = build_notice_for(exception, options)
+
+      result = {}
+      result[:action]           = notice.action      rescue nil
+      result[:component]        = notice.component   rescue nil
+      result[:error_class]      = notice.error_class if notice.error_class
+      result[:environment_name] = 'production'
+
+      unless notice.backtrace.lines.empty?
+        result[:file]        = notice.backtrace.lines.first.file
+        result[:line_number] = notice.backtrace.lines.first.number
+      end
+
+      result
+    end
+
+    private
+
+    def send_notice(notice)
+      if configuration.configured? && configuration.public?
+        if configuration.async?
+          configuration.async.call(notice)
+          nil # make sure we never set env["airbrake.error_id"] for async notices
+        else
+          sender.send_to_airbrake(notice)
+        end
+      else
+        report_notice_not_sent_for_configuration
+      end
+    end
+
+    def build_notice_for(exception, opts = {})
+      exception_classes = [exception.class.to_s]
+      exception = unwrap_exception(exception)
+      opts = opts.merge(:exception => exception) if exception.is_a?(Exception)
+      opts = opts.merge(exception.to_hash) if exception.respond_to?(:to_hash)
+      opts = opts.merge(:exception_classes => exception_classes)
+      Notice.new(configuration.merge(opts))
+    end
+
+    def unwrap_exception(exception)
+      if exception.respond_to?(:original_exception)
+        exception.original_exception
+      elsif exception.respond_to?(:continued_exception)
+        exception.continued_exception
+      end || exception
+    end
+  end
+end

data/lib/airbrake/backtrace.rb

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

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