rollbar 2.19.1 → 2.27.1

data/lib/rollbar/encoding/encoder.rb

@@ -1,9 +1,8 @@
 module Rollbar
   module Encoding
     class Encoder
-      ALL_ENCODINGS = [::Encoding::UTF_8, ::Encoding::ISO_8859_1, ::Encoding::ASCII_8BIT, ::Encoding::US_ASCII]
-      ASCII_ENCODINGS = [::Encoding::US_ASCII, ::Encoding::ASCII_8BIT, ::Encoding::ISO_8859_1]
-      ENCODING_OPTIONS = { :invalid => :replace, :undef => :replace, :replace => '' }
+      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
       UTF8 = 'UTF-8'.freeze
       BINARY = 'binary'.freeze
 
@@ -18,13 +17,22 @@ module Rollbar
         encoding = value.encoding
 
         # This will be most of cases so avoid force anything for them
-        if encoding == ::Encoding::UTF_8 && value.valid_encoding?
-          encoded_value = value
-        else
-          encoded_value = force_encoding(value).encode(*encoding_args(value))
-        end
+        encoded_value = if encoding == ::Encoding::UTF_8 && value.valid_encoding?
+                          value
+                        else
+                          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
@@ -45,7 +53,7 @@ module Rollbar
             # Seems #codepoints is faster than #valid_encoding?
             value.force_encoding(encoding).encode(::Encoding::UTF_8).codepoints
             true
-          rescue
+          rescue StandardError
             false
           end
         end
@@ -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/exception_reporter.rb

@@ -1,10 +1,11 @@
 module Rollbar
-  module ExceptionReporter
+  module ExceptionReporter # :nodoc:
     def report_exception_to_rollbar(env, exception)
-      exception_message = exception.respond_to?(:message) ? exception.message : 'No Exception Message'
-      Rollbar.log_debug "[Rollbar] Reporting exception: #{exception_message}"
+      return unless capture_uncaught?
+
+      log_exception_message(exception)
 
-      exception_data = Rollbar.log(Rollbar.configuration.uncaught_exception_level, exception, :use_exception_level_filters => true)
+      exception_data = exception_data(exception)
 
       if exception_data.is_a?(Hash)
         env['rollbar.exception_uuid'] = exception_data[:uuid]
@@ -14,8 +15,21 @@ module Rollbar
       elsif exception_data == 'ignored'
         Rollbar.log_debug '[Rollbar] Exception not reported because it was ignored'
       end
-    rescue => e
+    rescue StandardError => e
       Rollbar.log_warning "[Rollbar] Exception while reporting exception to Rollbar: #{e.message}"
     end
+
+    def capture_uncaught?
+      Rollbar.configuration.capture_uncaught != false
+    end
+
+    def log_exception_message(exception)
+      exception_message = exception.respond_to?(:message) ? exception.message : 'No Exception Message'
+      Rollbar.log_debug "[Rollbar] Reporting exception: #{exception_message}"
+    end
+
+    def exception_data(exception)
+      Rollbar.log(Rollbar.configuration.uncaught_exception_level, exception, :use_exception_level_filters => true)
+    end
   end
 end

data/lib/rollbar/item/backtrace.rb

@@ -32,7 +32,7 @@ module Rollbar
         end
       end
 
-      alias_method :build, :to_h
+      alias build to_h
 
       def get_file_lines(filename)
         files[filename] ||= read_file(filename)
@@ -44,7 +44,7 @@ module Rollbar
         return unless File.exist?(filename)
 
         File.read(filename).split("\n")
-      rescue
+      rescue StandardError
         nil
       end
 
@@ -74,10 +74,20 @@ module Rollbar
       end
 
       def map_frames(current_exception)
-        exception_backtrace(current_exception).reverse.map do |frame|
+        frames = cleaned_backtrace(current_exception).map do |frame|
           Rollbar::Item::Frame.new(self, frame,
                                    :configuration => configuration).to_h
         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

@@ -1,5 +1,6 @@
 # We want to use Gem.path
 require 'rubygems'
+require 'rollbar/item/locals'
 
 module Rollbar
   class Item
