bugsnag-maglev- 2.8.12

data/lib/bugsnag/rack.rb

@@ -0,0 +1,53 @@
+module Bugsnag
+  class Rack
+    def initialize(app)
+      @app = app
+
+      # Configure bugsnag rack defaults
+      Bugsnag.configure do |config|
+        # Try to set the release_stage automatically if it hasn't already been set
+        config.release_stage ||= ENV["RACK_ENV"] if ENV["RACK_ENV"]
+
+        # Try to set the project_root if it hasn't already been set, or show a warning if we can't
+        unless config.project_root && !config.project_root.to_s.empty?
+          if defined?(settings)
+            config.project_root = settings.root
+          else
+            Bugsnag.warn("You should set your app's project_root (see https://bugsnag.com/docs/notifiers/ruby#project_root).")
+          end
+        end
+
+        # Hook up rack-based notification middlewares
+        config.middleware.insert_before([Bugsnag::Middleware::Rails3Request,Bugsnag::Middleware::Callbacks], Bugsnag::Middleware::RackRequest) if defined?(::Rack)
+        config.middleware.insert_before(Bugsnag::Middleware::Callbacks, Bugsnag::Middleware::WardenUser) if defined?(Warden)
+
+        Bugsnag.configuration.app_type ||= "rack"
+      end
+    end
+
+    def call(env)
+      # Set the request data for bugsnag middleware to use
+      Bugsnag.set_request_data(:rack_env, env)
+
+      begin
+        response = @app.call(env)
+      rescue Exception => raised
+        # Notify bugsnag of rack exceptions
+        Bugsnag.auto_notify(raised)
+
+        # Re-raise the exception
+        raise
+      end
+
+      # Notify bugsnag of rack exceptions
+      if env["rack.exception"]
+        Bugsnag.auto_notify(env["rack.exception"])
+      end
+
+      response
+    ensure
+      # Clear per-request data after processing the each request
+      Bugsnag.clear_request_data
+    end
+  end
+end

data/lib/bugsnag/rails.rb

@@ -0,0 +1,66 @@
+# Rails 2.x hooks
+# For Rails 3+ hooks, see railtie.rb
+
+require "bugsnag"
+require "bugsnag/rails/controller_methods"
+require "bugsnag/rails/action_controller_rescue"
+require "bugsnag/rails/active_record_rescue"
+require "bugsnag/middleware/rails2_request"
+require "bugsnag/middleware/callbacks"
+
+module Bugsnag
+  module Rails
+    def self.initialize
+      if defined?(ActionController::Base)
+        ActionController::Base.send(:include, Bugsnag::Rails::ActionControllerRescue)
+        ActionController::Base.send(:include, Bugsnag::Rails::ControllerMethods)
+      end
+      if defined?(ActiveRecord::Base) && Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("4.3")
+        unless ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks) && ActiveRecord::Base.raise_in_transactional_callbacks
+          ActiveRecord::Base.send(:include, Bugsnag::Rails::ActiveRecordRescue)
+        end
+      end
+
+      Bugsnag.configure do |config|
+        config.logger ||= rails_logger
+        config.release_stage = rails_env if rails_env
+        config.project_root = rails_root if rails_root
+
+        config.middleware.insert_before(Bugsnag::Middleware::Callbacks,Bugsnag::Middleware::Rails2Request)
+      end
+
+      # Auto-load configuration settings from config/bugsnag.yml if it exists
+      config_file = File.join(rails_root, "config", "bugsnag.yml")
+      config = YAML.load_file(config_file) if File.exists?(config_file)
+      Bugsnag.configure(config[rails_env] ? config[rails_env] : config) if config
+
+      Bugsnag.configuration.app_type = "rails"
+    end
+
+    def self.rails_logger
+      if defined?(::Rails.logger)
+        rails_logger = ::Rails.logger
+      elsif defined?(RAILS_DEFAULT_LOGGER)
+        rails_logger = RAILS_DEFAULT_LOGGER
+      end
+    end
+
+    def self.rails_env
+      if defined?(::Rails.env)
+        ::Rails.env
+      elsif defined?(RAILS_ENV)
+        RAILS_ENV
+      end
+    end
+
+    def self.rails_root
+      if defined?(::Rails.root)
+        ::Rails.root
+      elsif defined?(RAILS_ROOT)
+        RAILS_ROOT
+      end
+    end
+  end
+end
+
+Bugsnag::Rails.initialize

