honeybadger 2.0.12 → 2.1.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca4e68b01d27f3bd64f695192d1d21c99fda28f8
-  data.tar.gz: b807a14363195319e0a9048b38b939b930a2b8b8
+  metadata.gz: c15d3c01298686c17a3a9d7e3bff2ea5e8f9c405
+  data.tar.gz: 1adcb986179de4841b049ca5e4ad32991abf6d20
 SHA512:
-  metadata.gz: 36b00b23c94852b8cd62d78a99f7e8aa14d9658c719cbdc4d0bd809069f63f22eeb29a760d9e6b68a92a69c23f328818f0870f44ab8b0321442f467972f96e53
-  data.tar.gz: 697be46d36628a635d0cd0adffe1cdc378a076d236dbdc6d2456afe72c4facabf75b8c0e347d289d4f144fceb50fc182bdc67b2ad18955a7e8de1c57c65f6199
+  metadata.gz: 3703b084a51b6b101c203ab1eb3a858a0fad93af5f65bf4fe4b2a8a661b9211feb0515f8c18dbc50663090870701b6494f17f220e76e4df78bd2389ec2f9c716
+  data.tar.gz: 59f5fe48854c4ee55b9ac424ffa86a2f99141aeaed3dfd66efaa873ea64b429612d06faa15ea9dbacdc73c829155f9c839bac835f8ad66090b66d3d58ae20a4f

data/CHANGELOG.md

@@ -1,7 +1,80 @@
+* Trim all sanitized strings to 2k.
+
+  *Joshua Wood*
+
+* Add events to instrumented traces (i.e. in background jobs).
+
+  *Joshua Wood*
+
+* Restart workers once per hour when shutdown due to 40x.
+
+  *Joshua Wood*
+
+* Fix a tracing issue with net/http requests.
+
+  *Joshua Wood*
+
+* Send request data with traces.
+
+  *Joshua Wood*
+
+* Ditch per-controller metrics and add render_partial event to traces.
+
+  *Benjamin Curtis*
+
+* Disable local variables when BetterErrors is detected.
+
+  *Joshua Wood*
+
+* Exit with 1 from deploy command when request fails but ignore the failures in
+  the capistrano task.
+
+  *Joshua Wood*
+
+* Support Resque natively.
+
+  *Joshua Wood*
+
+* Configure sidekiq.attempt_threshold to suppress notifications until retry
+  threshold is reached.
+
+  *Joshua Wood*
+
+* Prevent Sinatra from using the same middleware more than once and add
+  sinatra.enabled setting (default true) to disable auto-initialization
+  of Sinatra.
+
+  *Joshua Wood*
+
+* Update default ignored exceptions to include the latest Rails rescue
+  responses. (see issue #107)
+
+  *Joshua Wood*
+
 * Fix bug when processing source extract for action_view templates.
 
   *Joshua Wood*
 
+* Exceptions with the same type but caused within different delayed jobs are not grouped together. They have their component and action set so that the application class name and excecuted action is displayed in the UI.
+
+  *Panos Korros*
+
+* All events logged within a delayed_job even those logged by Honeybadger.notify inherit the context of the delayed job and include the job_id, attempts, last_error and queue
+
+  *Panos Korros*
+
+* Catch Errno::ENFILE when reading system stats.
+
+  *Dmitry Polushkin*
+
+* Use explicit types for config options when casting from ENV.
+
+  *Joshua Wood*
+
+* Add exceptions.unwrap to config.
+
+  *Joshua Wood*
+
 * Don't access secrets before Rails initialization.
 
   *Joshua Wood*

data/lib/honeybadger/agent/metrics_collection.rb

@@ -23,14 +23,12 @@ module Honeybadger
       # in the array. If only a single value is provided in the array, that is
       # returned
       def percentile(threshold)
-        if (count > 1)
-          self.sort!
-          # strip off the top 100-threshold
-          threshold_index = (((100 - threshold).to_f / 100) * count).round
-          self[0..-threshold_index].last
-        else
-          self.first
-        end
+        return self.first unless count > 1
+
+        self.sort!
+        # strip off the top 100-threshold
+        threshold_index = (((100 - threshold).to_f / 100) * count).round
+        self[0..-threshold_index].last
       end
 
       # Calculates the mean squared error of values in the array

data/lib/honeybadger/agent/worker.rb

@@ -40,12 +40,12 @@ module Honeybadger
         @marker = ConditionVariable.new
         @queue = Queue.new(1000)
         @shutdown = false
+        @start_at = nil
       end
 
       def push(obj)
-        if start
-          queue.push(obj)
-        end
+        return false unless start
+        queue.push(obj)
       end
 
       # Internal: Shutdown the worker after sending remaining data.
@@ -76,6 +76,7 @@ module Honeybadger
         mutex.synchronize do
           @shutdown = true
           @pid = nil
+          queue.clear
         end
 
         d { sprintf('killing worker thread feature=%s', feature) }
@@ -101,8 +102,12 @@ module Honeybadger
       end
 
       def start
+        return false unless can_start?
+
         mutex.synchronize do
-          return false if @shutdown
+          @shutdown = false
+          @start_at = nil
+
           return true if thread && thread.alive?
 
           @pid = Process.pid
@@ -117,6 +122,21 @@ module Honeybadger
       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) }
