honeybadger 5.29.1 → 6.0.0

data/lib/honeybadger/event.rb

@@ -1,6 +1,6 @@
-require 'forwardable'
+require "forwardable"
 
-require 'honeybadger/util/sanitizer'
+require "honeybadger/util/sanitizer"
 
 module Honeybadger
   class Event
@@ -18,7 +18,7 @@ module Honeybadger
     def_delegators :payload, :dig, :[], :[]=, :delete
 
     # @api private
-    def initialize(event_type_or_payload, payload={})
+    def initialize(event_type_or_payload, payload = {})
       if event_type_or_payload.is_a?(String)
         @event_type = event_type_or_payload
         @payload = payload

data/lib/honeybadger/events_worker.rb

@@ -1,7 +1,7 @@
-require 'forwardable'
-require 'net/http'
+require "forwardable"
+require "net/http"
 
-require 'honeybadger/logging'
+require "honeybadger/logging"
 
 module Honeybadger
   # A concurrent queue to notify the backend.
@@ -58,7 +58,7 @@ module Honeybadger
     end
 
     def shutdown(force = false)
-      d { 'shutting down events worker' }
+      d { "shutting down events worker" }
 
       mutex.synchronize do
         @shutdown = true
@@ -68,11 +68,11 @@ module Honeybadger
       return true unless thread&.alive?
 
       if throttled?
-        warn { sprintf('Unable to send %s event(s) to Honeybadger (currently throttled)', queue.size) } unless queue.empty?
+        warn { sprintf("Unable to send %s event(s) to Honeybadger (currently throttled)", queue.size) } unless queue.empty?
         return true
       end
 
-      info { sprintf('Waiting to send %s events(s) to Honeybadger', queue.size) } unless queue.empty?
+      info { sprintf("Waiting to send %s events(s) to Honeybadger", queue.size) } unless queue.empty?
       queue.push(FLUSH)
       queue.push(SHUTDOWN)
       !!thread.join
@@ -84,7 +84,7 @@ module Honeybadger
     # Blocks until queue is processed up to this point in time.
     def flush
       mutex.synchronize do
-        if thread && thread.alive?
+        if thread&.alive?
           queue.push(FLUSH)
           queue.push(marker)
           marker.wait(mutex)
@@ -135,7 +135,7 @@ module Honeybadger
     end
 
     def kill!
-      d { 'killing worker thread' }
+      d { "killing worker thread" }
 
       if thread
         Thread.kill(thread)
@@ -165,7 +165,7 @@ module Honeybadger
 
     def run
       begin
-        d { 'worker started' }
+        d { "worker started" }
         mutex.synchronize do
           @last_sent = Time.now
         end
@@ -179,9 +179,9 @@ module Honeybadger
           end
         end
       ensure
-        d { 'stopping worker' }
+        d { "stopping worker" }
       end