data/lib/bugsnag/rails/action_controller_rescue.rb

@@ -0,0 +1,62 @@
+# Rails 2.x only
+module Bugsnag::Rails
+  module ActionControllerRescue
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      # Hook into rails exception rescue stack
+      base.send(:alias_method, :rescue_action_in_public_without_bugsnag, :rescue_action_in_public)
+      base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_bugsnag)
+
+      base.send(:alias_method, :rescue_action_locally_without_bugsnag, :rescue_action_locally)
+      base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_bugsnag)
+
+      # Run filters on requests to capture request data
+      base.send(:prepend_before_filter, :set_bugsnag_request_data)
+    end
+
+    private
+    def set_bugsnag_request_data
+      Bugsnag.clear_request_data
+      Bugsnag.set_request_data(:rails2_request, request)
+    end
+
+    def rescue_action_in_public_with_bugsnag(exception)
+      Bugsnag.auto_notify(exception)
+
+      rescue_action_in_public_without_bugsnag(exception)
+    end
+
+    def rescue_action_locally_with_bugsnag(exception)
+      Bugsnag.auto_notify(exception)
+
+      rescue_action_locally_without_bugsnag(exception)
+    end
+
+    module ClassMethods
+
+      def self.extended(base)
+        base.singleton_class.class_eval do
+          alias_method_chain :filter_parameter_logging, :bugsnag
+        end
+      end
+
+      # Rails 2 does parameter filtering via a controller configuration method
+      # that dynamically defines a method on the controller, so the configured
+      # parameters aren't easily accessible. Intercept these parameters as
+      # they're configured so that the Bugsnag configuration can take them
+      # into account.
+      #
+      def filter_parameter_logging_with_bugsnag(*filter_words, &block)
+        if filter_words.length > 0
+          Bugsnag.configure do |config|
+            # Use the same regular expression that Rails parameter filtering uses.
+            config.params_filters << Regexp.new(filter_words.collect{ |s| s.to_s }.join('|'), true)
+          end
+        end
+        filter_parameter_logging_without_bugsnag(*filter_words, &block)
+      end
+    end
+
+  end
+end

data/lib/bugsnag/rails/active_record_rescue.rb

@@ -0,0 +1,20 @@
+module Bugsnag::Rails
+  module ActiveRecordRescue
+    KINDS = [:commit, :rollback].freeze
+
+    def run_callbacks(kind, *args, &block)
+      if KINDS.include?(kind)
+        begin
+          super
+        rescue StandardError => exception
+          # This exception will NOT be escalated, so notify it here.
+          Bugsnag.auto_notify(exception)
+          raise
+        end
+      else
+        # Let the post process handle the exception
+        super
+      end
+    end
+  end
+end

data/lib/bugsnag/rails/controller_methods.rb

@@ -0,0 +1,44 @@
+module Bugsnag::Rails
+  module ControllerMethods
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      private
+      def before_bugsnag_notify(*methods, &block)
+        _add_bugsnag_notify_callback(:before_callbacks, *methods, &block)
+      end
+
+      def after_bugsnag_notify(*methods, &block)
+        _add_bugsnag_notify_callback(:after_callbacks, *methods, &block)
+      end
+
+      def _add_bugsnag_notify_callback(callback_key, *methods, &block)
+        options = methods.last.is_a?(Hash) ? methods.pop : {}
+
+        before_filter(options) do |controller|
+          request_data = Bugsnag.configuration.request_data
+          request_data[callback_key] ||= []
+
+          # Set up "method symbol" callbacks
+          methods.each do |method_symbol|
+            request_data[callback_key] << lambda { |notification|
+              controller.send(method_symbol, notification)
+            }
+          end
+
+          # Set up "block" callbacks
+          request_data[callback_key] << lambda { |notification|
+            controller.instance_exec(notification, &block)
+          } if block_given?
+        end
+      end
+    end
+
+    private
+    def notify_bugsnag(exception, custom_data=nil)
+      Bugsnag.notify(exception, custom_data)
+    end
+  end
+end

