honeybadger 2.0.0.beta.6 → 2.0.0.beta.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9805ffd53c0cada4c33bfbd62bd20d891c4f039
-  data.tar.gz: 71ab06bd9401356104a2c109d8948fbc54233604
+  metadata.gz: ea4729431078cbb1e542a22bbb1ac422a038be32
+  data.tar.gz: 7da4b010726bd765840424ad160a8235e04ad5b8
 SHA512:
-  metadata.gz: e386d4b064d2df292bd15580045bda368367366d46991abf23b2dd02cd778c00e8dd222e55adb5279dcb4aa05ec5cd59bb4a29d2f845e00fa4aa069c0f3b2022
-  data.tar.gz: accd30aa1300df10932d20e93da8bc0088532d9baaa37af9e270d025bce3034777861092c01b49b85c797610aeb82a8647d44565695597bc4537a9d0c6dc3d0b
+  metadata.gz: 685b29b9328d62dda5c9b5bfda43968601d9f6f7861060c2ad8531c9afcb650e386e1bcf82785ff37a630957b21eeebe8d07ac8b80d406d9d391e52c9b672d3b
+  data.tar.gz: 6c503a35df7698efa690e1c8552c8f2c6b829ccdeeca7263ae20ed3b0f4eb3afd20f8fbc4375907fb49587f51c75905c3517b2b8b3b437c8d2acfa20c658dfe9

data/lib/honeybadger/{worker → agent}/batch.rb

@@ -1,7 +1,7 @@
 require 'securerandom'
 
 module Honeybadger
-  class Worker
+  class Agent
     class Batch
       def initialize(config, name = :data, max = 100, interval = 60, now = now)
         @id = SecureRandom.uuid

data/lib/honeybadger/{worker → agent}/metered_queue.rb

@@ -1,5 +1,5 @@
 module Honeybadger
-  class Worker
+  class Agent
     # Internal: A thread-safe first-in-first-out queue. Values are pushed onto
     # the queue and released at a defined interval.
     class MeteredQueue

data/lib/honeybadger/{worker → agent}/metrics_collection.rb

@@ -1,5 +1,5 @@
 module Honeybadger
-  class Worker
+  class Agent
     # This code comes from batsd
     class MetricsCollection < Array
       PERCENTILE_METHOD_SIGNATURE = /\Apercentile_(.+)\z/.freeze

data/lib/honeybadger/{worker → agent}/metrics_collector.rb

@@ -2,8 +2,8 @@ require 'securerandom'
 require 'forwardable'
 
 module Honeybadger
-  class Worker
-    autoload :MetricsCollection, 'honeybadger/worker/metrics_collection'
+  class Agent
+    autoload :MetricsCollection, 'honeybadger/agent/metrics_collection'
 
     class MetricsCollector
       extend Forwardable
@@ -46,21 +46,31 @@ module Honeybadger
         now >= future
       end
 
-      def to_a
-        [].tap do |m|
-          metrics[:counter].each do |metric, values|
-            m << "#{metric} #{values.sum}"
+      def size
+        mutex.synchronize do
+          metrics.reduce(0) do |count, hash|
+            count + hash[1].size
           end
-          metrics[:timing].each do |metric, values|
-            m << "#{metric}:mean #{values.mean}"
-            m << "#{metric}:median #{values.median}"
-            m << "#{metric}:percentile_90 #{values.percentile(90)}"
-            m << "#{metric}:min #{values.min}"
-            m << "#{metric}:max #{values.max}"
-            m << "#{metric}:stddev #{values.standard_dev}" if values.count > 1
-            m << "#{metric} #{values.count}"
+        end
+      end
+
+      def to_a
+        mutex.synchronize do
+          [].tap do |m|
+            metrics[:counter].each do |metric, values|
+              m << "#{metric} #{values.sum}"
+            end
+            metrics[:timing].each do |metric, values|
+              m << "#{metric}:mean #{values.mean}"
+              m << "#{metric}:median #{values.median}"
+              m << "#{metric}:percentile_90 #{values.percentile(90)}"
+              m << "#{metric}:min #{values.min}"
+              m << "#{metric}:max #{values.max}"
+              m << "#{metric}:stddev #{values.standard_dev}" if values.count > 1
+              m << "#{metric} #{values.count}"
+            end
+            m.compact!
           end
