honeybadger 4.3.1 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 154fe2f9fde40cf439b82bf35d5fb32474304e79b29fa6202d7de64920475435
-  data.tar.gz: 347644c0b97c94f0b9995186bd2ebbdda67ea9a8af9933defe07370f29203980
+  metadata.gz: 5bd1d88346f34070874c2929f1f322ed318157fd7772d2d89848685d3e23adcb
+  data.tar.gz: dada0e8a7039c5750a7406e5c5c8452ae942c369ebac17e816ba15a977b1ea33
 SHA512:
-  metadata.gz: aebf85527c70c7cf5531e12d18625ce8a61f0ad005a9a07a274ca59cc38146cea10f48c344d19091adadf64da779f93c313c18b0943d552acbeec2887f25e18a
-  data.tar.gz: 4975a88db66f69085b14446d7d3e9ff16722d0391f4fcb4ddb4e59893c001e988a418e0928fe6e1bfae3e1d6d113adb482927d5aab92435bca7556f32f82fa2b
+  metadata.gz: ad7229d00efd55f9a1f02b32d510bb7f97f022df4de9713e750063539ef67db1a482841e51b079c1b7b6659e161bb2235d41273095c3e776b5b8cb536a6af755
+  data.tar.gz: f6ee33891464589594aa9c3b4cdf3489943b9a4accf99e199723b395d999a0b45b242f9e510d7f3466c6133aca47b8abff8927ef9ac022b58fc00f285421cb22

data/CHANGELOG.md

@@ -5,6 +5,12 @@ adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [4.4.0] - 2019-07-24
+### Added
+- Added the ability to store and send Breadcrumbs along with the notice.
+  Breadcrumbs are disabled by default in this version so they must be enabled
+  via the config (option `breadcrumbs.enabled`) to work.
+
 ## [4.3.1] - 2019-05-30
 ### Fixed
 - Add Rails 6 RC1 Support

data/lib/honeybadger/agent.rb

@@ -7,6 +7,7 @@ require 'honeybadger/notice'
 require 'honeybadger/plugin'
 require 'honeybadger/logging'
 require 'honeybadger/worker'
+require 'honeybadger/breadcrumbs'
 
 module Honeybadger
   # The Honeybadger agent contains all the methods for interacting with the
@@ -62,7 +63,10 @@ module Honeybadger
       end
 
       @context = opts.delete(:context)
-      @context ||= ContextManager.new if opts.delete(:local_context)
+      if opts.delete(:local_context)
+        @context ||= ContextManager.new
+        @breadcrumbs = Breadcrumbs::Collector.new(config)
+      end
 
       @config ||= Config.new(opts)
 
@@ -120,8 +124,15 @@ module Honeybadger
 
       validate_notify_opts!(opts)
 
+      add_breadcrumb(
+        "Honeybadger Notice",
+        metadata: opts,
+        category: "notice"
+      ) if config[:'breadcrumbs.enabled']
+
       opts[:rack_env] ||= context_manager.get_rack_env
       opts[:global_context] ||= context_manager.get_context
+      opts[:breadcrumbs] ||= breadcrumbs.dup
 
       notice = Notice.new(config, opts)
 
@@ -214,10 +225,10 @@ module Honeybadger
       self
     end
 
-    # @api private
-    # Used to clear context via `#context.clear!`.
-    def clear! # :nodoc:
+    # Clear all transaction scoped data.
+    def clear!
       context_manager.clear!
+      breadcrumbs.clear!
     end
 
     # Get global context for the current request.
@@ -231,6 +242,46 @@ module Honeybadger
       context_manager.get_context
     end
 
