rookout 0.1.0

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

@@ -0,0 +1,208 @@
+module Rookout
+  module Processor
+    module Namespaces
+      module RubyObjectSerializer
+        require_relative "../../logger"
+        require_relative "../rook_error"
+
+        require_relative "../../protobuf/variant_pb"
+
+        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::Variant.new variant_type: :VARIANT_ERROR
+
+          if log_object_errors
+            Logger.instance.exception message, e
+
+            error = RookError.new e, message
+            variant = error.dumps
+          end
+          variant
+        end
+
+        # rubocop:disable Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity
+        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
+            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
+            dump_array obj, variant, current_depth, config, log_object_errors
+          elsif obj.is_a? 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
+          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
+          end
+
+          variant
+        end
+
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/PerceivedComplexity
+
+        def create_base_variant obj, current_depth, config, log_object_errors
+          variant = Com::Rookout::Variant.new original_type: obj.class.to_s
+
+          object_weight = obj.instance_variables.length > config.max_width ? 2 : 1
+          next_depth = current_depth + object_weight
+          if next_depth >= config.max_depth
+            variant.max_depth = true
+            return variant
+          end
+
+          obj.instance_variables.each do |name|
+            raw_value = obj.instance_variable_get name
+            variant_value = dump_raw_object raw_value, current_depth + 1, config, log_object_errors
+            variant.attributes << Com::Rookout::Variant::NamedValue.new(name: name, value: variant_value)
+          end
+
+          variant
+        end
+
+        def dump_nil variant
+          variant.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
+          if obj == true
+            variant.variant_type = :VARIANT_INT
+            variant.int_value = 1
+          elsif obj == false
+            variant.variant_type = :VARIANT_INT
+            variant.int_value = 0
+          elsif obj.is_a? Integer
+            dump_integer obj, variant
+          elsif obj.is_a? Float
+            variant.variant_type = :VARIANT_DOUBLE
+            variant.double_value = obj.to_f
+          elsif obj.is_a? 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
+            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"
+          end
+          # TODO: ADD SUPPORT FOR RATIONALS
+        end
+
+        def dump_integer obj, variant
+          if obj > INT32_MIN && obj < INT32_MAX
+            variant.variant_type = :VARIANT_INT
+            variant.int_value = obj
+          elsif obj > INT64_MIN && obj < INT64_MAX
+            variant.variant_type = :VARIANT_LONG
+            variant.long_value = obj
+          else
+            variant.variant_type = :VARIANT_LARGE_INT
+            variant.large_int_value = Com::Rookout::Variant::LargeInt.new value: obj.to_s
+          end
+        end
+
+        def dump_string obj, variant, config
+          if obj.length > config.max_string
+            final_obj = obj[0...config.max_string]
+          else
+            final_obj = obj
+          end
+
+          variant.variant_type = :VARIANT_STRING
+          variant.string_value = Com::Rookout::Variant::String.new value: final_obj, original_size: obj.length
+        end
+
+        def dump_time obj, variant
+          variant.variant_type = :VARIANT_TIME
+          variant.time_value = Google::Protobuf::Timestamp.new
+          variant.time_value.from_time obj
+        end
+
+        def dump_array obj, variant, current_depth, config, log_object_errors
+          variant.variant_type = :VARIANT_LIST
+          variant.list_value = Com::Rookout::Variant::List.new type: "array", original_size: obj.length
+
+          return unless current_depth < config.max_collection_depth
+
+          obj.each_with_index do |value, index|
+            break if index >= config.max_width
+            variant.list_value.values << dump_raw_object(value, current_depth + 1, config, log_object_errors)
+          end
+        end
+
+        def dump_hash obj, variant, current_depth, config, log_object_errors
+          variant.variant_type = :VARIANT_MAP
+          variant.map_value = Com::Rookout::Variant::Map.new original_size: obj.length
+
+          return unless current_depth < config.max_collection_depth
+
+          obj.each_with_index do |(key, value), index|
+            break if index >= config.max_width
+            key_variant = dump_raw_object key, current_depth + 1, config, log_object_errors
+            value_variant = dump_raw_object value, current_depth + 1, config, log_object_errors
+            pair = Com::Rookout::Variant::Pair.new first: key_variant, second: value_variant
+            variant.map_value.pairs << pair
+          end
+        end
+
+        def dump_exception obj, variant, current_depth, config, log_object_errors
+          variant.variant_type = :VARIANT_OBJECT
+
+          message = dump_raw_object obj.message, current_depth + 1, config, log_object_errors
+          variant.attributes << Com::Rookout::Variant::NamedValue.new(name: "message", value: message)
+
+          cause = dump_raw_object obj.cause, current_depth + 1, config, log_object_errors
+          variant.attributes << Com::Rookout::Variant::NamedValue.new(name: "cause", value: cause)
+
+          backtrace = dump_raw_object obj.backtrace, current_depth + 1, config, log_object_errors
+          variant.attributes << Com::Rookout::Variant::NamedValue.new(name: "backtrace", value: backtrace)
+        end
+
+        def dump_code_object obj, variant
+          variant.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_value = Com::Rookout::Variant::CodeObject.new name: name,
+                                                                     filename: source_location[0],
+                                                                     lineno: source_location[1]
+        end
+
+        def dump_user_class variant
+          variant.variant_type = :VARIANT_OBJECT
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Rookout
+  module Processor
+    module Namespaces
+      require "English"
+
+      require_relative "../../exceptions"
+
+      require_relative "namespace"
+      require_relative "ruby_object_namespace"
+
+      class RubyUtilsNamespace < Namespace
+        def initialize
+          super
+        end
+
+        def call_method name, args
+          case name
+          when "exception"
+            RubyObjectNamespace.new $ERROR_INFO
+          when "module"
+            find_module args
+          when "env"
+            raise Exceptions::RookKeyNotFound, args unless ENV.include? args
+            RubyObjectNamespace.new ENV[args]
+          when "thread_id"
+            RubyObjectNamespace.new Thread.current.__id__
+          when "thread_name"
+            RubyObjectNamespace.new Thread.current.name
+          when "threads"
+            RubyObjectNamespace.new Thread.list
+          when "thread_tracebacks"
+            thread_tracebacks
+          else
+            super
+          end
+        end
+
+        def read_attribute _name
+          RubyObjectNamespace.new nil
+        end
+
+        def read_key _key
+          RubyObjectNamespace.new nil
+        end
+
+        private
+
+        def find_module args
+          RubyObjectNamespace.new Object.const_get(args)
+        rescue NameError
+          raise Exceptions::RookKeyNotFound, args
+        end
+
+        def thread_tracebacks
+          result = Thread.list.map do |thread|
+            { id: thread.__id__,
+              name: thread.name,
+              traceback: thread.backtrace }
+          end
+          RubyObjectNamespace.new result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Rookout
+  module Processor
+    module Namespaces
+      require_relative "namespace"
+      require_relative "frame_namespace"
+      require_relative "traceback_namespace"
+
+      class StackNamespace < Namespace
+        def initialize backtrace, offset = 0
+          @backtrace = backtrace
+          @offset = offset
+        end
+
+        def read_key key
+          FrameNamespace.new @backtrace[key + @offset]
+        end
+
+        def call_method name, args
+          return create_traceback args if name == "traceback"
+          super
+        end
+
+        def create_traceback args
+          args = 1000 if args == ""
+          TracebackNamespace.new @backtrace, @offset, args.to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Rookout
+  module Processor
+    module Namespaces
+      require_relative "namespace"
+      require_relative "frame_namespace"
+
+      require_relative "../../protobuf/variant_pb"
+
+      class TracebackNamespace < Namespace
+        def initialize backtrace, offset, depth
+          @backtrace = backtrace
+          @offset = offset
+          @depth = depth
+        end
+
+        def read_key key
+          FrameNamespace.new @backtrace[key + @offset]
+        end
+
+        def dump _log_object_errors
+          traceback = Com::Rookout::Variant::Traceback.new
+
+          @depth.times do |i|
+            position = i + @offset
+            break if position >= @backtrace.length
+            frame = @backtrace[position]
+
+            code_object = Com::Rookout::Variant::CodeObject.new filename: frame.source_location[0],
+                                                                lineno: frame.source_location[1],
+                                                                name: frame.eval("__method__").to_s
+
+            traceback.locations << code_object
+          end
+
+          Com::Rookout::Variant.new variant_type: :VARIANT_TRACEBACK, traceback: traceback
+        end
+      end
+    end
+  end
+end

