honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/plugin.rb

@@ -0,0 +1,110 @@
+require 'forwardable'
+
+module Honeybadger
+  class Plugin
+    CALLER_FILE = Regexp.new('\A([^:]+)(?=(:\d+))').freeze
+
+    class << self
+      @@instances = {}
+
+      def instances
+        @@instances
+      end
+
+      def register(name = nil)
+        name ||= name_from_caller(caller) or
+          raise(ArgumentError, 'Plugin name is required, but was nil.')
+        instances[key = name.to_sym] and fail("Already registered: #{name}")
+        instances[key] = new(name).tap { |d| d.instance_eval(&Proc.new) }
+      end
+
+      def load!(config)
+        instances.each_pair do |name, plugin|
+          if config.load_plugin?(name)
+            plugin.load!(config)
+          else
+            config.logger.debug(sprintf('skip plugin name=%s reason=disabled', name))
+          end
+        end
+      end
+
+      def name_from_caller(caller)
+        caller && caller[0].match(CALLER_FILE) or
+          fail("Unable to determine name from caller: #{caller.inspect}")
+        File.basename($1)[/[^\.]+/]
+      end
+    end
+
+    class Execution
+      extend Forwardable
+
+      def initialize(config, &block)
+        @config = config
+        @block = block
+      end
+
+      def call
+        instance_eval(&block)
+      end
+
+      private
+
+      attr_reader :config, :block
+      def_delegator :@config, :logger
+    end
+
+    def initialize(name)
+      @name         = name
+      @loaded       = false
+      @requirements = []
+      @executions   = []
+    end
+
+    def requirement
+      @requirements << Proc.new
+    end
+
+    def execution
+      @executions << Proc.new
+    end
+
+    def ok?(config)
+      @requirements.all? {|r| Execution.new(config, &r).call }
+    rescue => e
+      config.logger.error(sprintf('plugin error name=%s class=%s message=%s location=%s', name, e.class, e.message.dump, e.backtrace.first.dump))
+      false
+    end
+
+    def load!(config)
+      if @loaded
+        config.logger.debug(sprintf('skip plugin name=%s reason=loaded', name))
+        return false
+      elsif ok?(config)
+        config.logger.debug(sprintf('load plugin name=%s', name))
+        @executions.each {|e| Execution.new(config, &e).call }
+        @loaded = true
+      else
+        config.logger.debug(sprintf('skip plugin name=%s reason=requirement', name))
+      end
+
+      @loaded
+    rescue => e
+      config.logger.error(sprintf('plugin error name=%s class=%s message=%s location=%s', name, e.class, e.message.dump, e.backtrace.first.dump))
+      @loaded = true
+      false
+    end
+
+    # Private: Used for testing only; don't normally call this. :)
+    #
+    # Returns nothing
+    def reset!
+      @loaded = false
+    end
+
+    def loaded?
+      @loaded
+    end
+
+    attr_reader :name, :requirements, :executions
+  end
+end

data/lib/honeybadger/plugins/delayed_job.rb

@@ -0,0 +1,22 @@
+require 'honeybadger/plugin'
+
+module Honeybadger
+  Plugin.register do
+    requirement { defined?(::Delayed::Plugin) }
+    requirement { defined?(::Delayed::Worker.plugins) }
+    requirement do
+      if delayed_job_honeybadger = defined?(::Delayed::Plugins::Honeybadger)
+        logger.warn("Support for Delayed Job has been moved " \
+                    "to the honeybadger gem. Please remove " \
+                    "delayed_job_honeybadger from your " \
+                    "Gemfile.")
+      end
+      !delayed_job_honeybadger
+    end
+
+    execution do
+      require 'honeybadger/plugins/delayed_job/plugin'
+      ::Delayed::Worker.plugins << Plugins::DelayedJob::Plugin
+    end
+  end
+end

data/lib/honeybadger/{integrations → plugins}/delayed_job/plugin.rb