+    # @api private
+    # Direct access to the Breadcrumbs::Collector instance
+    def breadcrumbs
+      return @breadcrumbs if @breadcrumbs
+
+      Thread.current[:__hb_breadcrumbs] ||= Breadcrumbs::Collector.new(config)
+    end
+
+    # Appends a breadcrumb to the trace. Use this when you want to add some
+    # custom data to your breadcrumb trace in effort to help debugging. If a
+    # notice is reported to Honeybadger, all breadcrumbs within the execution
+    # path will be appended to the notice. You will be able to view the
+    # breadcrumb trace in the Honeybadger interface to see what events led up
+    # to the notice.
+    #
+    # @example
+    #   Honeybadger.add_breadcrumb("Email Sent", metadata: { user: user.id, message: message })
+    #
+    # @param message [String] The message you want to send with the breadcrumb
+    # @param params [Hash] extra options for breadcrumb building
+    # @option params [Hash] :metadata Any metadata that you want to pass along
+    #   with the breadcrumb. We only accept a hash with simple primatives as
+    #   values (Strings, Numbers, Booleans & Symbols) (optional)
+    # @option params [String] :category You can provide a custom category. This
+    #   affects how the breadcrumb is displayed, so we recommend that you pick a
+    #   known category. (optional)
+    #
+    # @return self
+    def add_breadcrumb(message, metadata: {}, category: "custom")
+      params = Util::Sanitizer.new(max_depth: 2).sanitize({
+        category: category,
+        message: message,
+        metadata: metadata
+      })
+
+      breadcrumbs.add!(Breadcrumbs::Breadcrumb.new(params))
+
+      self
+    end
+
     # Flushes all data from workers before returning. This is most useful in
     # tests when using the test backend, where normally the asynchronous nature
     # of this library could create race conditions.

data/lib/honeybadger/breadcrumbs.rb

@@ -0,0 +1,8 @@
+require 'honeybadger/breadcrumbs/ring_buffer'
+require 'honeybadger/breadcrumbs/breadcrumb'
+require 'honeybadger/breadcrumbs/collector'
+
+module Honeybadger
+  module Breadcrumbs
+  end
+end

data/lib/honeybadger/breadcrumbs/active_support.rb

@@ -0,0 +1,108 @@
+require 'honeybadger/util/sql'
+
+module Honeybadger
+  module Breadcrumbs
+    class ActiveSupport
+      def self.default_notifications
+        {
+          # ActiveRecord Actions
+          #
+          "sql.active_record" => {
+            message: lambda do |data|
+              # Disregard empty string names
+              name = data[:name] if data[:name] && !data[:name].strip.empty?
+
+              ["Active Record", name].compact.join(" - ")
+            end,
+            category: "query",
+            select_keys: [:sql, :name, :connection_id, :cached],
+            transform: lambda do |data|
+              if data[:sql]
+                adapter = ::ActiveRecord::Base.connection_config[:adapter]
+                data[:sql] = Util::SQL.obfuscate(data[:sql], adapter)
+              end
+              data
+            end,
+            exclude_when: lambda do |data|
+              # Ignore schema, begin, and commit transaction queries
+              data[:name] == "SCHEMA" || (data[:sql] && (data[:sql] =~ /^(begin|commit)( transaction)?$/i))
+            end
+          },
+
+          # ActionCable Actions
+          #
+          "perform_action.action_cable" => {
+            message: "Action Cable Perform Action",
+            select_keys: [:channel_class, :action],
+            category: "render"
+          },
+
+          # ActiveJob Actions
+          #
+          "enqueue.active_job" => {
+            message: "Active Job Enqueue",
+            select_keys: [],
+            category: "job"
+          },
+          "perform_start.active_job" => {
+            message: "Active Job Perform Start",
+            select_keys: [],
+            category: "job",
+          },
+
+          # ActiveSupport Actions
+          #
+          "cache_read.active_support" => {
+            message: "Active Support Cache Read",
+            category: "query"
+          },
+          "cache_fetch_hit.active_support" => {
+            message: "Active Support Cache Fetch Hit",
+            category: "query"
+          },
+
+          # Controller Actions
+          #
+          "halted_callback.action_controller" => {
+            message: "Action Controller Callback Halted",
+            category: "request",
+          },
+          "process_action.action_controller" => {
+            message: "Action Controller Action Process",
+            select_keys: [:controller, :action, :format, :method, :path, :status, :view_runtime, :db_runtime],
+            category: "request",
+          },
+          "start_processing.action_controller" => {
+            message: "Action Controller Start Process",
+            select_keys: [:controller, :action, :format, :method, :path],
+            category: "request",
+          },
+          "redirect_to.action_controller" => {
+            message: "Action Controller Redirect",
+            category: "request",
+          },
+
+          # View Actions
+          #
+          "render_template.action_view" => {
+            message: "Action View Template Render",
+            category: "render",
+          },
+          "render_partial.action_view" => {
+            message: "Action View Partial Render",
+            category: "render",
+          },
+
+          # Mailer actions
+          #
+          "deliver.action_mailer" => {
+            message: "Action Mailer Deliver",
+            select_keys: [:mailer, :message_id, :from, :date],
+            category: "render"
+          }
+        }
+      end
+
+    end
+  end
+end

