honeybadger 2.0.12 → 2.1.0.beta.1

data/lib/honeybadger/plugins/local_variables.rb

@@ -26,6 +26,15 @@ module Honeybadger
       Plugin.register do
         requirement { config[:'exceptions.local_variables'] }
         requirement { defined?(::BindingOfCaller) }
+        requirement do
+          if res = defined?(::BetterErrors)
+            logger.warn("The local variables feature is incompatible with the " \
+                        "better_errors gem; to remove this warning, set " \
+                        "exceptions.local_variables to false for environments " \
+                        "which load better_errors.")
+          end
+          !res
+        end
         requirement { !::Exception.included_modules.include?(ExceptionExtension) }
 
         execution { ::Exception.send(:include, ExceptionExtension) }

data/lib/honeybadger/plugins/net_http.rb

@@ -1,4 +1,5 @@
 require 'honeybadger/plugin'
+require 'honeybadger/trace'
 
 module Honeybadger
   module Plugins
@@ -18,7 +19,9 @@ module Honeybadger
           end
 
           ActiveSupport::Notifications.instrument("net_http.request", { :uri => uri, :method => request.method }) do
-            request_without_honeybadger(*args, &block)
+            # Disable tracing during #request so that additional calls (i.e.
+            # when connection wasn't started) don't result in double counting.
+            Trace.ignore_events { request_without_honeybadger(*args, &block) }
           end
         end
       end

data/lib/honeybadger/plugins/resque.rb

@@ -0,0 +1,63 @@
+require 'honeybadger/plugin'
+require 'honeybadger'
+
+module Honeybadger
+  module Plugins
+    module Resque
+      module Extension
+        def around_perform_with_honeybadger(*args)
+          Honeybadger.flush do
+            begin
+              Honeybadger::Trace.instrument("#{self.name}#perform", { source: 'resque', class: self.name }) do
+                yield
+              end
+            rescue Exception => e
+              Honeybadger.notify(e, parameters: { job_arguments: args })
+              raise e
+            end
+          end
+        ensure
+          Honeybadger.context.clear!
+        end
+      end
+
+      module Installer
+        def self.included(base)
+          base.send(:alias_method, :payload_class_without_honeybadger, :payload_class)
+          base.send(:alias_method, :payload_class, :payload_class_with_honeybadger)
+        end
+
+        def payload_class_with_honeybadger
+          payload_class_without_honeybadger.tap do |klass|
+            unless klass.respond_to?(:around_perform_with_honeybadger)
+              klass.instance_eval do
+                extend(::Honeybadger::Plugins::Resque::Extension)
+              end
+            end
+          end
+        end
+      end
+
+      Plugin.register do
+        requirement { defined?(::Resque::Job) }
+
+        requirement do
+          if resque_honeybadger = defined?(::Resque::Failure::Honeybadger)
+            logger.warn("Support for Resque has been moved " \
+                        "to the honeybadger gem. Please remove " \
+                        "resque-honeybadger from your " \
+                        "Gemfile.")
+          end
+          !resque_honeybadger
+        end
+
+        execution do
+          ::Resque::Job.send(:include, Installer)
+          ::Resque.after_fork do |job|
+            Honeybadger::Agent.fork
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/sidekiq.rb

@@ -17,15 +17,18 @@ module Honeybadger
         requirement { defined?(::Sidekiq) }
 
         execution do
-          ::Sidekiq.configure_server do |config|
-            config.server_middleware do |chain|
+          ::Sidekiq.configure_server do |sidekiq|
+            sidekiq.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) }
+            ::Sidekiq.configure_server do |sidekiq|
+              sidekiq.error_handlers << lambda {|ex, params|
+                return if params['retry'] && params['retry_count'].to_i < config[:'sidekiq.attempt_threshold'].to_i
+                Honeybadger.notify_or_ignore(ex, parameters: params)
+              }
             end
           end
         end

data/lib/honeybadger/trace.rb

@@ -15,7 +15,31 @@ module Honeybadger
     end
 
     def self.instrument(key, payload = {}, &block)
