rookout 0.1.0 → 0.1.56

data/lib/rookout/processor/namespace_serializer2.rb

@@ -0,0 +1,331 @@
+module Rookout
+  module Processor
+    class NamespaceSerializer2
+      require_relative "../logger"
+
+      require_relative "../protobuf/variant_pb"
+      require_relative "../protobuf/variant2_pb"
+      require_relative "../user_warnings"
+      require_relative "./namespaces/container_namespace"
+      require_relative "./namespaces/traceback_namespace"
+
+      begin
+        require "hashie/mash"
+        MASH = ::Hashie::Mash
+      rescue LoadError
+        MASH = nil
+      end
+
+      begin
+        require "active_support/core_ext/hash/indifferent_access"
+        HASH_WITH_INDIFFERENT_ACCESS = ActiveSupport::HashWithIndifferentAccess
+      rescue LoadError
+        HASH_WITH_INDIFFERENT_ACCESS = nil
+      end
+
+      def initialize
+        @string_cache = {}
+        @estimated_pending_bytes = 0
+      end
+
+      attr_reader :string_cache
+      attr_reader :estimated_pending_bytes
+
+      def get_string_index_in_cache str
+        if @string_cache.key? str
+          @string_cache[str]
+        else
+          @estimated_pending_bytes += str.length + 5
+          current_size = @string_cache.size
+          @string_cache.store str, current_size
+          current_size
+        end
+      end
+
+      def dump_variant_type variant, type
+        variant.variant_type_max_depth = type << 1
+        @estimated_pending_bytes += 2 # Field header + short number
+      end
+
+      def dump_variant_type_max_depth variant, type
+        variant.variant_type_max_depth = (type << 1) | 1
+        @estimated_pending_bytes += 2 # Field header + short number
+      end
+
+      def dump namespace, log_errors
+        case namespace
+        when Namespaces::RubyObjectNamespace
+          dump_ruby_object_namespace namespace, log_errors
+        when Namespaces::ContainerNamespace
+          dump_container_namespace namespace, log_errors
+        when Namespaces::TracebackNamespace
+          dump_traceback_namespace namespace
+        else
+          raise NotImplementedError
+        end
+      rescue StandardError => e
+        message = "Failed to serialize namespace"
+        variant = Com::Rookout::Variant2.new
+        @estimated_pending_bytes = 0
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_ERROR
+
+        if log_errors
+          Logger.instance.exception message, e
+
+          error = RookError.new e, message
+          UserWarnings.notify_warning error
+        end
+        variant
+      end
+
+      def dump_ruby_object_namespace namespace, log_errors
+        dump_raw_object namespace.obj, 0, namespace.dump_config, log_errors
+      end
+
+      def dump_raw_object obj, current_depth, config, log_object_errors
+        unsafe_dump_object obj, current_depth, config, log_object_errors
+      rescue StandardError => e
+        message = "Failed to serialize object"
+        variant = Com::Rookout::Variant2.new
+        @estimated_pending_bytes = 0
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_ERROR
+
+        if log_object_errors
+          Logger.instance.exception message, e
+
+          error = RookError.new e, message
+          UserWarnings.notify_warning error
+        end
+        variant
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Style/ClassEqualityComparison
+      def unsafe_dump_object obj, current_depth, config, log_object_errors
+        variant = Com::Rookout::Variant2.new original_type_index_in_cache: get_string_index_in_cache(obj.class.to_s)
+
+        if obj.nil?
+          dump_nil variant
+        elsif obj.is_a?(Numeric) || obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+          dump_numeric obj, variant, config
+        elsif obj.is_a?(String) || obj.is_a?(Symbol)
+          dump_string obj, variant, config
+        elsif obj.is_a? Time
+          dump_time obj, variant
+        elsif obj.class == Array
+          dump_array obj, variant, current_depth, config, log_object_errors
+        elsif obj.class == Hash || (!MASH.nil? && obj.is_a?(MASH)) ||
+              (!HASH_WITH_INDIFFERENT_ACCESS.nil? && obj.is_a?(HASH_WITH_INDIFFERENT_ACCESS))
+          dump_hash obj, variant, current_depth, config, log_object_errors
+        elsif obj.is_a? Exception
+          dump_exception obj, variant, current_depth, config, log_object_errors
+        elsif obj.is_a?(Method) || obj.is_a?(Proc) || obj.is_a?(Class) || obj.is_a?(Module)
+          dump_code_object obj, variant
+        else
+          dump_user_class variant, obj, current_depth, config, log_object_errors
+        end
+
+        variant
+      end
+      # rubocop:enable Style/ClassEqualityComparison
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def dump_nil variant
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_NONE
+      end
+
+      # Based off protobuf for Python
+      INT32_MIN = -2147483648
+      INT32_MAX = 2147483647
+      INT64_MIN = -(1 << 63)
+      INT64_MAX = (1 << 63) - 1
+
+      def dump_numeric obj, variant, config
+        case obj
+        when true
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
+          variant.long_value = 1
+          @estimated_pending_bytes += 2 # Header + short number
+        when false
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
+          variant.long_value = 0
+          @estimated_pending_bytes += 2 # Header + short number
+        when Integer
+          dump_integer obj, variant
+        when Float
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_DOUBLE
+          variant.double_value = obj.to_f
+          @estimated_pending_bytes += 7 # Header + 64 bit float
+        when BigDecimal
+          dump_string obj.to_s, variant, config # TODO: NS: This might cut the decimal value, is that ok?
+        when Complex
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_COMPLEX
+          variant.complex_value = Com::Rookout::Variant::Complex.new real: obj.real.to_f,
+                                                                     imaginary: obj.imaginary.to_f
+          @estimated_pending_bytes += 8 # Large header + size + (header + 64 bit float) * 2
+        else
+          raise Exceptions::RookClassCannotBeSerialized.new(obj.class, "Unknown Numeric Type")
+        end
+        # TODO: ADD SUPPORT FOR RATIONALS
+      end
+
+      def dump_integer obj, variant
+        if obj > INT32_MIN && obj < INT64_MAX
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
+          variant.long_value = obj
+        else
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LARGE_INT
+          variant.bytes_index_in_cache = get_string_index_in_cache obj.to_s
+        end
+        @estimated_pending_bytes += 3 # Header + number
+      end
+
+      def dump_string obj, variant, config
+        obj = obj.to_s
+        if obj.length > config.max_string
+          final_obj = obj[0...config.max_string]
+        else
+          final_obj = obj
+        end
+
+        variant.original_size = obj.length
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_STRING
+        variant.bytes_index_in_cache = get_string_index_in_cache final_obj
+        @estimated_pending_bytes += 6 # Header + number + header + number
+      end
+
+      def dump_time obj, variant
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_TIME
+        variant.time_value = Google::Protobuf::Timestamp.new
+        variant.time_value.from_time obj
+
+        @estimated_pending_bytes += 16 # Header + size + (header + 32 bit number + header + 64 bit number)
+      end
+
+      def dump_array obj, variant, current_depth, config, log_object_errors
+        variant.original_size = obj.length
+        @estimated_pending_bytes += 3 # Header + number
+
+        weighted_children_depth = current_depth + 1
+        if weighted_children_depth <= config.max_collection_depth
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LIST
+          obj.each_with_index do |value, index|
+            break if index >= config.max_width
+            variant.collection_values << dump_raw_object(value, weighted_children_depth, config, log_object_errors)
+            @estimated_pending_bytes += 3 # Header + size
+          end
+        else
+          dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_LIST
+        end
+      end
+
+      def dump_hash obj, variant, current_depth, config, log_object_errors
+        variant.original_size = obj.length
+
+        weighted_children_depth = current_depth + 1
+        if current_depth <= config.max_collection_depth
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_MAP
+          obj.each_with_index do |(key, value), index|
+            break if index >= config.max_width
+            variant.collection_keys << dump_raw_object(key, weighted_children_depth, config, log_object_errors)
+            variant.collection_values << dump_raw_object(value, weighted_children_depth, config, log_object_errors)
+            @estimated_pending_bytes += 6 # Header + size + header + size
+          end
+        else
+          dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_MAP
+        end
+      end
+
+      def dump_exception obj, variant, current_depth, config, log_object_errors
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
+        variant.attribute_names_in_cache << get_string_index_in_cache("message")
+        variant.attribute_values << dump_raw_object(obj.message, current_depth + 1, config, log_object_errors)
+        @estimated_pending_bytes += 6 # Header + number + header + size
+
+        variant.attribute_names_in_cache << get_string_index_in_cache("cause")
+        variant.attribute_values << dump_raw_object(obj.cause, current_depth + 1, config, log_object_errors)
+        @estimated_pending_bytes += 6 # Header + number + header + size
+
+        variant.attribute_names_in_cache << get_string_index_in_cache("backtrace")
+        variant.attribute_values << dump_raw_object(obj.backtrace, current_depth + 1, config, log_object_errors)
+        @estimated_pending_bytes += 6 # Header + number + header + size
+      end
+
+      def dump_code_object obj, variant
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_CODE_OBJECT
+
+        if obj.is_a?(Proc) || obj.is_a?(Method)
+          source_location = obj.source_location
+        else
+          source_location = [nil, nil]
+        end
+
+        if obj.is_a? Proc
+          name = ""
+        else
+          name = obj.name
+        end
+
+        variant.code_values << Com::Rookout::Variant::CodeObject.new(name: name,
+                                                                     filename: source_location[0],
+                                                                     lineno: source_location[1])
+        # NOTE: This size is probably less, in Python we use the optional fields of CodeObject and in Ruby we don't,
+        # but it is better to estimate more
+        @estimated_pending_bytes += 14 # Header + size + (header + number) * 4
+      end
+
+      def dump_user_class variant, obj, current_depth, config, log_object_errors
+        weighted_children_depth = current_depth + 1
+        if weighted_children_depth <= config.max_collection_depth
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
+
+          obj.instance_variables.each do |name|
+            raw_value = obj.instance_variable_get name
+            variant.attribute_names_in_cache << get_string_index_in_cache(name.to_s)
+            variant.attribute_values << dump_raw_object(raw_value, weighted_children_depth, config, log_object_errors)
+            @estimated_pending_bytes += 6 # Header + number + header + number
+          end
+        else
+          dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
+        end
+      end
+
+      def dump_container_namespace namespace, log_errors
+        variant = Com::Rookout::Variant2.new
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_NAMESPACE
+
+        namespace.hash.each do |key, value|
+          variant.attribute_names_in_cache << get_string_index_in_cache(key.to_s)
+          variant.attribute_values << dump(value, log_errors)
+        end
+
+        @estimated_pending_bytes += 4 # One number (packed field), One header + length
+
+        variant
+      end
+
+      def dump_traceback_namespace namespace
+        variant = Com::Rookout::Variant2.new
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_TRACEBACK
+
+        namespace.depth.times do |i|
+          position = i + namespace.offset
+          break if position >= namespace.stack_trace.length
+          frame_info = namespace.stack_trace[position]
+
+          code_object = Com::Rookout::Variant::CodeObject.new filename: frame_info.path,
+                                                              lineno: frame_info.lineno,
+                                                              name: frame_info.label
+          variant.code_values << code_object
+          # See dump_code_object
+          @estimated_pending_bytes += 14 # Header + size + (header + number) * 4
+        end
+        variant
+      end
+    end
+  end
+end