data/lib/honeybadger/breadcrumbs/breadcrumb.rb

@@ -0,0 +1,53 @@
+require 'time'
+
+module Honeybadger
+  module Breadcrumbs
+    class Breadcrumb
+      # Raw breadcrumb data structure
+      #
+      attr_reader :category, :timestamp
+      attr_accessor :message, :metadata, :active
+
+      include Comparable
+
+      def initialize(category: "custom", message: nil, metadata: {})
+        @active = true
+        @timestamp = Time.now.utc
+
+        @category = category
+        @message = message
+        @metadata = metadata.is_a?(Hash) ? metadata : {}
+      end
+
+      def to_h
+        {
+          category: category,
+          message: message,
+          metadata: metadata,
+          timestamp: timestamp.iso8601(3)
+        }
+      end
+
+      def <=>(other)
+        to_h <=> other.to_h
+      end
+
+
+      # Is the Breadcrumb active or not. Inactive Breadcrumbs not be included
+      # with any outgoing payloads.
+      #
+      # @return [Boolean]
+      def active?
+        @active
+      end
+
+      # Sets the breadcrumb to inactive
+      #
+      # @return self
+      def ignore!
+        @active = false
+        self
+      end
+    end
+  end
+end

data/lib/honeybadger/breadcrumbs/collector.rb

@@ -0,0 +1,82 @@
+require 'forwardable'
+
+module Honeybadger
+  module Breadcrumbs
+    class Collector
+      include Enumerable
+      extend Forwardable
+      # The Collector manages breadcrumbs and provides an interface for accessing
+      # and affecting breadcrumbs
+      #
+      # Most actions are delegated to the current buffer implementation. A
+      # Buffer must implement all delegated methods to work with the Collector.
+
+      # Flush all breadcrumbs, delegates to buffer
+      def_delegator :@buffer, :clear!
+
+      # Iterate over all Breadcrumbs and satify Enumerable, delegates to buffer
+      # @yield [Object] sequentially gives breadcrumbs to the block
+      def_delegator :@buffer, :each
+
+      # Raw Array of Breadcrumbs, delegates to buffer
+      # @return [Array] Raw set of breadcrumbs
+      def_delegator :@buffer, :to_a
+
+      # Last item added to the buffer
+      # @return [Breadcrumb]
+      def_delegator :@buffer, :previous
+
+      def initialize(config, buffer = RingBuffer.new)
+        @config = config
+        @buffer = buffer
+      end
+
+      # Add Breadcrumb to stack
+      #
+      # @return [self] Filtered breadcrumbs
+      def add!(breadcrumb)
+        return unless @config[:'breadcrumbs.enabled']
+        @buffer.add!(breadcrumb)
+
+        self
+      end
+
+      alias_method :<<, :add!
+
+      # @api private
+      # Removes the prevous breadcrumb from the buffer if the supplied
+      # block returns a falsy value
+      #
+      def drop_previous_breadcrumb_if
+        @buffer.drop if (previous && block_given? && yield(previous))
+      end
+
+      # All active breadcrumbs you want to remove a breadcrumb from the trail,
+      # then you can selectively ignore breadcrumbs while building a notice.
+      #
+      # @return [Array] Active breadcrumbs
+      def trail
+        select(&:active?)
+      end
+
+      def to_h
+        {
+          enabled: @config[:'breadcrumbs.enabled'],
+          trail: trail.map(&:to_h)
+        }
+      end
+
+      private
+
+      # @api private
+      # Since the collector is shared with the worker thread, there is a chance
+      # it can be cleared before we have prepared the request. We provide the
+      # ability to duplicate a collector which should also duplicate the buffer
+      # instance, as that holds the breadcrumbs.
+      def initialize_dup(source)
+        @buffer = source.instance_variable_get(:@buffer).dup
+        super
+      end
+    end
+  end
+end