@@ -47,7 +48,8 @@ module Rollbar
 
         {
           :code => code_data(file_lines, lineno),
-          :context => context_data(file_lines, lineno)
+          :context => context_data(file_lines, lineno),
+          :locals => locals_data(filename, lineno)
         }
       end
 
@@ -94,6 +96,12 @@ module Rollbar
         }
       end
 
+      def locals_data(filename, lineno)
+        return unless configuration.locals[:enabled]
+
+        ::Rollbar::Item::Locals.locals_for_location(filename, lineno)
+      end
+
       def post_data(file_lines, lineno)
         from_line = lineno
         number_of_lines = [from_line + MAX_CONTEXT_LENGTH, file_lines.size].min - from_line

data/lib/rollbar/item/locals.rb

@@ -0,0 +1,100 @@
+require 'rollbar/notifier'
+require 'rollbar/scrubbers/params'
+require 'rollbar/util'
+
+module Rollbar
+  class Item
+    class Locals # :nodoc:
+      class << self
+        def exception_frames
+          Rollbar.notifier.exception_bindings
+        end
+
+        def locals_for_location(filename, lineno)
+          if (frame = frame_for_location(filename, lineno))
+            scrub(locals_for(frame[:binding]))
+          else
+            {}
+          end
+        end
+
+        def frame_for_location(filename, lineno)
+          while (frame = exception_frames.pop)
+            return nil unless frame
+            return frame if matching_frame?(frame, filename, lineno)
+          end
+          nil
+        end
+
+        private
+
+        def matching_frame?(frame, filename, lineno)
+          frame[:path] == filename && frame[:lineno].to_i <= lineno.to_i
+        end
+
+        def locals_for(frame)
+          {}.tap do |hash|
+            frame.local_variables.map do |var|
+              hash[var] = prepare_value(frame.local_variable_get(var))
+            end
+          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)
+          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)
+          Rollbar::Scrubbers::Params.call(
+            :params => hash,
+            :config => Rollbar.configuration.scrub_fields,
+            :whitelist => Rollbar.configuration.scrub_whitelist
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/item.rb

@@ -12,6 +12,7 @@ require 'rollbar/util'
 require 'rollbar/encoding'
 require 'rollbar/truncation'
 require 'rollbar/json'
+require 'rollbar/scrubbers/params'
 
 module Rollbar
   # This class represents the payload to be sent to the API.
@@ -64,7 +65,6 @@ module Rollbar
     def build
       data = build_data
       self.payload = {
-        'access_token' => configuration.access_token,
         'data' => data
       }
 
@@ -83,7 +83,8 @@ module Rollbar
         :server => server_data,
         :notifier => {
           :name => 'rollbar-gem',
-          :version => VERSION
+          :version => VERSION,
+          :configured_options => configured_options
         },
         :body => build_body
       }
@@ -101,29 +102,61 @@ module Rollbar
       data
     end
 
+    def configured_options
+      if Gem.loaded_specs['activesupport'] && Gem.loaded_specs['activesupport'].version < Gem::Version.new('4.1')
+        # There are too many types that crash ActiveSupport JSON serialization, and not worth
+        # 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 && !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
+    end
+
     def dump
       # Ensure all keys are strings since we can receive the payload inline or
       # from an async handler job, which can be serialized.
       stringified_payload = Util::Hash.deep_stringify_keys(payload)
-      result = Truncation.truncate(stringified_payload)
+      attempts = []
+      result = Truncation.truncate(stringified_payload, attempts)
 
       return result unless Truncation.truncate?(result)
 
-      handle_too_large_payload(stringified_payload, result)
+      handle_too_large_payload(stringified_payload, result, attempts)
 
       nil
     end
 
-    def handle_too_large_payload(stringified_payload, final_payload)
-      original_size = Rollbar::JSON.dump(stringified_payload).bytesize
-      final_size = final_payload.bytesize
+    def handle_too_large_payload(stringified_payload, final_payload, attempts)
       uuid = stringified_payload['data']['uuid']
       host = stringified_payload['data'].fetch('server', {})['host']
 