data/lib/rookout/processor/namespaces/container_namespace.rb

@@ -8,11 +8,16 @@ module Rookout
 
       require_relative "../../protobuf/variant_pb"
 
+
       class ContainerNamespace < Namespace
         def initialize hash = {}
+          super()
           @hash = hash
         end
 
+        attr_reader :hash
+
+
         def call_method name, args
           return RubyObjectNamespace.new @hash.length if name == "size"
           super

data/lib/rookout/processor/namespaces/frame_namespace.rb

@@ -7,33 +7,35 @@ module Rookout
       require_relative "../../exceptions"
 
       class FrameNamespace < Namespace
-        def initialize binding
-          @binding = binding
+        def initialize frame_binding, top_frame_info
+          super()
+          @frame_binding = frame_binding
+          @top_frame_info = top_frame_info
         end
 
         def read_attribute name
-          raise Exceptions::RookAttributeNotFound, name unless @binding.local_variable_defined? name
-          RubyObjectNamespace.new @binding.local_variable_get name
+          raise Exceptions::RookLocalsUnavailable if @frame_binding.nil?
+          return RubyObjectNamespace.new @frame_binding.receiver if name == "self"
+          raise Exceptions::RookAttributeNotFound, name unless @frame_binding.local_variable_defined? name
+          RubyObjectNamespace.new @frame_binding.local_variable_get name
         end
 
         def call_method name, args
           case name
