honeybadger 1.11.2 → 1.12.0.beta2

data/lib/honeybadger.rb

@@ -4,6 +4,7 @@ require 'json'
 require 'digest'
 require 'logger'
 
+require 'honeybadger/dependency'
 require 'honeybadger/configuration'
 require 'honeybadger/backtrace'
 require 'honeybadger/notice'
@@ -12,11 +13,13 @@ require 'honeybadger/sender'
 require 'honeybadger/stats'
 require 'honeybadger/user_informer'
 require 'honeybadger/user_feedback'
+require 'honeybadger/integrations'
+require 'honeybadger/exception_extensions'
 
 require 'honeybadger/railtie' if defined?(Rails::Railtie)
 
 module Honeybadger
-  VERSION = '1.11.2'
+  VERSION = '1.12.0.beta2'
   LOG_PREFIX = "** [Honeybadger] "
 
   HEADERS = {
@@ -161,11 +164,13 @@ module Honeybadger
     private
 
     def send_notice(notice)
+      return false unless sender
+
       if configuration.public?
         if configuration.async?
           configuration.async.call(notice)
         else
-          notice.deliver
+          Honeybadger.sender.send_to_honeybadger(notice)
         end
       end
     end
@@ -178,13 +183,14 @@ module Honeybadger
     end
 
     def unwrap_exception(exception)
-      if exception.respond_to?(:original_exception)
-        exception.original_exception
-      elsif exception.respond_to?(:continued_exception)
-        exception.continued_exception
-      else
-        exception
-      end
+      exception.respond_to?(:original_exception) && exception.original_exception ||
+      exception.respond_to?(:continued_exception) && exception.continued_exception ||
+      exception.respond_to?(:cause) && exception.cause ||
+      exception
     end
   end
 end
+
+unless defined?(Rails)
+  Honeybadger::Dependency.inject!
+end

data/lib/honeybadger/configuration.rb

@@ -8,7 +8,8 @@ module Honeybadger
                :params_filters, :project_root, :port, :protocol, :proxy_host, :proxy_pass,
                :proxy_port, :proxy_user, :secure, :use_system_ssl_cert_chain, :framework,
                :user_information, :feedback, :rescue_rake_exceptions, :source_extract_radius,
-               :send_request_session, :debug, :fingerprint, :hostname, :metrics, :log_exception_on_send_failure].freeze
+               :send_request_session, :debug, :fingerprint, :hostname, :features, :metrics,
+               :log_exception_on_send_failure, :send_local_variables].freeze
 
     # The API key for your project, found on the project edit form.
     attr_accessor :api_key
@@ -100,6 +101,9 @@ module Honeybadger
     # +true+ to send session data, +false+ to exclude
     attr_accessor :send_request_session
 
+    # +true+ to send local variables, +false+ to exclude
+    attr_accessor :send_local_variables
+
     # +true+ to log extra debug info, +false+ to suppress
     attr_accessor :debug
 
@@ -175,11 +179,12 @@ module Honeybadger
       @rescue_rake_exceptions        = nil
       @source_extract_radius         = 2
       @send_request_session          = true
+      @send_local_variables          = false
       @debug                         = false
       @log_exception_on_send_failure = false
       @hostname                      = Socket.gethostname
       @metrics                       = true
-      @features                      = { 'notices' => true }
+      @features                      = {'notices' => true, 'local_variables' => true}
       @limit                         = nil
       @feedback                      = true
     end
@@ -283,10 +288,10 @@ module Honeybadger
     #
     # Examples
     #
-    #   config.async = Proc.new { |notice| Thread.new { notice.deliver } }
+    #   config.async = Proc.new { |notice| Thread.new { Honeybadger.sender.send_to_honeybadger(notice) } }
     #
     #   config.async do |notice|
-    #     Thread.new { notice.deliver }
+    #     Thread.new { Honeybadger.sender.send_to_honeybadger(notice) }
     #   end
     #
     # Returns configured async handler (should respond to #call(notice))

data/lib/honeybadger/dependency.rb

@@ -0,0 +1,65 @@
+module Honeybadger
+  class Dependency
+    class << self
+      @@instances = []
+
+      def instances
+        @@instances
+      end
+
+      def register
+        instances << new.tap { |d| d.instance_eval(&Proc.new) }
+      end
+
+      def inject!
+        instances.each do |dependency|
+          dependency.inject! if dependency.ok?
+        end
+      end
+
+      def reset!
+        instances.each(&:reset!)
+      end
+    end
+
+    def initialize
+      @injected     = false
+      @requirements = []
+      @injections   = []
+    end
+
+    def requirement
+      @requirements << Proc.new
+    end
+
+    def injection
+      @injections << Proc.new
+    end
+
+    def ok?
+      !@injected && @requirements.all?(&:call)
+    rescue => e
+      Honeybadger.write_verbose_log("Exception caught while verifying dependency: #{e.class} -- #{e.message}", :error)
+      false
+    end
+
+    def inject!
+      @injections.each(&:call)
+    rescue => e
+      Honeybadger.write_verbose_log("Exception caught while injecting dependency: #{e.class} -- #{e.message}", :error)
+      false
+    ensure
+      @injected = true
+    end
+
+    def reset!
+      @injected = false
+    end
+
+    def injected?
+      @injected
+    end
+
+    attr_reader :requirements, :injections
+  end
+end