-          m.compact!
         end
       end
 

data/lib/honeybadger/agent/null_worker.rb

@@ -0,0 +1,26 @@
+module Honeybadger
+  class Agent
+    # Internal: A default worker which does nothing.
+    class NullWorker
+      def push(obj)
+        true
+      end
+
+      def shutdown(timeout = nil)
+        true
+      end
+
+      def shutdown!
+        true
+      end
+
+      def flush
+        true
+      end
+
+      def start
+        true
+      end
+    end
+  end
+end

data/lib/honeybadger/agent/worker.rb

@@ -0,0 +1,217 @@
+require 'forwardable'
+require 'net/http'
+
+require 'honeybadger/logging'
+require 'honeybadger/agent/null_worker'
+
+module Honeybadger
+  class Agent
+    # Internal: A concurrent queue to notify the backend.
+    class Worker
+      extend Forwardable
+
+      include Honeybadger::Logging::Helper
+
+      # Internal: See Agent::Thread
+      class Thread < ::Thread; end
+
+      # Internal: A queue which enforces a maximum size.
+      class Queue < ::Queue
+        attr_reader :max_size
+
+        def initialize(max_size)
+          @max_size = max_size
+          super()
+        end
+
+        def push(obj)
+          super unless size == max_size
+        end
+      end
+
+      SHUTDOWN = :__hb_worker_shutdown!
+
+      def initialize(config, feature)
+        @config = config
+        @feature = feature
+        @backend = config.backend
+        @throttles = []
+        @mutex = Mutex.new
+        @marker = ConditionVariable.new
+        @queue = Queue.new(1000)
+        @shutdown = false
+      end
+
+      def push(obj)
+        if start
+          queue.push(obj)
+        end
+      end
+
+      # Internal: Shutdown the worker.
+      #
+      # timeout - The Integer timeout to wait before killing thread.
+      #
+      # Returns false if timeout reached, otherwise true.
+      def shutdown(timeout = 3)
+        mutex.synchronize do
+          @shutdown = true
+          @pid = nil
+          queue.push(SHUTDOWN)
+        end
+
+        return true unless thread
+
+        r = true
+        unless Thread.current.eql?(thread)
+          begin
+            r = !!thread.join(timeout)
+          ensure
+            shutdown! unless r
+          end
+        end
+
+        r
+      end
+
+      def shutdown!
+        mutex.synchronize do
+          @shutdown = true
+          @pid = nil
+        end
+
+        d { sprintf('killing worker thread feature=%s', feature) }
+
+        if thread
+          Thread.kill(thread)
+          thread.join # Allow ensure blocks to execute.
+        end
+
+        true
+      end
+
+      # Internal: Blocks until queue is processed up to this point in time.
+      #
+      # Returns nothing.
+      def flush
+        mutex.synchronize do
+          if thread && thread.alive?
+            queue.push(marker)
+            marker.wait(mutex)
+          end
+        end
+      end
+
+      def start
+        mutex.synchronize do
+          return false if @shutdown
+          return true if thread && thread.alive?
+
+          @pid = Process.pid
+          @thread = Thread.new { run }
+        end
+
+        true
+      end
+
+      private
+
+      attr_reader :config, :backend, :feature, :queue, :pid, :mutex, :marker,
+        :thread, :throttles
+
+      def run
+        begin
+          d { sprintf('worker started feature=%s', feature) }
+          loop do
+            case msg = queue.pop
+            when SHUTDOWN then break
+            when ConditionVariable then signal_marker(msg)
+            else process(msg)
+            end
+          end
+        ensure
+          d { sprintf('stopping worker feature=%s', feature) }
+        end
+      rescue Exception => e
+        error(sprintf('error in worker thread (shutting down) feature=%s class=%s message=%s at=%s', feature, e.class, e.message.dump, e.backtrace.first.dump))
+      ensure
+        release_marker
+      end
+
+      def process(msg)
+        handle_response(notify_backend(msg))
+        sleep(throttle_interval)
+      rescue StandardError => e
+        error(sprintf('error in worker thread feature=%s class=%s message=%s at=%s', feature, e.class, e.message.dump, e.backtrace.first.dump))
+        sleep(1)
+      end
+
+      def throttle_interval
+        return 0 unless throttles[0]
+        mutex.synchronize do
+          throttles.reduce(1) {|a,e| a*e }
+        end
+      end
+
+      def notify_backend(payload)
+        debug { sprintf('worker notifying backend feature=%s id=%s', feature, payload.id) }
+        backend.notify(feature, payload)
+      end
+
+      def add_throttle(t)
+        mutex.synchronize do
+          throttles.push(t)
+        end
+      end
+
+      def del_throttle
+        mutex.synchronize do
+          throttles.shift
+        end
+      end
+
+      def handle_response(response)
+        debug { sprintf('worker response feature=%s code=%s message=%s', feature, response.code, response.message.to_s.dump) }
+
+        case response.code
+        when 429, 503
+          add_throttle(1.25)
+          debug { sprintf('worker applying throttle=1.25 interval=%s feature=%s code=%s', throttle_interval, feature, response.code) }
+        when 402
+          warn { sprintf('worker shutting down (payment required) feature=%s code=%s', feature, response.code) }
+          shutdown!
+        when 403
+          warn { sprintf('worker shutting down (unauthorized) feature=%s code=%s', feature, response.code) }
+          shutdown!
+        when 201
+          if throttle = del_throttle
+            debug { sprintf('worker removing throttle=%s interval=%s feature=%s code=%s', throttle, throttle_interval, feature, response.code) }
+          end
+        when :error
+          # Error logged by backend.
+        else
+          warn { sprintf('worker unknown response feature=%s code=%s', feature, response.code) }
+        end
+      end
+
+      # Internal: Release the marker. Important to perform during cleanup when
+      # shutting down, otherwise it could end up waiting indefinitely.
+      #
+      # Returns nothing.
+      def release_marker
+        signal_marker(marker)
+      end
+
+      # Internal: Signal a marker.
+      #
+      # marker - The ConditionVariable marker to signal.
+      #
+      # Returns nothing.
+      def signal_marker(marker)
+        mutex.synchronize do
+          marker.signal
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/agent.rb

