honeybadger 5.29.1 → 6.0.6

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

data/lib/honeybadger/karafka.rb

@@ -1,4 +1,4 @@
-require 'honeybadger/instrumentation_helper'
+require "honeybadger/instrumentation_helper"
 
 module Honeybadger
   module Karafka
@@ -10,7 +10,6 @@ module Honeybadger
         context = {
           type: event[:type]
         }
-        tags = ["type:#{event[:type]}"]
 
         if (consumer = event.payload[:caller]).respond_to?(:messages)
           messages = consumer.messages
@@ -38,28 +37,28 @@ module Honeybadger
       # Note, that the once with `_d` come from Karafka, not rdkafka or Kafka
       RD_KAFKA_METRICS = [
         # Client metrics
-        RdKafkaMetric.new(:increment_counter, :root, 'messages_consumed', 'rxmsgs_d'),
-        RdKafkaMetric.new(:increment_counter, :root, 'messages_consumed_bytes', 'rxmsg_bytes'),
+        RdKafkaMetric.new(:increment_counter, :root, "messages_consumed", "rxmsgs_d"),
+        RdKafkaMetric.new(:increment_counter, :root, "messages_consumed_bytes", "rxmsg_bytes"),
 
         # Broker metrics
-        RdKafkaMetric.new(:increment_counter, :brokers, 'consume_attempts', 'txretries_d'),
-        RdKafkaMetric.new(:increment_counter, :brokers, 'consume_errors', 'txerrs_d'),
-        RdKafkaMetric.new(:increment_counter, :brokers, 'receive_errors', 'rxerrs_d'),
-        RdKafkaMetric.new(:increment_counter, :brokers, 'connection_connects', 'connects_d'),
-        RdKafkaMetric.new(:increment_counter, :brokers, 'connection_disconnects', 'disconnects_d'),
-        RdKafkaMetric.new(:gauge, :brokers, 'network_latency_avg', %w[rtt avg]),
-        RdKafkaMetric.new(:gauge, :brokers, 'network_latency_p95', %w[rtt p95]),
-        RdKafkaMetric.new(:gauge, :brokers, 'network_latency_p99', %w[rtt p99]),
+        RdKafkaMetric.new(:increment_counter, :brokers, "consume_attempts", "txretries_d"),
+        RdKafkaMetric.new(:increment_counter, :brokers, "consume_errors", "txerrs_d"),
+        RdKafkaMetric.new(:increment_counter, :brokers, "receive_errors", "rxerrs_d"),
+        RdKafkaMetric.new(:increment_counter, :brokers, "connection_connects", "connects_d"),
+        RdKafkaMetric.new(:increment_counter, :brokers, "connection_disconnects", "disconnects_d"),
+        RdKafkaMetric.new(:gauge, :brokers, "network_latency_avg", %w[rtt avg]),
+        RdKafkaMetric.new(:gauge, :brokers, "network_latency_p95", %w[rtt p95]),
+        RdKafkaMetric.new(:gauge, :brokers, "network_latency_p99", %w[rtt p99]),
 
         # Topics metrics
-        RdKafkaMetric.new(:gauge, :topics, 'consumer_lags', 'consumer_lag_stored'),
-        RdKafkaMetric.new(:gauge, :topics, 'consumer_lags_delta', 'consumer_lag_stored_d')
+        RdKafkaMetric.new(:gauge, :topics, "consumer_lags", "consumer_lag_stored"),
+        RdKafkaMetric.new(:gauge, :topics, "consumer_lags_delta", "consumer_lag_stored_d")
       ].freeze
 
       # Metrics that sum values on topics levels and not on partition levels
       AGGREGATED_RD_KAFKA_METRICS = [
         # Topic aggregated metrics
-        RdKafkaMetric.new(:gauge, :topics, 'consumer_aggregated_lag', 'consumer_lag_stored')
+        RdKafkaMetric.new(:gauge, :topics, "consumer_aggregated_lag", "consumer_lag_stored")
       ].freeze
 
       def initialize
@@ -79,7 +78,7 @@ module Honeybadger
         statistics = event[:statistics]
         consumer_group_id = event[:consumer_group_id]
 
-        base_tags = { consumer_group: consumer_group_id }
+        base_tags = {consumer_group: consumer_group_id}
 
         RD_KAFKA_METRICS.each do |metric|
           report_metric(metric, statistics, base_tags)
