honeybadger 2.6.1 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d602a9205496510494a04ef272fd244394280071
-  data.tar.gz: a2a9ef904df4c7aae69a2a5ecd7aedcf520ebd81
+  metadata.gz: bfe22be20c43fd975d126fc91fb7cb898c670757
+  data.tar.gz: 23b9996827b81249114e8c87b016d00f01f08762
 SHA512:
-  metadata.gz: 4f437187a727ce3cc61542e0df3a64dbd7e0af43fcee10e8346a9476f0a78f1a50225a0a3e3861090f5de16e33362c2f7bcc4e3c5ee13da0bab780abab5cffb9
-  data.tar.gz: 84a063b994896e85b8a10024b60cb79674e6d904ffcdb3412445afdf4d549d85a6885ad294f6cc3c8f36f93f6ba927b6ab9e3ff76222d422dfe9c0c62d067771
+  metadata.gz: 6d5319144574a8f37e9256aa3786162a185da7abdaf2805844e9b100a4952659a53edce559b3e7c03b51a211e16cc2817338a512f35f159c19ec0a875192a3da
+  data.tar.gz: b15017e7866fb9c3acc9d09543644d088b5914a1f671fa85bdbfaf7665b20a2755f1fee272614370536efe5e2bb98d6911584d934347a054a11f3120964fba27

data/CHANGELOG.md

@@ -5,6 +5,15 @@ adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased][unreleased]
 
+## [2.7.0] - 2016-10-20
+### Added
+- Support Sinatra 2.0.
+
+### Changed
+- Sunset performance metrics. See
+  http://blog.honeybadger.io/sunsetting-performance-metrics/
+- Backtraces are now limited to a maximum of 1000 lines.
+
 ## [2.6.1] - 2016-08-24
 ### Added
 - shoryuken plugin. -@ivanvc

data/README.md

@@ -132,7 +132,6 @@ Honeybadger.start(honeybadger_config)
  
 # And use Honeybadger's rack middleware
 use Honeybadger::Rack::ErrorNotifier, honeybadger_config
