honeybadger 1.8.1 → 1.9.0.beta1

data/honeybadger.gemspec

@@ -4,8 +4,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = '1.3.5'
 
   s.name              = 'honeybadger'
-  s.version           = '1.8.1'
-  s.date              = '2013-10-01'
+  s.version           = '1.9.0.beta1'
+  s.date              = '2013-10-08'
 
   s.summary     = 'Error reports you can be happy about.'
   s.description = 'Make managing application errors a more pleasant experience.'
@@ -19,19 +19,22 @@ Gem::Specification.new do |s|
   s.rdoc_options = ['--charset=UTF-8', '--markup tomdoc']
   s.extra_rdoc_files = %w[README.md MIT-LICENSE]
 
+  s.add_dependency('faraday')
   s.add_dependency('json')
 
   s.add_development_dependency('cucumber',          '~> 1.2.1')
-  s.add_development_dependency('rspec',             '~> 2.12.0')
+  s.add_development_dependency('rspec',             '~> 2.14.0')
   s.add_development_dependency('fakeweb',           '~> 1.3.0')
   s.add_development_dependency('sham_rack',         '~> 1.3.0')
-  s.add_development_dependency('bourne',            '>= 1.0')
-  s.add_development_dependency('shoulda',           '~> 2.11.3')
   s.add_development_dependency('capistrano')
   s.add_development_dependency('rake')
   s.add_development_dependency('sinatra')
   s.add_development_dependency('aruba')
   s.add_development_dependency('appraisal')
+  s.add_development_dependency('guard')
+  s.add_development_dependency('guard-rspec')
+  s.add_development_dependency('fuubar')
+  s.add_development_dependency('growl')
 
   ## Leave this section as-is. It will be automatically generated from the
   ## contents of your Git repository via the gemspec task. DO NOT REMOVE
@@ -84,9 +87,14 @@ Gem::Specification.new do |s|
     generators/honeybadger/templates/initializer.rb
     honeybadger.gemspec
     lib/honeybadger.rb
+    lib/honeybadger/array.rb
     lib/honeybadger/backtrace.rb
     lib/honeybadger/capistrano.rb
     lib/honeybadger/configuration.rb
+    lib/honeybadger/monitor.rb
+    lib/honeybadger/monitor/railtie.rb
+    lib/honeybadger/monitor/sender.rb
+    lib/honeybadger/monitor/worker.rb
     lib/honeybadger/notice.rb
     lib/honeybadger/rack.rb
     lib/honeybadger/rails.rb
@@ -106,18 +114,24 @@ Gem::Specification.new do |s|
     resources/README.md
     resources/ca-bundle.crt
     script/integration_test.rb
-    test/test_helper.rb
-    test/unit/backtrace_test.rb
-    test/unit/capistrano_test.rb
-    test/unit/configuration_test.rb
-    test/unit/honeybadger_tasks_test.rb
-    test/unit/logger_test.rb
-    test/unit/notice_test.rb
-    test/unit/notifier_test.rb
-    test/unit/rack_test.rb
-    test/unit/rails/action_controller_catcher_test.rb
-    test/unit/rails_test.rb
-    test/unit/sender_test.rb
+    spec/honeybadger/backtrace_spec.rb
+    spec/honeybadger/capistrano_spec.rb
+    spec/honeybadger/configuration_spec.rb
+    spec/honeybadger/logger_spec.rb
+    spec/honeybadger/monitor/worker_spec.rb
+    spec/honeybadger/notice_spec.rb
+    spec/honeybadger/notifier_spec.rb
+    spec/honeybadger/rack_spec.rb
+    spec/honeybadger/rails/action_controller_spec.rb
+    spec/honeybadger/rails_spec.rb
+    spec/honeybadger/sender_spec.rb
+    spec/honeybadger_tasks_spec.rb
+    spec/spec_helper.rb
+    spec/support/array_including.rb
+    spec/support/backtraced_exception.rb
+    spec/support/collected_sender.rb
+    spec/support/defines_constants.rb
+    spec/support/helpers.rb
   ]
   # = MANIFEST =
 

data/lib/honeybadger.rb