-          when "filename"
-            RubyObjectNamespace.new @binding.source_location[0]
+          when "filename", "module"
+            RubyObjectNamespace.new @top_frame_info.path
           when "line"
-            RubyObjectNamespace.new @binding.source_location[1]
+            RubyObjectNamespace.new @top_frame_info.lineno
           when "function"
-            RubyObjectNamespace.new @binding.eval("__method__").to_s
-          when "module"
-            RubyObjectNamespace.new @binding.source_location[0]
+            RubyObjectNamespace.new @top_frame_info.label
           when "locals"
             locals args
           when "dump"
             result = {
-              "filename" => RubyObjectNamespace.new(@binding.source_location[0]),
-              "line" => RubyObjectNamespace.new(@binding.source_location[1]),
-              "function" => RubyObjectNamespace.new(@binding.eval("__method__").to_s),
-              "module" => RubyObjectNamespace.new(@binding.source_location[0]),
+              "filename" => RubyObjectNamespace.new(@top_frame_info.path),
+              "line" => RubyObjectNamespace.new(@top_frame_info.lineno),
+              "function" => RubyObjectNamespace.new(@top_frame_info.label),
+              "module" => RubyObjectNamespace.new(@top_frame_info.path),
               "locals" => locals(args)
             }
             ContainerNamespace.new result