data/lib/bugsnag/railtie.rb

@@ -0,0 +1,78 @@
+# Rails 3.x hooks
+
+require "rails"
+require "bugsnag"
+require "bugsnag/middleware/rails3_request"
+require "bugsnag/middleware/rack_request"
+
+module Bugsnag
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require "bugsnag/rake"
+      load "bugsnag/tasks/bugsnag.rake"
+    end
+
+    # send notifications if a command fails in a 'rails runner' call
+    if self.respond_to? :runner
+      runner do
+        at_exit do
+          if $!
+            Bugsnag.auto_notify($!)
+          end
+        end
+      end
+    end
+
+    config.before_initialize do
+      # Configure bugsnag rails defaults
+      Bugsnag.configure do |config|
+        config.logger = ::Rails.logger
+        config.release_stage = ::Rails.env.to_s
+        config.project_root = ::Rails.root.to_s
+        config.middleware.insert_before Bugsnag::Middleware::Callbacks, Bugsnag::Middleware::Rails3Request
+      end
+
+      # Auto-load configuration settings from config/bugsnag.yml if it exists
+      config_file = ::Rails.root.join("config", "bugsnag.yml")
+      config = YAML.load_file(config_file) if File.exists?(config_file)
+      Bugsnag.configure(config[::Rails.env] ? config[::Rails.env] : config) if config
+
+      if defined?(::ActionController::Base)
+        require "bugsnag/rails/controller_methods"
+        ::ActionController::Base.send(:include, Bugsnag::Rails::ControllerMethods)
+      end
+      if defined?(ActionController::API)
+        ActionController::API.send(:include, Bugsnag::Rails::ControllerMethods)
+      end
+      if defined?(ActiveRecord::Base)
+        require "bugsnag/rails/active_record_rescue"
+        ActiveRecord::Base.send(:include, Bugsnag::Rails::ActiveRecordRescue)
+      end
+
+      Bugsnag.configuration.app_type = "rails"
+    end
+
+    # Configure params_filters after initialization, so that rails initializers
+    # may set filter_parameters which will be picked up by Bugsnag.
+    config.after_initialize do
+      Bugsnag.configure do |config|
+        config.params_filters += ::Rails.configuration.filter_parameters.map do |filter|
+          case filter
+          when String, Symbol
+            /\A#{filter}\z/
+          else
+            filter
+          end
+        end
+      end
+    end
+
+    initializer "bugsnag.use_rack_middleware" do |app|
+      begin
+        app.config.middleware.insert_after ActionDispatch::DebugExceptions, "Bugsnag::Rack"
+      rescue
+        app.config.middleware.use "Bugsnag::Rack"
+      end
+    end
+  end
+end

data/lib/bugsnag/rake.rb

@@ -0,0 +1,25 @@
+require 'bugsnag'
+
+Rake::TaskManager.record_task_metadata = true
+
+class Rake::Task
+
+  def execute_with_bugsnag(args=nil)
+    Bugsnag.configuration.app_type = "rake"
+    old_task = Bugsnag.configuration.request_data[:bugsnag_running_task]
+    Bugsnag.set_request_data :bugsnag_running_task, self
+
+    execute_without_bugsnag(args)
+
+  rescue Exception => ex
+    Bugsnag.auto_notify(ex)
+    raise
+  ensure
+    Bugsnag.set_request_data :bugsnag_running_task, old_task
+  end
+
+  alias_method :execute_without_bugsnag, :execute
+  alias_method :execute, :execute_with_bugsnag
+end
+
+Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Rake)

data/lib/bugsnag/resque.rb