data/lib/rookout/processor/operations/operation.rb

@@ -0,0 +1,11 @@
+module Rookout
+  module Processor
+    module Operations
+      class Operation
+        def execute _namespace
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/rookout/processor/operations/set_operation.rb

@@ -0,0 +1,48 @@
+module Rookout
+  module Processor
+    module Operations
+      require_relative "operation"
+
+      require_relative "../rook_error"
+      require_relative "../../logger"
+      require_relative "../../user_warnings"
+
+      class SetOperation < Operation
+        def initialize configuration, factory
+          @paths = []
+
+          configuration["paths"].each do |key, value|
+            begin
+              dest_path = factory.create_path key
+              source_path = factory.create_path value
+              @paths.push [dest_path, source_path]
+            rescue StandardError => e
+              message = "Failed to load dest:source path pair"
+              Logger.instance.exception message, e
+              warning = RookError.new e, message
+              UserWarnings.notify_warning warning
+            end
+          end
+        end
+
+        def execute namespace
+          @paths.each do |dest_path, source_path|
+            begin
+              value = source_path.read_from namespace
+              if value.is_a?(RubyObjectNamespace) && value.dump_config == Namespaces::OBJECT_DUMP_CONFIG_DEFAULT
+                value.tailor_limits!
+              end
+
+              dest_path.write_to namespace, value
+            rescue StandardError => e
+              message = "Failed to execute dest:source path pair"
+              Logger.instance.exception message, e
+              warning = RookError.new e, message
+              UserWarnings.notify_warning warning
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rookout/processor/paths/arithmetic_path.rb