@@ -182,11 +202,11 @@ module Honeybadger
           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!
+          warn { sprintf('data will not be reported until next restart (payment required) feature=%s code=%s', feature, response.code) }
+          suspend(3600)
         when 403
-          warn { sprintf('worker shutting down (unauthorized) feature=%s code=%s', feature, response.code) }
-          shutdown!
+          warn { sprintf('data will not be reported until next restart (unauthorized) feature=%s code=%s', feature, response.code) }
+          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) }

data/lib/honeybadger/backend/debug.rb

@@ -8,6 +8,7 @@ module Honeybadger
     class Debug < Null
       def notify(feature, payload)
         logger.unknown("notifying debug backend of feature=#{feature}\n\t#{payload.to_json}")
+        return Response.new(ENV['DEBUG_BACKEND_STATUS'].to_i, nil) if ENV['DEBUG_BACKEND_STATUS']
         super
       end
     end

data/lib/honeybadger/cli/main.rb

@@ -47,6 +47,7 @@ module Honeybadger
           say("Deploy notification for #{payload[:environment]} complete.", :green)
         else
           say("Deploy notification failed: #{response.code}", :red)
+          exit(1)
         end
       rescue => e
         say("An error occurred during deploy notification: #{e}\n\t#{e.backtrace.join("\n\t")}", :red)
@@ -179,6 +180,7 @@ module Honeybadger
             say(tab_indent(hierarchy.size) << "#{key}:")
             indent = tab_indent(hierarchy.size+1)
             say(indent + "Description: #{Config::OPTIONS[dotted_key][:description]}")
+            say(indent + "Type: #{Config::OPTIONS[dotted_key].fetch(:type, String).name.split('::').last}")
             say(indent + "Default: #{Config::OPTIONS[dotted_key][:default].inspect}")
             say(indent + "Current: #{value.inspect}")
           end

data/lib/honeybadger/config.rb

@@ -10,6 +10,7 @@ require 'honeybadger/backend'
 require 'honeybadger/config/defaults'
 require 'honeybadger/util/http'
 require 'honeybadger/logging'
+require 'honeybadger/rack/request_hash'
 
 module Honeybadger
   class Config
@@ -25,8 +26,6 @@ module Honeybadger
 
     KEY_REPLACEMENT = Regexp.new('[^a-z\d_]', Regexp::IGNORECASE).freeze
 
-    DISALLOWED_KEYS = [:'config.path'].freeze
-
     DOTTED_KEY = Regexp.new('\A([^\.]+)\.(.+)\z').freeze
 
     NOT_BLANK = Regexp.new('\S').freeze
@@ -39,6 +38,8 @@ module Honeybadger
       :'exceptions.ignore' => :'exceptions.ignore_only'
     }.freeze
 
+    DEFAULT_REQUEST_HASH = {}.freeze
+
     def initialize(opts = {})
       l = opts.delete(:logger)
 
@@ -136,16 +137,16 @@ module Honeybadger
       end
     end
 
-    # Internal: Path to honeybadger.yml configuration file; this should be the root
-    # directory if no path was specified.
+    # Internal: Path to honeybadger.yml configuration file; this should be the
+    # root directory if no path was specified.
     #
     # Returns the Pathname configuration path.
     def config_path
-      locate_absolute_path(Array(self[:'config.path']).first, self[:root])
+      config_paths.first
     end
 
     def config_paths
-      Array(self[:'config.path']).map do |c|
+      Array(ENV['HONEYBADGER_CONFIG_PATH'] || get(:'config.path')).map do |c|
         locate_absolute_path(c, self[:root])
       end
     end
@@ -191,6 +192,11 @@ module Honeybadger
       Thread.current[:__honeybadger_request] = nil
     end
 
+    def request_hash
+      return DEFAULT_REQUEST_HASH unless request
+      Rack::RequestHash.new(request)
+    end
+
     def params_filters
       self[:'request.filter_keys'] + rails_params_filters
     end

data/lib/honeybadger/config/defaults.rb

@@ -2,206 +2,279 @@ require 'socket'
 
 module Honeybadger
   class Config
