rollbar 2.8.3 → 3.6.0

data/lib/rollbar/item.rb

@@ -0,0 +1,314 @@
+require 'socket'
+require 'forwardable'
+
+begin
+  require 'securerandom'
+rescue LoadError
+  nil
+end
+
+require 'rollbar/item/backtrace'
+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.
+  # It contains the logic to build the payload, trucante it
+  # and dump the JSON.
+  class Item
+    extend Forwardable
+
+    attr_writer :payload
+
+    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 = item.add_access_token_to_payload(payload)
+        end
+      end
+    end
+
+    def initialize(options)
+      @level = options[:level]
+      @message = options[:message]
+      @exception = options[:exception]
+      @extra = options[:extra]
+      @configuration = options[:configuration]
+      @logger = options[:logger]
+      @scope = options[:scope]
+      @payload = nil
+      @notifier = options[:notifier]
+      @context = options[:context]
+    end
+
+    def payload
+      @payload ||= build
+    end
+
+    def build
+      data = build_data
+      self.payload = add_access_token_to_payload({ 'data' => data })
+
+      enforce_valid_utf8
+      transform
+      payload
+    end
+
+    def build_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,
+        :language => 'ruby',
+        :framework => configuration.framework,
+        :server => server_data,
+        :notifier => {
+          :name => 'rollbar-gem',
+          :version => VERSION,
+          :configured_options => configured_options
+        },
+        :body => build_body
+      }
+    end
+
+    def build_optional_data(data)
+      if configuration.project_gem_paths.any?
+        data[:project_package_paths] = configuration.project_gem_paths
+      end
+
+      data[:code_version] = configuration.code_version if configuration.code_version
+
+      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
+        # that 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)
+      attempts = []
+      result = Truncation.truncate(stringified_payload, attempts)
+
+      return result unless Truncation.truncate?(result)
+
+      handle_too_large_payload(stringified_payload, result, attempts)
+
+      nil
+    end
+
+    def handle_too_large_payload(stringified_payload, _final_payload, attempts)
+      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, 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']
+
+      return unless data[:person]
+
+      person_id = data[:person][configuration.person_id_method.to_sym]
+      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
+      env = configuration.environment
+      env = 'unspecified' if env.nil? || env.empty?
+
+      env
+    end
+
+    def build_body
+      exception ? build_backtrace_body : build_message_body
+    end
+
+    def build_backtrace_body
+      backtrace = Backtrace.new(exception,
+                                :message => message,
+                                :extra => build_extra,
+                                :configuration => configuration)
+
+      backtrace.to_h
+    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), merged_extra)
+      else
+        # 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
+
+      options = {
+        :params => data,
+        :config => Rollbar.configuration.scrub_fields,
+        :whitelist => Rollbar.configuration.scrub_whitelist
+      }
+      Rollbar::Scrubbers::Params.call(options)
+    end
+
+    def custom_data_method?
+      !!configuration.custom_data_method
+    end
+
+    def custom_data
+      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 StandardError => e
+      return {} if configuration.safely?
+
+      report_custom_data_error(e)
+    end
+
+    def report_custom_data_error(e)
+      data = notifier.safely.error(e)
+
+      return {} unless data.is_a?(Hash) && data[:uuid]
+
+      uuid_url = Util.uuid_rollbar_url(data, configuration)
+
+      { :_error_in_custom_data_method => uuid_url }
+    end
+
+    def build_message_body
+      extra = build_extra
+      result = { :body => message || 'Empty message' }
+      result[:extra] = extra if extra
+
+      { :message => result }
+    end
+
+    def server_data
+      data = {
+        :host => configuration.host || Socket.gethostname
+      }
+      data[:root] = configuration.root.to_s if configuration.root
+      data[:branch] = configuration.branch if configuration.branch
+      data[:pid] = Process.pid
+
+      data
+    end
+
+    def enforce_valid_utf8
+      Util.enforce_valid_utf8(payload)
+    end
+
+    def transform
+      handlers = configuration.transform
+
+      handlers.each do |handler|
+        begin
+          handler.call(transform_options)
+        rescue StandardError => e
+          logger.error("[Rollbar] Error calling the `transform` hook: #{e}")
+
+          break
+        end
+      end
+    end
+
+    def transform_options
+      {
+        :level => level,
+        :scope => scope,
+        :exception => exception,
+        :message => message,
+        :extra => extra,
+        :payload => payload
+      }
+    end
+  end
+end