-      new(SecureRandom.uuid).instrument(key, payload, &block)
+      current = self.current
+      self.create(SecureRandom.uuid).instrument(key, payload, &block)
+    ensure
+      Thread.current[:__hb_trace] = current
+    end
+
+    # Internal: Disables event tracing for executed code block.
+    #
+    # block - The code which should not be traced.
+    #
+    # Returns the return value from the block.
+    def self.ignore_events
+      return yield if ignoring_events?
+
+      begin
+        Thread.current[:__hb_ignore_trace_events] = true
+        yield
+      ensure
+        Thread.current[:__hb_ignore_trace_events] = false
+      end
+    end
+
+    # Internal: Is event tracing currently disabled?
+    def self.ignoring_events?
+      !!Thread.current[:__hb_ignore_trace_events]
     end
 
     def initialize(id)
@@ -27,28 +51,28 @@ module Honeybadger
     end
 
     def add(event)
+      return if ignoring_events?
       ce = clean_event(event)
       @events << ce.to_a if ce.render?
     end
 
     def add_query(event)
-      if event.duration < 6
-        ce = clean_event(event)
-        return unless ce.render?
-        query = ce.to_s
-        if @fast_queries[query]
-          @fast_queries[query][:duration] += ce.event.duration
-          @fast_queries[query][:count] += 1
-        else
-          @fast_queries[query] = { :duration => ce.event.duration, :count => 1 }
-        end
+      return if ignoring_events?
+      return add(event) unless event.duration < 6
+
+      ce = clean_event(event)
+      return unless ce.render?
+      query = ce.to_s
+      if @fast_queries[query]
+        @fast_queries[query][:duration] += ce.event.duration
+        @fast_queries[query][:count] += 1
       else
-        add(event)
+        @fast_queries[query] = { :duration => ce.event.duration, :count => 1 }
       end
     end
 
-    def complete(event)
-      @meta = clean_event(event).to_h
+    def complete(event, payload = {})
+      @meta = clean_event(event).to_h.merge(payload)
       @duration = event.duration
       @key = "#{event.payload[:controller]}##{event.payload[:action]}"
       Thread.current[:__hb_trace] = nil
@@ -72,8 +96,16 @@ module Honeybadger
       @meta.merge({ :events => @events, :key => @key, :fast_queries => @fast_queries.map {|k,v| [ k, v[:duration], v[:count] ] } })
     end
 
+    # Private helpers: use at your own risk.
+
+    attr_reader :meta
+
     protected
 
+    def ignoring_events?
+      self.class.ignoring_events?
+    end
+
     def clean_event(event)
       TraceCleaner.create(event)
     end

data/lib/honeybadger/util/request_payload.rb

@@ -0,0 +1,36 @@
+require 'honeybadger/util/sanitizer'
+
+module Honeybadger
+  module Util
+    # Internal: Constructs/sanitizes request data for notices and traces.
+    module RequestPayload
+      # Internal: default values to use for request data.
+      DEFAULTS = {
+        url: nil,
+        component: nil,
+        action: nil,
+        params: {}.freeze,
+        session: {}.freeze,
+        cgi_data: {}.freeze
+      }.freeze
+
+      # Internal: allowed keys.
+      KEYS = DEFAULTS.keys.freeze
+
+      def self.build(opts = {})
+        sanitizer = opts.fetch(:sanitizer) { Sanitizer.new }
+
+        payload = DEFAULTS.dup
+        KEYS.each do |key|
+          next unless opts[key]
+          payload[key] = sanitizer.sanitize(opts[key])
+        end
+
+        payload[:session] = opts[:session][:data] if opts[:session] && opts[:session][:data]
+        payload[:url] = sanitizer.filter_url(payload[:url]) if payload[:url]
+
+        payload
+      end
+    end
+  end
+end

data/lib/honeybadger/util/sanitizer.rb

@@ -5,6 +5,10 @@ module Honeybadger
 
       FILTERED_REPLACEMENT = '[FILTERED]'.freeze
 
+      TRUNCATION_REPLACEMENT = '[TRUNCATED]'.freeze
+
+      MAX_STRING_SIZE = 2048
+
       def initialize(opts = {})
         @max_depth = opts.fetch(:max_depth, 20)
 
@@ -92,7 +96,7 @@ module Honeybadger
          )
       end
 
-      def sanitize_string(data)
+      def valid_encoding(data)
         return data if valid_encoding?(data)
 
         if data.encoding == Encoding::UTF_8