@@ -1,5 +1,4 @@
-require 'net/http'
-require 'net/https'
+require 'faraday'
 require 'json'
 require 'digest'
 require 'logger'
@@ -14,7 +13,7 @@ require 'honeybadger/stats'
 require 'honeybadger/railtie' if defined?(Rails::Railtie)
 
 module Honeybadger
-  VERSION = '1.8.1'
+  VERSION = '1.9.0.beta1'
   LOG_PREFIX = "** [Honeybadger] "
 
   HEADERS = {

data/lib/honeybadger/array.rb

@@ -0,0 +1,53 @@
+# This code comes from batsd - I just decided to put this in a child
+# class rather than re-opening Array.
+class Honeybadger::Array < Array
+  # 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)
+    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
+  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_(.+)$/
+       percentile($1.to_i)
+     else
+       super
+     end
+  end
+
+end

data/lib/honeybadger/configuration.rb

@@ -1,3 +1,5 @@
+require 'socket'
+
 module Honeybadger
   class Configuration
     OPTIONS = [:api_key, :backtrace_filters, :development_environments, :environment_name,
@@ -107,6 +109,12 @@ module Honeybadger
     # Override the hostname of the local server (optional)
     attr_accessor :hostname
 
+    # Send metrics?
+    attr_accessor :metrics
+
+    # Which features the API says we have
+    attr_accessor :features
+
     DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
 
     DEFAULT_BACKTRACE_FILTERS = [
@@ -161,7 +169,10 @@ module Honeybadger
       @source_extract_radius     = 2
       @send_request_session      = true
       @debug                     = false
-      @hostname                  = nil
+      @hostname                  = Socket.gethostname
+      @metrics                   = true
+      @features                  = { 'notices' => true }
+      @limit                     = nil
     end
 
     # Public: Takes a block and adds it to the list of backtrace filters. When
@@ -248,7 +259,13 @@ module Honeybadger
     #
     # Returns false if in a development environment, true otherwise.
     def public?
-      !development_environments.include?(environment_name)
+      !development_environments.include?(environment_name) && features['notices']
+    end
+
+    # Public: Determines whether to send metrics
+    #
+    def metrics?
+      public? && @metrics
     end
 
     # Public: Configure async delivery

data/lib/honeybadger/monitor.rb

@@ -0,0 +1,16 @@
+require "honeybadger/array"
+require "honeybadger/monitor/sender"
+require "honeybadger/monitor/worker"
+require "honeybadger/monitor/railtie" if defined?(Rails)
+
+module Honeybadger
+  module Monitor
+    class << self
+
+      def worker
+        Worker.instance
+      end
+
+    end
+  end
+end

data/lib/honeybadger/monitor/railtie.rb

@@ -0,0 +1,52 @@
+module Honeybadger
+  module Monitor
+    class Railtie < ::Rails::Railtie
+
+      config.after_initialize do
+        if Honeybadger.configuration.metrics?
+
+          ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            status = event.payload[:exception] ? 500 : event.payload[:status]
+            Monitor.worker.timing("app.request.#{status}", event.duration)
+
+            controller = event.payload[:controller]
+            action = event.payload[:action]
+            if controller && action
+              Monitor.worker.timing("app.controller.#{controller}.#{action}.total", event.duration)
+              Monitor.worker.timing("app.controller.#{controller}.#{action}.view", event.payload[:view_runtime]) if event.payload[:view_runtime]
+              Monitor.worker.timing("app.controller.#{controller}.#{action}.db", event.payload[:db_runtime]) if event.payload[:db_runtime]
+            end
+          end
+
+          ActiveSupport::Notifications.subscribe(/render_(partial|template)\.action_view\Z/) do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            if !event.name.start_with?('!')
+              metric = event.name.split('.').first
+              file = event.payload[:identifier].gsub(::Rails.root.to_s + File::SEPARATOR,'').gsub('.', '_')
+              Monitor.worker.timing("app.view.#{metric}.#{file}", event.duration)
+            end
+          end
+
+          ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            if event.name != 'SCHEMA' && !event.name == 'CACHE'
+              metric = event.payload[:sql].strip.split(' ', 2).first.downcase
+              Monitor.worker.timing("app.active_record.#{metric}", event.duration)
+            end
+          end
+
+          ActiveSupport::Notifications.subscribe(/(deliver|receive).action_mailer\Z/) do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            if !event.name.start_with?('!')
+              metric = event.name.split('.').first
+              Monitor.worker.timing("app.mail.#{metric}", event.duration)
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/honeybadger/monitor/sender.rb

@@ -0,0 +1,33 @@
+module Honeybadger
+  module Monitor
+    class Sender < Honeybadger::Sender
+      def send_metrics(data)
+        return unless Honeybadger.configuration.metrics?
+
+        if !Honeybadger.configuration.features['metrics']
+          log(:error, "Can't send metrics -- the gem has been deactivated by the remote service.  Try restarting your app or contacting support@honeybadger.io.")
+          Honeybadger.configuration.metrics = false
+          return nil
+        end
+
+        response = client.post do |p|
+          p.url "/v1/metrics"
+          p.body = data.to_json
+        end
+
+        if response.success?
+          true
+        else
+          Honeybadger.configuration.features['metrics'] = false if response.status == 403
+          log(:error, "Metrics Failure", response, data)
+          false
+        end
+
+      rescue => e
+        log(:error, "[Honeybadger::Monitor::Sender#send_metrics] Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
+        true
+      end
+
+    end
+  end
+end

data/lib/honeybadger/monitor/worker.rb

@@ -0,0 +1,71 @@
+require "singleton"
+
+module Honeybadger
+  module Monitor
+    class Worker
+      include Singleton
+
+      def initialize
+        init_metrics
+        @delay = 60
+        @per_request = 100
+        @sender = Monitor::Sender.new(Honeybadger.configuration)
+        @thread = Thread.new do
+          while true do
+            send_metrics
+            sleep @delay
+          end
+        end
+      end
+
+      def timing(name, value)
+        add_metric(name, value, :timing)
+      end
+
+      def increment(name, value)
+        add_metric(name, value, :counter)
+      end
+
+      protected
+
+        def init_metrics
+          @metrics = { :timing => {}, :counter => {} }
+        end
+
+        def send_metrics
+          metrics = @metrics.dup
+          return unless metrics[:timing].any? || metrics[:counter].any?
+          init_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, :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 add_metric(name, value, kind)
+          (@metrics[kind][name] ||= Honeybadger::Array.new) << value
+        end
+
+        def log(level, message)
+          Honeybadger.write_verbose_log(message, level)
+        end
+
+    end
+  end
+end

data/lib/honeybadger/railtie.rb

@@ -1,4 +1,5 @@
 require 'honeybadger'
+require 'honeybadger/monitor'
 require 'rails'
 
 module Honeybadger
@@ -40,6 +41,15 @@ module Honeybadger
         require 'honeybadger/rails/middleware/exceptions_catcher'
         ::ActionDispatch::ShowExceptions.send(:include,Honeybadger::Rails::Middleware::ExceptionsCatcher)
       end
+
+      if Honeybadger.configuration.public?
+        if result = Honeybadger.sender.ping({ :version => Honeybadger::VERSION, :framework => Honeybadger.configuration.framework, :environment => Honeybadger.configuration.environment_name, :hostname => Honeybadger.configuration.hostname })
+          Honeybadger.configure(true) do |config|
+            config.features = result['features'] if result['features']
+            config.limit = result['limit'] if result['limit']
+          end
+        end
+      end
     end
   end
 end

data/lib/honeybadger/sender.rb

@@ -5,9 +5,6 @@ module Honeybadger
                    Errno::EINVAL,
                    Errno::ECONNRESET,
                    EOFError,
-                   Net::HTTPBadResponse,
-                   Net::HTTPHeaderSyntaxError,
-                   Net::ProtocolError,
                    Errno::ECONNREFUSED].freeze
 
     def initialize(options = {})
@@ -34,38 +31,57 @@ module Honeybadger
     #
     # Returns error id from successful response
     def send_to_honeybadger(notice)
-      if api_key.nil?
-        log(:error, "API key not found.")
+      if !Honeybadger.configuration.features['notices']
+        log(:error, "Can't send error report -- the gem has been deactivated by the remote service.  Try restarting your app or contacting support@honeybadger.io.")
         return nil
       end
 
-      data = notice.is_a?(String) ? notice : notice.to_json
-
-      http     = setup_http_connection
-      headers  = HEADERS
+      return nil unless api_key_ok?
 
-      headers.merge!({ 'X-API-Key' => api_key})
+      data = notice.is_a?(String) ? notice : notice.to_json
 
       response = begin
-                   http.post(url.path, data, headers)
+                   client.post do |p|
+                     p.url NOTICES_URI
+                     p.body = data
+                   end
                  rescue *HTTP_ERRORS => e
                    log(:error, "Unable to contact the Honeybadger server. HTTP Error=#{e}")
                    nil
                  end
 
-      case response
-      when Net::HTTPSuccess then
+      if response.success?
         log(Honeybadger.configuration.debug ? :info : :debug, "Success: #{response.class}", response, data)
-        JSON.parse(response.body)['id']
+        JSON.parse(response.body).fetch('id')
       else
         log(:error, "Failure: #{response.class}", response, data)
-        nil
       end
+
     rescue => e
       log(:error, "[Honeybadger::Sender#send_to_honeybadger] Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
       nil
     end
 
+    def ping(data = {})
+      return nil unless api_key_ok?
+
+      response = client.post do |p|
+        p.url "/v1/ping"
+        p.body = data.to_json
+      end
+
+      if response.success?
+        JSON.parse(response.body)
+      else
+        log(:error, "Ping Failure", response, data)
+        nil
+      end
+
+    rescue => e
+      log(:error, "[Honeybadger::Sender#ping] Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
+      nil
+    end
+
     attr_reader :api_key,
       :proxy_host,
       :proxy_port,
@@ -84,8 +100,34 @@ module Honeybadger
 
     private
 
-    def url
-      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+    def api_key_ok?
+      if api_key.nil? || api_key == ''
+        log(:error, "API key not found.")
+        return nil
+      end
+      true
+    end
+
+    def client
+      request_options = { :timeout => http_read_timeout, :open_timeout => http_open_timeout }
+      request_options.merge!({ :proxy => { :uri => "#{protocol}://#{proxy_host}:#{proxy_port || port}", :user => proxy_user, :password => proxy_pass } }) if proxy_host
+
+      @client ||= Faraday.new(:request => request_options) do |conn|
+        conn.adapter Faraday.default_adapter
+        conn.url_prefix = "#{protocol}://#{host}:#{port}"
+        conn.headers['User-agent'] = "HB-Ruby #{Honeybadger::VERSION}; #{RUBY_VERSION}; #{RUBY_PLATFORM}"
+        conn.headers['X-API-Key'] = api_key.to_s
+        conn.headers['Content-Type'] = 'application/json'
+        conn.headers['Accept'] = 'text/json, application/json'
+
+        if secure?
+          conn.ssl[:verify_mode] = OpenSSL::SSL::VERIFY_PEER
+          conn.ssl[:ca_file] = Honeybadger.configuration.ca_bundle_path
+        end
+      end
+    rescue => e
+      log(:error, "[Honeybadger::Sender#client] Failure initializing the HTTP connection.\nError: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
+      raise e
     end
 
     def log(level, message, response = nil, data = nil)
@@ -94,31 +136,8 @@ module Honeybadger
 
       # Log debug information:
       Honeybadger.report_environment_info
-      Honeybadger.report_response_body(response.body) if response && response.respond_to?(:body)
+      Honeybadger.report_response_body(response.body) if response && response.body =~ /\S/
       Honeybadger.write_verbose_log("Notice: #{data}", :debug) if data && Honeybadger.configuration.debug
     end
-
-    def setup_http_connection
-      http =
-        Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
-          new(url.host, url.port)
-
-      http.read_timeout = http_read_timeout
-      http.open_timeout = http_open_timeout
-
-      if secure?
-        http.use_ssl     = true
-
-        http.ca_file      = Honeybadger.configuration.ca_bundle_path
-        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
-      else
-        http.use_ssl     = false
-      end
-
-      http
-    rescue => e
-      log(:error, "[Honeybadger::Sender#setup_http_connection] Failure initializing the HTTP connection.\nError: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
-      raise e
-    end
   end
 end