data/lib/honeybadger/breadcrumbs/logging.rb

@@ -0,0 +1,50 @@
+module Honeybadger
+  module Breadcrumbs
+    # @api private
+    #
+    module LogWrapper
+      def add(severity, message = nil, progname = nil)
+        message, progname = [progname, nil] if message.nil?
+        message = message && message.strip
+        unless should_ignore_log?(message, progname)
+          Honeybadger.add_breadcrumb(message, category: :log, metadata: {
+            severity: format_severity(severity),
+            progname: progname
+          })
+        end
+
+        super
+      end
+
+      private
+
+      def should_ignore_log?(message, progname)
+        message.nil? ||
+        message == "" ||
+        Thread.current[:__hb_within_log_subscriber] ||
+        progname == "honeybadger"
+      end
+    end
+
+    # @api private
+    #
+    # This module is designed to be prepended into the
+    # ActiveSupport::LogSubscriber for the sole purpose of silencing breadcrumb
+    # log events. Since we already have specific breadcrumb events for each
+    # class that provides LogSubscriber events, we want to filter out those
+    # logs as they just become noise.
+    module LogSubscriberInjector
+      %w(info debug warn error fatal unknown).each do |level|
+        define_method(level) do |*args|
+          begin
+            Thread.current[:__hb_within_log_subscriber] = true
+            super(*args)
+          ensure
+            Thread.current[:__hb_within_log_subscriber] = false
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/honeybadger/breadcrumbs/ring_buffer.rb

@@ -0,0 +1,44 @@
+module Honeybadger
+  module Breadcrumbs
+    class RingBuffer
+      # Simple ring buffer implementation that keeps item count constrained using
+      # a rolling window. Items from the front of the buffer are dropped as more
+      # are pushed on the end of the stack.
+      include Enumerable
+
+      attr_reader :buffer
+
+      def initialize(buffer_size = 40)
+        @buffer_size = buffer_size
+        clear!
+      end
+
+      def add!(item)
+        @buffer << item
+        @ct += 1
+        @buffer.shift(1) if @ct > @buffer_size
+      end
+
+      def clear!
+        @buffer = []
+        @ct = 0
+      end
+
+      def to_a
+        @buffer
+      end
+
+      def each(&blk)
+        @buffer.each(&blk)
+      end
+
+      def previous
+        @buffer.last
+      end
+
+      def drop
+        @buffer.pop
+      end
+    end
+  end
+end

data/lib/honeybadger/config/defaults.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'honeybadger/breadcrumbs/active_support'
 
 module Honeybadger
   class Config
@@ -287,6 +288,21 @@ module Honeybadger
         description: 'Send exceptions when retrying job.',
         default: true,
         type: Boolean
+      },
+      :'breadcrumbs.enabled' => {
+        description: 'Enable/Disable breadcrumb functionality.',
+        default: false,
+        type: Boolean
+      },
+      :'breadcrumbs.active_support_notifications' => {
+        description: 'Configuration for automatic Active Support Instrumentation events.',
+        default: Breadcrumbs::ActiveSupport.default_notifications,
+        type: Hash
+      },
+      :'breadcrumbs.logging.enabled' => {
+        description: 'Enable/Disable automatic breadcrumbs from log messages.',
+        default: true,
+        type: Boolean
       }
     }.freeze
 

