honeybadger 2.0.12 → 2.1.0.beta.1

data/lib/honeybadger/config/env.rb

@@ -8,31 +8,26 @@ module Honeybadger
       def initialize(env = ENV)
         env.each_pair do |k,v|
           next unless k.match(CONFIG_KEY)
-          next if DISALLOWED_KEYS.include?(CONFIG_MAPPING[$1])
-          self[CONFIG_MAPPING[$1] || $1.downcase.to_sym] = cast_value(v)
+          next unless config_key = CONFIG_MAPPING[$1]
+          self[config_key] = cast_value(v, OPTIONS[config_key][:type])
         end
       end
 
       private
 
-      def cast_value(value)
-        if value.match(ARRAY_VALUES)
-          return value.split(ARRAY_VALUES).map(&method(:cast_value))
-        end
+      def cast_value(value, type = String)
+        v = value.to_s
 
-        case value
-        when /\Atrue\Z/
-          true
-        when /\Afalse\Z/
-          false
-        when /\Anil\Z/
-          nil
-        when /\A\d+\z/
-          value.to_i
-        when /\A\d+\.\d+\z/
-          value.to_f
+        if type == Boolean
+          !!(v =~ /\A(true|t|1)\z/i)
+        elsif type == Array
+          v.split(ARRAY_VALUES).map(&method(:cast_value))
+        elsif type == Integer
+          v.to_i
+        elsif type == Float
+          v.to_f
         else
-          value.to_s
+          v
         end
       end
     end

data/lib/honeybadger/config/yaml.rb

@@ -5,6 +5,8 @@ require 'erb'
 module Honeybadger
   class Config
     class Yaml < ::Hash
+      DISALLOWED_KEYS = [:'config.path'].freeze
+
       def initialize(path, env = 'production')
         @path = path.kind_of?(Pathname) ? path : Pathname.new(path)
 

data/lib/honeybadger/init/rails.rb

@@ -1,5 +1,7 @@
 require 'rails'
 require 'yaml'
+require 'honeybadger/util/sanitizer'
+require 'honeybadger/util/request_payload'
 
 module Honeybadger
   module Init
@@ -30,7 +32,7 @@ module Honeybadger
                 Trace.current.add_query(event) if Trace.current and event.name != 'SCHEMA'
               end
 
-              ActiveSupport::Notifications.subscribe(/^render_(template|action|collection)\.action_view/) do |*args|
+              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
@@ -43,7 +45,10 @@ module Honeybadger
               ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
                 event = ActiveSupport::Notifications::Event.new(*args)
                 if Trace.current && event.payload[:controller] && event.payload[:action]
-                  Trace.current.complete(event)
+                  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
@@ -53,14 +58,6 @@ module Honeybadger
                 event = ActiveSupport::Notifications::Event.new(*args)
                 status = event.payload[:exception] ? 500 : event.payload[:status]
                 Agent.timing("app.request.#{status}", event.duration)
-
-                controller = event.payload[:controller]
-                action = event.payload[:action]
-                if controller && action
-                  Agent.timing("app.controller.#{controller}.#{action}.total", event.duration)
-                  Agent.timing("app.controller.#{controller}.#{action}.view", event.payload[:view_runtime]) if event.payload[:view_runtime]
-                  Agent.timing("app.controller.#{controller}.#{action}.db", event.payload[:db_runtime]) if event.payload[:db_runtime]
-                end
               end
             end
           end
@@ -77,6 +74,27 @@ 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

@@ -4,12 +4,7 @@ module Honeybadger
       ::Sinatra::Base.class_eval do
         class << self
           def build_with_honeybadger(*args, &block)
-            config = Honeybadger::Config.new(honeybadger_config(self))
-            if Honeybadger.start(config)
-              use(Honeybadger::Rack::ErrorNotifier, config) if config.feature?(:notices) && config[:'exceptions.enabled']
-              use(Honeybadger::Rack::MetricsReporter, config) if config.feature?(:metrics) && config[:'metrics.enabled']
-            end
-
+            install_honeybadger
             build_without_honeybadger(*args, &block)
           end
           alias :build_without_honeybadger :build