@@ -43,19 +45,20 @@ module Rookout
         end
 
         def locals args
+          raise Exceptions::RookLocalsUnavailable if @frame_binding.nil?
           dump_config = nil
           unless args.nil?
             dump_config = OBJECT_DUMP_TABLE[args.downcase]
           end
 
           hash = {}
-          local_variables = @binding.local_variables
+          local_variables = @frame_binding.local_variables
           local_variables.each do |var|
-            value = @binding.local_variable_get var
+            value = @frame_binding.local_variable_get var
             hash[var.to_s] = RubyObjectNamespace.new value, dump_config
           end
 
-          hash["self"] = RubyObjectNamespace.new @binding.receiver, dump_config
+          hash["self"] = RubyObjectNamespace.new @frame_binding.receiver, dump_config
 
           ContainerNamespace.new hash
         end

data/lib/rookout/processor/namespaces/namespace.rb

@@ -3,8 +3,9 @@ module Rookout
     module Namespaces
       class Namespace
         require_relative "../../exceptions"
+
         def call_method name, _args
-          raise Exceptions::RookMethodNotFound, self.class.to_s, name
+          raise Exceptions::RookMethodNotFound.new(self.class.to_s, name)
         end
 
         def read_attribute name
@@ -12,7 +13,7 @@ module Rookout
         end
 
         def write_attribute name, _value
-          raise Exceptions::RookWriteAttributeNotSupported, self.class.to_s, name
+          raise Exceptions::RookWriteAttributeNotSupported.new(self.class.to_s, name)
         end
 
         def read_key key

data/lib/rookout/processor/namespaces/noop_namespace.rb

@@ -6,21 +6,17 @@ module Rookout
 
       require_relative "../../protobuf/variant_pb"
 
-      class RubyUtilsNamespace < Namespace
-        def initialize
-          super
-        end
-
+      class NoopNamespace < Namespace
         def call_method _name, _args
-          RubyObjectNamespace nil
+          Rookout::Processor::Namespaces::RubyObjectNamespace.new nil
         end
 
         def read_attribute _name
-          RubyObjectNamespace nil
+          Rookout::Processor::Namespaces::RubyObjectNamespace.new nil
         end
 
         def read_key _key
-          RubyObjectNamespace nil
+          Rookout::Processor::Namespaces::RubyObjectNamespace.new nil
         end
 
         def dump _log_object_errors