@@ -94,14 +93,14 @@ module Honeybadger
       # @param consumer_group_id [String] cg in context which we operate
       def report_aggregated_topics_metrics(statistics, consumer_group_id)
         AGGREGATED_RD_KAFKA_METRICS.each do |metric|
-          statistics.fetch('topics').each do |topic_name, topic_values|
+          statistics.fetch("topics").each do |topic_name, topic_values|
             sum = 0
 
-            topic_values['partitions'].each do |partition_name, partition_statistics|
-              next if partition_name == '-1'
+            topic_values["partitions"].each do |partition_name, partition_statistics|
+              next if partition_name == "-1"
               # Skip until lag info is available
-              next if partition_statistics['consumer_lag'] == -1
-              next if partition_statistics['consumer_lag_stored'] == -1
+              next if partition_statistics["consumer_lag"] == -1
+              next if partition_statistics["consumer_lag_stored"] == -1
 
               sum += partition_statistics.dig(*metric.key_location)
             end
@@ -121,7 +120,7 @@ module Honeybadger
       #
       # @param event [Karafka::Core::Monitoring::Event]
       def on_error_occurred(event)
-        extra_tags = { type: event[:type] }
+        extra_tags = {type: event[:type]}
 
         if event.payload[:caller].respond_to?(:messages)
           extra_tags.merge!(consumer_tags(event.payload[:caller]))
@@ -132,7 +131,7 @@ module Honeybadger
         end
 
         if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
-          increment_counter('error_occurred', value: 1, **extra_tags)
+          increment_counter("error_occurred", value: 1, **extra_tags)
         end
       end
 
@@ -143,11 +142,11 @@ module Honeybadger
         time_taken = event[:time]
         messages_count = event[:messages_buffer].size
         consumer_group_id = event[:subscription_group].consumer_group.id
-        extra_tags = { consumer_group: consumer_group_id }
+        extra_tags = {consumer_group: consumer_group_id}
 
         if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
-          histogram('listener_polling_time_taken', value: time_taken, **extra_tags)
-          histogram('listener_polling_messages', value: messages_count, **extra_tags)
+          histogram("listener_polling_time_taken", value: time_taken, **extra_tags)
+          histogram("listener_polling_messages", value: messages_count, **extra_tags)
         end
       end
 
@@ -173,13 +172,13 @@ module Honeybadger
         end
 
         if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
-          increment_counter('consumer_messages', value: messages.count, **tags)
-          increment_counter('consumer_batches', value: 1, **tags)
-          gauge('consumer_offset', value: metadata.last_offset, **tags)
-          histogram('consumer_consumed_time_taken', value: event[:time], **tags)
-          histogram('consumer_batch_size', value: messages.count, **tags)
-          histogram('consumer_processing_lag', value: metadata.processing_lag, **tags)
-          histogram('consumer_consumption_lag', value: metadata.consumption_lag, **tags)
+          increment_counter("consumer_messages", value: messages.count, **tags)
+          increment_counter("consumer_batches", value: 1, **tags)
+          gauge("consumer_offset", value: metadata.last_offset, **tags)
+          histogram("consumer_consumed_time_taken", value: event[:time], **tags)
+          histogram("consumer_batch_size", value: messages.count, **tags)
+          histogram("consumer_processing_lag", value: metadata.processing_lag, **tags)
+          histogram("consumer_consumption_lag", value: metadata.consumption_lag, **tags)
         end
       end
 
@@ -189,15 +188,15 @@ module Honeybadger
         ticked: :tick
       }.each do |after, name|
         class_eval <<~RUBY, __FILE__, __LINE__ + 1
-              # Keeps track of user code execution
-              #
-              # @param event [Karafka::Core::Monitoring::Event]
-              def on_consumer_#{after}(event)
-                if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
-                  tags = consumer_tags(event.payload[:caller])
-                  increment_counter('consumer_#{name}', value: 1, **tags)
-                end
-              end
+          # Keeps track of user code execution
+          #
+          # @param event [Karafka::Core::Monitoring::Event]
+          def on_consumer_#{after}(event)
+            if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
+              tags = consumer_tags(event.payload[:caller])
+              increment_counter('consumer_#{name}', value: 1, **tags)
+            end
+          end
         RUBY
       end
 
@@ -207,9 +206,9 @@ module Honeybadger
         jq_stats = event[:jobs_queue].statistics
 
         if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