@@ -2,18 +2,25 @@ require 'forwardable'
 
 require 'honeybadger/version'
 require 'honeybadger/config'
-require 'honeybadger/worker'
 require 'honeybadger/notice'
 require 'honeybadger/plugin'
 require 'honeybadger/logging'
 
 module Honeybadger
-  # Internal: A broker for the configuration and the worker.
+  # Internal: A broker for the configuration and the workers.
   class Agent
     extend Forwardable
 
     include Logging::Helper
 
+    # Internal: Sub-class thread so we have a named thread (useful for debugging in Thread.list).
+    class Thread < ::Thread; end
+
+    autoload :Worker, 'honeybadger/agent/worker'
+    autoload :NullWorker, 'honeybadger/agent/worker'
+    autoload :Batch, 'honeybadger/agent/batch'
+    autoload :MetricsCollector, 'honeybadger/agent/metrics_collector'
+
     class << self
       extend Forwardable
 
@@ -64,7 +71,8 @@ module Honeybadger
       config.logger.info("Starting Honeybadger version #{VERSION}")
       load_plugins(config)
       @instance = new(config)
-      @instance.start
+
+      true
     end
 
     def self.stop(*args)
@@ -88,6 +96,16 @@ module Honeybadger
       self.instance ? self.instance.increment(*args) : false
     end
 
+    def self.flush(&block)
+      if self.instance
+        self.instance.flush(&block)
+      elsif !block_given?
+        false
+      else
+        yield
+      end
+    end
+
     # Internal: Callback to perform after agent has been stopped at_exit.
     #
     # block - An optional block to execute.
@@ -112,9 +130,21 @@ module Honeybadger
       end
     end
 
+    attr_reader :delay, :workers, :pid, :thread, :traces, :metrics
+
     def initialize(config)
       @config = config
-      @worker = Worker.new(config)
+      @delay = config.debug? ? 10 : 60
+      @mutex = Mutex.new
+      @pid = Process.pid
+
+      unless config.backend.kind_of?(Backend::Server)
+        warn('Initializing development backend: data will not be reported.')
+      end
+
+      init_workers
+      init_traces
+      init_metrics
 
       at_exit do
         stop