-    IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
-                      'ActionController::RoutingError',
+    class Boolean; end
+
+    IGNORE_DEFAULT = ['ActionController::RoutingError',
+                      'AbstractController::ActionNotFound',
+                      'ActionController::MethodNotAllowed',
+                      'ActionController::UnknownHttpMethod',
+                      'ActionController::NotImplemented',
+                      'ActionController::UnknownFormat',
                       'ActionController::InvalidAuthenticityToken',
+                      'ActionController::InvalidCrossOriginRequest',
+                      'ActionDispatch::ParamsParser::ParseError',
+                      'ActionController::BadRequest',
+                      'ActionController::ParameterMissing',
+                      'ActiveRecord::RecordNotFound',
                       'ActionController::UnknownAction',
-                      'ActionController::UnknownFormat',
-                      'AbstractController::ActionNotFound',
                       'CGI::Session::CookieStore::TamperedWithCookie',
                       'Mongoid::Errors::DocumentNotFound',
                       'Sinatra::NotFound'].map(&:freeze).freeze
 
     DEVELOPMENT_ENVIRONMENTS = ['development', 'test', 'cucumber'].map(&:freeze).freeze
 
+    DEFAULT_PATHS = ['honeybadger.yml', 'config/honeybadger.yml'].map(&:freeze).freeze
+
     OPTIONS = {
       api_key: {
         description: 'The API key for your Honeybadger project.',
-        default: nil
+        default: nil,
+        type: String
       },
       env: {
         description: 'The current application\'s environment name.',
-        default: ENV['HONEYBADGER_ENV'] || ENV['RACK_ENV']
+        default: ENV['HONEYBADGER_ENV'] || ENV['RACK_ENV'],
+        type: String
       },
       report_data: {
         description: 'Enable/disable reporting of data. Defaults to true for non-development environments.',
-        default: nil
+        default: nil,
+        type: Boolean
       },
       root: {
         description: 'The project\'s absolute root path.',
-        default: Dir.pwd
+        default: Dir.pwd,
+        type: String
       },
       hostname: {
         description: 'The hostname of the current box.',
-        default: Socket.gethostname
+        default: Socket.gethostname,
+        type: String
       },
       backend: {
         description: 'An alternate backend to use for reporting data.',
-        default: nil
+        default: nil,
+        type: String
       },
       debug: {
         description: 'Forces metrics and traces to be reported every 10 seconds rather than 60.',
-        default: false
+        default: false,
+        type: Boolean
       },
       disabled: {
         description: 'Prevents Honeybadger from starting entirely.',
-        default: false
+        default: false,
+        type: Boolean
       },
       development_environments: {
         description: 'Environments which will not report data by default (use report_data to enable/disable explicitly).',
-        default: DEVELOPMENT_ENVIRONMENTS
+        default: DEVELOPMENT_ENVIRONMENTS,
+        type: Array
       },
       :'send_data_at_exit' => {
         description: 'Send remaining data when Ruby exits.',
-        default: true
+        default: true,
+        type: Boolean
       },
       plugins: {
         description: 'An optional list of plugins to load. Default is to load all plugins.',
-        default: nil
+        default: nil,
+        type: Array
       },
       :'plugins.skip' => {
         description: 'An optional list of plugins to skip.',
-        default: nil
+        default: nil,
+        type: Array
       },
       :'config.path' => {
         description: 'The path (absolute, or relative from config.root) to the project\'s YAML configuration file.',
-        default: ENV['HONEYBADGER_CONFIG_PATH'] || ['honeybadger.yml', 'config/honeybadger.yml']
+        default: DEFAULT_PATHS,
+        type: String
       },
       :'logging.path' => {
         description: 'The path (absolute, or relative from config.root) to the log file.',
-        default: nil
+        default: nil,
+        type: String
       },
       :'logging.level' => {
         description: 'The log level.',
-        default: 'INFO'
+        default: 'INFO',
+        type: String
       },
       :'logging.debug' => {
         description: 'Override debug logging.',
-        default: nil
+        default: nil,
+        type: Boolean
       },
       :'logging.tty_level' => {
         description: 'Level to log when attached to a terminal (anything < logging.level will always be ignored).',
-        default: 'DEBUG'
+        default: 'DEBUG',
+        type: String
       },
       :'connection.secure' => {
         description: 'Use SSL when sending data.',
-        default: true
+        default: true,
+        type: Boolean
       },
       :'connection.host' => {
         description: 'The host to use when sending data.',
-        default: 'api.honeybadger.io'.freeze
+        default: 'api.honeybadger.io'.freeze,
+        type: String
       },
       :'connection.port' => {
         description: 'The port to use when sending data.',
-        default: nil
+        default: nil,
+        type: Integer
       },
       :'connection.system_ssl_cert_chain' => {
         description: 'Use the system\'s SSL certificate chain (if available).',
-        default: false
+        default: false,
+        type: Boolean
       },
       :'connection.http_open_timeout' => {
         description: 'The HTTP open timeout when connecting to the server.',
-        default: 2
+        default: 2,
+        type: Integer
       },
       :'connection.http_read_timeout' => {
         description: 'The HTTP read timeout when connecting to the server.',
-        default: 5
+        default: 5,
+        type: Integer
       },
       :'connection.proxy_host' => {
         description: 'The proxy host to use when sending data.',
-        default: nil
+        default: nil,
+        type: String
       },
       :'connection.proxy_port' => {
         description: 'The proxy port to use when sending data.',
-        default: nil
+        default: nil,
+        type: Integer
       },
       :'connection.proxy_user' => {
         description: 'The proxy user to use when sending data.',
-        default: nil
+        default: nil,
+        type: String
       },
       :'connection.proxy_pass' => {
         description: 'The proxy password to use when sending data.',
-        default: nil
+        default: nil,
+        type: String
       },
       :'request.filter_keys' => {
         description: 'A list of keys to filter when sending request data.',
-        default: ['password'.freeze, 'password_confirmation'.freeze].freeze
+        default: ['password'.freeze, 'password_confirmation'.freeze].freeze,
+        type: Array
       },
       :'request.disable_session' => {
         description: 'Prevent session from being sent with request data.',
-        default: false
+        default: false,
+        type: Boolean
       },
       :'request.disable_params' => {
         description: 'Prevent params from being sent with request data.',
-        default: false
+        default: false,
+        type: Boolean
       },
       :'request.disable_environment' => {
         description: 'Prevent Rack environment from being sent with request data.',
-        default: false
+        default: false,
+        type: Boolean
       },
       :'request.disable_url' => {
         description: 'Prevent url from being sent with request data (Rack environment may still contain it in some cases).',
-        default: false
+        default: false,
+        type: Boolean
       },
       :'user_informer.enabled' => {
         description: 'Enable the UserInformer middleware.',
-        default: true
+        default: true,
+        type: Boolean
       },
       :'user_informer.info' => {
         description: 'Replacement string for HTML comment in templates.',
-        default: 'Honeybadger Error {{error_id}}'.freeze
+        default: 'Honeybadger Error {{error_id}}'.freeze,
+        type: String
       },
       :'feedback.enabled' => {
         description: 'Enable the UserFeedback middleware.',
-        default: true
+        default: true,
+        type: Boolean
       },
       :'exceptions.enabled' => {
         description: 'Enable automatic reporting of exceptions.',
-        default: true
+        default: true,
+        type: Boolean
       },
       :'exceptions.ignore' => {
         description: 'A list of additional exceptions to ignore (includes default ignored exceptions).',
-        default: IGNORE_DEFAULT
+        default: IGNORE_DEFAULT,
+        type: Array
       },
       :'exceptions.ignore_only' => {
         description: 'A list of exceptions to ignore (overrides the default ignored exceptions).',
-        default: [].freeze
+        default: [].freeze,
+        type: Array
       },
       :'exceptions.ignored_user_agents' => {
         description: 'A list of user agents to ignore.',
-        default: [].freeze
+        default: [].freeze,
+        type: Array
       },
       :'exceptions.rescue_rake' => {
         description: 'Enable rescuing exceptions in rake tasks.',
-        default: true
+        default: true,
+        type: Boolean
       },
       :'exceptions.source_radius' => {
         description: 'The number of lines before and after the source when reporting snippets.',
-        default: 2
+        default: 2,
+        type: Integer
       },
       :'exceptions.local_variables' => {
         description: 'Enable sending local variables. Requires binding_of_caller to be loaded.',
-        default: false
+        default: false,
+        type: Boolean
+      },
+      :'exceptions.unwrap' => {
+        description: 'Reports #original_exception or #cause one level up from rescued exception when available.',
+        default: false,
+        type: Boolean
       },
       :'metrics.enabled' => {
         description: 'Enable sending metrics.',
-        default: true
+        default: true,
+        type: Boolean
       },
       :'metrics.gc_profiler' => {
         description: 'Enable sending GC metrics (GC::Profiler must be enabled)',
-        default: false
+        default: false,
+        type: Boolean
       },
       :'traces.enabled' => {
         description: 'Enable sending traces.',
-        default: true
+        default: true,
+        type: Boolean
       },
       :'traces.threshold' => {
         description: 'The threshold in seconds to send traces.',
-        default: 2000
+        default: 2000,
+        type: Integer
       },
       :'delayed_job.attempt_threshold' => {
         description: 'The number of attempts before notifications will be sent.',
-        default: 0
+        default: 0,
+        type: Integer
+      },
+      :'sidekiq.attempt_threshold' => {
+        description: 'The number of attempts before notifications will be sent.',
+        default: 0,
+        type: Integer
+      },
+      :'sinatra.enabled' => {
+        description: 'Enable Sinatra auto-initialization.',
+        default: true,
+        type: Boolean
       }
     }.freeze