honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/monitor/worker.rb

@@ -1,169 +0,0 @@
-require "singleton"
-
-module Honeybadger
-  module Monitor
-    class Worker
-      include Singleton
-
-      # Sub-class thread so we have a named thread (useful for debugging in Thread.list).
-      class MetricsThread < Thread
-      end
-
-      def initialize
-        init_metrics
-        init_traces
-        @delay = defined?(::Rails) && ::Rails.env.development? ? 10 : 60
-        @per_request = 100
-        @traces_per_request = 20
-        @sender = Monitor::Sender.new(Honeybadger.configuration)
-        @lock = Mutex.new
-        start
-        at_exit { stop }
-      end
-
-      def start
-        Honeybadger.write_verbose_log('Starting worker')
-
-        @thread = MetricsThread.new do
-          begin
-            until Thread.current[:should_exit] do
-              send_metrics
-              send_traces
-              sleep @delay
-            end
-          rescue Exception => e
-            Honeybadger.write_verbose_log("Error in MetricsThread (shutting down): #{e.class} - #{e.message}\n#{e.backtrace.join("\n\t")}", :error)
-            raise e
-          end
-        end
-      end
-
-      def stop
-        Honeybadger.write_verbose_log('Stopping worker')
-        @thread[:should_exit] = true if @thread
-      end
-
-      def fork
-        Honeybadger.write_verbose_log('Forking worker')
-
-        stop
-
-        @lock.unlock if @lock.locked?
-        @lock.synchronize do
-          init_metrics
-          init_traces
-        end
-
-        start
-      end
-
-      def timing(name, value)
-        add_metric(name, value, :timing)
-      end
-
-      def increment(name, value)
-        add_metric(name, value, :counter)
-      end
-
-      def pending_traces
-        @pending_traces ||= {}
-      end
-
-      def trace
-        Thread.current[:hb_trace_id] ? @pending_traces[Thread.current[:hb_trace_id]] : nil
-      end
-
-      def queue_trace
-        return unless trace
-
-        @lock.synchronize do
-          if trace.duration > Honeybadger.configuration.trace_threshold && (!@traces[trace.key] || @traces[trace.key].duration < trace.duration)
-            @traces[trace.key] = trace
-          end
-          @pending_traces[Thread.current[:hb_trace_id]] = nil
-          Thread.current[:hb_trace_id] = nil
-        end
-      end
-
-      protected
-
-        def init_metrics
-          @metrics = { :timing => {}, :counter => {} }
-        end
-
-        def init_traces
-          @traces = {}
-        end
-
-        def collect_metrics
-          @lock.synchronize do
-            metrics = @metrics
-            init_metrics
-            metrics
-          end
-        end
-
-        def collect_traces
-          @lock.synchronize do
-            traces = @traces.values
-            init_traces
-            traces
-          end
-        end
-
-        def send_metrics
-          metrics = collect_metrics
-          return unless metrics[:timing].any? || metrics[:counter].any?
-
-          Honeybadger.write_verbose_log('Sending metrics')
-
-          [].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
-          end.each_slice(@per_request) do |mm|
-            begin
-              @sender.send_metrics({ :metrics => mm.compact, :environment => Honeybadger.configuration.environment_name, :hostname => Honeybadger.configuration.hostname })
-            rescue Exception => e
-              log(:error, "[Honeybadger::Monitor::Worker#send_metrics] Failed to send #{mm.count} metrics: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
-            end
-          end
-        end
-
-        def send_traces
-          traces = collect_traces
-          return unless traces.any?
-
-          Honeybadger.write_verbose_log('Sending traces')
-
-          traces.each_slice(@traces_per_request) do |t|
-            begin
-              @sender.send_traces({ :traces => t.compact.map(&:to_h), :environment => Honeybadger.configuration.environment_name, :hostname => Honeybadger.configuration.hostname })
-            rescue Exception => e
-              log(:error, "[Honeybadger::Monitor::Worker#send_traces] Failed to send #{t.count} metrics: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
-            end
-          end
-        end
-
-        def add_metric(name, value, kind)
-          @lock.synchronize do
-            (@metrics[kind][name] ||= Honeybadger::Array.new) << value
-          end
-        end
-
-        def log(level, message)
-          Honeybadger.write_verbose_log(message, level)
-        end
-
-    end
-  end
-end

data/lib/honeybadger/payload.rb

@@ -1,101 +0,0 @@
-require 'delegate'
-
-module Honeybadger
-  class Payload < SimpleDelegator
-    TOP_LEVEL_KEYS = [:api_key, :notifier, :error, :request, :server]
-    OBJECT_WHITELIST = [Hash, Array, String, Integer, Float, TrueClass, FalseClass, NilClass]
-
-    # Define getters for top level keys
-    TOP_LEVEL_KEYS.each do |key|
-      define_method key do
-        self[key]
-      end
-    end
-
-    def initialize(hash = {}, options = {})
-      fail ArgumentError, 'must be a Hash' unless hash.kind_of?(Hash)
-
-      @max_depth = options[:max_depth] || 20
-      @filters = options[:filters]
-
-      super(sanitize(hash))
-
-      TOP_LEVEL_KEYS.each {|k| self[k] ||= {} }
-
-      filter_url!(request[:url]) if request[:url]
-      filter_urls!(request[:cgi_data]) if request[:cgi_data]
-
-      filter!(request[:params]) if request[:params]
-      filter!(request[:session]) if request[:session]
-      filter!(request[:cgi_data]) if request[:cgi_data]
-      filter!(request[:local_variables]) if request[:local_variables]
-    end
-
-    protected
-
-    attr_reader :max_depth, :filters
-
-    # Removes non-serializable data and truncates to max depth.
-    def sanitize(data, depth = 0, stack = [])
-      return '[possible infinite recursion halted]' if stack.any?{|item| item == data.object_id }
-
-      if data.respond_to?(:to_hash)
-        return '[max depth reached]' if depth >= max_depth
-        data.to_hash.reduce({}) do |result, (key, value)|
-          result.merge(key => sanitize(value, depth+1, stack + [data.object_id]))
-        end
-      elsif data.respond_to?(:to_ary)
-        return '[max depth reached]' if depth >= max_depth
-        data.to_ary.collect do |value|
-          sanitize(value, depth+1, stack + [data.object_id])
-        end
-      elsif OBJECT_WHITELIST.any? {|c| data.kind_of?(c) }
-        data
-      else
-        data.to_s
-      end
-    end
-
-    def filter!(hash)
-      if filters
-        hash.each do |key, value|
-          if filter_key?(key)
-            hash[key] = "[FILTERED]"
-          elsif value.respond_to?(:to_hash)
-            filter!(hash[key])
-          end
-        end
-      end
-    end
-
-    def filter_key?(key)
-      return false unless filters
-
-      filters.any? do |filter|
-        if filter.is_a?(Regexp)
-          key.to_s =~ filter
-        else
-          key.to_s.eql?(filter.to_s)
-        end
-      end
-    end
-
-    def filter_url!(url)
-      return nil unless url =~ /\S/
-
-      url.scan(/(?:^|&|\?)([^=?&]+)=([^&]+)/).each do |m|
-        next unless filter_key?(m[0])
-        url.gsub!(/#{m[1]}/, '[FILTERED]')
-      end
-
-      url
-    end
-
-    def filter_urls!(hash)
-      hash.each_pair do |key, value|
-        next unless value.kind_of?(String) && key =~ /\A[A-Z_]+\Z/ && value =~ /\S/
-        filter_url!(value)
-      end
-    end
-  end
-end

data/lib/honeybadger/rack.rb

@@ -1,12 +0,0 @@
-require 'honeybadger/rack/error_notifier'
-require 'honeybadger/rack/user_informer'
-require 'honeybadger/rack/user_feedback'
-
-module Honeybadger
-  module Rack
-    def self.new(*args, &block)
-      warn '[DEPRECATION] Honeybadger::Rack is deprecated in 2.0. Use Honeybadger::Rack::ErrorNotifier.'
-      ErrorNotifier.new(*args, &block)
-    end
-  end
-end

data/lib/honeybadger/rails.rb

@@ -1,45 +0,0 @@
-require 'honeybadger'
-require 'honeybadger/rails/controller_methods'
-require 'honeybadger/rails/action_controller_catcher'
-
-module Honeybadger
-  module Rails
-    def self.initialize
-      if defined?(ActionController::Base)
-        ActionController::Base.send(:include, Honeybadger::Rails::ActionControllerCatcher)
-        ActionController::Base.send(:include, Honeybadger::Rails::ControllerMethods)
-      end
-
-      rails_logger = if defined?(::Rails.logger)
-                       ::Rails.logger
-                     elsif defined?(RAILS_DEFAULT_LOGGER)
-                       RAILS_DEFAULT_LOGGER
-                     end
-
-      if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
-        ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
-                                                      Honeybadger::Rack::ErrorNotifier
-        ::Rails.configuration.middleware.insert_after 'Rack::Lock',
-                                                      Honeybadger::Rack::UserInformer
-        ::Rails.configuration.middleware.insert_after Honeybadger::Rack::UserInformer,
-                                                      Honeybadger::Rack::UserFeedback
-      end
-
-      Honeybadger.configure(true) do |config|
-        config.logger           = rails_logger
-        config.environment_name = defined?(::Rails.env) && ::Rails.env || defined?(RAILS_ENV) && RAILS_ENV
-        config.project_root     = defined?(::Rails.root) && ::Rails.root || defined?(RAILS_ROOT) && RAILS_ROOT
-        config.framework        = defined?(::Rails.version) && "Rails: #{::Rails.version}" || defined?(::Rails::VERSION::STRING) && "Rails: #{::Rails::VERSION::STRING}"
-      end
-
-      if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:after_initialize)
-        ::Rails.configuration.after_initialize do
-          Honeybadger::Dependency.inject!
-          Honeybadger.ping(Honeybadger.configuration)
-        end
-      end
-    end
-  end
-end
-
-Honeybadger::Rails.initialize

data/lib/honeybadger/rails/action_controller_catcher.rb

@@ -1,30 +0,0 @@
-module Honeybadger
-  module Rails
-    module ActionControllerCatcher
-
-      # Sets up an alias chain to catch exceptions when Rails does
-      def self.included(base) #:nodoc:
-        base.send(:alias_method, :rescue_action_in_public_without_honeybadger, :rescue_action_in_public)
-        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_honeybadger)
-      end
-
-      private
-
-      # Overrides the rescue_action method in ActionController::Base, but does not inhibit
-      # any custom processing that is defined with Rails 2's exception helpers.
-      def rescue_action_in_public_with_honeybadger(exception)
-        unless honeybadger_ignore_user_agent?
-          error_id = Honeybadger.notify_or_ignore(exception, honeybadger_request_data)
-          request.env['honeybadger.error_id'] = error_id
-        end
-        rescue_action_in_public_without_honeybadger(exception)
-      end
-
-      def honeybadger_ignore_user_agent? #:nodoc:
-        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
-        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
-        Honeybadger.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
-      end
-    end
-  end
-end

data/lib/honeybadger/rails/controller_methods.rb

@@ -1,78 +0,0 @@
-module Honeybadger
-  module Rails
-    module ControllerMethods
-      def honeybadger_request_data
-        { :parameters       => honeybadger_filter_if_filtering(params.to_hash),
-          :session_data     => honeybadger_filter_if_filtering(honeybadger_session_data),
-          :controller       => params[:controller],
-          :action           => params[:action],
-          :url              => honeybadger_request_url,
-          :cgi_data         => honeybadger_filter_if_filtering(request.env) }
-      end
-
-      private
-
-      # This method should be used for sending manual notifications while you are still
-      # inside the controller. Otherwise it works like Honeybadger.notify.
-      def notify_honeybadger(hash_or_exception)
-        unless honeybadger_local_request?
-          Honeybadger.notify(hash_or_exception, honeybadger_request_data)
-        end
-      end
-
-      # Same as the notify_honeybadger method but taking into account the ignored exceptions.
-      def notify_honeybadger_or_ignore(hash_or_exception)
-        unless honeybadger_local_request?
-          Honeybadger.notify_or_ignore(hash_or_exception, honeybadger_request_data)
-        end
-      end
-
-      def honeybadger_local_request?
-        if defined?(::Rails.application.config)
-          ::Rails.application.config.consider_all_requests_local || (request.local? && (!request.env["HTTP_X_FORWARDED_FOR"]))
-        else
-          consider_all_requests_local || (local_request? && (!request.env["HTTP_X_FORWARDED_FOR"]))
-        end
-      end
-
-      def honeybadger_ignore_user_agent? #:nodoc:
-        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
-        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
-        Honeybadger.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
-      end
-
-      def honeybadger_filter_if_filtering(hash)
-        return hash if ! hash.is_a?(Hash)
-
-        # Rails 2 filters parameters in the controller
-        # In Rails 3+ we use request.env['action_dispatch.parameter_filter']
-        # to filter parameters in Honeybadger::Notice (avoids filtering twice)
-        if respond_to?(:filter_parameters)
-          filter_parameters(hash)
-        else
-          hash
-        end
-      end
-
-      def honeybadger_session_data
-        return {} unless session
-        if session.respond_to?(:to_hash)
-          session.to_hash
-        else
-          session.data
-        end
-      end
-
-      def honeybadger_request_url
-        url = "#{request.protocol}#{request.host}"
-
-        unless [80, 443].include?(request.port)
-          url << ":#{request.port}"
-        end
-
-        url << request.fullpath
-        url
-      end
-    end
-  end
-end

data/lib/honeybadger/rails/middleware/exceptions_catcher.rb

@@ -1,29 +0,0 @@
-module Honeybadger
-  module Rails
-    module Middleware
-      module ExceptionsCatcher
-        def self.included(base)
-          base.send(:alias_method_chain,:render_exception,:honeybadger)
-        end
-
-        def skip_user_agent?(env)
-          user_agent = env["HTTP_USER_AGENT"]
-          ::Honeybadger.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
-        rescue
-          false
-        end
-
-        def render_exception_with_honeybadger(env,exception)
-          controller = env['action_controller.instance']
-          env['honeybadger.error_id'] = Honeybadger.
-            notify_or_ignore(exception,
-                   (controller.respond_to?(:honeybadger_request_data) ? controller.honeybadger_request_data : {:rack_env => env})) unless skip_user_agent?(env)
-          if defined?(controller.rescue_action_in_public_without_honeybadger)
-            controller.rescue_action_in_public_without_honeybadger(exception)
-          end
-          render_exception_without_honeybadger(env,exception)
-        end
-      end
-    end
-  end
-end