-use Honeybadger::Rack::MetricsReporter, honeybadger_config
  
 run app
 ```
@@ -222,8 +221,8 @@ You can use any of the options below in your config file, or in the environment.
 |`root`                           | String  | The project's absolute root path.<br/>_Default: `Dir.pwd`_|
 |`hostname`                       | String  | The hostname of the current box.<br/>_Default: `Socket.gethostname`_|
 |`backend`                        | String  | An alternate backend to use for reporting data.<br/>_Default: `nil`_|
-|`debug`                          | Boolean | Forces metrics and traces to be reported every 10 seconds rather than 60, and enables verbose debug logging.<br/>_Default: `false`_|
-|`send_data_at_exit`              | Boolean | Finish sending enqueued exceptions and metrics data before allowing program to exit.<br/>_Default: `true`_|
+|`debug`                          | Boolean | Enables verbose debug logging.<br/>_Default: `false`_|
+|`send_data_at_exit`              | Boolean | Finish sending enqueued exceptions before allowing program to exit.<br/>_Default: `true`_|
 |`disabled`                       | Boolean | Prevents Honeybadger from starting entirely.<br/>_Default: `false`_|
 | `config_path`                   | String  | The path of the honeybadger config file. Can only be set via the `$HONEYBADGER_CONFIG_PATH` environment variable |
 |`development_environments`       | Array   | Environments which will not report data by default (use report_data to enable/disable explicitly).<br/>_Default: `["development", "test", "cucumber"]`_|
@@ -269,13 +268,6 @@ You can use any of the options below in your config file, or in the environment.
 |`exceptions.local_variables`     | Boolean | Enable sending local variables. Requires the [binding_of_caller gem](https://rubygems.org/gems/binding_of_caller).<br/>_Default: `false`_|
 |`exceptions.unwrap`              | Boolean | Reports #original_exception or #cause one level up from rescued exception when available.<br/>_Default: `false`_|
 |&nbsp;                           |         ||
-|__METRIC REPORTING__             |         ||
-|`metrics.enabled`                | Boolean | Enable sending metrics, such as requests per minute.<br/>_Default: `true`_|
-|`metrics.gc_profiler`            | Boolean | Enable sending GC metrics (GC::Profiler must be enabled)<br/>_Default: `false`_|
-|&nbsp;                           |         ||
-|__TRACE REPORTING__              |         ||
-|`traces.enabled`                 | Boolean | Enable sending performance traces for slow actions.<br/>_Default: `true`_|
-|`traces.threshold`               | Integer | The threshold in seconds to send traces.<br/>_Default: `2000`_|
 |__SIDEKIQ__                      |         ||
 |`sidekiq.attempt_threshold`      | Integer | The number of attempts before notifications will be sent.<br/>_Default: `0`_|
 |`sidekiq.use_component`          | Boolean | Automatically set the component to the class of the job. Helps with grouping.<br/>_Default: `false`_|

data/lib/honeybadger/agent/worker.rb

@@ -12,7 +12,7 @@ module Honeybadger
 
       include Honeybadger::Logging::Helper
 
-      # Internal: See Agent::Thread
+      # 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.
@@ -52,6 +52,8 @@ module Honeybadger
       #
       # Returns true.
       def shutdown
+        d { sprintf('shutting down worker feature=%s', feature) }
+
         mutex.synchronize do
           @shutdown = true
           @pid = nil

data/lib/honeybadger/agent.rb

@@ -13,14 +13,8 @@ module Honeybadger
 
     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'
-    autoload :TraceCollection, 'honeybadger/agent/trace_collection'
 
     class << self
       extend Forwardable
@@ -83,19 +77,7 @@ module Honeybadger
     end
 
     def self.fork(*args)
-      self.instance ? self.instance.fork(*args) : false
-    end
-
-    def self.trace(*args)
-      self.instance ? self.instance.trace(*args) : false
-    end
-
-    def self.timing(*args)
-      self.instance ? self.instance.timing(*args) : false
-    end
-
-    def self.increment(*args)
-      self.instance ? self.instance.increment(*args) : false
+      # noop
     end
 
     def self.flush(&block)
@@ -132,21 +114,17 @@ module Honeybadger
       end
     end
 
-    attr_reader :delay, :workers, :pid, :thread, :traces, :metrics
+    attr_reader :workers
 
     def initialize(config)
       @config = 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
         # Fix for https://bugs.ruby-lang.org/issues/5218
@@ -162,38 +140,7 @@ module Honeybadger
       end
     end
 
-    # Internal: Spawn the agent thread. This method is idempotent.
-    #
-    # Returns false if the Agent is stopped, otherwise true.
-    def start
-      mutex.synchronize do
-        return false unless pid
-        return true if thread && thread.alive?
-
-        debug { 'starting agent' }
-
-        @pid = Process.pid
-        @thread = Thread.new { run }
-      end
-
-      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
@@ -201,10 +148,6 @@ module Honeybadger
       true
     end
 
-    def fork
-      # noop
-    end
-
     def notice(opts)
       opts.merge!(callbacks: self.class.callbacks)
       notice = Notice.new(config, opts)
@@ -219,44 +162,6 @@ module Honeybadger
       end
     end
 
-    def trace(trace)
-      return false unless config.traces?
-
-      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)
-      return false unless config.metrics?
-
-      start
-
-      mutex.synchronize { metrics.timing(*args, &block) }
-      flush_metrics if metrics.flush?
-
-      true
-    end
-
-    def increment(*args, &block)
-      return false unless config.metrics?
-
-      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.
@@ -266,8 +171,6 @@ module Honeybadger
       return true unless block_given?
       yield
     ensure
-      flush_metrics
-      flush_traces
       workers.values.each(&:flush)
     end
 
@@ -286,62 +189,9 @@ module Honeybadger
       true
     end
 
-    def run
-      loop { work }
-    rescue Exception => e
-      error {
-        msg = "error in agent thread (shutting down) class=%s message=%s\n\t%s"
-        sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
-      }
-    ensure
-      d { sprintf('stopping agent') }
-    end
-
-    def work
-      flush_metrics if metrics.flush?
-      flush_traces if traces.flush?
-      sleep(delay)
-    rescue StandardError => e
-      error {
-        msg = "error in agent thread class=%s message=%s\n\t%s"
-        sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
-      }
-      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, max: 20, interval: config.debug? ? 10 : 60, collection: TraceCollection.new)
-    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
 
     def notify_at_exit(ex)

data/lib/honeybadger/backend/base.rb

@@ -60,7 +60,7 @@ module Honeybadger
       # Internal: Process payload for feature.
       #
       # feature - A Symbol feature name (corresponds to HTTP endpoint). Current
-      #           options are: :notices, :metrics, :traces.
+      #           options are: :notices, :deploys, :ping
       # payload - Any Object responding to #to_json.
       #
       # Examples:

data/lib/honeybadger/backend/server.rb

@@ -12,8 +12,6 @@ module Honeybadger
       ENDPOINTS = {
         ping: '/v1/ping'.freeze,
         notices: '/v1/notices'.freeze,
-        metrics: '/v1/metrics'.freeze,
-        traces: '/v1/traces'.freeze,
         deploys: '/v1/deploys'.freeze
       }.freeze
 

data/lib/honeybadger/backtrace.rb

@@ -39,20 +39,22 @@ module Honeybadger
         if filtered_line
           _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
           _, *filtered_args = filtered_line.match(INPUT_FORMAT).to_a
-          new(file, number, method, *filtered_args)
+          new(file, number, method, *filtered_args, opts.fetch(:source_radius, 2))
         else
           nil
         end
       end
 
       def initialize(file, number, method, filtered_file = file,
-                     filtered_number = number, filtered_method = method)
+                     filtered_number = number, filtered_method = method,
+                     source_radius = 2)
         self.filtered_file   = filtered_file
         self.filtered_number = filtered_number
         self.filtered_method = filtered_method
         self.file            = file
         self.number          = number
         self.method          = method
+        self.source_radius   = source_radius
       end
 
       # Reconstructs the line in a readable fashion.
@@ -73,16 +75,16 @@ module Honeybadger
         (filtered_file =~ /^\[PROJECT_ROOT\]/i) && !(filtered_file =~ /^\[PROJECT_ROOT\]\/vendor/i)
       end
 
-      # An excerpt from the source file, lazily loaded to preserve
-      # performance.
-      def source(radius = 2)
-        @source ||= get_source(file, number, radius)
+      def source
+        @source ||= get_source(file, number, source_radius)
       end
 
       private
 
       attr_writer :file, :number, :method, :filtered_file, :filtered_number, :filtered_method
 
+      attr_accessor :source_radius
+
       # Open source file and read line(s).
       #
       # Returns an array of line(s) from source file.
@@ -126,7 +128,7 @@ module Honeybadger
     #
     # Returns array containing backtrace lines.
     def to_ary
-      lines.map { |l| { :number => l.filtered_number, :file => l.filtered_file, :method => l.filtered_method } }
+      lines.take(1000).map { |l| { :number => l.filtered_number, :file => l.filtered_file, :method => l.filtered_method, :source => l.source } }
     end
     alias :to_a :to_ary
 

data/lib/honeybadger/config/defaults.rb

@@ -57,7 +57,7 @@ module Honeybadger
         type: String
       },
       debug: {
-        description: 'Forces metrics and traces to be reported every 10 seconds rather than 60.',
+        description: 'Enables debug logging.',
         default: false,
         type: Boolean
       },
@@ -256,26 +256,6 @@ module Honeybadger
         default: false,
         type: Boolean
       },
-      :'metrics.enabled' => {
-        description: 'Enable sending metrics.',
-        default: true,
-        type: Boolean
-      },
-      :'metrics.gc_profiler' => {
-        description: 'Enable sending GC metrics (GC::Profiler must be enabled)',
-        default: false,
-        type: Boolean
-      },
-      :'traces.enabled' => {
-        description: 'Enable sending traces.',
-        default: true,
-        type: Boolean
-      },
-      :'traces.threshold' => {
-        description: 'The threshold in seconds to send traces.',
-        default: 2000,
-        type: Integer
-      },
       :'delayed_job.attempt_threshold' => {
         description: 'The number of attempts before notifications will be sent.',
         default: 0,

data/lib/honeybadger/config.rb

@@ -30,7 +30,7 @@ module Honeybadger
 
     NOT_BLANK = Regexp.new('\S').freeze
 
-    FEATURES = [:notices, :local_variables, :metrics, :traces].freeze
+    FEATURES = [:notices, :local_variables].freeze
 
     MERGE_DEFAULT = [:'exceptions.ignore'].freeze
 
@@ -88,14 +88,6 @@ module Honeybadger
       !!features[feature.to_sym]
     end
 
-    def traces?
-      feature?(:traces) && !!self[:'traces.enabled']
-    end
-
-    def metrics?
-      feature?(:metrics) && !!self[:'metrics.enabled']
-    end
-
     def logger
       @logger || Logging::BootLogger.instance
     end

data/lib/honeybadger/const.rb

@@ -7,12 +7,10 @@ module Honeybadger
   autoload :Config, 'honeybadger/config'
   autoload :Logging, 'honeybadger/logging'
   autoload :Notice, 'honeybadger/notice'
-  autoload :Trace, 'honeybadger/trace'
   autoload :Plugin, 'honeybadger/plugin'
 
   module Rack
     autoload :ErrorNotifier, 'honeybadger/rack/error_notifier'
-    autoload :MetricsReporter, 'honeybadger/rack/metrics_reporter'
     autoload :UserFeedback, 'honeybadger/rack/user_feedback'
     autoload :UserInformer, 'honeybadger/rack/user_informer'
     autoload :RequestHash, 'honeybadger/rack/request_hash'

data/lib/honeybadger/init/rails.rb

@@ -25,45 +25,6 @@ module Honeybadger
                 middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback, config) if config[:'feedback.enabled']
               end
             end
-
-            if config.traces?
-              ActiveSupport::Notifications.subscribe('start_processing.action_controller') do |name, started, finished, id, data|
-                Trace.create(id)
-              end
-
-              ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
-                event = ActiveSupport::Notifications::Event.new(*args)
-                Trace.current.add_query(event) if Trace.current and event.name != 'SCHEMA'
-              end
-
-              ActiveSupport::Notifications.subscribe(/^render_(template|partial|action|collection)\.action_view/) do |*args|
-                event = ActiveSupport::Notifications::Event.new(*args)
-                Trace.current.add(event) if Trace.current
-              end
-
-              ActiveSupport::Notifications.subscribe('net_http.request') do |*args|
-                event = ActiveSupport::Notifications::Event.new(*args)
-                Trace.current.add(event) if Trace.current
-              end
-
-              ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
-                event = ActiveSupport::Notifications::Event.new(*args)
-                if Trace.current && event.payload[:controller] && event.payload[:action]
-                  payload = { source: 'web' }
-                  payload[:path] = Util::Sanitizer.new(filters: config.params_filters).filter_url(event.payload[:path]) if event.payload[:path]
-                  payload[:request] = request_data(event, config)
-                  Trace.current.complete(event, payload)
-                end
-              end
-            end
-
-            if config.metrics?
-              ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
-                event = ActiveSupport::Notifications::Event.new(*args)
-                status = event.payload[:exception] ? 500 : event.payload[:status]
-                Agent.timing("app.request.#{status}", event.duration)
-              end
-            end
           end
         end
 
@@ -78,27 +39,6 @@ module Honeybadger
             :framework      => :rails
           }
         end
-
-        def request_data(event, config)
-          h = {
-            url: event.payload[:path],
-            component: event.payload[:controller],
-            action: event.payload[:action],
-            params: event.payload[:params]
-          }
-          h.merge!(config.request_hash)
-          h.delete_if {|k,v| config.excluded_request_keys.include?(k) }
-          h[:sanitizer] = Util::Sanitizer.new(filters: config.params_filters)
-          Util::RequestPayload.build(h).update({
-            context: context_data
-          })
-        end
-
-        def context_data
-          if Thread.current[:__honeybadger_context]
-            Util::Sanitizer.new.sanitize(Thread.current[:__honeybadger_context])
-          end
-        end
       end
     end
   end

data/lib/honeybadger/init/sinatra.rb

@@ -12,7 +12,8 @@ module Honeybadger
 
           def honeybadger_config(app)
             {
-              api_key: defined?(honeybadger_api_key) ? honeybadger_api_key : nil
+              api_key: defined?(honeybadger_api_key) ? honeybadger_api_key : nil,
+              env: ENV['APP_ENV']
             }
           end
 
@@ -23,7 +24,6 @@ module Honeybadger
             return unless Honeybadger.start(config)
 
             install_honeybadger_middleware(Honeybadger::Rack::ErrorNotifier, config) if config.feature?(:notices) && config[:'exceptions.enabled']
-            install_honeybadger_middleware(Honeybadger::Rack::MetricsReporter, config) if config.feature?(:metrics) && config[:'metrics.enabled']
           end
 
           def install_honeybadger_middleware(klass, config)

data/lib/honeybadger/notice.rb

@@ -64,7 +64,7 @@ module Honeybadger
     # Public: The message from the exception, or a general description of the error.
     attr_reader :error_message
 
-    # Public: Excerpt from source file.
+    # Deprecated: Excerpt from source file.
     attr_reader :source
 
     # Public: CGI variables such as HTTP_METHOD.
@@ -139,7 +139,6 @@ module Honeybadger
         "#{exception.class.name}: #{exception.message}"
       end
       @backtrace = parse_backtrace(exception_attribute(:backtrace, caller))
-      @source = extract_source_from_backtrace(@backtrace, config, opts)
       @fingerprint = construct_fingerprint(opts)
 
       @request = construct_request_hash(config, opts)
@@ -175,7 +174,6 @@ module Honeybadger
           class: s(error_class),
           message: s(error_message),
           backtrace: s(backtrace.to_a),
-          source: s(source),
           fingerprint: s(fingerprint),
           tags: s(tags),
           causes: s(causes)
@@ -316,16 +314,6 @@ module Honeybadger
       context.empty? ? nil : context
     end
 
-    def extract_source_from_backtrace(backtrace, config, opts)
-      return nil if backtrace.lines.empty?
-
-      if backtrace.application_lines.any?
-        backtrace.application_lines.first.source(config[:'exceptions.source_radius'])
-      else
-        backtrace.lines.first.source(config[:'exceptions.source_radius'])
-      end
-    end
-
     def fingerprint_from_opts(opts)
       callback = opts[:fingerprint]
       callback ||= opts[:callbacks] && opts[:callbacks].exception_fingerprint
@@ -398,7 +386,8 @@ module Honeybadger
       Backtrace.parse(
         backtrace,
         filters: construct_backtrace_filters(opts),
-        config: config
+        config: config,
+        source_radius: config[:'exceptions.source_radius']
       )
     end
 

data/lib/honeybadger/plugins/delayed_job/plugin.rb

@@ -34,9 +34,7 @@ module Honeybadger
                 :queue         => job.queue
               )
 
-              ::Honeybadger::Trace.instrument("#{job.payload_object.class}#perform", {source: 'delayed_job', jid: job.id, class: job.payload_object.class.name}) do
-                block.call(job)
-              end
+              block.call(job)
             rescue Exception => error
               ::Honeybadger.notify_or_ignore(
                 :component     => component,

data/lib/honeybadger/plugins/resque.rb

@@ -8,9 +8,7 @@ module Honeybadger
         def around_perform_with_honeybadger(*args)
           Honeybadger.flush do
             begin
-              Honeybadger::Trace.instrument("#{self.name}#perform", { source: 'resque', class: self.name }) do
-                yield
-              end
+              yield
             rescue Exception => e
               Honeybadger.notify(e, parameters: { job_arguments: args }) if send_exception?(e, args)
               raise e

data/lib/honeybadger/plugins/shoryuken.rb

@@ -11,18 +11,15 @@ module Honeybadger
             return
           end
 
-          klass = worker.class.name
           Honeybadger.flush do
-            Honeybadger::Trace.instrument("#{klass}#perform", { :source => 'shoryuken'.freeze, :queue => sqs_msg.queue_name.freeze, :message_id => sqs_msg.data.message_id.freeze, :class => klass }) do
-              begin
-                yield
-              rescue => e
-                receive_count = sqs_msg.attributes['ApproximateReceiveCount'.freeze]
-                if receive_count && ::Honeybadger::Agent.config[:'shoryuken.attempt_threshold'].to_i <= receive_count.to_i
-                  Honeybadger.notify(e, parameters: body)
-                end
-                raise e
+            begin
+              yield
+            rescue => e
+              receive_count = sqs_msg.attributes['ApproximateReceiveCount'.freeze]
+              if receive_count && ::Honeybadger::Agent.config[:'shoryuken.attempt_threshold'].to_i <= receive_count.to_i
+                Honeybadger.notify(e, parameters: body)
               end
+              raise e
             end
           end
         ensure

data/lib/honeybadger/plugins/sidekiq.rb

@@ -7,10 +7,7 @@ module Honeybadger
       class Middleware
         def call(worker, msg, queue)
           Honeybadger.context.clear!
-          klass = msg['wrapped'.freeze] || msg['class'.freeze]
-          Honeybadger::Trace.instrument("#{klass}#perform", { :source => 'sidekiq'.freeze, :jid => msg['jid'.freeze], :class => klass }) do
-            yield
-          end
+          yield
         end
       end
 

data/lib/honeybadger/rack/metrics_reporter.rb

@@ -3,38 +3,13 @@ require 'honeybadger'
 module Honeybadger
   module Rack
     class MetricsReporter
-      GC_TIME_METRIC = 'app.gc.time'.freeze
-      GC_COLLECTIONS_METRIC = 'app.gc.collections'.freeze
-
       def initialize(app, config)
         @app = app
-        @config = config
+        config.logger.warn('DEPRECATION WARNING: `Honeybadger::Rack::MetricsReporter` no longer has any effect and will be removed.')
       end
 
       def call(env)
-        start = Time.now
-        track_gc? and GC::Profiler.clear
-        status, headers, body = app.call(env)
-        duration = (Time.now - start) * 1000
-        report_metrics(status, duration)
-        [status, headers, body]
-      end
-
-      private
-
-      attr_reader :app, :config
-
-      def track_gc?
-        config[:'metrics.gc_profiler']
-      end
-
-      def report_metrics(status, duration)
-        Agent.timing("app.request.#{status}", duration)
-
-        if track_gc? && GC::Profiler.total_time > 0
-          Agent.timing(GC_TIME_METRIC, GC::Profiler.total_time * 1000)
-          Agent.increment(GC_COLLECTIONS_METRIC, GC::Profiler.result[/\d+/].to_i)
-        end
+        @app.call(env)
       end
     end
   end

data/lib/honeybadger/rack/request_hash.rb

@@ -4,7 +4,7 @@ module Honeybadger
     # /v1/notices API specification.
     class RequestHash < ::Hash
       # Internal
-      CGI_BLACKLIST = ['QUERY_STRING', 'RAW_POST_DATA'].freeze
+      CGI_BLACKLIST = ['QUERY_STRING', 'RAW_POST_DATA', 'ORIGINAL_FULLPATH', 'REQUEST_URI'].freeze
       CGI_KEY_REGEXP = /\A[A-Z_]+\Z/
 
       def initialize(request)

data/lib/honeybadger/util/request_payload.rb

@@ -2,7 +2,7 @@ require 'honeybadger/util/sanitizer'
 
 module Honeybadger
   module Util
-    # Internal: Constructs/sanitizes request data for notices and traces.
+    # Internal: Constructs/sanitizes request data for notices
     module RequestPayload
       # Internal: Default values to use for request data.
       DEFAULTS = {

data/lib/honeybadger/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 2.6.1
+  version: 2.7.0
 platform: ruby
 authors:
 - Honeybadger Industries LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-24 00:00:00.000000000 Z
+date: 2016-10-20 00:00:00.000000000 Z
 dependencies: []
 description: Make managing application errors a more pleasant experience.
 email:
@@ -26,11 +26,7 @@ files:
 - 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/trace_collection.rb
 - lib/honeybadger/agent/worker.rb
 - lib/honeybadger/backend.rb
 - lib/honeybadger/backend/base.rb
@@ -58,7 +54,6 @@ files:
 - lib/honeybadger/plugins/delayed_job.rb
 - lib/honeybadger/plugins/delayed_job/plugin.rb
 - lib/honeybadger/plugins/local_variables.rb
-- lib/honeybadger/plugins/net_http.rb
 - lib/honeybadger/plugins/passenger.rb
 - lib/honeybadger/plugins/rails.rb
 - lib/honeybadger/plugins/resque.rb
@@ -75,7 +70,6 @@ files:
 - lib/honeybadger/rack/user_informer.rb
 - lib/honeybadger/tasks.rb
 - lib/honeybadger/templates/feedback_form.erb
-- lib/honeybadger/trace.rb
 - lib/honeybadger/util/http.rb
 - lib/honeybadger/util/request_payload.rb
 - lib/honeybadger/util/sanitizer.rb

data/lib/honeybadger/agent/metered_queue.rb

@@ -1,80 +0,0 @@
-module Honeybadger
-  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
-      def initialize(interval = 1, max = 1000, now = now())
-        @interval = interval
-        @max = max
-        @values = Array.new
-        @throttles = Array.new
-        @future = calculate_future(now, interval)
-        @mutex = Mutex.new
-      end
-
-      def size
-        mutex.synchronize { values.size }
-      end
-
-      def push(value)
-        unless values.size == max
-          mutex.synchronize { values.push(value) }
-        end
-      end
-
-      def pop
-        if now.to_i >= future
-          mutex.synchronize do
-            @future = calculate_future
-            values.shift
-          end
-        end
-      end
-
-      def pop!
-        mutex.synchronize { values.shift }
-      end
-
-      # Applies a new throttle to this queue and adjusts the future.
-      #
-      # Returns nothing
-      def throttle(throttle)
-        mutex.synchronize do
-          old_interval = throttled_interval
-          throttles << throttle
-          @future += (throttled_interval - old_interval)
-        end
-      end
-
-      # Removes the last throttle from this queue and adjusts the future.
-      #
-      # Returns Float throttle
-      def unthrottle
-        mutex.synchronize do
-          old_interval = throttled_interval
-          throttles.pop.tap do |throttle|
-            if throttle
-              @future -= (old_interval - throttled_interval)
-            end
-          end
-        end
-      end
-
-      private
-
-      attr_reader :interval, :max, :values, :throttles, :future, :mutex
-
-      def now
-        Time.now
-      end
-
-      def calculate_future(now = now(), interval = interval())
-        now.to_i + throttled_interval(interval)
-      end
-
-      def throttled_interval(interval = interval())
-        throttles.reduce(interval) {|a,e| a * e }
-      end
-    end
-  end
-end

data/lib/honeybadger/agent/metrics_collection.rb

@@ -1,59 +0,0 @@
-module Honeybadger
-  class Agent
-    # This code comes from batsd
-    class MetricsCollection < Array
-      PERCENTILE_METHOD_SIGNATURE = /\Apercentile_(.+)\z/.freeze
-
-      # Calculates the sum of values in the array
-      def sum
-        inject( nil ) { |sum,x| sum ? sum+x : x };
-      end
-
-      # Calculates the arithmetic mean of values in the array
-      def mean
-        self.sum.to_f / self.length
-      end
-
-      # Calculates the median of values in the array
-      def median
-        self.sort[self.length/2]
-      end
-
-      # Calculates the value of the upper percentile of values
-      # in the array. If only a single value is provided in the array, that is
-      # returned
-      def percentile(threshold)
-        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
-      def mean_squared
-        m = mean
-        self.class.new(map{|v| (v-m)**2}).sum
-      end
-
-      # Calculates the standard deviatiation of values in the array
-      def standard_dev
-        (mean_squared/(count-1))**0.5
-      end
-
-      # Allow [1,2,3].percentile_90, [1,2,3].percentile(75), etc.
-      def method_missing(method, *args, &block)
-        if method.to_s =~ PERCENTILE_METHOD_SIGNATURE
-          percentile($1.to_i)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        method.to_s =~ PERCENTILE_METHOD_SIGNATURE or super
-      end
-    end
-  end
-end

data/lib/honeybadger/agent/metrics_collector.rb

@@ -1,106 +0,0 @@
-require 'securerandom'
-require 'forwardable'
-
-module Honeybadger
-  class Agent
-    autoload :MetricsCollection, 'honeybadger/agent/metrics_collection'
-
-    class MetricsCollector
-      extend Forwardable
-
-      class Chunk
-        extend Forwardable
-
-        attr_reader :id
-
-        def initialize(id, metrics)
-          @id = SecureRandom.uuid
-          @metrics = metrics
-        end
-
-        def_delegators :@metrics, :to_json, :size
-      end
-
-      def initialize(config, interval = 60, now = now())
-        @id = SecureRandom.uuid
-        @config = config
-        @interval = interval
-        @future = now + interval
-        @mutex = Mutex.new
-        @metrics = { :timing => {}, :counter => {} }
-      end
-
-      attr_reader :id
-
-      def_delegators :@metrics, :[]
-
-      def timing(name, value)
-        add_metric(name, value, :timing)
-      end
-
-      def increment(name, value)
-        add_metric(name, value, :counter)
-      end
-
-      def flush?
-        now >= future
-      end
-
-      def size
-        mutex.synchronize do
-          metrics.reduce(0) do |count, hash|
-            count + hash[1].size
-          end
-        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
-        end
-      end
-
-      def chunk(size)
-        to_a.each_slice(size) do |metrics|
-          yield(Chunk.new(id, as_json(metrics)))
-        end
-      end
-
-      def as_json(metrics = to_a)
-        {metrics: metrics, :environment => config[:env], :hostname => config[:hostname]}
-      end
-
-      def to_json(*args)
-        as_json.to_json(*args)
-      end
-
-      private
-
-      attr_reader :config, :future, :metrics, :mutex
-
-      def now
-        Time.now.to_i
-      end
-
-      def add_metric(name, value, kind)
-        mutex.synchronize do
-          (metrics[kind][name] ||= MetricsCollection.new) << value
-        end
-      end
-    end
-  end
-end

data/lib/honeybadger/agent/trace_collection.rb

@@ -1,32 +0,0 @@
-require 'forwardable'
-
-# Internal: A collection for de-duping traces. Not currently thread-safe (so
-# make sure access is synchronized.)
-module Honeybadger
-  class Agent
-    class TraceCollection
-      extend Forwardable
-      include Enumerable
-
-      def initialize
-        @traces = {}
-      end
-
-      def_delegators :to_a, :each, :empty?, :size
-
-      def push(trace)
-        if !traces.key?(trace.key) || traces[trace.key].duration < trace.duration
-          traces[trace.key] = trace
-        end
-      end
-
-      def to_a
-        traces.values
-      end
-
-      private
-
-      attr_reader :traces
-    end
-  end
-end

data/lib/honeybadger/plugins/net_http.rb

@@ -1,38 +0,0 @@
-require 'honeybadger/plugin'
-require 'honeybadger/trace'
-
-module Honeybadger
-  module Plugins
-    module NetHttp
-      module Instrumentation
-        def self.included(base)
-          base.send(:alias_method, :request_without_honeybadger, :request)
-          base.send(:alias_method, :request, :request_with_honeybadger)
-        end
-
-        def request_with_honeybadger(*args, &block)
-          request = args[0]
-          uri = request.path.to_s.match(%r{https?://}) ? URI(request.path) : URI("http#{use_ssl? ? 's' : ''}://#{address}:#{port}#{request.path}")
-
-          if uri.host.to_s.match("honeybadger.io")
-            return request_without_honeybadger(*args, &block)
-          end
-
-          ActiveSupport::Notifications.instrument("net_http.request", { :uri => uri, :method => request.method }) do
-            # Disable tracing during #request so that additional calls (i.e.
-            # when connection wasn't started) don't result in double counting.
-            Trace.ignore_events { request_without_honeybadger(*args, &block) }
-          end
-        end
-      end
-
-      Plugin.register do
-        requirement { defined?(::ActiveSupport::Notifications) }
-        requirement { defined?(::Net::HTTP) }
-        requirement { config[:'traces.enabled'] }
-
-        execution { ::Net::HTTP.send(:include, Instrumentation) }
-      end
-    end
-  end
-end

data/lib/honeybadger/trace.rb

@@ -1,229 +0,0 @@
-require 'securerandom'
-
-require 'honeybadger/agent'
-require 'honeybadger/util/sanitizer'
-
-module Honeybadger
-  class Trace
-    attr_reader :id, :duration, :key
-
-    def self.current
-      Thread.current[:__hb_trace]
-    end
-
-    def self.create(id)
-      Thread.current[:__hb_trace] = new(id)
-    end
-
-    def self.instrument(key, payload = {}, &block)
-      current = self.current
-      self.create(SecureRandom.uuid).instrument(key, payload, &block)
-    ensure
-      Thread.current[:__hb_trace] = current
-    end
-
-    # Internal: Disables event tracing for executed code block.
-    #
-    # block - The code which should not be traced.
-    #
-    # Returns the return value from the block.
-    def self.ignore_events
-      return yield if ignoring_events?
-
-      begin
-        Thread.current[:__hb_ignore_trace_events] = true
-        yield
-      ensure
-        Thread.current[:__hb_ignore_trace_events] = false
-      end
-    end
-
-    # Internal: Is event tracing currently disabled?
-    def self.ignoring_events?
-      !!Thread.current[:__hb_ignore_trace_events]
-    end
-
-    def initialize(id)
-      @id = id
-      @events = []
-      @meta = {}
-      @fast_queries = {}
-      @duration = 0
-    end
-
-    def add(event)
-      return if ignoring_events?
-      ce = clean_event(event)
-      @events << ce.to_a if ce.render?
-    end
-
-    def add_query(event)
-      return if ignoring_events?
-      return add(event) unless event.duration < 6
-
-      ce = clean_event(event)
-      return unless ce.render?
-      query = ce.to_s
-      if @fast_queries[query]
-        @fast_queries[query][:duration] += ce.event.duration
-        @fast_queries[query][:count] += 1
-      else
-        @fast_queries[query] = { :duration => ce.event.duration, :count => 1 }
-      end
-    end
-
-    def complete(event, payload = {})
-      @meta = clean_event(event).to_h.merge(payload)
-      @duration = event.duration
-      @key = "#{event.payload[:controller]}##{event.payload[:action]}"
-      Thread.current[:__hb_trace] = nil
-      Agent.trace(self)
-    end
-
-    def instrument(key, payload)
-      @key = key
-      @meta = payload
-      started = Time.now
-      yield
-    rescue Exception => e
-      @meta[:exception] = [e.class.name, e.message]
-      raise e
-    ensure
-      @meta.merge!(:duration => @duration = 1000.0 * (Time.now - started))
-      Agent.trace(self)
-    end
-
-    def to_h
-      @meta.merge({ :events => @events, :key => @key, :fast_queries => @fast_queries.map {|k,v| [ k, v[:duration], v[:count] ] } })
-    end
-
-    # Private helpers: use at your own risk.
-
-    attr_reader :meta
-
-    protected
-
-    def ignoring_events?
-      self.class.ignoring_events?
-    end
-
-    def clean_event(event)
-      TraceCleaner.create(event)
-    end
-
-  end
-
-  module TraceCleaner
-
-    def self.create(event)
-      Classes[event.name].new(event)
-    end
-
-    class Base
-      attr_reader :event
-
-      def initialize(event)
-        @event = event
-      end
-
-      def render?
-        true
-      end
-
-      def payload
-        event.payload
-      end
-
-      def to_s
-        payload[:path] || payload[:key] || payload.inspect
-      end
-
-      def to_h
-        { :name => event.name, :desc => to_s, :duration => event.duration }
-      end
-
-      def to_a
-        [ event.name, event.duration, to_s ]
-      end
-
-    end
-
-    class NetHttpRequest < Base
-      Replacement = "..."
-      def to_s
-        uri = payload[:uri]
-        uri.user = Replacement if uri.user
-        uri.password = Replacement if uri.password
-        uri.query = Replacement if uri.query
-        "#{payload[:method]} #{uri}"
-      end
-    end
-
-    class ActiveRecord < Base
-      Schema = "SCHEMA".freeze
-      SchemaMigrations = /schema_migrations/.freeze
-      EscapedQuotes = /(\\"|\\')/.freeze
-      SQuotedData = /'(?:[^']|'')*'/.freeze
-      DQuotedData = /"(?:[^"]|"")*"/.freeze
-      NumericData = /\b\d+\b/.freeze
-      Newline = /\n/.freeze
-      Replacement = "?".freeze
-      EmptyReplacement = "".freeze
-      DoubleQuoters = /(postgres|sqlite|postgis)/.freeze
-
-      def initialize(event)
-        super
-        @sql = Util::Sanitizer.sanitize_string(event.payload[:sql])
-      end
-
-      def render?
-        event.payload[:name] != Schema && !sql.match(SchemaMigrations)
-      end
-
-      def to_s
-        s = sql.dup
-        s.gsub!(EscapedQuotes, EmptyReplacement)
-        s.gsub!(SQuotedData, Replacement)
-        s.gsub!(DQuotedData, Replacement) unless ::ActiveRecord::Base.connection_pool.spec.config[:adapter] =~ DoubleQuoters
-        s.gsub!(NumericData, Replacement)
-        s.gsub!(Newline, EmptyReplacement)
-        s.squeeze!(' ')
-        s
-      end
-
-      private
-        attr_reader :sql
-    end
-
-    class ActionView < Base
-      EmptyReplacement = "".freeze
-
-      def to_s
-        event.payload[:identifier].to_s.gsub(::Rails.root.to_s + '/', EmptyReplacement)
-      end
-    end
-
-    class ActionController < Base
-      def payload
-        event.payload.reject {|k, v| k == :params || k == :headers }
-      end
-
-      def to_s
-        payload.inspect
-      end
-
-      def to_h
-        payload.merge({ :duration => event.duration })
-      end
-    end
-
-    Classes = Hash.new(Base).merge({
-      'sql.active_record' => ActiveRecord,
-      'render_template.action_view' => ActionView,
-      'render_partial.action_view' => ActionView,
-      'render_collection.action_view' => ActionView,
-      'process_action.action_controller' => ActionController,
-      'net_http.request' => NetHttpRequest
-    })
-  end
-end