-    rescue Exception => e
+    rescue => e
       error {
         msg = "Error in worker thread (shutting down) class=%s message=%s\n\t%s"
         sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
@@ -208,10 +208,10 @@ module Honeybadger
       send_now(mutex.synchronize { send_queue })
       mutex.synchronize do
         @last_sent = Time.now
-        debug { sprintf('Sending %s events', send_queue.length) }
+        debug { sprintf("Sending %s events", send_queue.length) }
         send_queue.clear
         if @dropped_events > 0
-          warn { sprintf('Dropped %s messages due to exceeding max queue size of %s', @dropped_events, config.events_max_queue_size) }
+          warn { sprintf("Dropped %s messages due to exceeding max queue size of %s", @dropped_events, config.events_max_queue_size) }
         end
         @dropped_events = 0
       end
@@ -227,7 +227,7 @@ module Honeybadger
     def flush_send_queue
       return if mutex.synchronize { send_queue.empty? }
       send_batch
-    rescue StandardError => e
+    rescue => e
       error {
         msg = "Error in worker thread class=%s message=%s\n\t%s"
         sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
@@ -239,28 +239,26 @@ module Honeybadger
       check_and_send
 
       if shutdown? && throttled?
-        warn { sprintf('Unable to send %s events(s) to Honeybadger (currently throttled)', queue.size) } if queue.size > 1
+        warn { sprintf("Unable to send %s events(s) to Honeybadger (currently throttled)", queue.size) } if queue.size > 1
         kill!
         return
       end
 
       sleep(throttle_interval)
-    rescue StandardError => e
+    rescue => e
       error {
         msg = "Error in worker thread class=%s message=%s\n\t%s"
         sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
       }
     end
 
-
     def send_to_backend(msg)
-      d { 'events_worker sending to backend' }
-      response = backend.event(msg)
-      response
+      d { "events_worker sending to backend" }
+      backend.event(msg)
     end
 
     def calc_throttle_interval
-      ((BASE_THROTTLE ** throttle) - 1).round(3)
+      ((BASE_THROTTLE**throttle) - 1).round(3)
     end
 
     def inc_throttle
@@ -281,32 +279,32 @@ module Honeybadger
     end
 
     def handle_response(response)
-      d { sprintf('events_worker response code=%s message=%s', response.code, response.message.to_s.dump) }
+      d { sprintf("events_worker response code=%s message=%s", response.code, response.message.to_s.dump) }
 
       case response.code
       when 429, 503
         throttle = inc_throttle
-        warn { sprintf('Event send failed: project is sending too many events. code=%s throttle=%s interval=%s', response.code, throttle, throttle_interval) }
+        warn { sprintf("Event send failed: project is sending too many events. code=%s throttle=%s interval=%s", response.code, throttle, throttle_interval) }
       when 402
-        warn { sprintf('Event send failed: payment is required. code=%s', response.code) }
+        warn { sprintf("Event send failed: payment is required. code=%s", response.code) }
         suspend(3600)
       when 403
-        warn { sprintf('Event send failed: API key is invalid. code=%s', response.code) }
+        warn { sprintf("Event send failed: API key is invalid. code=%s", response.code) }
         suspend(3600)
       when 413
-        warn { sprintf('Event send failed: Payload is too large. code=%s', response.code) }
+        warn { sprintf("Event send failed: Payload is too large. code=%s", response.code) }
       when 201
-        if throttle = dec_throttle
-          debug { sprintf('Success ⚡ Event sent code=%s throttle=%s interval=%s', response.code, throttle, throttle_interval) }
+        if (throttle = dec_throttle)
+          debug { sprintf("Success ⚡ Event sent code=%s throttle=%s interval=%s", response.code, throttle, throttle_interval) }
         else
-          debug { sprintf('Success ⚡ Event sent code=%s', response.code) }
+          debug { sprintf("Success ⚡ Event sent code=%s", response.code) }
         end
       when :stubbed
-        info { sprintf('Success ⚡ Development mode is enabled; This event will be sent after app is deployed.') }
+        info { "Success ⚡ Development mode is enabled; This event will be sent after app is deployed." }
       when :error
-        warn { sprintf('Event send failed: an unknown error occurred. code=%s error=%s', response.code, response.message.to_s.dump) }
+        warn { sprintf("Event send failed: an unknown error occurred. code=%s error=%s", response.code, response.message.to_s.dump) }
       else
-        warn { sprintf('Event send failed: unknown response from server. code=%s', response.code) }
+        warn { sprintf("Event send failed: unknown response from server. code=%s", response.code) }
       end
     end
 
@@ -317,8 +315,10 @@ module Honeybadger
     end
 
     def signal_marker(marker)
-      mutex.synchronize do
+      if mutex.owned?
         marker.signal
+      else
+        mutex.synchronize { marker.signal }
       end
     end
   end

data/lib/honeybadger/gauge.rb

@@ -1,4 +1,4 @@
-require 'honeybadger/metric'
+require "honeybadger/metric"
 
 module Honeybadger
   class Gauge < Metric
@@ -8,7 +8,7 @@ module Honeybadger
       @samples += 1
 
       @total ||= 0
-      @total = @total + value
+      @total += value
 
       @min = value if @min.nil? || @min > value
       @max = value if @max.nil? || @max < value

data/lib/honeybadger/histogram.rb

@@ -1,9 +1,9 @@
-require 'honeybadger/metric'
+require "honeybadger/metric"
 
 module Honeybadger
   class Histogram < Metric
     DEFAULT_BINS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]
-    INFINITY = 1e20.to_f # not quite, but pretty much
+    INFINITY = 1e20 # not quite, but pretty much
 
     def record(value)
       return unless value
@@ -11,7 +11,7 @@ module Honeybadger
       @samples += 1
 
       @total ||= 0
-      @total = @total + value
+      @total += value
 
       @min = value if @min.nil? || @min > value
       @max = value if @max.nil? || @max < value
@@ -23,7 +23,7 @@ module Honeybadger
     end
 
     def find_bin(value)
-      bin = bins.find {|b| b >= value  }
+      bin = bins.find { |b| b >= value }
       bin = INFINITY if bin.nil?
       bin
     end

data/lib/honeybadger/init/hanami.rb

@@ -1,14 +1,14 @@
-require 'honeybadger/ruby'
+require "honeybadger/ruby"
 
 Honeybadger.init!({
-  :framework => :hanami,
-  :env => ENV['HANAMI_ENV'] || ENV['RACK_ENV'],
-  :'logging.path' => 'STDOUT'
+  framework: :hanami,
+  env: ENV["HANAMI_ENV"] || ENV["RACK_ENV"],
+  "logging.path": "STDOUT"
 })
 
 Honeybadger.load_plugins!
 
-if Hanami::VERSION >= '2.0' && Honeybadger.config[:'exceptions.enabled']
+if Hanami::VERSION >= "2.0" && Honeybadger.config[:"exceptions.enabled"]
   Hanami.app.instance_eval do
     config.middleware.use Honeybadger::Rack::UserFeedback
     config.middleware.use Honeybadger::Rack::UserInformer

data/lib/honeybadger/init/rails.rb

@@ -1,33 +1,33 @@
-require 'rails'
-require 'yaml'
+require "rails"
+require "yaml"
 
-require 'honeybadger/ruby'
+require "honeybadger/ruby"
 
 module Honeybadger
   module Init
     module Rails
       class Railtie < ::Rails::Railtie
         rake_tasks do
-          load 'honeybadger/tasks.rb'
+          load "honeybadger/tasks.rb"
         end
 
-        initializer 'honeybadger.install_middleware' do |app|
+        initializer "honeybadger.install_middleware" do |app|
           honeybadger_config = Honeybadger::Agent.instance.config
 
-          if honeybadger_config[:'exceptions.enabled']
+          if honeybadger_config[:"exceptions.enabled"]
             app.config.middleware.insert(0, Honeybadger::Rack::ErrorNotifier)
-            app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer) if honeybadger_config[:'user_informer.enabled']
-            app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback) if honeybadger_config[:'feedback.enabled']
+            app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer) if honeybadger_config[:"user_informer.enabled"]
+            app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback) if honeybadger_config[:"feedback.enabled"]
           end
         end
 
         config.before_initialize do
           Honeybadger.init!({
-            :root           => ::Rails.root.to_s,
-            :env            => ::Rails.env,
-            :'config.path'  => ::Rails.root.join('config', 'honeybadger.yml'),
-            :logger         => Logging::FormattedLogger.new(::Rails.logger),
-            :framework      => :rails
+            root: ::Rails.root.to_s,
+            env: ::Rails.env,
+            "config.path": ::Rails.root.join("config", "honeybadger.yml"),
+            logger: Logging::FormattedLogger.new(::Rails.logger),
+            framework: :rails
           })
         end
 
