rollbar 2.22.1 → 2.27.1

data/lib/rollbar/delay/sidekiq.rb

@@ -17,10 +17,8 @@ module Rollbar
 
       def perform(*args)
         Rollbar.process_from_async_handler(*args)
-      rescue StandardError
-        # Raise the exception so Sidekiq can track the errored job
-        # and retry it
-        raise
+
+        # Do not rescue. Sidekiq will call the error handler.
       end
     end
   end

data/lib/rollbar/delay/sucker_punch.rb

@@ -33,7 +33,7 @@ module Rollbar
 
       def perform(*args)
         Rollbar.process_from_async_handler(*args)
-      rescue StandardError
+
         # SuckerPunch can configure an exception handler with:
         #
         # SuckerPunch.exception_handler { # do something here }
@@ -41,9 +41,8 @@ module Rollbar
         # This is just passed to Celluloid.exception_handler which will
         # push the reiceved block to an array of handlers, by default empty, [].
         #
-        # We reraise the exception here casue it's safe and users could have defined
-        # their own exception handler for SuckerPunch
-        raise
+
+        # Do not rescue. SuckerPunch will call the error handler.
       end
     end
   end

data/lib/rollbar/delay/thread.rb

@@ -9,7 +9,10 @@ module Rollbar
       Error        = Class.new(StandardError)
       TimeoutError = Class.new(Error)
 
+      DEFAULT_PRIORITY = 1
+
       class << self
+        attr_writer :options
         attr_reader :reaper
 
         def call(payload)
@@ -20,6 +23,10 @@ module Rollbar
           thread
         end
 
+        def options
+          @options || {}
+        end
+
         private
 
         def threads
@@ -61,9 +68,16 @@ module Rollbar
         end
       end # class << self
 
+      def priority
+        self.class.options[:priority] || DEFAULT_PRIORITY
+      end
+
       def call(payload)
+        priority = self.priority
+
         ::Thread.new do
           begin
+            ::Thread.current.priority = priority
             Rollbar.process_from_async_handler(payload)
           rescue StandardError
             # Here we swallow the exception:

data/lib/rollbar/deploy.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module Rollbar
   # Deploy Tracking API wrapper module
   module Deploy

data/lib/rollbar/encoding/encoder.rb

@@ -3,7 +3,6 @@ module Rollbar
     class Encoder
       ALL_ENCODINGS = [::Encoding::UTF_8, ::Encoding::ISO_8859_1, ::Encoding::ASCII_8BIT, ::Encoding::US_ASCII].freeze
       ASCII_ENCODINGS = [::Encoding::US_ASCII, ::Encoding::ASCII_8BIT, ::Encoding::ISO_8859_1].freeze
-      ENCODING_OPTIONS = { :invalid => :replace, :undef => :replace, :replace => '' }.freeze
       UTF8 = 'UTF-8'.freeze
       BINARY = 'binary'.freeze
 
@@ -21,10 +20,19 @@ module Rollbar
         encoded_value = if encoding == ::Encoding::UTF_8 && value.valid_encoding?
                           value
                         else
-                          force_encoding(value).encode(*encoding_args(value))
+                          force_encoding(value).encode(
+                            *encoding_args(value),
+                            # Ruby 2.7 requires this to look like keyword args,
+                            # and Ruby 1.9.3 doesn't understand keyword args, so
+                            # don't use hash rockets here and both will be happy.
+                            invalid: :replace, undef: :replace, replace: '' # rubocop:disable Style/HashSyntax
+                          )
                         end
 
         object.is_a?(Symbol) ? encoded_value.to_sym : encoded_value
+      rescue StandardError => e
+        # If encoding fails for any reason, replace the string with a diagnostic error.
+        "error encoding string: #{e.class}: #{e.message}"
       end
 
       private
@@ -54,7 +62,6 @@ module Rollbar
       def encoding_args(value)
         args = [UTF8]
         args << BINARY if ASCII_ENCODINGS.include?(value.encoding)
-        args << ENCODING_OPTIONS
 
         args
       end

data/lib/rollbar/item/backtrace.rb

@@ -74,10 +74,20 @@ module Rollbar
       end
 
       def map_frames(current_exception)
-        exception_backtrace(current_exception).map do |frame|
+        frames = cleaned_backtrace(current_exception).map do |frame|
           Rollbar::Item::Frame.new(self, frame,
                                    :configuration => configuration).to_h
-        end.reverse
+        end
+        frames.reverse!
+      end
+
+      def cleaned_backtrace(current_exception)
+        normalized_backtrace = exception_backtrace(current_exception)
+        if configuration.backtrace_cleaner
+          configuration.backtrace_cleaner.clean(normalized_backtrace)
+        else
+          normalized_backtrace
+        end
       end
 
       # Returns the backtrace to be sent to our API. There are 3 options:

data/lib/rollbar/item/frame.rb

@@ -97,6 +97,8 @@ module Rollbar
       end
 
       def locals_data(filename, lineno)
+        return unless configuration.locals[:enabled]
+
         ::Rollbar::Item::Locals.locals_for_location(filename, lineno)
       end
 

data/lib/rollbar/item/locals.rb

@@ -1,5 +1,6 @@
 require 'rollbar/notifier'
 require 'rollbar/scrubbers/params'
+require 'rollbar/util'
 
 module Rollbar
   class Item
@@ -39,8 +40,51 @@ module Rollbar
           end
         end
 