data/lib/rookout/processor/namespaces/ruby_object_namespace.rb

@@ -17,15 +17,18 @@ module Rookout
           @max_string = max_string
         end
 
-        attr_reader :max_depth, :max_width, :max_collection_depth, :max_string
+        attr_reader :max_depth
+        attr_reader :max_width
+        attr_reader :max_collection_depth
+        attr_reader :max_string
       end
 
-      OBJECT_DUMP_CONFIG_STRICT = ObjectDumpConfig.new 2, 10, 1, 128
-      OBJECT_DUMP_CONFIG_DEFAULT = ObjectDumpConfig.new 4, 20, 2, 512
-      OBJECT_DUMP_CONFIG_TOLERANT = ObjectDumpConfig.new 5, 50, 4, 4 * 1024
+      OBJECT_DUMP_CONFIG_STRICT = ObjectDumpConfig.new 2, 10, 2, 128
+      OBJECT_DUMP_CONFIG_DEFAULT = ObjectDumpConfig.new 4, 15, 4, 512
+      OBJECT_DUMP_CONFIG_TOLERANT = ObjectDumpConfig.new 5, 20, 5, 4 * 1024
 
       OBJECT_DUMP_CONFIG_STRING = ObjectDumpConfig.new 1, 0, 0, 64 * 1024