@@ -0,0 +1,40 @@
+require "resque"
+require "resque/failure/multiple"
+
+module Bugsnag
+  class Resque < ::Resque::Failure::Base
+    def self.configure(&block)
+      add_failure_backend
+      Bugsnag.configure(&block)
+    end
+
+    def self.add_failure_backend
+      return if ::Resque::Failure.backend == self
+
+      # Ensure resque is using a "Multiple" failure backend
+      unless ::Resque::Failure.backend < ::Resque::Failure::Multiple
+        original_backend = ::Resque::Failure.backend
+        ::Resque::Failure.backend = ::Resque::Failure::Multiple
+        ::Resque::Failure.backend.classes ||= []
+        ::Resque::Failure.backend.classes << original_backend
+      end
+
+      # Add Bugsnag failure backend
+      unless ::Resque::Failure.backend.classes.include?(self)
+        ::Resque::Failure.backend.classes << self
+      end
+    end
+
+    def save
+      Bugsnag.auto_notify(exception, {:context => "resque##{queue}", :payload => payload, :delivery_method => :synchronous})
+    end
+  end
+end
+
+# For backwards compatibility
+Resque::Failure::Bugsnag = Bugsnag::Resque
+
+# Auto-load the failure backend
+Bugsnag::Resque.add_failure_backend
+
+Bugsnag.configuration.app_type = "resque"

data/lib/bugsnag/sidekiq.rb

@@ -0,0 +1,38 @@
+require 'sidekiq'
+
+module Bugsnag
+  class Sidekiq
+    def call(worker, msg, queue)
+      begin
+
+        # store msg/queue in thread local state to be read by Bugsnag::Middleware::Sidekiq
+        Bugsnag.set_request_data :sidekiq, { :msg => msg, :queue => queue }
+
+        yield
+      rescue Exception => ex
+        raise ex if [Interrupt, SystemExit, SignalException].include? ex.class
+        Bugsnag.auto_notify(ex)
+        raise
+      ensure
+        Bugsnag.clear_request_data
+      end
+    end
+  end
+end
+
+if ::Sidekiq::VERSION < '3'
+  ::Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add ::Bugsnag::Sidekiq
+    end
+  end
+else
+  ::Sidekiq.configure_server do |config|
+    config.error_handlers << lambda do |ex, ctx|
+      Bugsnag.auto_notify(ex, :sidekiq => ctx, :context => "sidekiq##{ctx['queue']}")
+    end
+  end
+end
+
+Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Sidekiq)
+Bugsnag.configuration.app_type = "sidekiq"

data/lib/bugsnag/tasks.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].each do |task|
+  load task
+end

data/lib/bugsnag/tasks/bugsnag.cap

@@ -0,0 +1,48 @@
+namespace :load do
+
+  task :defaults do
+
+    set :bugsnag_default_hooks, ->{ true }
+
+  end
+
+end
+
+namespace :deploy do
+
+  before :starting, :bugsnag_hooks do
+    invoke 'bugsnag:add_default_hooks' if fetch(:bugsnag_default_hooks)
+  end
+
+end
+
+namespace :bugsnag do
+
+  task :add_default_hooks do
+    after 'deploy:published', 'bugsnag:deploy'
+  end
+
+  desc 'Notify Bugsnag that new production code has been deployed'
+  task :deploy do
+    run_locally do
+      begin
+        Bugsnag::Deploy.notify({
+          :api_key => fetch(:bugsnag_api_key, ENV["BUGSNAG_API_KEY"]),
+          :release_stage => fetch(:bugsnag_env) || fetch(:rails_env) || fetch(:stage) || ENV["BUGSNAG_RELEASE_STAGE"] || "production",
+          :revision => fetch(:current_revision, ENV["BUGSNAG_REVISION"]),
+          :repository => fetch(:repo_url, ENV["BUGSNAG_REPOSITORY"]),
+          :branch => fetch(:branch, ENV["BUGSNAG_BRANCH"]),
+          :app_version => fetch(:app_version, ENV["BUGSNAG_APP_VERSION"]),
+          :endpoint => fetch(:bugsnag_endpoint, Bugsnag::Configuration::DEFAULT_ENDPOINT),
+          :use_ssl => fetch(:bugsnag_use_ssl, true)
+        })
+      rescue
+        error "Bugsnag deploy notification failed, #{$!.inspect}"
+      end
+
+      info 'Bugsnag deploy notification complete.'
+    end
+  end
+
+end
+# vi:ft=ruby