-      notifier.send_failsafe("Could not send payload due to it being too large after truncating attempts. Original size: #{original_size} Final size: #{final_size}", nil, uuid, host)
+      original_error = {
+        :message => message,
+        :exception => exception,
+        :configuration => configuration,
+        :uuid => uuid,
+        :host => host
+      }
+
+      notifier.send_failsafe(
+        too_large_payload_string(attempts),
+        nil,
+        original_error
+      )
       logger.error("[Rollbar] Payload too large to be sent for UUID #{uuid}: #{Rollbar::JSON.dump(payload)}")
     end
 
+    def too_large_payload_string(attempts)
+      'Could not send payload due to it being too large after truncating attempts. ' \
+        "Original size: #{attempts.first} Attempts: #{attempts.join(', ')} Final size: #{attempts.last}"
+    end
+
     def ignored?
       data = payload['data']
 
@@ -156,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
 
@@ -179,14 +218,14 @@ module Rollbar
     end
 
     def custom_data
-      if configuration.custom_data_method.arity == 3
-        data = configuration.custom_data_method.call(message, exception, context)
-      else
-        data = configuration.custom_data_method.call
-      end
+      data = if configuration.custom_data_method.arity == 3
+               configuration.custom_data_method.call(message, exception, context)
+             else
+               configuration.custom_data_method.call
+             end
 
       Rollbar::Util.deep_copy(data)
-    rescue => e
+    rescue StandardError => e
       return {} if configuration.safely?
 
       report_custom_data_error(e)
@@ -231,7 +270,7 @@ module Rollbar
       handlers.each do |handler|
         begin
           handler.call(transform_options)
-        rescue => e
+        rescue StandardError => e
           logger.error("[Rollbar] Error calling the `transform` hook: #{e}")
 
           break

data/lib/rollbar/json.rb

@@ -1,65 +1,20 @@
-require 'multi_json'
-require 'rollbar/json/oj'
-require 'rollbar/json/default'
 require 'rollbar/language_support'
-
-begin
-  require 'oj'
-rescue LoadError
-end
+require 'json'
 
 module Rollbar
-  module JSON
+  module JSON # :nodoc:
     extend self
 
     attr_writer :options_module
 
     def dump(object)
-      with_adapter { MultiJson.dump(object, adapter_options) }
-    end
-
-    def load(string)
-      with_adapter { MultiJson.load(string, adapter_options) }
-    end
-
-    def with_adapter(&block)
-      MultiJson.with_adapter(detect_multi_json_adapter, &block)
-    end
-
-    def detect_multi_json_adapter
-      options = {}
-      options[:adapter] = :oj if defined?(::Oj)
-
-      MultiJson.current_adapter(options)
-    end
-
-    def adapter_options
-      options_module.options
-    end
-
-    def options_module
-      @options_module ||= find_options_module
-    end
-
-    def find_options_module
-      module_name = multi_json_adapter_module_name
-
-      if LanguageSupport.const_defined?(Rollbar::JSON, module_name, false)
-        LanguageSupport.const_get(Rollbar::JSON, module_name, false)
-      else
-        Default
+      Rollbar.plugins.get('basic_socket').load_scoped!(true) do
+        ::JSON.generate(object)
       end
     end
 
-    # MultiJson adapters have this name structure:
-    # "MultiJson::Adapters::{AdapterModule}"
-    #
-    # Ex: MultiJson::Adapters::Oj
-    # Ex: MultiJson::Adapters::JsonGem
-    #
-    # In this method we just get the last module name.
-    def multi_json_adapter_module_name
-      detect_multi_json_adapter.name[/^MultiJson::Adapters::(.*)$/, 1]
+    def load(string)
+      ::JSON.parse(string)
     end
   end
 end

data/lib/rollbar/language_support.rb

@@ -1,29 +1,13 @@
 module Rollbar
   module LanguageSupport
-    extend self
+    module_function
 
     def const_defined?(mod, target, inherit = true)
-      if ruby_18?
-        mod.const_defined?(target)
-      else
-        mod.const_defined?(target, inherit)
-      end
+      mod.const_defined?(target, inherit)
     end
 
     def const_get(mod, target, inherit = true)
-      if ruby_18?
-        mod.const_get(target)
-      else
-        mod.const_get(target, inherit)
-      end
-    end
-
-    def can_scrub_url?
-      !version?('1.8')
-    end
-
-    def ruby_18?
-      version?('1.8')
+      mod.const_get(target, inherit)
     end
 
     def ruby_19?