-          gauge('worker_total_threads', value: ::Karafka::App.config.concurrency)
-          histogram('worker_processing', value: jq_stats[:busy])
-          histogram('worker_enqueued_jobs', value: jq_stats[:enqueued])
+          gauge("worker_total_threads", value: ::Karafka::App.config.concurrency)
+          histogram("worker_processing", value: jq_stats[:busy])
+          histogram("worker_enqueued_jobs", value: jq_stats[:enqueued])
         end
       end
 
@@ -220,7 +219,7 @@ module Honeybadger
         jq_stats = event[:jobs_queue].statistics
 
         if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
-          histogram('worker_processing', value: jq_stats[:busy])
+          histogram("worker_processing", value: jq_stats[:busy])
         end
       end
 
@@ -240,30 +239,30 @@ module Honeybadger
             **base_tags
           )
         when :brokers
-          statistics.fetch('brokers').each_value do |broker_statistics|
+          statistics.fetch("brokers").each_value do |broker_statistics|
             # Skip bootstrap nodes
             # Bootstrap nodes have nodeid -1, other nodes have positive
             # node ids
-            next if broker_statistics['nodeid'] == -1
+            next if broker_statistics["nodeid"] == -1
 
             public_send(
               metric.type,
               metric.name,
               value: broker_statistics.dig(*metric.key_location),
-              **base_tags.merge(broker: broker_statistics['nodename'])
+              **base_tags.merge(broker: broker_statistics["nodename"])
             )
           end
         when :topics
-          statistics.fetch('topics').each do |topic_name, topic_values|
-            topic_values['partitions'].each do |partition_name, partition_statistics|
-              next if partition_name == '-1'
+          statistics.fetch("topics").each do |topic_name, topic_values|
+            topic_values["partitions"].each do |partition_name, partition_statistics|
+              next if partition_name == "-1"
               # Skip until lag info is available
-              next if partition_statistics['consumer_lag'] == -1
-              next if partition_statistics['consumer_lag_stored'] == -1
+              next if partition_statistics["consumer_lag"] == -1
+              next if partition_statistics["consumer_lag_stored"] == -1
 
               # Skip if we do not own the fetch assignment