@@ -1,15 +1,14 @@
+require 'delayed_job'
+require 'honeybadger'
+
 module Honeybadger
-  module Integrations
+  module Plugins
     module DelayedJob
       class Plugin < ::Delayed::Plugin
         callbacks do |lifecycle|
           lifecycle.around(:invoke_job) do |job, &block|
             begin
-              if defined?(::Honeybadger::Monitor)
-                ::Honeybadger::Monitor::Trace.instrument("#{job.payload_object.class}#perform", { :source => 'delayed_job', :jid => job.id, :class => job.payload_object.class.name }) do
-                  block.call(job)
-                end
-              else
+              ::Honeybadger::Trace.instrument("#{job.payload_object.class}#perform", {source: 'delayed_job', jid: job.id, class: job.payload_object.class.name}) do
                 block.call(job)
               end
             rescue Exception => error
@@ -24,7 +23,7 @@ module Honeybadger
                   :attempts      => job.attempts,
                   :queue         => job.queue
                 }
-              ) if job.attempts.to_i >= ::Honeybadger.configuration.delayed_job_attempt_threshold.to_i
+              )
               raise error
             ensure
               ::Honeybadger.context.clear!

data/lib/honeybadger/{integrations → plugins}/local_variables.rb

@@ -1,5 +1,8 @@
+require 'honeybadger/plugin'
+require 'honeybadger/backtrace'
+
 module Honeybadger
-  module Integrations
+  module Plugins
     module LocalVariables
       module ExceptionExtension
         def self.included(base)
@@ -20,16 +23,12 @@ module Honeybadger
         end
       end
 
-      Dependency.register do
-        requirement { ::Honeybadger.configuration.send_local_variables }
+      Plugin.register do
+        requirement { config[:'exceptions.local_variables'] }
         requirement { defined?(::BindingOfCaller) }
         requirement { !::Exception.included_modules.include?(ExceptionExtension) }
 
-        injection { Honeybadger.write_verbose_log('Installing local variables integration') }
-
-        injection do
-          ::Exception.send(:include, ExceptionExtension)
-        end
+        execution { ::Exception.send(:include, ExceptionExtension) }
       end
     end
   end

data/lib/honeybadger/{integrations → plugins}/net_http.rb

@@ -1,5 +1,7 @@
+require 'honeybadger/plugin'
+
 module Honeybadger
-  module Integrations
+  module Plugins
     module NetHttp
       module Instrumentation
         def self.included(base)
@@ -20,14 +22,14 @@ module Honeybadger
           end
         end
       end
-    end
-  end
 
-  Dependency.register do
-    requirement { defined?(::ActiveSupport::Notifications) }
-    requirement { defined?(::Net::HTTP) }
-    requirement { defined?(::Honeybadger::Monitor) }
+      Plugin.register do
+        requirement { defined?(::ActiveSupport::Notifications) }
+        requirement { defined?(::Net::HTTP) }
+        requirement { config[:'traces.enabled'] }
 
-    injection { ::Net::HTTP.send(:include, Integrations::NetHttp::Instrumentation) }
+        execution { ::Net::HTTP.send(:include, Instrumentation) }
+      end
+    end
   end
 end

data/lib/honeybadger/plugins/passenger.rb

@@ -0,0 +1,24 @@
+require 'honeybadger/plugin'
+require 'honeybadger/agent'
+
+module Honeybadger
+  module Plugins
+    module Passenger
+      Plugin.register do
+        requirement { defined?(::PhusionPassenger) }
+
+        execution do
+          ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
+            logger.debug('Starting passenger worker process')
+            Honeybadger::Agent.fork if forked
+          end
+
+          ::PhusionPassenger.on_event(:stopping_worker_process) do
+            logger.debug('Stopping passenger worker process')
+            Honeybadger::Agent.stop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/rails.rb