@@ -0,0 +1,84 @@
+module Rookout
+  module Processor
+    module Paths
+      require_relative "path"
+
+      require_relative "../../exceptions"
+
+      require_relative "../namespaces/ruby_object_namespace"
+
+      require_relative "canopy/maps"
+      require_relative "canopy/actions"
+      require_relative "canopy/markers"
+
+      class ArithmeticPath < Path
+        def initialize path
+          if path.is_a? Hash
+            path = path["path"] || path[:path]
+          end
+
+          @raw_path = path
+
+          if path.start_with?("NOT(") && path.end_with?(")")
+            @path = path["NOT(".length..-2]
+            @negation = true
+          else
+            @path = path
+            @negation = false
+          end
+
+          raise RookInvalidArithmeticPath, @raw_path if @path.empty?
+        end
+
+        def read_from namespace
+          begin
+            result = Maps.parse @path, actions: Canopy::Actions.new(namespace)
+          rescue Maps::ParseError => e
+            raise RookInvalidArithmeticPath.new(@path, e)
+          end
+
+          normalize result
+        end
+
+        def write_to namespace, value
+          context = Canopy::Actions.new namespace
+
+          begin
+            # initialize operations chain - by parsing the expression - ignore return value
+            Maps.parse @path, actions: context
+          rescue Maps::ParseError => e
+            raise RookInvalidArithmeticPath.new(@path, e)
+          end
+
+          raise RookInvalidArithmeticPath, @raw_path if context.operations.empty?
+
+          (context.operations.length - 1).times do |i|
+            namespace = context.operations[i].read namespace, true
+          end
+
+          context.operations[context.operations.length - 1].write namespace, value
+        end
+
+        def normalize result
+          if result.is_a? Canopy::List
+            new_array = result.obj.map(&:obj)
+            return Namespaces::RubyObjectNamespace.new new_array
+          end
+
+          if result.is_a? Canopy::NamespaceResult
+            return result.obj
+          end
+
+          if result.is_a? Canopy::ToolExceptionMarker
+            raise result.obj if result.obj.is_a? Exceptions::ToolException
+            raise Exceptions::RookInvalidArithmeticPath, @raw_path, result.obj
+          end
+
+          res = result.obj
+          res = !res if [true, false].include?(res) && @negation
+          Namespaces::RubyObjectNamespace.new res
+        end
+      end
+    end
+  end
+end