-      OBJECT_DUMP_CONFIG_COLLECTION = ObjectDumpConfig.new 4, 100, 2, 512
+      OBJECT_DUMP_CONFIG_COLLECTION = ObjectDumpConfig.new 4, 100, 4, 512
 
       OBJECT_DUMP_TABLE = {
         "" => OBJECT_DUMP_CONFIG_DEFAULT,
@@ -37,18 +40,22 @@ module Rookout
       class RubyObjectNamespace < Namespace
         include RubyObjectSerializer
 
-        def initialize obj, dump_config = OBJECT_DUMP_CONFIG_DEFAULT
+        def initialize obj, dump_config = nil
+          super()
           @obj = obj
-          @dump_config = dump_config
+          @dump_config = dump_config || OBJECT_DUMP_CONFIG_DEFAULT
         end
 
-        attr_reader :obj, :dump_config
+        attr_reader :obj
+        attr_reader :dump_config
 
         def tailor_limits!
           if @obj.is_a? String
             @dump_config = OBJECT_DUMP_CONFIG_STRING
-          elsif @obj.is_a?(Hash) || @obj.is_a?(Array)
+          elsif (@obj.is_a?(Hash) || @obj.is_a?(Array)) && @obj.length > OBJECT_DUMP_CONFIG_TOLERANT.max_width
             @dump_config = OBJECT_DUMP_CONFIG_COLLECTION
+          else
+            @dump_config = OBJECT_DUMP_CONFIG_TOLERANT
           end
           self
         end
@@ -60,20 +67,13 @@ module Rookout
         end
 
         def read_key key
-          if @obj.is_a? Array
-            key_int = key.to_i
-            return RubyObjectNamespace.new @obj[key_int] if key_int >= 0 && key_int < @obj.length
-            raise Exceptions::RookKeyNotFound, key
-
-          elsif @obj.is_a? Hash
-            return RubyObjectNamespace.new @obj[key] if @obj.key? key
-            return RubyObjectNamespace.new @obj[key.to_sym] if key.is_a?(String) && @obj.key?(key.to_sym)
-
-            @obj.each { |it, value| return RubyObjectNamespace.new value if it.to_s == key }
-
-            raise Exceptions::RookKeyNotFound, key
+          case @obj
+          when Array, String
+            read_key_as_int key
+          when Hash
+            read_key_from_hash key
           else
-            raise Exceptions::RookInvalidObjectForAccess.new(obj.class.to_s, "ReadKey")
+            raise Exceptions::RookInvalidObjectForAccess.new(@obj.class.to_s, "ReadKey")
           end
         end
 
@@ -91,6 +91,23 @@ module Rookout
         def dump log_object_errors
           dump_raw_object @obj, 0, @dump_config, log_object_errors
         end
+
+        private
+
+        def read_key_as_int key
+          key_int = key.to_i
+          return RubyObjectNamespace.new @obj[key_int] if key_int >= 0 && key_int < @obj.length
+          raise Exceptions::RookKeyNotFound, key
+        end
+
+        def read_key_from_hash key
+          return RubyObjectNamespace.new @obj[key] if @obj.key? key
+          return RubyObjectNamespace.new @obj[key.to_sym] if @obj.key? key.to_s.to_sym
+
+          @obj.each { |it, value| return RubyObjectNamespace.new value if it.to_s == key }
+
+          raise Exceptions::RookKeyNotFound, key
+        end
       end
     end
   end

data/lib/rookout/processor/namespaces/ruby_object_serializer.rb

@@ -17,27 +17,28 @@ module Rookout
             Logger.instance.exception message, e
 
             error = RookError.new e, message
-            variant = error.dumps
+            variant.error_value = error.dumps
           end
           variant
         end
 
         # rubocop:disable Metrics/PerceivedComplexity
         # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Style/ClassEqualityComparison
         def unsafe_dump_object obj, current_depth, config, log_object_errors
           variant = create_base_variant obj, current_depth, config, log_object_errors
 
           if obj.nil?
             dump_nil variant
-          elsif obj.is_a?(Numeric) || obj == true || obj == false
+          elsif obj.is_a?(Numeric) || obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
             dump_numeric obj, variant
           elsif obj.is_a?(String) || obj.is_a?(Symbol)
             dump_string obj, variant, config
           elsif obj.is_a? Time
             dump_time obj, variant
-          elsif obj.is_a? Array
+          elsif obj.class == Array
             dump_array obj, variant, current_depth, config, log_object_errors
-          elsif obj.is_a? Hash
+          elsif obj.class == Hash
             dump_hash obj, variant, current_depth, config, log_object_errors
           elsif obj.is_a? Exception
             dump_exception obj, variant, current_depth, config, log_object_errors
@@ -49,7 +50,7 @@ module Rookout
 
           variant
         end
-
+        # rubocop:enable Style/ClassEqualityComparison
         # rubocop:enable Metrics/CyclomaticComplexity
         # rubocop:enable Metrics/PerceivedComplexity
 
@@ -83,28 +84,29 @@ module Rookout
         INT64_MAX = (1 << 63) - 1
 
         def dump_numeric obj, variant
-          if obj == true
+          case obj
+          when true
             variant.variant_type = :VARIANT_INT
             variant.int_value = 1
-          elsif obj == false
+          when false
             variant.variant_type = :VARIANT_INT
             variant.int_value = 0
-          elsif obj.is_a? Integer
+          when Integer
             dump_integer obj, variant
-          elsif obj.is_a? Float
+          when Float
             variant.variant_type = :VARIANT_DOUBLE
             variant.double_value = obj.to_f
-          elsif obj.is_a? BigDecimal
+          when BigDecimal
             serialized_decimal = obj.to_s
             variant.variant_type = :VARIANT_STRING
             variant.string_value = Com::Rookout::Variant::String.new value: serialized_decimal,
                                                                      original_size: serialized_decimal.length
-          elsif obj.is_a? Complex
+          when Complex
             variant.variant_type = :VARIANT_COMPLEX
             variant.complex_value = Com::Rookout::Variant::Complex.new real: obj.real.to_f,
                                                                        imaginary: obj.imaginary.to_f
           else
-            raise Exceptions.RookClassCannotBeSerialized, obj.class, "Unknown Numeric Type"
+            raise Exceptions::RookClassCannotBeSerialized.new(obj.class, "Unknown Numeric Type")
           end
           # TODO: ADD SUPPORT FOR RATIONALS
         end
@@ -123,6 +125,7 @@ module Rookout
         end
 
         def dump_string obj, variant, config
+          obj = obj.to_s
           if obj.length > config.max_string
             final_obj = obj[0...config.max_string]
           else

data/lib/rookout/processor/namespaces/ruby_utils_namespace.rb

@@ -9,10 +9,6 @@ module Rookout
       require_relative "ruby_object_namespace"
 
       class RubyUtilsNamespace < Namespace
-        def initialize
-          super
-        end
-
         def call_method name, args
           case name
           when "exception"