@@ -0,0 +1,61 @@
+require 'honeybadger/plugin'
+
+module Honeybadger
+  module Plugins
+    module Rails
+      module ExceptionsCatcher
+        def self.included(base)
+          base.send(:alias_method, :render_exception_without_honeybadger, :render_exception)
+          base.send(:alias_method, :render_exception, :render_exception_with_honeybadger)
+        end
+
+        def render_exception_with_honeybadger(env, exception)
+          env['honeybadger.exception'] = exception
+          render_exception_without_honeybadger(env,exception)
+        end
+      end
+
+      module ControllerMethods
+        def honeybadger_request_data
+          warn('#honeybadger_request_data has been deprecated and has no effect.')
+          {}
+        end
+
+        def notify_honeybadger(*args, &block)
+          warn('#notify_honeybadger has been deprecated; please use `Honeybadger.notify`.')
+          Honeybadger.notify(*args, &block)
+        end
+
+        def notify_honeybadger_or_ignore(*args, &block)
+          warn('#notify_honeybadger_or_ignore has been deprecated; please use `Honeybadger.notify`.')
+          Honeybadger.notify(*args, &block)
+        end
+      end
+
+      Plugin.register :rails_controller_methods do
+        requirement { defined?(::Rails) }
+
+        execution do
+          ActiveSupport.on_load(:action_controller) do
+            # Lazily load action_controller methods
+            include ::Honeybadger::Plugins::Rails::ControllerMethods
+          end
+        end
+      end
+
+      Plugin.register :rails_exceptions_catcher do
+        requirement { defined?(::Rails) }
+
+        execution do
+          if defined?(::ActionDispatch::DebugExceptions)
+            # Rails 3.2.x+
+            ::ActionDispatch::DebugExceptions.send(:include, ExceptionsCatcher)
+          elsif defined?(::ActionDispatch::ShowExceptions)
+            # Rails 3.0.x and 3.1.x
+            ::ActionDispatch::ShowExceptions.send(:include, ExceptionsCatcher)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/sidekiq.rb