+        # Prepare objects to be handled by the payload serializer.
+        #
+        # Hashes and Arrays are traversed. Then all types execpt strings and
+        # immediates are exported using #inspect. Sending the object itself to the
+        # serializer can result in large recursive expansions, especially in Rails
+        # environments with ActiveRecord, ActiveSupport, etc. on the stack.
+        # Other export options could be #to_s, #to_h, and #as_json. Several of these
+        # will omit the class name, or are not implemented for many types.
+        #
+        # #inspect has the advantage that it is specifically intended for debugging
+        # output. If the user wants more or different information in the payload
+        # about a specific type, #inspect is the correct place to implement it.
+        # Likewise the default implementation should be oriented toward usefulness
+        # in debugging.
+        #
+        # Because #inspect outputs a string, it can be handled well by the string
+        # truncation strategy for large payloads.
+        #
         def prepare_value(value)
-          value.to_s
+          return simple_value?(value) ? value : value.inspect unless value.is_a?(Hash) || value.is_a?(Array)
+
+          cloned_value = ::Rollbar::Util.deep_copy(value)
+          ::Rollbar::Util.iterate_and_update_with_block(cloned_value) do |v|
+            simple_value?(v) ? v : v.inspect
+          end
+
+          cloned_value
+        end
+
+        def simple_classes
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.4.0')
+            [String, Symbol, Integer, Float, TrueClass, FalseClass, NilClass]
+          else
+            [String, Symbol, Fixnum, Bignum, Float, TrueClass, FalseClass, NilClass] # rubocop:disable Lint/UnifiedInteger
+          end
+        end
+
+        def simple_value?(value)
+          simple_classes.each do |klass|
+            # Use instance_of? so that subclasses and module containers will
+            # be treated like complex object types, not simple values.
+            return true if value.instance_of?(klass)
+          end
+
+          false
         end
 
         def scrub(hash)

data/lib/rollbar/item.rb

@@ -65,7 +65,6 @@ module Rollbar
     def build
       data = build_data
       self.payload = {
-        'access_token' => configuration.access_token,
         'data' => data
       }
 
@@ -109,15 +108,11 @@ module Rollbar
         # the risk just to send this diagnostic object. In versions < 4.1, ActiveSupport hooks
         # Ruby's JSON.generate so deeply there's no workaround.
         'not serialized in ActiveSupport < 4.1'
-      elsif configuration.use_async
-        # Currently serialization is performed by each handler, and this invariably
-        # means it is actually performed by ActiveSupport.
-        #
-        # TODO: Since serialization must be done prior to scheduling the job,
-        # it should at least be done by rollbar-gem itself. Much work has been done
-        # to avoid the bugs in ActiveSupport JSON. The async handlers are currently
-        # still subject to all those knnown issues.
-        'not serialized for async/delayed handlers'
+      elsif configuration.use_async && !configuration.async_json_payload
+        # The setting allows serialization to be performed by each handler,
+        # and this usually means it is actually performed by ActiveSupport,
+        # which cannot safely serialize this key.
+        'not serialized when async_json_payload is not set'
       else
         scrub(configuration.configured_options.configured)
       end
@@ -141,11 +136,18 @@ module Rollbar
       uuid = stringified_payload['data']['uuid']
       host = stringified_payload['data'].fetch('server', {})['host']
 
+      original_error = {
+        :message => message,
+        :exception => exception,
+        :configuration => configuration,
+        :uuid => uuid,
+        :host => host
+      }
+
       notifier.send_failsafe(
         too_large_payload_string(attempts),
         nil,
-        uuid,
-        host
+        original_error
       )
       logger.error("[Rollbar] Payload too large to be sent for UUID #{uuid}: #{Rollbar::JSON.dump(payload)}")
     end
@@ -187,13 +189,19 @@ module Rollbar
     end
 
     def build_extra
+      merged_extra = Util.deep_merge(scrub(extra), scrub(error_context))
+
       if custom_data_method? && !Rollbar::Util.method_in_stack(:custom_data, __FILE__)
-        Util.deep_merge(scrub(custom_data), scrub(extra) || {})
+        Util.deep_merge(scrub(custom_data), merged_extra)
       else
-        scrub(extra)
+        merged_extra.empty? ? nil : merged_extra # avoid putting an empty {} in the payload.
       end
     end
 
+    def error_context
+      exception.respond_to?(:rollbar_context) && exception.rollbar_context
+    end
+
     def scrub(data)
       return data unless data.is_a? Hash
 

data/lib/rollbar/json.rb

@@ -1,4 +1,5 @@
 require 'rollbar/language_support'
+require 'json'
 
 module Rollbar
   module JSON # :nodoc:

data/lib/rollbar/middleware/js.rb

@@ -80,10 +80,18 @@ module Rollbar
         return app_result unless response_string
 
         env[JS_IS_INJECTED_KEY] = true
-        response = ::Rack::Response.new(response_string, app_result[0],
-                                        app_result[1])
 
-        response.finish
+        status, headers, = app_result
+        headers['Content-Length'] = response_string.bytesize.to_s if headers.key?('Content-Length')
+
+        response = ::Rack::Response.new(response_string, status, headers)
+
+        finished = response.finish
+
+        # Rack < 2.x Response#finish returns self in array[2]. Rack >= 2.x returns self.body.
+        # Always return with the response object here regardless of rack version.
+        finished[2] = response
+        finished
       end
 
       def build_body_with_js(env, body, head_open_end)
@@ -116,6 +124,8 @@ module Rollbar
       end
 
       def config_js_tag(env)
+        require 'json'
+
         js_config = Rollbar::Util.deep_copy(config[:options])
 
         add_person_data(js_config, env)