honeybadger 2.7.2 → 3.0.0.beta1

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # Public: The current String Honeybadger version.
-  VERSION = '2.7.2'.freeze
+  VERSION = '3.0.0.beta1'.freeze
 end

data/lib/honeybadger/worker.rb

@@ -0,0 +1,246 @@
+require 'forwardable'
+require 'net/http'
+
+require 'honeybadger/logging'
+
+module Honeybadger
+  # Internal: A concurrent queue to notify the backend.
+  class Worker
+    extend Forwardable
+
+    include Honeybadger::Logging::Helper
+
+    # Internal: Sub-class thread so we have a named thread (useful for debugging in Thread.list).
+    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(msg)
+        super unless size == max_size
+      end
+    end
+
+    SHUTDOWN = :__hb_worker_shutdown!
+
+    def initialize(config)
+      @config = config
+      @throttles = []
+      @mutex = Mutex.new
+      @marker = ConditionVariable.new
+      @queue = Queue.new(config.max_queue_size)
+      @shutdown = false
+      @start_at = nil
+    end
+
+    def push(msg)
+      return false unless start
+      queue.push(msg)
+    end
+
+    def send_now(msg)
+      handle_response(msg, notify_backend(msg))
+    end
+
+    # Internal: Shutdown the worker after sending remaining data.
+    #
+    # Returns true.
+    def shutdown
+      d { 'shutting down worker' }
+
+      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
+        ensure
+          shutdown! unless r
+        end
+      end
+
+      r
+    end
+
+    def shutdown!
+      mutex.synchronize do
+        @shutdown = true
+        @pid = nil
+        queue.clear
+      end
+
+      d { 'killing worker thread' }
+
+      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
+      return false unless can_start?
+
+      mutex.synchronize do
+        @shutdown = false
+        @start_at = nil
+
+        return true if thread && thread.alive?
+
+        @pid = Process.pid
+        @thread = Thread.new { run }
+      end
+
+      true
+    end
+
+    private
+
+    attr_reader :config, :queue, :pid, :mutex, :marker,
+      :thread, :throttles
+
+    def_delegator :config, :backend
+
+    def can_start?
+      mutex.synchronize do
+        return true unless @shutdown
+        return false unless @start_at
+        Time.now.to_i >= @start_at
+      end
+    end
+
+    def suspend(interval)
+      mutex.synchronize { @start_at = Time.now.to_i + interval }
+
+      # Must be performed last since this may kill the current thread.
+      shutdown!
+    end
+
+    def run
+      begin
+        d { 'worker started' }
+        loop do
+          case msg = queue.pop
+          when SHUTDOWN then break
+          when ConditionVariable then signal_marker(msg)
+          else work(msg)
+          end
+        end
+      ensure
+        d { 'stopping worker' }
+      end
+    rescue Exception => 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"))
+      }
+    ensure
+      release_marker
+    end
+
+    def work(msg)
+      send_now(msg)
+      sleep(throttle_interval)
+    rescue StandardError => 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"))
+      }
+      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 id=%s', payload.id) }
+      backend.notify(:notices, 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(msg, response)
+      debug { sprintf('worker response code=%s message=%s', response.code, response.message.to_s.dump) }
+
+      case response.code
+      when 429, 503
+        warn { sprintf('Error report failed: project is sending too many errors. id=%s code=%s throttle=1.25 interval=%s', msg.id, throttle_interval, response.code) }
+        add_throttle(1.25)
+      when 402
+        warn { sprintf('Error report failed: payment is required. id=%s code=%s', msg.id, response.code) }
+        suspend(3600)
+      when 403
+        warn { sprintf('Error report failed: API key is invalid. id=%s code=%s', msg.id, response.code) }
+        suspend(3600)
+      when 201
+        if throttle = del_throttle
+          info { sprintf('Success ⚡ https://app.honeybadger.io/notice/%s id=%s code=%s throttle=%s interval=%s', msg.id, msg.id, response.code, throttle_interval, response.code) }
+        else
+          info { sprintf('Success ⚡ https://app.honeybadger.io/notice/%s id=%s code=%s', msg.id, msg.id, response.code) }
+        end
+      when :error
+        warn { sprintf('Error report failed: an unknown error occurred. code=%s error=%s', response.code, response.message.to_s.dump) }
+      else
+        warn { sprintf('Error report failed: unknown response from server. code=%s', 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 2.7.2
+  version: 3.0.0.beta1
 platform: ruby
 authors:
 - Honeybadger Industries LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-13 00:00:00.000000000 Z
+date: 2016-12-03 00:00:00.000000000 Z
 dependencies: []
 description: Make managing application errors a more pleasant experience.
 email:
@@ -25,9 +25,6 @@ files:
 - bin/honeybadger
 - lib/honeybadger.rb
 - lib/honeybadger/agent.rb
-- lib/honeybadger/agent/batch.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
@@ -36,17 +33,23 @@ files:
 - lib/honeybadger/backend/test.rb
 - lib/honeybadger/backtrace.rb
 - lib/honeybadger/cli.rb
-- lib/honeybadger/cli/helpers.rb
+- lib/honeybadger/cli/deploy.rb
+- lib/honeybadger/cli/exec.rb
 - lib/honeybadger/cli/heroku.rb
+- lib/honeybadger/cli/install.rb
 - lib/honeybadger/cli/main.rb
+- lib/honeybadger/cli/notify.rb
+- lib/honeybadger/cli/test.rb
 - lib/honeybadger/config.rb
-- lib/honeybadger/config/callbacks.rb
 - lib/honeybadger/config/defaults.rb
 - lib/honeybadger/config/env.rb
+- lib/honeybadger/config/ruby.rb
 - lib/honeybadger/config/yaml.rb
 - lib/honeybadger/const.rb
+- lib/honeybadger/context_manager.rb
 - lib/honeybadger/init/rails.rb
 - lib/honeybadger/init/rake.rb
+- lib/honeybadger/init/ruby.rb
 - lib/honeybadger/init/sinatra.rb
 - lib/honeybadger/logging.rb
 - lib/honeybadger/notice.rb
@@ -61,20 +64,21 @@ files:
 - lib/honeybadger/plugins/sidekiq.rb
 - lib/honeybadger/plugins/sucker_punch.rb
 - lib/honeybadger/plugins/thor.rb
-- lib/honeybadger/plugins/unicorn.rb
 - lib/honeybadger/plugins/warden.rb
 - lib/honeybadger/rack/error_notifier.rb
-- lib/honeybadger/rack/metrics_reporter.rb
-- lib/honeybadger/rack/request_hash.rb
 - lib/honeybadger/rack/user_feedback.rb
 - lib/honeybadger/rack/user_informer.rb
+- lib/honeybadger/ruby.rb
+- lib/honeybadger/singleton.rb
 - lib/honeybadger/tasks.rb
 - lib/honeybadger/templates/feedback_form.erb
 - lib/honeybadger/util/http.rb
+- lib/honeybadger/util/request_hash.rb
 - lib/honeybadger/util/request_payload.rb
 - lib/honeybadger/util/sanitizer.rb
 - lib/honeybadger/util/stats.rb
 - lib/honeybadger/version.rb
+- lib/honeybadger/worker.rb
 - resources/ca-bundle.crt
 - vendor/capistrano-honeybadger/lib/capistrano/honeybadger.rb
 - vendor/capistrano-honeybadger/lib/capistrano/tasks/deploy.cap
@@ -128,12 +132,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1

data/lib/honeybadger/agent/batch.rb

@@ -1,50 +0,0 @@
-require 'securerandom'
-
-module Honeybadger
-  class Agent
-    class Batch
-      def initialize(config, name, opts = {})
-        @id = SecureRandom.uuid
-        @config = config
-        @name = name
-        @max = opts.fetch(:max, 100)
-        @interval = opts.fetch(:interval, 60)
-        @future = opts.fetch(:now, now()) + interval
-        @values = opts.fetch(:collection, Array.new)
-        @mutex = Mutex.new
-      end
-
-      attr_reader :id
-
-      def push(val)
-        mutex.synchronize { values.push(val) }
-      end
-
-      def empty?
-        mutex.synchronize { values.empty? }
-      end
-
-      def size
-        mutex.synchronize { values.size }
-      end
-
-      def flush?
-        size >= max || now >= future
-      end
-
-      def as_json(*args)
-        mutex.synchronize do
-          { name => values.map(&:to_h), :environment => config[:env], :hostname => config[:hostname] }
-        end
-      end
-
-      private
-
-      attr_reader :config, :name, :max, :interval, :values, :future, :mutex
-
-      def now
-        Time.now.to_i
-      end
-    end
-  end
-end

data/lib/honeybadger/agent/null_worker.rb

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

data/lib/honeybadger/agent/worker.rb

@@ -1,243 +0,0 @@
-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: Sub-class thread so we have a named thread (useful for debugging in Thread.list).
-      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(config.max_queue_size)
-        @shutdown = false
-        @start_at = nil
-      end
-
-      def push(obj)
-        return false unless start
-        queue.push(obj)
-      end
-
-      # Internal: Shutdown the worker after sending remaining data.
-      #
-      # Returns true.
-      def shutdown
-        d { sprintf('shutting down worker feature=%s', feature) }
-
-        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
-          ensure
-            shutdown! unless r
-          end
-        end
-
-        r
-      end
-
-      def shutdown!
-        mutex.synchronize do
-          @shutdown = true
-          @pid = nil
-          queue.clear
-        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
-        return false unless can_start?
-
-        mutex.synchronize do
-          @shutdown = false
-          @start_at = nil
-
-          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 can_start?
-        mutex.synchronize do
-          return true unless @shutdown
-          return false unless @start_at
-          Time.now.to_i >= @start_at
-        end
-      end
-
-      def suspend(interval)
-        mutex.synchronize { @start_at = Time.now.to_i + interval }
-
-        # Must be performed last since this may kill the current thread.
-        shutdown!
-      end
-
-      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 {
-          msg = "error in worker thread (shutting down) feature=%s class=%s message=%s\n\t%s"
-          sprintf(msg, feature, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
-        }
-      ensure
-        release_marker
-      end
-
-      def process(msg)
-        handle_response(notify_backend(msg))
-        sleep(throttle_interval)
-      rescue StandardError => e
-        error {
-          msg = "error in worker thread feature=%s class=%s message=%s\n\t%s"
-          sprintf(msg, feature, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
-        }
-        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('data will not be reported (payment required) feature=%s code=%s', feature, response.code) }
-          suspend(3600)
-        when 403
-          warn { sprintf('data will not be reported feature=%s code=%s error=%s', feature, response.code, response.error.to_s.dump) }
-          suspend(3600)
-        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