@@ -36,7 +36,7 @@ module Honeybadger
         end
 
         console do
-          unless Honeybadger::Agent.instance.config[:'insights.enabled'] = Honeybadger::Agent.instance.config[:'insights.console.enabled']
+          unless (Honeybadger::Agent.instance.config[:"insights.enabled"] = Honeybadger::Agent.instance.config[:"insights.console.enabled"])
             Honeybadger::Agent.instance.config.logger.debug("Rails console detected, shutting down Honeybadger Insights workers.")
             Honeybadger::Agent.instance.stop_insights
           end

data/lib/honeybadger/init/rake.rb

@@ -1,4 +1,4 @@
-require 'honeybadger/ruby'
+require "honeybadger/ruby"
 
 module Honeybadger
   # @api private
@@ -6,7 +6,7 @@ module Honeybadger
   module RakeHandler
     def self.included(klass)
       klass.class_eval do
-        include Rake087Methods unless defined?(Rake::VERSION) && Rake::VERSION >= '0.9.0'
+        include Rake087Methods unless defined?(Rake::VERSION) && Rake::VERSION >= "0.9.0"
         alias_method :display_error_message_without_honeybadger, :display_error_message
         alias_method :display_error_message, :display_error_message_with_honeybadger
       end
@@ -20,7 +20,7 @@ module Honeybadger
     end
 
     def reconstruct_command_line