data/lib/honeybadger/exception_extensions.rb

@@ -0,0 +1,35 @@
+module Honeybadger
+  module ExceptionExtensions
+    module Bindings
+      def self.included(base)
+        base.send(:alias_method, :set_backtrace_without_honeybadger, :set_backtrace)
+        base.send(:alias_method, :set_backtrace, :set_backtrace_with_honeybadger)
+      end
+
+      def set_backtrace_with_honeybadger(*args, &block)
+        if caller.none? { |loc| loc.match(Honeybadger::Backtrace::Line::INPUT_FORMAT) && Regexp.last_match(1) == __FILE__ }
+          @__honeybadger_bindings_stack = binding.callers.drop(1)
+        end
+
+        set_backtrace_without_honeybadger(*args, &block)
+      end
+
+      def __honeybadger_bindings_stack
+        @__honeybadger_bindings_stack || []
+      end
+    end
+
+    module NullBindings
+      def __honeybadger_bindings_stack
+        []
+      end
+    end
+  end
+end
+
+begin
+  require 'binding_of_caller'
+  Exception.send(:include, Honeybadger::ExceptionExtensions::Bindings)
+rescue LoadError
+  Exception.send(:include, Honeybadger::ExceptionExtensions::NullBindings)
+end

data/lib/honeybadger/integrations.rb

@@ -0,0 +1,4 @@
+module Honeybadger::Integrations; end
+
+require 'honeybadger/integrations/delayed_job'
+require 'honeybadger/integrations/sidekiq'

data/lib/honeybadger/integrations/delayed_job.rb

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

data/lib/honeybadger/integrations/delayed_job/plugin.rb

@@ -0,0 +1,31 @@
+module Honeybadger
+  module Integrations
+    module DelayedJob
+      class Plugin < ::Delayed::Plugins::Plugin
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job) do |job, *args, &block|
+            begin
+              block.call(job, *args)
+            rescue Exception => error
+              ::Honeybadger.notify_or_ignore(
+                :error_class   => error.class.name,
+                :error_message => "#{ error.class.name }: #{ error.message }",
+                :backtrace     => error.backtrace,
+                  :context       => {
+                  :job_id        => job.id,
+                  :handler       => job.handler,
+                  :last_error    => job.last_error,
+                  :attempts      => job.attempts,
+                  :queue         => job.queue
+                }
+              )
+              raise error
+            ensure
+              ::Honeybadger.context.clear!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/integrations/sidekiq.rb

@@ -0,0 +1,34 @@
+module Honeybadger
+  module Integrations
+    module Sidekiq
+      class Middleware
+        def call(worker, msg, queue)
+          Honeybadger.context.clear!
+          yield
+        end
+      end
+    end
+  end
+
+  Dependency.register do
+    requirement { defined?(::Sidekiq) }
+
+    injection do
+      ::Sidekiq.configure_server do |config|
+        config.server_middleware do |chain|
+          chain.add Integrations::Sidekiq::Middleware
+        end
+      end
+    end
+  end
+
+  Dependency.register do
+    requirement { defined?(::Sidekiq::VERSION) && ::Sidekiq::VERSION > '3' }
+
+    injection do
+      ::Sidekiq.configure_server do |config|
+        config.error_handlers << Proc.new {|ex,context| Honeybadger.notify_or_ignore(ex, :parameters => context) }
+      end
+    end
+  end
+end

data/lib/honeybadger/notice.rb

@@ -1,3 +1,4 @@
+require 'honeybadger/payload'
 require 'socket'
 
 module Honeybadger
@@ -85,8 +86,15 @@ module Honeybadger
     # The api_key to use when sending notice (optional)
     attr_reader :api_key
 
+    # Local variables are extracted from first frame of backtrace
+    attr_reader :local_variables
+
+    # Additional features to enable/disable
+    attr_reader :features
+
     def initialize(args)
       self.args         = args
+      self.features     = args[:features] || {}
       self.exception    = args[:exception]
       self.project_root = args[:project_root]
 
@@ -124,7 +132,9 @@ module Honeybadger
       self.source_extract_radius = args[:source_extract_radius] || 2
       self.source_extract        = extract_source_from_backtrace
 