@@ -101,6 +105,12 @@ module Honeybadger
           data.encode(Encoding::UTF_8, ENCODE_OPTS)
         end
       end
+
+      def sanitize_string(data)
+        data = valid_encoding(data)
+        return data unless data.respond_to?(:size) && data.size > MAX_STRING_SIZE
+        data[0...MAX_STRING_SIZE] + TRUNCATION_REPLACEMENT
+      end
     end
   end
 end

data/lib/honeybadger/util/stats.rb

@@ -12,8 +12,8 @@ module Honeybadger
         # From https://github.com/bloopletech/webstats/blob/master/server/data_providers/mem_info.rb
         def memory
           out = {}
-          if HAS_MEM
-            out[:total], out[:free], out[:buffers], out[:cached] = IO.readlines("/proc/meminfo")[0..4].map { |l| l =~ /^.*?\: +(.*?) kB$/; ($1.to_i / 1024.0).to_f }
+          if HAS_MEM && (meminfo = run_meminfo)
+            out[:total], out[:free], out[:buffers], out[:cached] = meminfo[0..4].map { |l| l =~ /^.*?\: +(.*?) kB$/; ($1.to_i / 1024.0).to_f }
             out[:free_total] = out[:free] + out[:buffers] + out[:cached]
           end
           out
@@ -22,9 +22,28 @@ module Honeybadger
         # From https://github.com/bloopletech/webstats/blob/master/server/data_providers/cpu_info.rb
         def load
           out = {}
-          out[:one], out[:five], out[:fifteen] = IO.read("/proc/loadavg").split(' ', 4).map(&:to_f) if HAS_LOAD
+          if HAS_LOAD && (loadavg = run_loadavg)
+            out[:one], out[:five], out[:fifteen] = loadavg.split(' ', 4).map(&:to_f)
+          end
           out
         end
+
+        private
+
+        def run_meminfo
+          run { IO.readlines("/proc/meminfo") }
+        end
+
+        def run_loadavg
+          run { IO.read("/proc/loadavg") }
+        end
+
+        def run
+          yield
+        rescue Errno::ENFILE
+          # Catch issues like 'Too many open files in system'
+          nil
+        end
       end
     end
   end

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # Public: The current String Honeybadger version.
-  VERSION = '2.0.12'.freeze
+  VERSION = '2.1.0.beta.1'.freeze
 end

data/vendor/capistrano-honeybadger/lib/capistrano/tasks/deploy.cap

@@ -35,7 +35,7 @@ namespace :honeybadger do
         end
 
         within release_path do
-          execute executable, options
+          execute executable, options, raise_on_non_zero_exit: false
         end
 
         info 'Honeybadger notification complete.'

data/vendor/capistrano-honeybadger/lib/honeybadger/capistrano/legacy.rb

@@ -31,7 +31,7 @@ module Honeybadger
               logger.info 'DRY RUN: Notification not actually run.'
             else
               result = ''
-              run(notify_options, :once => true, :pty => false) { |ch, stream, data| result << data }
+              run("#{ notify_options }; true", :once => true, :pty => false) { |ch, stream, data| result << data }
             end
             logger.info 'Honeybadger Notification Complete.'
           end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 2.0.12
+  version: 2.1.0.beta.1
 platform: ruby
 authors:
 - Honeybadger Industries LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-27 00:00:00.000000000 Z
+date: 2015-05-27 00:00:00.000000000 Z
 dependencies: []
 description: Make managing application errors a more pleasant experience.
 email:
@@ -60,6 +60,7 @@ files:
 - lib/honeybadger/plugins/net_http.rb
 - lib/honeybadger/plugins/passenger.rb
 - lib/honeybadger/plugins/rails.rb
+- lib/honeybadger/plugins/resque.rb
 - lib/honeybadger/plugins/sidekiq.rb
 - lib/honeybadger/plugins/thor.rb
 - lib/honeybadger/plugins/unicorn.rb
@@ -73,6 +74,7 @@ files:
 - lib/honeybadger/templates/feedback_form.erb
 - lib/honeybadger/trace.rb
 - lib/honeybadger/util/http.rb
+- lib/honeybadger/util/request_payload.rb
 - lib/honeybadger/util/sanitizer.rb
 - lib/honeybadger/util/stats.rb
 - lib/honeybadger/version.rb
@@ -139,9 +141,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5