rollbar 2.22.1 → 3.4.0

data/lib/rollbar/item/backtrace.rb

@@ -3,11 +3,7 @@ require 'rollbar/item/frame'
 module Rollbar
   class Item
     class Backtrace
-      attr_reader :exception
-      attr_reader :message
-      attr_reader :extra
-      attr_reader :configuration
-      attr_reader :files
+      attr_reader :exception, :message, :extra, :configuration, :files
 
       private :files
 
@@ -54,7 +50,10 @@ module Rollbar
 
         current_exception = exception
 
-        while current_exception.respond_to?(:cause) && (cause = current_exception.cause) && cause.is_a?(Exception) && !visited.include?(cause)
+        while current_exception.respond_to?(:cause) &&
+              (cause = current_exception.cause) &&
+              cause.is_a?(Exception) &&
+              !visited.include?(cause)
           traces << trace_data(cause)
           visited << cause
           current_exception = cause
@@ -74,10 +73,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:
@@ -90,7 +99,9 @@ module Rollbar
       # are those from the user's Rollbar.error line until this method. We want
       # to remove those lines.
       def exception_backtrace(current_exception)
-        return current_exception.backtrace if current_exception.backtrace.respond_to?(:map)
+        if current_exception.backtrace.respond_to?(:map)
+          return current_exception.backtrace
+        end
         return [] unless configuration.populate_empty_backtraces
 
         caller_backtrace = caller
@@ -99,7 +110,8 @@ module Rollbar
       end
 
       def rollbar_lib_gem_dir
-        Gem::Specification.find_by_name('rollbar').gem_dir + '/lib'
+        gem_dir = Gem::Specification.find_by_name('rollbar').gem_dir
+        "#{gem_dir}/lib"
       end
     end
   end

data/lib/rollbar/item/frame.rb

@@ -6,9 +6,7 @@ module Rollbar
   class Item
     # Representation of the trace data per frame in the payload
     class Frame
-      attr_reader :backtrace
-      attr_reader :frame
-      attr_reader :configuration
+      attr_reader :backtrace, :frame, :configuration
 
       MAX_CONTEXT_LENGTH = 4
 
@@ -97,12 +95,15 @@ 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
+        number_of_lines = [from_line + MAX_CONTEXT_LENGTH,
+                           file_lines.size].min - from_line
 
         file_lines[from_line, number_of_lines]
       end
@@ -111,7 +112,9 @@ module Rollbar
         to_line = lineno - 2
         from_line = [to_line - MAX_CONTEXT_LENGTH + 1, 0].max
 
-        file_lines[from_line, (to_line - from_line + 1)].select { |line| line && !line.empty? }
+        file_lines[from_line, (to_line - from_line + 1)].select do |line|
+          line && !line.empty?
+        end
       end
     end
   end

data/lib/rollbar/item/locals.rb

@@ -1,5 +1,5 @@
-require 'rollbar/notifier'
 require 'rollbar/scrubbers/params'
+require 'rollbar/util'
 
 module Rollbar
   class Item
@@ -32,6 +32,8 @@ module Rollbar
         end
 
         def locals_for(frame)
+          return {} unless frame
+
           {}.tap do |hash|
             frame.local_variables.map do |var|
               hash[var] = prepare_value(frame.local_variable_get(var))
@@ -39,8 +41,53 @@ 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
+          unless value.is_a?(Hash) || value.is_a?(Array)
+            return simple_value?(value) ? value : value.inspect
+          end
+
+          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

@@ -23,24 +23,15 @@ module Rollbar
 
     attr_writer :payload
 
-    attr_reader :level
-    attr_reader :message
-    attr_reader :exception
-    attr_reader :extra
-
-    attr_reader :configuration
-    attr_reader :scope
-    attr_reader :logger
-    attr_reader :notifier
-
-    attr_reader :context
+    attr_reader :level, :message, :exception, :extra, :configuration, :scope, :logger,
+                :notifier, :context
 
     def_delegators :payload, :[]
 
     class << self
       def build_with(payload, options = {})
         new(options).tap do |item|
-          item.payload = payload
+          item.payload = item.add_access_token_to_payload(payload)
         end
       end
     end
@@ -64,10 +55,7 @@ module Rollbar
 
     def build
       data = build_data
-      self.payload = {
-        'access_token' => configuration.access_token,
-        'data' => data
-      }
+      self.payload = add_access_token_to_payload({ 'data' => data })
 
       enforce_valid_utf8
       transform
@@ -75,7 +63,22 @@ module Rollbar
     end
 
     def build_data
-      data = {
+      data = initial_data
+
+      build_optional_data(data)
+
+      Util.deep_merge(data, configuration.payload_options)
+      Util.deep_merge(data, scope)
+
+      # Our API doesn't allow null context values, so just delete
+      # the key if value is nil.
+      data.delete(:context) unless data[:context]
+
+      data
+    end
+
+    def initial_data
+      {
         :timestamp => Time.now.to_i,
         :environment => build_environment,
         :level => level,
@@ -89,35 +92,33 @@ module Rollbar
         },
         :body => build_body
       }
-      data[:project_package_paths] = configuration.project_gem_paths if configuration.project_gem_paths.any?
-      data[:code_version] = configuration.code_version if configuration.code_version
-      data[:uuid] = SecureRandom.uuid if defined?(SecureRandom) && SecureRandom.respond_to?(:uuid)
+    end
 
-      Util.deep_merge(data, configuration.payload_options)
-      Util.deep_merge(data, scope)
+    def build_optional_data(data)
+      if configuration.project_gem_paths.any?
+        data[:project_package_paths] = configuration.project_gem_paths
+      end
 