@@ -20,6 +15,21 @@ module Honeybadger
               api_key: defined?(honeybadger_api_key) ? honeybadger_api_key : nil
             }
           end
+
+          def install_honeybadger
+            config = Honeybadger::Config.new(honeybadger_config(self))
+
+            return unless config[:'sinatra.enabled']
+            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)
+            return if middleware.any? {|m| m[0] == klass }
+            use(klass, config)
+          end
         end
       end
     end

data/lib/honeybadger/notice.rb

@@ -1,13 +1,12 @@
 require 'json'
 require 'securerandom'
 require 'forwardable'
-require 'ostruct'
 
 require 'honeybadger/version'
 require 'honeybadger/backtrace'
 require 'honeybadger/util/stats'
 require 'honeybadger/util/sanitizer'
-require 'honeybadger/rack/request_hash'
+require 'honeybadger/util/request_payload'
 
 module Honeybadger
   NOTIFIER = {
@@ -32,16 +31,6 @@ module Honeybadger
   # Internal: Matches lines beginning with ./
   RELATIVE_ROOT = Regexp.new('^\.\/').freeze
 
-  # Internal: default values to use for request data.
-  REQUEST_DEFAULTS = {
-    url: nil,
-    component: nil,
-    action: nil,
-    params: {}.freeze,
-    session: {}.freeze,
-    cgi_data: {}.freeze
-  }.freeze
-
   MAX_EXCEPTION_CAUSES = 5
 
   class Notice
@@ -79,24 +68,25 @@ module Honeybadger
     attr_reader :source
 
     # Public: CGI variables such as HTTP_METHOD.
-    def_delegator :@request, :cgi_data
+    def cgi_data; @request[:cgi_data]; end
 
     # Public: A hash of parameters from the query string or post body.
-    def_delegator :@request, :params
+    def params; @request[:params]; end
     alias_method :parameters, :params
 
     # Public: The component (if any) which was used in this request. (usually the controller)
-    def_delegator :@request, :component
+    def component; @request[:component]; end
     alias_method :controller, :component
 
     # Public: The action (if any) that was called in this request.
-    def_delegator :@request, :action
+    def action; @request[:action]; end
 
     # Public: A hash of session data from the request.
     def_delegator :@request, :session
+    def session; @request[:session]; end
 
     # Public: The URL at which the error occurred (if any).
-    def_delegator :@request, :url
+    def url; @request[:url]; end
 
     # Public: Local variables are extracted from first frame of backtrace.
     attr_reader :local_variables
@@ -138,24 +128,21 @@ module Honeybadger
       @config = config
 
       @sanitizer = Util::Sanitizer.new
-      @filtered_sanitizer = Util::Sanitizer.new(filters: config.params_filters)
 
-      @exception = opts[:exception]
+      @exception = unwrap_exception(opts[:exception])
       @error_class = exception_attribute(:error_class) {|exception| exception.class.name }
-      @error_message = trim_size(1024) do
-        exception_attribute(:error_message, 'Notification') do |exception|
-          "#{exception.class.name}: #{exception.message}"
-        end
+      @error_message = exception_attribute(:error_message, 'Notification') do |exception|
+        "#{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 = OpenStruct.new(construct_request_hash(config.request, opts, config.excluded_request_keys))
+      @request = construct_request_hash(config, opts)
 
       @context = construct_context_hash(opts)
 
-      @causes = unwrap_causes(opts[:exception])
+      @causes = unwrap_causes(@exception)
 
       @tags = construct_tags(opts[:tags])
       @tags = construct_tags(context[:tags]) | @tags if context
@@ -186,16 +173,10 @@ module Honeybadger
           tags: s(tags),
           causes: s(causes)
         },