@@ -122,14 +152,47 @@ module Honeybadger
       end
     end
 
-    def_delegators :@worker, :stop, :fork, :trace, :timing, :increment
-
+    # Internal: Spawn the agent thread. This method is idempotent.
+    #
+    # Returns false if the Agent is stopped, otherwise true.
     def start
-      unless worker.backend.kind_of?(Backend::Server)
-        warn('Initializing development backend: data will not be reported.')
+      mutex.synchronize do
+        return false unless pid
+        return true if thread && thread.alive?
+
+        debug { 'starting agent' }
+
+        @pid = Process.pid
+        @thread = Thread.new { run }
       end
 
-      worker.start
+      true
+    end
+
+    def stop(force = false)
+      debug { 'stopping agent' }
+
+      mutex.synchronize do
+        @pid = nil
+      end
+
+      # Kill the collector
+      Thread.kill(thread) if thread
+
+      unless force
+        flush_traces
+        flush_metrics
+      end
+
+      workers.each_pair do |key, worker|
+        worker.send(force ? :shutdown! : :shutdown)
+      end
+
+      true
+    end
+
+    def fork
+      # noop
     end
 
     def notice(opts)
@@ -141,13 +204,122 @@ module Honeybadger
         false
       else
         debug { sprintf('notice feature=notices id=%s', notice.id) }
-        worker.notice(notice)
+        workers[:notices].push(notice)
         notice.id
       end
     end
 
+    def trace(trace)
+      start
+
+      if trace.duration > config[:'traces.threshold']
+        debug { sprintf('agent adding trace duration=%s feature=traces id=%s', trace.duration.round(2), trace.id) }
+        mutex.synchronize { traces.push(trace) }
+        flush_traces if traces.flush?
+        true
+      else
+        debug { sprintf('agent discarding trace duration=%s feature=traces id=%s', trace.duration.round(2), trace.id) }
+        false
+      end
+    end
+
+    def timing(*args, &block)
+      start
+
+      mutex.synchronize { metrics.timing(*args, &block) }
+      flush_metrics if metrics.flush?
+
+      true
+    end
+
+    def increment(*args, &block)
+      start
+
+      mutex.synchronize { metrics.increment(*args, &block) }
+      flush_metrics if metrics.flush?
+
+      true
+    end
+
+    # Internal: Flush the workers. See Honeybadger#flush.
+    #
+    # block - an option block which is executed before flushing data.
+    #
+    # Returns value from block if block is given, otherwise true.
+    def flush
+      return true unless block_given?
+      yield
+    ensure
+      flush_metrics
+      flush_traces
+      workers.values.each(&:flush)
+    end
+
     private
 
-    attr_reader :worker, :config
+    attr_reader :config, :mutex
+
+    def push(feature, object)
+      unless config.features[feature]
+        debug { sprintf('agent dropping feature=%s reason=ping', feature) }
+        return false
+      end
+
+      workers[feature].push(object)
+
+      true
+    end
+
+    def run
+      loop { work }
+    rescue Exception => e
+      error(sprintf('error in agent thread (shutting down) class=%s message=%s at=%s', e.class, e.message.dump, e.backtrace.first.dump))
+    ensure
+      d { sprintf('stopping agent') }
+    end
+
+    def work
+      flush_metrics if metrics.flush?
+      flush_traces if traces.flush?
+    rescue StandardError => e
+      error(sprintf('error in agent thread class=%s message=%s at=%s', e.class, e.message.dump, e.backtrace.first.dump))
+    ensure
+      sleep(delay)
+    end
+
+    def init_workers
+      @workers = Hash.new(NullWorker.new)
+      workers[:notices] = Worker.new(config, :notices)
+      workers[:traces]  = Worker.new(config, :traces)
+      workers[:metrics] = Worker.new(config, :metrics)
+    end
+
+    def init_traces
+      @traces = Batch.new(config, :traces, 20, config.debug? ? 10 : 60)
+    end
+
+    def init_metrics
+      @metrics = MetricsCollector.new(config, config.debug? ? 10 : 60)
+    end
+
+    def flush_metrics
+      mutex.synchronize do
+        if (count = metrics.size) > 0
+          debug { sprintf('agent flushing metrics feature=metrics count=%d', count) }
+        end
+        metrics.chunk(100, &method(:push).to_proc.curry[:metrics])
+        init_metrics
+      end
+    end
+
+    def flush_traces
+      mutex.synchronize do
+        if (count = traces.size) > 0
+          debug { sprintf('agent flushing traces feature=traces count=%d', count) }
+        end
+        push(:traces, traces) unless traces.empty?
+        init_traces
+      end
+    end
   end
 end