@@ -37,7 +21,7 @@ module Rollbar
     end
 
     def timeout_exceptions
-      return [] if ruby_18? || ruby_19?
+      return [] if ruby_19?
 
       [Net::ReadTimeout, Net::OpenTimeout]
     end

data/lib/rollbar/lazy_store.rb

@@ -21,11 +21,11 @@ module Rollbar
     end
 
     def ==(other)
-      if other.is_a?(self.class)
-        raw == other.raw
-      else
-        raw == other
-      end
+      raw == if other.is_a?(self.class)
+               other.raw
+             else
+               other
+             end
     end
 
     # With this version of clone we ensure that the loaded_data is empty

data/lib/rollbar/logger.rb

@@ -67,6 +67,7 @@ module Rollbar
 
     def blank?(message)
       return message.blank? if message.respond_to?(:blank?)
+
       message.respond_to?(:empty?) ? !!message.empty? : !message
     end
 

data/lib/rollbar/logger_proxy.rb

@@ -26,7 +26,7 @@ module Rollbar
       return unless Rollbar.configuration.enabled && acceptable_levels.include?(level.to_sym)
 
       @object.send(level, message)
-    rescue
+    rescue StandardError
       puts "[Rollbar] Error logging #{level}:"
       puts "[Rollbar] #{message}"
     end
@@ -36,7 +36,11 @@ module Rollbar
     def acceptable_levels
       @acceptable_levels ||= begin
         levels = [:debug, :info, :warn, :error]
-        levels[levels.find_index(Rollbar.configuration.logger_level)..-1]
+        if Rollbar.configuration.logger_level
+          levels[levels.find_index(Rollbar.configuration.logger_level)..-1]
+        else
+          []
+        end
       end
     end
   end

data/lib/rollbar/middleware/js.rb

@@ -13,7 +13,7 @@ module Rollbar
       attr_reader :app
       attr_reader :config
 
-      JS_IS_INJECTED_KEY = 'rollbar.js_is_injected'
+      JS_IS_INJECTED_KEY = 'rollbar.js_is_injected'.freeze
       SNIPPET = File.read(File.expand_path('../../../../data/rollbar.snippet.js', __FILE__))
 
       def initialize(app, config)
@@ -29,7 +29,7 @@ module Rollbar
 
           response_string = add_js(env, app_result[2])
           build_response(env, app_result, response_string)
-        rescue => e
+        rescue StandardError => e
           Rollbar.log_error("[Rollbar] Rollbar.js could not be added because #{e} exception")
 
           app_result
@@ -71,7 +71,7 @@ module Rollbar
         return nil unless insert_after_idx
 
         build_body_with_js(env, body, insert_after_idx)
-      rescue => e
+      rescue StandardError => e
         Rollbar.log_error("[Rollbar] Rollbar.js could not be added because #{e} exception")
         nil
       end
@@ -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)
@@ -189,17 +199,17 @@ module Rollbar
 
         secure_headers_cls = nil
 
-        if !::SecureHeaders::respond_to?(:content_security_policy_script_nonce)
-          secure_headers_cls = SecureHeadersFalse
-        elsif config.respond_to?(:get)
-          secure_headers_cls = SecureHeaders3To5
-        elsif config.dup.respond_to?(:csp)
-          secure_headers_cls = SecureHeaders6
-        else
-          secure_headers_cls = SecureHeadersFalse
-        end
-
-          secure_headers_cls.new
+        secure_headers_cls = if !::SecureHeaders.respond_to?(:content_security_policy_script_nonce)
+                               SecureHeadersFalse
+                             elsif config.respond_to?(:get)
+                               SecureHeaders3To5
+                             elsif config.dup.respond_to?(:csp)
+                               SecureHeaders6
+                             else
+                               SecureHeadersFalse
+                             end
+
+        secure_headers_cls.new
       end
 
       class SecureHeadersResolver
@@ -217,7 +227,7 @@ module Rollbar
           !opt_out?(csp) && !unsafe_inline?(csp)
         end
 
-        def opt_out?(csp)
+        def opt_out?(_csp)
           raise NotImplementedError
         end