-        request: {
-          url: sanitized_url,
-          component: s(component),
-          action: s(action),
-          params: f(params),
-          session: f(session),
-          cgi_data: f(cgi_data),
+        request: @request.update({
           context: s(context),
           local_variables: s(local_variables)
-        },
+        }),
         server: {
           project_root: s(config[:root]),
           environment_name: s(config[:env]),
@@ -239,7 +220,7 @@ module Honeybadger
 
     private
 
-    attr_reader :config, :opts, :context, :stats, :api_key, :now, :pid, :causes, :sanitizer, :filtered_sanitizer
+    attr_reader :config, :opts, :context, :stats, :api_key, :now, :pid, :causes, :sanitizer
 
     def ignore_by_origin?
       opts[:origin] == :rake && !config[:'exceptions.rescue_rake']
@@ -262,7 +243,7 @@ module Honeybadger
     #
     # Returns attribute value from args or exception, otherwise default
     def exception_attribute(attribute, default = nil, &block)
-      opts[attribute] || (opts[:exception] && from_exception(attribute, &block)) || default
+      opts[attribute] || (exception && from_exception(attribute, &block)) || default
     end
 
     # Gets a property named +attribute+ from an exception.
@@ -274,12 +255,12 @@ module Honeybadger
     # If no block is given, a method with the same name as +attribute+ will be
     # invoked for the value.
     def from_exception(attribute)
-      return unless opts[:exception]
+      return unless exception
 
       if block_given?
-        yield(opts[:exception])
+        yield(exception)
       else
-        opts[:exception].send(attribute)
+        exception.send(attribute)
       end
     end
 
@@ -302,50 +283,24 @@ module Honeybadger
       ignored_class ? @ignore_by_class.call(ignored_class) : config[:'exceptions.ignore'].any?(&@ignore_by_class)
     end
 
-    # Limit size of string to bytes
-    #
-    # input - The String to be trimmed.
-    # bytes - The Integer bytes to trim.
-    # block - An optional block used in place of input.
-    #
-    # Examples
-    #
-    #   trimmed = trim_size("Honeybadger doesn't care", 3)
-    #
-    #   trimmed = trim_size(3) do
-    #     "Honeybadger doesn't care"
-    #   end
-    #
-    # Returns trimmed String
-    def trim_size(*args, &block)
-      input, bytes = args.first, args.last
-      input = yield if block_given?
-      input = input.dup
-      input = input[0...bytes] if input.respond_to?(:size) && input.size > bytes
-      input
-    end
-
     def construct_backtrace_filters(opts)
       [
         opts[:callbacks] ? opts[:callbacks].backtrace_filter : nil
       ].compact | BACKTRACE_FILTERS
     end
 
-    def construct_request_hash(rack_request, opts, excluded_keys = [])
+    # Internal: Construct the request object with data from various sources.
+    #
+    # Returns Request.
+    def construct_request_hash(config, opts)
       request = {}
-      request.merge!(Rack::RequestHash.new(rack_request)) if rack_request
-
+      request.merge!(config.request_hash)
+      request.merge!(opts)
       request[:component] = opts[:controller] if opts.has_key?(:controller)
       request[:params] = opts[:parameters] if opts.has_key?(:parameters)
-
-      REQUEST_DEFAULTS.each do |key, default|
-        request[key] = opts[key] if opts.has_key?(key)
-        request[key] = default if !request[key] || excluded_keys.include?(key)
-      end
-
-      request[:session] = request[:session][:data] if request[:session][:data]
-
-      request
+      request.delete_if {|k,v| config.excluded_request_keys.include?(k) }
+      request[:sanitizer] = Util::Sanitizer.new(filters: config.params_filters)
+      Util::RequestPayload.build(request)
     end
 
     def construct_context_hash(opts)
@@ -356,21 +311,19 @@ module Honeybadger
     end
 
     def extract_source_from_backtrace(backtrace, config, opts)
-      if backtrace.lines.empty?
-        nil
+      return nil if backtrace.lines.empty?
+
+      # ActionView::Template::Error has its own source_extract method.
+      # If present, use that instead.
+      if exception.respond_to?(:source_extract) && exception.source_extract
+        Hash[exception.source_extract.split("\n").map do |line|
+          parts = line.split(': ')
+          [parts[0].strip, parts[1] || '']
+        end]
+      elsif backtrace.application_lines.any?
+        backtrace.application_lines.first.source(config[:'exceptions.source_radius'])
       else
-        # ActionView::Template::Error has its own source_extract method.
-        # If present, use that instead.
-        if opts[:exception].respond_to?(:source_extract) && opts[:exception].source_extract
-          Hash[exception.source_extract.split("\n").map do |line|
-            parts = line.split(': ')
-            [parts[0].strip, parts[1] || '']
-          end]
-        elsif backtrace.application_lines.any?
-          backtrace.application_lines.first.source(config[:'exceptions.source_radius'])
-        else
-          backtrace.lines.first.source(config[:'exceptions.source_radius'])
-        end
+        backtrace.lines.first.source(config[:'exceptions.source_radius'])
       end
     end
 
@@ -408,15 +361,6 @@ module Honeybadger
       sanitizer.sanitize(data)
     end
 
-    def f(data)
-      filtered_sanitizer.sanitize(data)
-    end
-
-    def sanitized_url
-      return nil unless url
-      filtered_sanitizer.filter_url(s(url))
-    end
-
     # Internal: Fetch local variables from first frame of backtrace.
     #
     # exception - The Exception containing the bindings stack.
@@ -458,6 +402,17 @@ module Honeybadger
       )
     end
 