-      "rake #{ARGV.join( ' ' )}"
+      "rake #{ARGV.join(" ")}"
     end
 
     # This module brings Rake 0.8.7 error handling to 0.9.0 standards
@@ -29,30 +29,28 @@ module Honeybadger
       #
       # Provide standard exception handling for the given block.
       def standard_exception_handling
-        begin
-          yield
-        rescue SystemExit => ex
-          # Exit silently with current status
-          raise
-        rescue OptionParser::InvalidOption => ex
-          $stderr.puts ex.message
-          exit(false)
-        rescue Exception => ex
-          # Exit with error message
-          display_error_message(ex)
-          exit(false)
-        end
+        yield
+      rescue SystemExit
+        # Exit silently with current status
+        raise
+      rescue OptionParser::InvalidOption => ex
+        warn ex.message
+        exit(false)
+      rescue => ex
+        # Exit with error message
+        display_error_message(ex)
+        exit(false)
       end
 
       # Method extracted from Rake 0.8.7 source
       def display_error_message(ex)
-        $stderr.puts "#{name} aborted!"
-        $stderr.puts ex.message
+        warn "#{name} aborted!"
+        warn ex.message
         if options.trace
-          $stderr.puts ex.backtrace.join("\n")
+          warn ex.backtrace.join("\n")
         else