-      self.send_request_session     = args[:send_request_session].nil? ? true : args[:send_request_session]
+      self.local_variables = send_local_variables? ? local_variables_from_exception(exception) : {}
+
+      self.send_request_session = args[:send_request_session].nil? ? true : args[:send_request_session]
 
       also_use_rack_params_filters
       find_session_data
@@ -133,10 +143,7 @@ module Honeybadger
       set_context
     end
 
-    # Public: Send the notice to Honeybadger using the configured sender
-    #
-    # Returns a reference to the error in Honeybadger, false if sender isn't
-    # configured
+    # Deprecated. Remove in 2.0.
     def deliver
       return false unless Honeybadger.sender
       Honeybadger.sender.send_to_honeybadger(self)
@@ -146,7 +153,7 @@ module Honeybadger
     #
     # Returns JSON representation of notice
     def as_json(options = {})
-      {
+      Payload.new({
         :api_key => api_key,
         :notifier => {
           :name => notifier_name,
@@ -168,7 +175,8 @@ module Honeybadger
           :params => parameters,
           :session => session_data,
           :cgi_data => cgi_data,
-          :context => context
+          :context => context,
+          :local_variables => local_variables
         },
         :server => {
           :project_root => project_root,
@@ -176,7 +184,7 @@ module Honeybadger
           :hostname => hostname,
           :stats => stats
         }
-      }
+      })
     end
 
     # Public: Creates JSON
@@ -235,8 +243,9 @@ module Honeybadger
       :error_message, :backtrace_filters, :parameters, :params_filters,
       :environment_filters, :session_data, :project_root, :url, :ignore,
       :ignore_by_filters, :notifier_name, :notifier_url, :notifier_version,
-      :component, :action, :cgi_data, :environment_name, :hostname, :stats, :context,
-      :source_extract, :source_extract_radius, :send_request_session, :api_key
+      :component, :action, :cgi_data, :environment_name, :hostname, :stats,
+      :context, :source_extract, :source_extract_radius, :send_request_session,
+      :api_key, :features, :local_variables
 
     # Private: Arguments given in the initializer
     attr_accessor :args
@@ -331,7 +340,7 @@ module Honeybadger
 
     def filter_cgi_data_params(cgi_data)
       cgi_data.each_pair do |key, value|
-        next unless value.kind_of?(String) && key =~ /\A[A-Z_]+\Z/
+        next unless value.kind_of?(String) && key =~ /\A[A-Z_]+\Z/ && value =~ /\S/
         cgi_data[key] = filter_url(value)
       end
     end
@@ -340,6 +349,8 @@ module Honeybadger
       if cgi_data
         cgi_data.delete("rack.request.form_vars")
         cgi_data.delete("rack.request.query_string")
+        cgi_data.delete("action_dispatch.request.parameters")
+        cgi_data.delete("action_dispatch.request.request_parameters")
       end
     end
 
@@ -468,5 +479,31 @@ module Honeybadger
       input = input[0...bytes] if input.respond_to?(:size) && input.size > bytes
       input
     end
+
+    # Internal: Fetch local variables from first frame of backtrace.
+    #
+    # exception - The Exception containing the bindings stack.
+    #
+    # Returns a Hash of local variables
+    def local_variables_from_exception(exception)
+      return {} unless Exception === exception
+      return {} if exception.__honeybadger_bindings_stack.empty?
+
+      if project_root
+        binding = exception.__honeybadger_bindings_stack.find { |b| b.eval('__FILE__') =~ /^#{Regexp.escape(project_root.to_s)}/ }
+      end
+
+      binding ||= exception.__honeybadger_bindings_stack[0]
+
+      vars = binding.eval('local_variables')
+      Hash[vars.map {|arg| [arg, binding.eval(arg.to_s)]}]
+    end
+
+    # Internal: Should local variables be sent?
+    #
+    # Returns true to send local_variables
+    def send_local_variables?
+      args[:send_local_variables] && features['local_variables']
+    end
   end
 end

data/lib/honeybadger/payload.rb

@@ -0,0 +1,29 @@
+require 'delegate'
+
+module Honeybadger
+  class Payload < SimpleDelegator
+    attr_reader :max_depth
+
+    def initialize(hash = {}, options = {})
+      fail ArgumentError, 'must be a Hash' unless hash.kind_of?(Hash)
+      @max_depth = options[:max_depth] || 20
+      super(hash)
+      sanitize(self)
+    end
+
+    private
+
+    def sanitize(hash, depth = 0)
+      hash.each_pair do |k,v|
+        next unless v.kind_of?(Hash)
+        if depth >= max_depth
+          hash.delete(k)
+        else
+          hash[k] = sanitize(v, depth+1)
+        end
+      end
+
+      hash
+    end
+  end
+end