-              next if partition_statistics['fetch_state'] == 'stopped'
-              next if partition_statistics['fetch_state'] == 'none'
+              next if partition_statistics["fetch_state"] == "stopped"
+              next if partition_statistics["fetch_state"] == "none"
 
               public_send(
                 metric.type,

data/lib/honeybadger/logging.rb

@@ -1,12 +1,12 @@
-require 'logger'
-require 'singleton'
-require 'delegate'
-require 'forwardable'
+require "logger"
+require "singleton"
+require "delegate"
+require "forwardable"
 
 module Honeybadger
   # @api private
   module Logging
-    PREFIX = '** [Honeybadger] '.freeze
+    PREFIX = "** [Honeybadger] ".freeze
     LOGGER_PROG = "honeybadger".freeze
 
     # Logging helper methods. Requires a Honeybadger::Config @config instance
@@ -15,12 +15,13 @@ module Honeybadger
     # logger directly to avoid extra object allocation.
     module Helper
       private
+
       def debug(msg = nil)
         return true unless logger.debug?
         msg = yield if block_given?
         logger.debug(msg)
       end
-      alias :d :debug
+      alias_method :d, :debug
 
       def info(msg = nil)
         return true unless logger.info?
@@ -57,7 +58,7 @@ module Honeybadger
       end
 
       def add(severity, msg)
-        raise NotImplementedError, 'must define #add on subclass.'
+        raise NotImplementedError, "must define #add on subclass."
       end
 
       def level
@@ -88,13 +89,13 @@ module Honeybadger
       extend Forwardable
 
       def initialize(logger = Logger.new(nil))
-        raise ArgumentError, 'logger not specified' unless logger
-        raise ArgumentError, 'logger must be a logger' unless logger.respond_to?(:add)
+        raise ArgumentError, "logger not specified" unless logger
+        raise ArgumentError, "logger must be a logger" unless logger.respond_to?(:add)
 
         @logger = logger
       end
 
-      def add(severity, msg, progname=LOGGER_PROG)
+      def add(severity, msg, progname = LOGGER_PROG)
         @logger.add(severity, msg, progname)
       end
 
@@ -102,29 +103,29 @@ module Honeybadger
     end
 
     class FormattedLogger < StandardLogger
-      def add(severity, msg, progname=LOGGER_PROG)
+      def add(severity, msg, progname = LOGGER_PROG)
         super(severity, format_message(msg), progname)
       end
 
       private
 
       def format_message(msg)
-        return msg unless msg.kind_of?(String)
+        return msg unless msg.is_a?(String)
         PREFIX + msg
       end
     end
 
     class ConfigLogger < StandardLogger
-      LOCATE_CALLER_LOCATION = Regexp.new("#{Regexp.escape(__FILE__)}").freeze
-      CALLER_LOCATION = Regexp.new("#{Regexp.escape(File.expand_path('../../../', __FILE__))}/(.*)").freeze
+      LOCATE_CALLER_LOCATION = Regexp.new(Regexp.escape(__FILE__).to_s).freeze
+      CALLER_LOCATION = Regexp.new("#{Regexp.escape(File.expand_path("../../../", __FILE__))}/(.*)").freeze
 
-      INFO_SUPPLEMENT = ' level=%s pid=%s'.freeze
-      DEBUG_SUPPLEMENT = ' at=%s'.freeze
+      INFO_SUPPLEMENT = " level=%s pid=%s".freeze
+      DEBUG_SUPPLEMENT = " at=%s".freeze
 
       def initialize(config, logger = Logger.new(nil))
         @config = config
-        @tty = STDOUT.tty?
-        @tty_level = @config.log_level(:'logging.tty_level')
+        @tty = $stdout.tty?
+        @tty_level = @config.log_level(:"logging.tty_level")
         super(logger)
       end
 
@@ -156,11 +157,11 @@ module Honeybadger
       end
 
       def supplement(msg, severity)
-        return msg unless msg.kind_of?(String)
+        return msg unless msg.is_a?(String)
 
         r = msg.dup
         r << sprintf(INFO_SUPPLEMENT, severity, Process.pid)
-        if severity == Logger::Severity::DEBUG && l = caller_location
+        if severity == Logger::Severity::DEBUG && (l = caller_location)
           r << sprintf(DEBUG_SUPPLEMENT, l.dump)
         end
 
@@ -168,7 +169,7 @@ module Honeybadger
       end
 
       def caller_location
-        if caller && caller.find {|l| l !~ LOCATE_CALLER_LOCATION && l =~ CALLER_LOCATION }
+        if caller&.find { |l| l !~ LOCATE_CALLER_LOCATION && l =~ CALLER_LOCATION }
           Regexp.last_match(1)
         end
       end

data/lib/honeybadger/metric.rb

@@ -3,11 +3,11 @@ module Honeybadger
     attr_reader :name, :attributes, :samples
 
     def self.metric_type
-      name.split('::').last.downcase
+      name.split("::").last.downcase
     end
 
     def self.signature(metric_type, name, attributes)
-      Digest::SHA1.hexdigest("#{metric_type}-#{name}-#{attributes.keys.join('-')}-#{attributes.values.join('-')}").to_sym
+      Digest::SHA1.hexdigest("#{metric_type}-#{name}-#{attributes.keys.join("-")}-#{attributes.values.join("-")}").to_sym
     end
 
     def self.register(registry, metric_name, attributes)

data/lib/honeybadger/metrics_worker.rb

@@ -1,4 +1,4 @@
-require 'honeybadger/logging'
+require "honeybadger/logging"
 
 module Honeybadger
   # A concurrent queue to execute plugin collect blocks and registry.
@@ -40,7 +40,7 @@ module Honeybadger
     end
 
     def shutdown(force = false)
-      d { 'shutting down worker' }
+      d { "shutting down worker" }
 
       mutex.synchronize do
         @shutdown = true
@@ -59,7 +59,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(marker)
           marker.wait(mutex)
         end
@@ -101,7 +101,7 @@ module Honeybadger
     end
 
     def kill!
-      d { 'killing worker thread' }
+      d { "killing worker thread" }
 
       if thread
         Thread.kill(thread)
@@ -123,7 +123,7 @@ module Honeybadger
 
     def run
       begin
-        d { 'worker started' }
+        d { "worker started" }
         loop do
           case msg = queue.pop
           when SHUTDOWN then break
@@ -132,9 +132,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"))
@@ -148,9 +148,9 @@ module Honeybadger
 
       if shutdown?
         kill!
-        return
+        nil
       end
-    rescue StandardError => e
+    rescue => e
       error {
         err = "Error in worker thread class=%s message=%s\n\t%s"
         sprintf(err, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
@@ -167,8 +167,10 @@ module Honeybadger
     end
 
     def signal_marker(marker)
-      mutex.synchronize do
+      if mutex.owned?
         marker.signal
+      else
+        mutex.synchronize { marker.signal }
       end
     end
   end