-          $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
-          $stderr.puts "(See full trace by running task with --trace)"
+          warn ex.backtrace.find { |str| str =~ /#{@rakefile}/ } || ""
+          warn "(See full trace by running task with --trace)"
         end
       end
     end

data/lib/honeybadger/init/ruby.rb

@@ -1,9 +1,9 @@
-require 'honeybadger/ruby'
+require "honeybadger/ruby"
 
 Honeybadger.init!({
-  :framework      => :ruby,
-  :env            => ENV['RUBY_ENV'] || ENV['RACK_ENV'],
-  :'logging.path' => 'STDOUT'
+  framework: :ruby,
+  env: ENV["RUBY_ENV"] || ENV["RACK_ENV"],
+  "logging.path": "STDOUT"
 })
 
 Honeybadger.load_plugins!

data/lib/honeybadger/init/sinatra.rb

@@ -1,5 +1,5 @@
-require 'sinatra/base'
-require 'honeybadger/ruby'
+require "sinatra/base"
+require "honeybadger/ruby"
 
 module Honeybadger
   module Init
@@ -15,8 +15,8 @@ module Honeybadger
             Honeybadger.install_at_exit_callback
             build_without_honeybadger(*args, &block)
           end
-          alias :build_without_honeybadger :build
-          alias :build :build_with_honeybadger
+          alias_method :build_without_honeybadger, :build
+          alias_method :build, :build_with_honeybadger
 
           def configure_honeybadger
             return unless defined?(honeybadger_api_key)
@@ -27,21 +27,20 @@ module Honeybadger
 
           def install_honeybadger
             config = Honeybadger.config
-            return unless config[:'sinatra.enabled']
-            if config[:'exceptions.enabled']
+            return unless config[:"sinatra.enabled"]
+            if config[:"exceptions.enabled"]
               # These two must come before the ErrorNotifier, since an error/response
               # passes through middleware from inner to outer (bottom to top)
-              install_honeybadger_middleware(Honeybadger::Rack::UserFeedback) if config[:'feedback.enabled']
-              install_honeybadger_middleware(Honeybadger::Rack::UserInformer) if config[:'user_informer.enabled']
+              install_honeybadger_middleware(Honeybadger::Rack::UserFeedback) if config[:"feedback.enabled"]
+              install_honeybadger_middleware(Honeybadger::Rack::UserInformer) if config[:"user_informer.enabled"]
               install_honeybadger_middleware(Honeybadger::Rack::ErrorNotifier)
             end
           end
 
           def install_honeybadger_middleware(klass)
-            return if middleware.any? {|m| m[0] == klass }
+            return if middleware.any? { |m| m[0] == klass }
             use(klass)
           end
-
         end
       end
     end
@@ -49,9 +48,9 @@ module Honeybadger
 end
 
 Honeybadger.init!({
-  env: ENV['APP_ENV'] || ENV['RACK_ENV'],
+  env: ENV["APP_ENV"] || ENV["RACK_ENV"],
   framework: :sinatra,
-  :'logging.path' => 'STDOUT'
+  "logging.path": "STDOUT"
 })
 
 Honeybadger.load_plugins!

data/lib/honeybadger/instrumentation.rb

@@ -1,7 +1,7 @@
-require 'honeybadger/histogram'
-require 'honeybadger/timer'
-require 'honeybadger/counter'
-require 'honeybadger/gauge'
+require "honeybadger/histogram"
+require "honeybadger/timer"
+require "honeybadger/counter"
+require "honeybadger/gauge"
 
 module Honeybadger
   # +Honeybadger::Instrumentation+ defines the API for collecting metric data from anywhere
@@ -47,14 +47,13 @@ module Honeybadger
     def time(name, *args)
       attributes = extract_attributes(args)
       callable = extract_callable(args)
-      value = nil
 
-      if callable
-        value = monotonic_timer{ callable.call }[0]
+      value = if callable
+        monotonic_timer { callable.call }[0]
       elsif block_given?
-        value = monotonic_timer{ yield }[0]
+        monotonic_timer { yield }[0]
       else
-        value = attributes.delete(:duration) || attributes.delete(:value)
+        attributes.delete(:duration) || attributes.delete(:value)
       end
 
       Honeybadger::Timer.register(registry, name, attributes).tap do |timer|
@@ -69,14 +68,13 @@ module Honeybadger
     def histogram(name, *args)
       attributes = extract_attributes(args)
       callable = extract_callable(args)
-      value = nil
 
-      if callable
-        value = monotonic_timer{ callable.call }[0]
+      value = if callable
+        monotonic_timer { callable.call }[0]
       elsif block_given?
-        value = monotonic_timer{ yield }[0]
+        monotonic_timer { yield }[0]
       else
-        value = attributes.delete(:duration) || attributes.delete(:value)
+        attributes.delete(:duration) || attributes.delete(:value)
       end
 
       Honeybadger::Histogram.register(registry, name, attributes).tap do |histogram|
@@ -91,14 +89,13 @@ module Honeybadger
     def increment_counter(name, *args)
       attributes = extract_attributes(args)
       callable = extract_callable(args)
-      value = nil
 
-      if callable
-        value = callable.call
+      value = if callable
+        callable.call
       elsif block_given?
-        value = yield
+        yield
       else
-        value = attributes.delete(:by) || attributes.delete(:value) || 1
+        attributes.delete(:by) || attributes.delete(:value) || 1
       end
 
       Honeybadger::Counter.register(registry, name, attributes).tap do |counter|
@@ -109,14 +106,13 @@ module Honeybadger
     def decrement_counter(name, *args)
       attributes = extract_attributes(args)
       callable = extract_callable(args)
-      value = nil
 
-      if callable
-        value = callable.call
+      value = if callable
+        callable.call
       elsif block_given?
-        value = yield
+        yield
       else
-        value = attributes.delete(:by) || attributes.delete(:value) || 1
+        attributes.delete(:by) || attributes.delete(:value) || 1
       end
 
       Honeybadger::Counter.register(registry, name, attributes).tap do |counter|
@@ -127,14 +123,13 @@ module Honeybadger
     def gauge(name, *args)
       attributes = extract_attributes(args)
       callable = extract_callable(args)
-      value = nil
 
-      if callable
-        value = callable.call
+      value = if callable
+        callable.call
       elsif block_given?
-        value = yield
+        yield
       else
-        value = attributes.delete(:duration) || attributes.delete(:value)
+        attributes.delete(:duration) || attributes.delete(:value)
       end
 
       Honeybadger::Gauge.register(registry, name, attributes).tap do |gauge|
@@ -148,12 +143,12 @@ module Honeybadger
 
     # @api private
     def extract_attributes(args)
-      args.select { |a| a.is_a?(Hash) }.first || {}
+      args.find { |a| a.is_a?(Hash) } || {}
     end
 
     # @api private
     def extract_callable(args)
-      args.select { |a| a.respond_to?(:call) }.first
+      args.find { |a| a.respond_to?(:call) }
     end
   end
 end

data/lib/honeybadger/instrumentation_helper.rb

@@ -1,4 +1,4 @@
-require 'honeybadger/instrumentation'
+require "honeybadger/instrumentation"
 
 module Honeybadger
   # +Honeybadger::InstrumentationHelper+ is a module that can be included into any class. This module
@@ -25,7 +25,6 @@ module Honeybadger
   #     end
   #   end
   module InstrumentationHelper
-
     # returns two parameters, the first is the duration of the execution, and the second is
     # the return value of the passed block
     def monotonic_timer
@@ -53,9 +52,9 @@ module Honeybadger
       attributes = extract_attributes(args)
       callable = extract_callable(args)
       if callable
-        metric_instrumentation.time(name, attributes, ->{ callable.call })
+        metric_instrumentation.time(name, attributes, -> { callable.call })
       elsif block_given?
-        metric_instrumentation.time(name, attributes, ->{ yield })
+        metric_instrumentation.time(name, attributes, -> { yield })
       else
         metric_instrumentation.time(name, attributes)
       end
@@ -65,9 +64,9 @@ module Honeybadger
       attributes = extract_attributes(args)
       callable = extract_callable(args)
       if callable
-        metric_instrumentation.histogram(name, attributes, ->{ callable.call })
+        metric_instrumentation.histogram(name, attributes, -> { callable.call })
       elsif block_given?
-        metric_instrumentation.histogram(name, attributes, ->{ yield })
+        metric_instrumentation.histogram(name, attributes, -> { yield })
       else
         metric_instrumentation.histogram(name, attributes)
       end
@@ -77,9 +76,9 @@ module Honeybadger
       attributes = extract_attributes(args)
       callable = extract_callable(args)
       if callable
-        metric_instrumentation.increment_counter(name, attributes, ->{ callable.call })
+        metric_instrumentation.increment_counter(name, attributes, -> { callable.call })
       elsif block_given?
-        metric_instrumentation.increment_counter(name, attributes, ->{ yield })
+        metric_instrumentation.increment_counter(name, attributes, -> { yield })
       else
         metric_instrumentation.increment_counter(name, attributes)
       end
@@ -89,9 +88,9 @@ module Honeybadger
       attributes = extract_attributes(args)
       callable = extract_callable(args)
       if callable
-        metric_instrumentation.decrement_counter(name, attributes, ->{ callable.call })
+        metric_instrumentation.decrement_counter(name, attributes, -> { callable.call })
       elsif block_given?
-        metric_instrumentation.decrement_counter(name, attributes, ->{ yield })
+        metric_instrumentation.decrement_counter(name, attributes, -> { yield })
       else
         metric_instrumentation.decrement_counter(name, attributes)
       end
@@ -101,9 +100,9 @@ module Honeybadger
       attributes = extract_attributes(args)
       callable = extract_callable(args)
       if callable
-        metric_instrumentation.gauge(name, attributes, ->{ callable.call })
+        metric_instrumentation.gauge(name, attributes, -> { callable.call })
       elsif block_given?
-        metric_instrumentation.gauge(name, attributes, ->{ yield })
+        metric_instrumentation.gauge(name, attributes, -> { yield })
       else
         metric_instrumentation.gauge(name, attributes)
       end