honeybadger 1.13.2 → 1.14.0

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,12 +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)
-require 'honeybadger/integrations/sidekiq'
 
 module Honeybadger
-  VERSION = '1.13.2'
+  VERSION = '1.14.0'
   LOG_PREFIX = "** [Honeybadger] "
 
   HEADERS = {
@@ -171,11 +173,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
@@ -188,13 +192,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,5 @@
+module Honeybadger::Integrations; end
+
+require 'honeybadger/integrations/delayed_job'
+require 'honeybadger/integrations/sidekiq'
+require 'honeybadger/integrations/thor'

data/lib/honeybadger/integrations/delayed_job.rb

@@ -0,0 +1,20 @@
+module Honeybadger
+  Dependency.register do
+    requirement { defined?(::Delayed::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::Plugin
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job) do |job, &block|
+            begin
+              block.call(job)
+            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

@@ -9,18 +9,26 @@ module Honeybadger
       end
     end
   end
-end
 
-if defined?(::Sidekiq)
-  ::Sidekiq.configure_server do |config|
-    config.server_middleware do |chain|
-      chain.add Honeybadger::Integrations::Sidekiq::Middleware
+  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
-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) }
+  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/integrations/thor.rb

@@ -0,0 +1,29 @@
+module Honeybadger
+  module Integrations
+    module Thor
+      def self.included(base)
+        base.class_eval do
+          no_commands do
+            alias_method :invoke_command_without_honeybadger, :invoke_command
+            alias_method :invoke_command, :invoke_command_with_honeybadger
+          end
+        end
+      end
+
+      def invoke_command_with_honeybadger(*args)
+        invoke_command_without_honeybadger(*args)
+      rescue Exception => e
+        Honeybadger.notify_or_ignore(e)
+        raise
+      end
+    end
+  end
+
+  Dependency.register do
+    requirement { defined?(::Thor) }
+
+    injection do
+      Thor.send(:include, Integrations::Thor)
+    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]
 
@@ -116,7 +124,7 @@ module Honeybadger
         end
       end
 
-      self.url              = filter_url(args[:url] || rack_env(:url))
+      self.url              = args[:url] || rack_env(:url)
       self.hostname         = local_hostname
       self.stats            = Stats.all
       self.api_key          = args[:api_key]
@@ -124,19 +132,17 @@ module Honeybadger
       self.source_extract_radius = args[:source_extract_radius] || 2
       self.source_extract        = extract_source_from_backtrace
 
+      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]
 
       find_session_data
       clean_rack_request_data
       also_use_rack_params_filters
-      clean_params
       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 +152,7 @@ module Honeybadger
     #
     # Returns JSON representation of notice
     def as_json(options = {})
-      {
+      Payload.new({
         :api_key => api_key,
         :notifier => {
           :name => notifier_name,
@@ -168,7 +174,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 +183,7 @@ module Honeybadger
           :hostname => hostname,
           :stats => stats
         }
-      }
+      }, :filters => params_filters)
     end
 
     # Public: Creates JSON
@@ -235,8 +242,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
@@ -271,71 +279,6 @@ module Honeybadger
       end
     end
 
-    # Private: Removes non-serializable data from the given attribute.
-    # See #clean_unserializable_data
-    def clean_unserializable_data_from(attribute)
-      self.send(:"#{attribute}=", clean_unserializable_data(send(attribute)))
-    end
-
-    # Private: Removes non-serializable data. Allowed data types are strings, arrays,
-    # and hashes. All other types are converted to strings.
-    # TODO: move this onto Hash
-    def clean_unserializable_data(data, stack = [])
-      return "[possible infinite recursion halted]" if stack.any?{|item| item == data.object_id }
-
-      if data.respond_to?(:to_hash)
-        data.to_hash.inject({}) do |result, (key, value)|
-          result.merge(key => clean_unserializable_data(value, stack + [data.object_id]))
-        end
-      elsif data.respond_to?(:to_ary)
-        data.to_ary.collect do |value|
-          clean_unserializable_data(value, stack + [data.object_id])
-        end
-      else
-        data.to_s
-      end
-    end
-
-    # Internal: Filters query parameters from URL
-    #
-    # url - String URL to filter
-    #
-    # Returns filtered String URL
-    def filter_url(url)
-      return nil unless url =~ /\S/
-
-      url = url.dup
-      url.scan(/(?:^|&|\?)([^=?&]+)=([^&]+)/).each do |m|
-        next unless filter_key?(m[0])
-        url.gsub!(/#{m[1]}/, '[FILTERED]')
-      end
-
-      url
-    end
-
-    # Internal: Replaces the contents of params that match params_filters.
-    # TODO: extract this to a different class
-    def clean_params
-      clean_unserializable_data_from(:parameters)
-      filter(parameters)
-      if cgi_data
-        clean_unserializable_data_from(:cgi_data)
-        filter(cgi_data)
-        filter_cgi_data_params(cgi_data)
-      end
-      if session_data
-        clean_unserializable_data_from(:session_data)
-        filter(session_data)
-      end
-    end
-
-    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/ && value =~ /\S/
-        cgi_data[key] = filter_url(value)
-      end
-    end
-
     def clean_rack_request_data
       if cgi_data
         self.cgi_data = cgi_data.dup
@@ -381,28 +324,6 @@ module Honeybadger
       end
     end
 
-    def filter(hash)
-      if params_filters
-        hash.each do |key, value|
-          if filter_key?(key)
-            hash[key] = "[FILTERED]"
-          elsif value.respond_to?(:to_hash)
-            filter(hash[key])
-          end
-        end
-      end
-    end
-
-    def filter_key?(key)
-      params_filters.any? do |filter|
-        if filter.is_a?(Regexp)
-          key.to_s =~ filter
-        else
-          key.to_s.eql?(filter.to_s)
-        end
-      end
-    end
-
     def find_session_data
       if send_request_session
         self.session_data = args[:session_data] || args[:session] || rack_session || {}
@@ -416,7 +337,8 @@ module Honeybadger
     end
 
     def set_context
-      self.context = Thread.current[:honeybadger_context] || {}
+      self.context = {}
+      self.context.merge!(Thread.current[:honeybadger_context]) if Thread.current[:honeybadger_context]
       self.context.merge!(args[:context]) if args[:context]
       self.context = nil if context.empty?
     end
@@ -477,5 +399,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