+    # Internal: Unwrap the exception so that original exception is ignored or
+    # reported.
+    #
+    # exception - The exception which was rescued.
+    #
+    # Returns the Exception to report.
+    def unwrap_exception(exception)
+      return exception unless config[:'exceptions.unwrap']
+      exception_cause(exception) || exception
+    end
+
     # Internal: Fetch cause from exception.
     #
     # exception - Exception to fetch cause from.
@@ -484,7 +439,7 @@ module Honeybadger
       while (e = exception_cause(e)) && i < MAX_EXCEPTION_CAUSES
         c << {
           class: e.class.name,
-          message: trim_size(1024) { e.message },
+          message: e.message,
           backtrace: parse_backtrace(e.backtrace || caller)
         }
         i += 1

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

@@ -8,21 +8,34 @@ module Honeybadger
         callbacks do |lifecycle|
           lifecycle.around(:invoke_job) do |job, &block|
             begin
+              begin #buildin suport for Delayed::PerformableMethod
+                component = job.payload_object.object.is_a?(Class) ? job.payload_object.object.name : job.payload_object.object.class.name
+                action    = job.payload_object.method_name.to_s
+              rescue #fallback to support all other classes
+                component = job.payload_object.class.name
+                action    = 'perform'
+              end
+
+              ::Honeybadger.context(
+                :component     => component,
+                :action        => action,
+                :job_id        => job.id,
+                :handler       => job.handler,
+                :last_error    => job.last_error,
+                :attempts      => job.attempts,
+                :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
             rescue Exception => error
               ::Honeybadger.notify_or_ignore(
+                :component     => component,
+                :action        => action,
                 :error_class   => error.class.name,
                 :error_message => "#{ error.class.name }: #{ error.message }",
-                :backtrace     => error.backtrace,
-                  :context       => {
-                  :job_id        => job.id,
-                  :handler       => job.handler,
-                  :last_error    => job.last_error,
-                  :attempts      => job.attempts,
-                  :queue         => job.queue
-                }
+                :backtrace     => error.backtrace
               ) if job.attempts.to_i >= ::Honeybadger::Agent.config[:'delayed_job.attempt_threshold'].to_i
               raise error
             ensure