-      # Our API doesn't allow null context values, so just delete
-      # the key if value is nil.
-      data.delete(:context) unless data[:context]
+      data[:code_version] = configuration.code_version if configuration.code_version
 
-      data
+      return unless defined?(SecureRandom) && SecureRandom.respond_to?(:uuid)
+
+      data[:uuid] = SecureRandom.uuid
     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.
+      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
+        # that 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
@@ -137,22 +138,28 @@ module Rollbar
       nil
     end
 
-    def handle_too_large_payload(stringified_payload, final_payload, attempts)
+    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(
-        too_large_payload_string(attempts),
-        nil,
-        uuid,
-        host
-      )
-      logger.error("[Rollbar] Payload too large to be sent for UUID #{uuid}: #{Rollbar::JSON.dump(payload)}")
+      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}"
+        "Original size: #{attempts.first} Attempts: #{attempts.join(', ')} " \
+        "Final size: #{attempts.last}"
     end
 
     def ignored?
@@ -164,6 +171,22 @@ module Rollbar
       configuration.ignored_person_ids.include?(person_id)
     end
 
+    def add_access_token_to_payload(payload)
+      # Some use cases remain where the token is needed in the payload. For example:
+      #
+      # When using async senders, if the access token is changed dynamically in
+      # the main process config, the sender process won't see that change.
+      #
+      # Until the delayed sender interface is changed to allow passing dynamic
+      # config options, this workaround allows the main process to set the token
+      # by adding it to the payload.
+      if configuration && configuration.use_payload_access_token
+        payload['access_token'] ||= configuration.access_token
+      end
+
+      payload
+    end
+
     private
 
     def build_environment
@@ -187,13 +210,20 @@ 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)
+        # avoid putting an empty {} in the payload.
+        merged_extra.empty? ? nil : merged_extra
       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,8 +1,9 @@
 require 'rollbar/language_support'
+require 'json'
 
 module Rollbar
   module JSON # :nodoc:
-    extend self
+    module_function
 
     attr_writer :options_module
 

data/lib/rollbar/language_support.rb

@@ -10,10 +10,6 @@ module Rollbar
       mod.const_get(target, inherit)
     end
 
-    def ruby_19?
-      version?('1.9')
-    end
-
     def version?(version)
       numbers = version.split('.')
 
@@ -21,8 +17,6 @@ module Rollbar
     end
 
     def timeout_exceptions
-      return [] if ruby_19?
-
       [Net::ReadTimeout, Net::OpenTimeout]
     end
   end

data/lib/rollbar/lazy_store.rb

@@ -1,10 +1,8 @@
 module Rollbar
   class LazyStore
-    attr_reader :loaded_data
+    attr_reader :loaded_data, :raw
     private :loaded_data
 
-    attr_reader :raw
-
     def initialize(initial_data)
       initial_data ||= {}
 
@@ -41,8 +39,6 @@ module Rollbar
       raw[key] = value
 
       loaded_data.delete(key)
-
-      value
     end
 
     def data
@@ -76,8 +72,8 @@ module Rollbar
       super
     end
 
-    def respond_to?(method_sym)
-      super || raw.respond_to?(method_sym)
+    def respond_to_missing?(method_sym, include_all)
+      raw.respond_to?(method_sym, include_all)
     end
   end
 end

data/lib/rollbar/logger.rb

@@ -16,7 +16,9 @@ module Rollbar
   # Rails.logger.extend(ActiveSupport::Logger.broadcast(Rollbar::Logger.new))
   class Logger < ::Logger
     class Error < RuntimeError; end
+
     class DatetimeFormatNotSupported < Error; end
+
     class FormatterNotSupported < Error; end
 
     def initialize

data/lib/rollbar/logger_proxy.rb

@@ -23,7 +23,9 @@ module Rollbar
     end
 
     def log(level, message)
-      return unless Rollbar.configuration.enabled && acceptable_levels.include?(level.to_sym)
+      unless Rollbar.configuration.enabled && acceptable_levels.include?(level.to_sym)
+        return
+      end
 
       @object.send(level, message)
     rescue StandardError

data/lib/rollbar/middleware/js/json_value.rb

@@ -1,8 +1,12 @@
-# Allows a Ruby String to be used to create native Javascript objects
-# when calling JSON#generate.
+# Allows a Ruby String to be used to pass native Javascript objects/functions
+# when calling JSON#generate with a Rollbar::JSON::JsOptionsState instance.
 #
 # Example:
-# JSON.generate({ foo: Rollbar::JSON::Value.new('function(){ alert("bar") }') })
+# JSON.generate(
+#   { foo: Rollbar::JSON::Value.new('function(){ alert("bar") }') },
+#   Rollbar::JSON::JsOptionsState.new
+# )
+#
 # => '{"foo":function(){ alert(\"bar\") }}'
 #
 # MUST use the Ruby JSON encoder, as in the example. The ActiveSupport encoder,
@@ -11,6 +15,8 @@
 #
 module Rollbar
   module JSON
+    class JsOptionsState < ::JSON::State; end
+
     class Value # :nodoc:
       attr_accessor :value
 
@@ -18,8 +24,12 @@ module Rollbar
         @value = value
       end
 
-      def to_json(*_args)
-        value
+      def to_json(opts = {})
+        # Return the raw value if this is from the js middleware
+        return value if opts.class == Rollbar::JSON::JsOptionsState
+
+        # Otherwise convert to a string
+        %Q["#{value}"]
       end
     end
   end