data/lib/rollbar/js.rb

@@ -1,32 +1,4 @@
-require "rollbar/js/version"
-
 module Rollbar
   module Js
-    extend self
-
-    attr_reader :framework
-    attr_reader :framework_loader
-
-    def prepare
-      @framework ||= detect_framework
-      @framework_loader ||= load_framework_class.new
-
-      @framework_loader.prepare
-    end
-
-    private
-
-    def detect_framework
-      case
-      when defined?(::Rails::VERSION)
-        :rails
-      end
-    end
-
-    def load_framework_class
-      require "rollbar/js/frameworks/#{framework}"
-
-      Rollbar::Js::Frameworks.const_get(framework.to_s.capitalize)
-    end
   end
 end

data/lib/rollbar/json.rb

@@ -1,66 +1,18 @@
-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
-    extend self
-
-    attr_writer :options_module
+  module JSON # :nodoc:
+    module_function
 
     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 version?(version)
@@ -31,5 +15,9 @@ module Rollbar
 
       numbers == ::RUBY_VERSION.split('.')[0, numbers.size]
     end
+
+    def timeout_exceptions
+      [Net::ReadTimeout, Net::OpenTimeout]
+    end
   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 ||= {}
 
@@ -21,11 +19,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
@@ -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

@@ -0,0 +1,71 @@
+require 'logger'
+require 'rollbar'
+
+module Rollbar
+  # This class provides logger interface that can be used to replace
+  # the application logger and send all the log messages to Rollbar
+  #
+  # Usage:
+  # require 'rollbar/logger'
+  # logger = Rollbar::Logger.new
+  # logger.error('Error processing purchase')
+  #
+  # If using Rails, you can extend the Rails logger so messages are logged
+  # normally and also to Rollbar:
+  #
+  # Rails.logger.extend(ActiveSupport::Logger.broadcast(Rollbar::Logger.new))
+  class Logger < ::Logger
+    class Error < RuntimeError; end
+
+    def initialize
+      super(nil)
+
+      self.level = ERROR
+    end
+
+    def add(severity, message = nil, progname = nil)
+      return true if severity < @level
+
+      message ||= block_given? ? yield : progname
+
+      return true if blank?(message)
+
+      rollbar.log(rollbar_level(severity), message)
+    end
+
+    def <<(message)
+      error(message)
+    end
+
+    # Returns a Rollbar::Notifier instance with the current global scope and
+    # with a logger writing to /dev/null so we don't have a infinite loop
+    # when Rollbar.configuration.logger is Rails.logger.
+    def rollbar
+      notifier = Rollbar.scope
+      notifier.configuration.logger = ::Logger.new('/dev/null')
+
+      notifier
+    end
+
+    private
+
+    def blank?(message)
+      return message.blank? if message.respond_to?(:blank?)
+
+      message.respond_to?(:empty?) ? !!message.empty? : !message
+    end
+
+    # Find correct Rollbar level to use using the indexes in Logger::Severity
+    # DEBUG = 0
+    # INFO = 1
+    # WARN = 2
+    # ERROR = 3
+    # FATAL = 4
+    # UNKNOWN = 5
+    #
+    # If not found we'll use 'error' as the used level
+    def rollbar_level(severity)
+      [:debug, :info, :warning, :error, :critical, :error][severity] || :error
+    end
+  end
+end

data/lib/rollbar/logger_proxy.rb

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

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

@@ -0,0 +1,36 @@
+# 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") }') },
+#   Rollbar::JSON::JsOptionsState.new
+# )
+#
+# => '{"foo":function(){ alert(\"bar\") }}'
+#
+# MUST use the Ruby JSON encoder, as in the example. The ActiveSupport encoder,
+# which is installed with Rails, is invoked when calling Hash#to_json and #as_json,
+# and will not work.
+#
+module Rollbar
+  module JSON
+    class JsOptionsState < ::JSON::State; end
+
+    class Value # :nodoc:
+      attr_accessor :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      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
+end