data/lib/honeybadger/config/env.rb

@@ -1,9 +1,12 @@
+require 'set'
+
 module Honeybadger
   class Config
     module Env
       CONFIG_KEY = /\AHONEYBADGER_(.+)\Z/.freeze
       CONFIG_MAPPING = Hash[DEFAULTS.keys.map {|k| [k.to_s.upcase.gsub(KEY_REPLACEMENT, '_'), k] }].freeze
       ARRAY_VALUES = Regexp.new('\s*,\s*').freeze
+      IGNORED_TYPES = Set[Hash]
 
       def self.new(env = ENV)
         hash = {}
@@ -11,7 +14,9 @@ module Honeybadger
         env.each_pair do |k,v|
           next unless k.match(CONFIG_KEY)
           next unless config_key = CONFIG_MAPPING[$1]
-          hash[config_key] = cast_value(v, OPTIONS[config_key][:type])
+          type = OPTIONS[config_key][:type]
+          next if IGNORED_TYPES.include?(type)
+          hash[config_key] = cast_value(v, type)
         end
 
         hash

data/lib/honeybadger/init/rake.rb

@@ -16,7 +16,7 @@ module Honeybadger
       Honeybadger.notify(ex, origin: :rake, component: reconstruct_command_line)
       display_error_message_without_honeybadger(ex)
     ensure
-      Honeybadger.context.clear!
+      Honeybadger.clear!
     end
 
     def reconstruct_command_line

data/lib/honeybadger/logging.rb

@@ -7,6 +7,7 @@ module Honeybadger
   # @api private
   module Logging
     PREFIX = '** [Honeybadger] '.freeze
+    LOGGER_PROG = "honeybadger".freeze
 
     # Logging helper methods. Requires a Honeybadger::Config @config instance
     # variable to exist and/or #logger to be defined. Each method is
@@ -93,12 +94,16 @@ module Honeybadger
         @logger = logger
       end
 
-      def_delegators :@logger, :level, :add, :debug?, :info?, :warn?, :error?
+      def add(severity, msg, progname=LOGGER_PROG)
+        @logger.add(severity, msg, progname)
+      end
+
+      def_delegators :@logger, :level, :debug?, :info?, :warn?, :error?
     end
 
     class FormattedLogger < StandardLogger
-      def add(severity, msg)
-        super(severity, format_message(msg))
+      def add(severity, msg, progname=LOGGER_PROG)
+        super(severity, format_message(msg), progname)
       end
 
       private

data/lib/honeybadger/notice.rb

@@ -115,6 +115,9 @@ module Honeybadger
     # Deprecated: Excerpt from source file.
     attr_reader :source
 
+    # @return [Breadcrumbs::Collector] The collection of captured breadcrumbs
+    attr_accessor :breadcrumbs
+
     # @api private
     # Cache project path substitutions for backtrace lines.
     PROJECT_ROOT_CACHE = {}
@@ -184,6 +187,8 @@ module Honeybadger
 
       self.session = opts[:session][:data] if opts[:session] && opts[:session][:data]
 
+      self.breadcrumbs = opts[:breadcrumbs] || Breadcrumbs::Collector.new(config)
+
       # Fingerprint must be calculated last since callback operates on `self`.
       self.fingerprint = fingerprint_from_opts(opts)
     end