data/lib/honeybadger/backtrace.rb

@@ -28,6 +28,7 @@ module Honeybadger
       def self.parse(unparsed_line, opts = {})
         filters = opts[:filters] || []
         filtered_line = filters.reduce(unparsed_line) do |line, proc|
+          # TODO: Break if nil
           if proc.arity == 2
             proc.call(line, opts[:config])
           else

data/lib/honeybadger/config/defaults.rb

@@ -69,6 +69,10 @@ module Honeybadger
         description: 'The log level.',
         default: 'INFO'
       },
+      :'logging.debug' => {
+        description: 'Override debug logging.',
+        default: nil
+      },
       :'logging.tty_level' => {
         description: 'Level to log when attached to a terminal (anything < logging.level will always be ignored).',
         default: 'DEBUG'

data/lib/honeybadger/config.rb

@@ -79,10 +79,14 @@ module Honeybadger
       Backend.for((self[:backend] || default_backend).to_sym).new(self)
     end
 
+    def dev?
+      self[:env] && Array(self[:development_environments]).include?(self[:env])
+    end
+
     def public?
       return true if self[:report_data]
       return false if self[:report_data] == false
-      !self[:env] || !Array(self[:development_environments]).include?(self[:env])
+      !self[:env] || !dev?
     end
 
     def default_backend
@@ -98,7 +102,12 @@ module Honeybadger
     end
 
     def debug?
-      self[:debug]
+      !!self[:debug]
+    end
+
+    def log_debug?
+      return debug? if self[:'logging.debug'].nil?
+      !!self[:'logging.debug']
     end
 
     # Internal: Optional path to honeybadger.log log file. If nil, STDOUT will be used

data/lib/honeybadger/const.rb

@@ -7,7 +7,6 @@ module Honeybadger
   autoload :Config, 'honeybadger/config'
   autoload :Logging, 'honeybadger/logging'
   autoload :Notice, 'honeybadger/notice'
-  autoload :Worker, 'honeybadger/worker'
   autoload :Trace, 'honeybadger/trace'
   autoload :Plugin, 'honeybadger/plugin'
 

data/lib/honeybadger/logging.rb

@@ -11,6 +11,7 @@ module Honeybadger
     # method is defined/block captured in this module rather than delegating to
     # the logger directly to avoid extra object allocation.
     module Helper
+      private
       def debug(msg = nil)
         return true unless logger.debug?
         msg = yield if block_given?
@@ -134,7 +135,7 @@ module Honeybadger
       end
 
       def debug?
-        @config.debug?
+        @config.log_debug?
       end
 
       private

data/lib/honeybadger/version.rb

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

data/lib/honeybadger.rb

@@ -171,6 +171,40 @@ module Honeybadger
   def clear!
     Thread.current[:__honeybadger_context] = nil
   end
+
+  # Public: Flushes all data from workers before returning. This is most useful
+  # in tests when using the test backend, where normally the asynchronous
+  # nature of this library could create race conditions.
+  #
+  # block - The optional block to execute (exceptions will propagate after data
+  # is flushed).
+  #
+  # Examples:
+  #
+  #   # Without a block:
+  #   it "sends a notification to Honeybadger" do
+  #     expect {
+  #       Honeybadger.notify(StandardError.new('test backend'))
+  #       Honeybadger.flush
+  #     }.to change(Honeybadger::Backend::Test.notifications[:notices], :size).by(1)
+  #   end
+  #
+  #   # With a block:
+  #   it "sends a notification to Honeybadger" do
+  #     expect {
+  #       Honeybadger.flush do
+  #         50.times do
+  #           Honeybadger.notify(StandardError.new('test backend'))
+  #         end
+  #       end
+  #     }.to change(Honeybadger::Backend::Test.notifications[:notices], :size).by(50)
+  #   end
+  #
+  # Returns value of block if block is given, otherwise true on success or
+  # false if Honeybadger isn't running.
+  def flush(&block)
+    Agent.flush(&block)
+  end
 end
 
 if defined?(::Rails::Railtie)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta.6
+  version: 2.0.0.beta.7
 platform: ruby
 authors:
 - Honeybadger Industries LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-25 00:00:00.000000000 Z
+date: 2014-10-08 00:00:00.000000000 Z
 dependencies: []
 description: Make managing application errors a more pleasant experience.
 email:
@@ -23,6 +23,12 @@ files:
 - bin/honeybadger
 - lib/honeybadger.rb
 - lib/honeybadger/agent.rb
+- lib/honeybadger/agent/batch.rb
+- lib/honeybadger/agent/metered_queue.rb
+- lib/honeybadger/agent/metrics_collection.rb
+- lib/honeybadger/agent/metrics_collector.rb
+- lib/honeybadger/agent/null_worker.rb
+- lib/honeybadger/agent/worker.rb
 - lib/honeybadger/backend.rb
 - lib/honeybadger/backend/base.rb
 - lib/honeybadger/backend/debug.rb
@@ -64,11 +70,6 @@ files:
 - lib/honeybadger/util/sanitizer.rb
 - lib/honeybadger/util/stats.rb
 - lib/honeybadger/version.rb
-- lib/honeybadger/worker.rb
-- lib/honeybadger/worker/batch.rb
-- lib/honeybadger/worker/metered_queue.rb
-- lib/honeybadger/worker/metrics_collection.rb
-- lib/honeybadger/worker/metrics_collector.rb
 - resources/ca-bundle.crt
 - vendor/capistrano-honeybadger/lib/capistrano/honeybadger.rb
 - vendor/capistrano-honeybadger/lib/capistrano/tasks/deploy.cap

data/lib/honeybadger/worker.rb

@@ -1,237 +0,0 @@
-require 'forwardable'
-require 'net/http'
-
-require 'honeybadger/logging'
-
-module Honeybadger
-  class Worker
-    extend Forwardable
-
-    include Honeybadger::Logging::Helper
-
-    autoload :Batch, 'honeybadger/worker/batch'
-    autoload :MetricsCollector, 'honeybadger/worker/metrics_collector'
-    autoload :MeteredQueue, 'honeybadger/worker/metered_queue'
-
-    # Sub-class thread so we have a named thread (useful for debugging in Thread.list).
-    class Thread < ::Thread; end
-
-    attr_reader :backend, :queue, :features, :metrics, :traces, :pid, :mutex, :thread
-
-    def initialize(config)
-      @backend = config.backend
-      @config = config
-      @mutex = Mutex.new
-      prepare
-    end
-
-    def start
-      debug { 'starting worker' }
-
-      @pid = Process.pid
-      @thread = Thread.new { run }
-
-      true
-    end
-
-    def stop(force = false)
-      debug { 'stopping worker' }
-      if thread
-        if force
-          debug { 'killing worker' }
-          Thread.kill(thread)
-        else
-          thread[:should_exit] = true
-          unless thread.eql?(Thread.current)
-            mutex.unlock if mutex.locked?
-            thread.join
-          end
-        end
-      end
-      @thread = nil
-      @pid = nil
-    end
-
-    def fork
-      debug { 'forking worker' }
-
-      stop
-
-      mutex.synchronize { prepare }
-
-      start
-    end
-
-    def notice(notice)
-      debug { sprintf('worker adding notice feature=notices id=%s', notice.id) }
-      push(:notices, notice)
-    end
-
-    def trace(trace)
-      if trace.duration > config[:'traces.threshold']
-        debug { sprintf('worker adding trace duration=%s feature=traces id=%s', trace.duration.round(2), trace.id) }
-        traces.push(trace)
-        flush_traces if traces.flush?
-        true
-      else
-        debug { sprintf('worker discarding trace duration=%s feature=traces id=%s', trace.duration.round(2), trace.id) }
-        false
-      end
-    end
-
-    def timing(*args, &block)
-      metrics.timing(*args, &block)
-      flush_metrics if metrics.flush?
-      true
-    end
-
-    def increment(*args, &block)
-      metrics.increment(*args, &block)
-      flush_metrics if metrics.flush?
-      true
-    end
-
-    private
-
-    attr_reader :config
-
-    def init_queue
-      @queue = {
-        notices: MeteredQueue.new,
-        metrics: MeteredQueue.new,
-        traces: MeteredQueue.new
-      }.freeze
-
-      @features = {
-        notices: true,
-        metrics: true,
-        traces: true
-      }.freeze
-    end
-
-    def init_traces
-      @traces = Batch.new(config, :traces, 20, config[:debug] ? 10 : 60)
-    end
-
-    def init_metrics
-      @metrics = MetricsCollector.new(config, config[:debug] ? 10 : 60)
-    end
-
-    def flush_metrics
-      debug { 'worker flushing metrics feature=metrics' } # TODO: Include count.
-      mutex.synchronize do
-        metrics.chunk(100, &method(:push).to_proc.curry[:metrics])
-        init_metrics
-      end
-    end
-
-    def flush_traces
-      debug { sprintf('worker flushing traces feature=traces count=%d', traces.size) }
-      mutex.synchronize do
-        push(:traces, traces) unless traces.empty?
-        init_traces
-      end
-    end
-
-    def flush_queue
-      mutex.synchronize do
-        queue.each_pair do |feature, queue|
-          while payload = queue.pop!
-            handle_response(feature, notify_backend(feature, payload))
-          end
-        end
-      end
-    end
-
-    def prepare
-      init_queue
-      init_metrics
-      init_traces
-    end
-
-    def push(feature, object)
-      unless features[feature]
-        debug { sprintf('worker dropping feature=%s reason=collector', feature) }
-        return false
-      end
-
-      unless config.features[feature]
-        debug { sprintf('worker dropping feature=%s reason=ping', feature) }
-        return false
-      end
-
-      queue[feature].push(object)
-
-      true
-    end
-
-    def run
-      begin
-        debug { 'worker started' }
-        work until finish
-      rescue Exception => e
-        error(sprintf('error in worker thread (shutting down) class=%s message=%s at=%s', e.class, e.message.dump, e.backtrace.first.dump))
-        raise e
-      ensure
-        debug { 'stopping worker' }
-      end
-    end
-
-    def work
-      flush_metrics if metrics.flush?
-      flush_traces if traces.flush?
-
-      queue.each_pair do |feature, queue|
-        if payload = queue.pop
-          handle_response(feature, notify_backend(feature, payload))
-        end
-      end
-
-      sleep(0.1)
-    rescue StandardError => e
-      error(sprintf('error in worker thread class=%s message=%s at=%s', e.class, e.message.dump, e.backtrace.first.dump))
-      sleep(1)
-    end
-
-    def finish
-      if Thread.current[:should_exit]
-        debug { 'flushing worker data' }
-
-        flush_metrics
-        flush_traces
-        flush_queue
-
-        true
-      end
-    end
-
-    def notify_backend(feature, payload)
-      debug { sprintf('worker notifying backend feature=%s id=%s', feature, payload.id) }
-      backend.notify(feature, payload)
-    end
-
-    def handle_response(feature, response)
-      debug { sprintf('worker response feature=%s code=%s message=%s', feature, response.code, response.message.to_s.dump) }
-
-      case response.code
-      when 429, 503
-        debug { sprintf('worker applying throttle=1.25 feature=%s code=%s', feature, response.code) }
-        queue[feature].throttle(1.25)
-      when 402
-        warn { sprintf('worker disabling feature=%s code=%s', feature, response.code) }
-        mutex.synchronize { features[feature] = false }
-      when 403
-        error { sprintf('worker shutting down (unauthorized) feature=%s code=%s', feature, response.code) }
-        Honeybadger::Agent.stop(true)
-      when 201
-        if throttle = queue[feature].unthrottle
-          debug { sprintf('worker removing throttle=%s feature=%s code=%s', throttle, feature, response.code) }
-        end
-      when :error
-        # Error logged by backend.
-      else
-        warn { sprintf('worker unknown response feature=%s code=%s', feature, response.code) }
-      end
-    end
-  end
-end