@@ -0,0 +1,35 @@
+require 'honeybadger/plugin'
+require 'honeybadger'
+
+module Honeybadger
+  module Plugins
+    module Sidekiq
+      class Middleware
+        def call(worker, msg, queue)
+          Honeybadger.context.clear!
+          Honeybadger::Trace.instrument("#{msg['class']}#perform", { :source => 'sidekiq', :jid => msg['jid'], :class => msg['class'] }) do
+            yield
+          end
+        end
+      end
+
+      Plugin.register do
+        requirement { defined?(::Sidekiq) }
+
+        execution do
+          ::Sidekiq.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.add Middleware
+            end
+          end
+
+          if defined?(::Sidekiq::VERSION) && ::Sidekiq::VERSION > '3'
+            ::Sidekiq.configure_server do |config|
+              config.error_handlers << Proc.new {|ex,context| Honeybadger.notify_or_ignore(ex, parameters: context) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/{integrations → plugins}/thor.rb

@@ -1,5 +1,8 @@
+require 'honeybadger/plugin'
+require 'honeybadger'
+
 module Honeybadger
-  module Integrations
+  module Plugins
     module Thor
       def self.included(base)
         base.class_eval do
@@ -17,15 +20,13 @@ module Honeybadger
         raise
       end
     end
-  end
 
-  Dependency.register do
-    requirement { defined?(::Thor.no_commands) }
+    Plugin.register do
+      requirement { defined?(::Thor.no_commands) }
 
-    injection { Honeybadger.write_verbose_log('Installing Thor integration') }
-
-    injection do
-      ::Thor.send(:include, Integrations::Thor)
+      execution do
+        ::Thor.send(:include, Thor)
+      end
     end
   end
 end

data/lib/honeybadger/{integrations → plugins}/unicorn.rb

@@ -1,5 +1,8 @@
+require 'honeybadger/plugin'
+require 'honeybadger/agent'
+
 module Honeybadger
-  module Integrations
+  module Plugins
     module Unicorn
       module AfterForkExtension
         def self.included(base)
@@ -9,18 +12,16 @@ module Honeybadger
 
         def init_worker_process_with_honeybadger(*args, &block)
           init_worker_process_without_honeybadger(*args, &block).tap do
-            Honeybadger::Monitor.worker.fork
+            Honeybadger::Agent.fork
           end
         end
       end
-    end
-  end
 
-  Dependency.register do
-    requirement { defined?(::Honeybadger::Monitor) }
-    requirement { defined?(::Unicorn::HttpServer) }
+      Plugin.register do
+        requirement { defined?(::Unicorn::HttpServer) }
 
-    injection { Honeybadger.write_verbose_log('Installing Unicorn integration') }
-    injection { ::Unicorn::HttpServer.send(:include, Integrations::Unicorn::AfterForkExtension) }
+        execution { ::Unicorn::HttpServer.send(:include, AfterForkExtension) }
+      end
+    end
   end
 end

data/lib/honeybadger/rack/error_notifier.rb

@@ -1,12 +1,15 @@
+require 'rack'
+require 'honeybadger'
+require 'forwardable'
+
 module Honeybadger
   module Rack
-    # Middleware for Rack applications. Any errors raised by the upstream
+    # Public: Middleware for Rack applications. Any errors raised by the upstream
     # application will be delivered to Honeybadger and re-raised.
     #
-    # Synopsis:
+    # Examples:
     #
-    #   require 'rack'
-    #   require 'honeybadger'
+    #   require 'honeybadger/rack/error_notifier'
     #
     #   Honeybadger.configure do |config|
     #     config.api_key = 'my_api_key'
@@ -21,39 +24,53 @@ module Honeybadger
     #
     # Use a standard Honeybadger.configure call to configure your api key.
     class ErrorNotifier
-      def initialize(app)
+      extend Forwardable
+
+      def initialize(app, config)
         @app = app
-        Honeybadger.configuration.framework = "Rack: #{::Rack.release}"
+        @config = config
+      end
+
+      def call(env)
+        config.with_request(::Rack::Request.new(env)) do
+          begin
+            env['honeybadger.config'] = config
+            response = @app.call(env)
+          rescue Exception => raised
+            env['honeybadger.error_id'] = notify_honeybadger(raised, env)
+            raise
+          end
+
+          framework_exception = framework_exception(env)
+          if framework_exception
+            env['honeybadger.error_id'] = notify_honeybadger(framework_exception, env)
+          end
+
+          response
+        end
+      ensure
+        Honeybadger.context.clear!
       end
 
+      private
+
+      attr_reader :config
+      def_delegator :@config, :logger
+
       def ignored_user_agent?(env)
-        true if Honeybadger.
-          configuration.
-          ignore_user_agent.
+        true if config[:'exceptions.ignored_user_agents'].
           flatten.
           any? { |ua| ua === env['HTTP_USER_AGENT'] }
       end
 
-      def notify_honeybadger(exception,env)
-        Honeybadger.notify_or_ignore(exception, :rack_env => env) unless ignored_user_agent?(env)
+      def notify_honeybadger(exception, env)
+        return if ignored_user_agent?(env)
+        Honeybadger.notify_or_ignore(exception)
       end
 
-      def call(env)
-        begin
-          response = @app.call(env)
-        rescue Exception => raised
-          env['honeybadger.error_id'] = notify_honeybadger(raised, env)
-          raise
-        end
-
-        framework_exception = env['rack.exception'] || env['sinatra.error']
-        if framework_exception
-          env['honeybadger.error_id'] = notify_honeybadger(framework_exception, env)
-        end
-
-        response
-      ensure
-        Honeybadger.context.clear!
+      def framework_exception(env)
+        env['action_dispatch.exception'] || env['rack.exception'] ||
+          env['sinatra.error'] || env['honeybadger.exception']
       end
     end
   end