@@ -200,6 +205,7 @@ module Honeybadger
       {
         api_key: s(api_key),
         notifier: NOTIFIER,
+        breadcrumbs: sanitized_breadcrumbs,
         error: {
           token: id,
           class: s(error_class),
@@ -354,6 +360,12 @@ module Honeybadger
       Context(object)
     end
 
+    # Sanitize at the depth of 4 since we are sanitizing the breadcrumb root
+    # hash data structure.
+    def sanitized_breadcrumbs
+      Util::Sanitizer.new(max_depth: 4).sanitize(breadcrumbs.to_h)
+    end
+
     def construct_context_hash(opts, exception)
       context = {}
       context.merge!(Context(opts[:global_context]))

data/lib/honeybadger/plugins/breadcrumbs.rb

@@ -0,0 +1,109 @@
+require 'honeybadger/plugin'
+require 'honeybadger/breadcrumbs/logging'
+
+module Honeybadger
+  module Plugins
+    # @api private
+    #
+    # This plugin pounces on the dynamic nature of Ruby / Rails to inject into
+    # the runtime and provide automatic breadcrumb events.
+    #
+    # === Log events
+    #
+    # All log messages within the execution path will automatically be appened
+    # to the breadcrumb trace. You can disable all log events in the
+    # Honeybadger config:
+    #
+    # @example
+    #
+    #   Honeybadger.configure do |config|
+    #     config.breadcrumbs.logging.enabled = false
+    #   end
+    #
+    # === ActiveSupport Breadcrumbs
+    #
+    # We hook into Rails's ActiveSupport Instrumentation system to provide
+    # automatic breadcrumb event generation. You can customize these events by
+    # passing a Hash into the honeybadger configuration. The simplest method is
+    # to alter the current defaults:
+    #
+    # @example
+    #   notifications = Honeybadger::Breadcrumbs::ActiveSupport.default_notifications
+    #   notifications.delete("sql.active_record")
+    #   notifications["enqueue.active_job"][:exclude_when] = lambda do |data|
+    #     data[:job].topic == "salmon_activity"
+    #   end
+    #
+    #   Honeybadger.configure do |config|
+    #     config.breadcrumbs.active_support_notifications = notifications
+    #   end
+    #
+    # See RailsBreadcrumbs.send_breadcrumb_notification for specifics on the
+    # options for customization
+    Plugin.register :breadcrumbs do
+      requirement { config[:'breadcrumbs.enabled'] }
+
+      execution do
+        # Rails specific breadcrumb events
+        #
+        if defined?(::Rails.application) && ::Rails.application
+          config[:'breadcrumbs.active_support_notifications'].each do |name, config|
+            RailsBreadcrumbs.subscribe_to_notification(name, config)
+          end
+          ActiveSupport::LogSubscriber.prepend(Honeybadger::Breadcrumbs::LogSubscriberInjector) if config[:'breadcrumbs.logging.enabled']
+        end
+
+        ::Logger.prepend(Honeybadger::Breadcrumbs::LogWrapper) if config[:'breadcrumbs.logging.enabled']
+      end
+    end
+
+    class RailsBreadcrumbs
+      # @api private
+      # Used internally for sending out Rails Instrumentation breadcrumbs.
+      #
+      # @param [String] name The ActiveSupport instrumentation key
+      # @param [Number] duration The time spent in the instrumentation event
+      # @param [Hash] notification_config The instrumentation event configuration
+      # @param [Hash] data Custom metadata from the instrumentation event
+      #
+      # @option notification_config [String | Proc] :message A message that describes the event. You can dynamically build the message by passing a proc that accepts the event metadata.
+      # @option notification_config [Symbol] :category A key to group specific types of events
+      # @option notification_config [Array] :select_keys A set of keys that filters what data we select from the instrumentation data (optional)
+      # @option notification_config [Proc] :exclude_when A proc that accepts the data payload. A truthy return value will exclude this event from the payload (optional)
+      # @option notification_config [Proc] :transform A proc that accepts the data payload. The return value will replace the current data hash (optional)
+      #
+      def self.send_breadcrumb_notification(name, duration, notification_config, data = {})
+        return if notification_config[:exclude_when] && notification_config[:exclude_when].call(data)
+
+        message =
+          case (m = notification_config[:message])
+          when Proc
+            m.call(data)
+          when String
+            m
+          else
+            name
+          end
+
+        data = data.slice(*notification_config[:select_keys]) if notification_config[:select_keys]
+        data = notification_config[:transform].call(data) if notification_config[:transform]
+        data = data.is_a?(Hash) ? data : {}
+
+        data[:duration] = duration
+
+        Honeybadger.add_breadcrumb(
+          message,
+          category: notification_config[:category] || :custom,
+          metadata: data
+        )
+      end
+
+      # @api private
+      def self.subscribe_to_notification(name, notification_config)
+        ActiveSupport::Notifications.subscribe(name) do |_, started, finished, _, data|
+          send_breadcrumb_notification(name, finished - started, notification_config, data)
+        end
+      end
+    end
+  end
+end

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

@@ -46,7 +46,7 @@ module Honeybadger
               ) if job.attempts.to_i >= ::Honeybadger.config[:'delayed_job.attempt_threshold'].to_i
               raise error
             ensure
-              ::Honeybadger.context.clear!
+              ::Honeybadger.clear!
             end
           end
         end

data/lib/honeybadger/plugins/resque.rb

@@ -10,7 +10,7 @@ module Honeybadger
         def around_perform_with_honeybadger(*args)
           Honeybadger.flush { yield }
         ensure
-          Honeybadger.context.clear!
+          Honeybadger.clear!
         end
 
         # Error notifications must be synchronous as the +on_failure+ hook is

data/lib/honeybadger/plugins/shoryuken.rb

@@ -16,7 +16,7 @@ module Honeybadger
             raise e
           end
         ensure
-          Honeybadger.context.clear!
+          Honeybadger.clear!
         end
 
         private

data/lib/honeybadger/plugins/sidekiq.rb

@@ -6,7 +6,7 @@ module Honeybadger
     module Sidekiq
       class Middleware
         def call(worker, msg, queue)
-          Honeybadger.context.clear!
+          Honeybadger.clear!
           yield
         end
       end

data/lib/honeybadger/rack/error_notifier.rb

@@ -23,7 +23,7 @@ module Honeybadger
 
       def initialize(app, agent = nil)
         @app = app
-        @agent = agent.kind_of?(Agent) ? agent : Honeybadger::Agent.instance
+        @agent = agent.kind_of?(Agent) && agent
       end
 
       def call(env)
@@ -44,15 +44,18 @@ module Honeybadger
           response
         end
       ensure
-        agent.context.clear!
+        agent.clear!
       end
 
       private
 
-      attr_reader :agent
       def_delegator :agent, :config
       def_delegator :config, :logger
 
+      def agent
+        @agent || Honeybadger::Agent.instance
+      end
+
       def ignored_user_agent?(env)
         true if config[:'exceptions.ignored_user_agents'].
           flatten.
@@ -61,6 +64,22 @@ module Honeybadger
 
       def notify_honeybadger(exception, env)
         return if ignored_user_agent?(env)
+
+        if config[:'breadcrumbs.enabled']
+          # Drop the last breadcrumb only if the message contains the error class name
+          agent.breadcrumbs.drop_previous_breadcrumb_if do |bc|
+            bc.category == "log" && bc.message.include?(exception.class.to_s)
+          end
+
+          agent.add_breadcrumb(
+            exception.class,
+            metadata: {
+              exception_message: exception.message
+            },
+            category: "error"
+          )
+        end
+
         agent.notify(exception)
       end
 

data/lib/honeybadger/rack/user_feedback.rb

@@ -23,7 +23,7 @@ module Honeybadger
 
       def initialize(app, agent = nil)
         @app = app
-        @agent = agent.kind_of?(Agent) ? agent : Honeybadger::Agent.instance
+        @agent = agent.kind_of?(Agent) && agent
       end
 
       def call(env)
@@ -76,9 +76,13 @@ module Honeybadger
 
       private
 
-      attr_reader :agent
       def_delegator :agent, :config
       def_delegator :config, :logger
+
+      def agent
+        @agent || Honeybadger::Agent.instance
+      end
+
     end
   end
 end

data/lib/honeybadger/rack/user_informer.rb

@@ -9,7 +9,7 @@ module Honeybadger
 
       def initialize(app, agent = nil)
         @app = app
-        @agent = agent.kind_of?(Agent) ? agent : Honeybadger::Agent.instance
+        @agent = agent.kind_of?(Agent) && agent
       end
 
       def replacement(with)
@@ -34,9 +34,12 @@ module Honeybadger
 
       private
 
-      attr_reader :agent
       def_delegator :agent, :config
       def_delegator :config, :logger
+
+      def agent
+        @agent || Honeybadger::Agent.instance
+      end
     end
   end
 end

data/lib/honeybadger/singleton.rb

@@ -34,6 +34,9 @@ module Honeybadger
   def_delegator :'Honeybadger::Agent.instance', :exception_filter
   def_delegator :'Honeybadger::Agent.instance', :exception_fingerprint
   def_delegator :'Honeybadger::Agent.instance', :backtrace_filter
+  def_delegator :'Honeybadger::Agent.instance', :add_breadcrumb
+  def_delegator :'Honeybadger::Agent.instance', :breadcrumbs
+  def_delegator :'Honeybadger::Agent.instance', :clear!
 
   # @!macro [attach] def_delegator
   #   @!method $2(...)

data/lib/honeybadger/util/sql.rb

@@ -0,0 +1,25 @@
+module Honeybadger
+  module Util
+    class SQL
+      EscapedQuotes = /(\\"|\\')/.freeze
+      SQuotedData = /'(?:[^']|'')*'/.freeze
+      DQuotedData = /"(?:[^"]|"")*"/.freeze
+      NumericData = /\b\d+\b/.freeze
+      Newline = /\n/.freeze
+      Replacement = "?".freeze
+      EmptyReplacement = "".freeze
+      DoubleQuoters = /(postgres|sqlite|postgis)/.freeze
+
+      def self.obfuscate(sql, adapter)
+        sql.dup.tap do |s|
+          s.gsub!(EscapedQuotes, EmptyReplacement)
+          s.gsub!(SQuotedData, Replacement)
+          s.gsub!(DQuotedData, Replacement) if adapter =~ DoubleQuoters
+          s.gsub!(NumericData, Replacement)
+          s.gsub!(Newline, EmptyReplacement)
+          s.squeeze!(' ')
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # The current String Honeybadger version.
-  VERSION = '4.3.1'.freeze
+  VERSION = '4.4.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 4.3.1
+  version: 4.4.0
 platform: ruby
 authors:
 - Honeybadger Industries LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-31 00:00:00.000000000 Z
+date: 2019-07-25 00:00:00.000000000 Z
 dependencies: []
 description: Make managing application errors a more pleasant experience.
 email:
@@ -32,6 +32,12 @@ files:
 - lib/honeybadger/backend/server.rb
 - lib/honeybadger/backend/test.rb
 - lib/honeybadger/backtrace.rb
+- lib/honeybadger/breadcrumbs.rb
+- lib/honeybadger/breadcrumbs/active_support.rb
+- lib/honeybadger/breadcrumbs/breadcrumb.rb
+- lib/honeybadger/breadcrumbs/collector.rb
+- lib/honeybadger/breadcrumbs/logging.rb
+- lib/honeybadger/breadcrumbs/ring_buffer.rb
 - lib/honeybadger/cli.rb
 - lib/honeybadger/cli/deploy.rb
 - lib/honeybadger/cli/exec.rb
@@ -56,6 +62,7 @@ files:
 - lib/honeybadger/logging.rb
 - lib/honeybadger/notice.rb
 - lib/honeybadger/plugin.rb
+- lib/honeybadger/plugins/breadcrumbs.rb
 - lib/honeybadger/plugins/delayed_job.rb
 - lib/honeybadger/plugins/delayed_job/plugin.rb
 - lib/honeybadger/plugins/local_variables.rb
@@ -79,6 +86,7 @@ files:
 - lib/honeybadger/util/request_payload.rb
 - lib/honeybadger/util/revision.rb
 - lib/honeybadger/util/sanitizer.rb
+- lib/honeybadger/util/sql.rb
 - lib/honeybadger/util/stats.rb
 - lib/honeybadger/version.rb
 - lib/honeybadger/worker.rb