rookout 0.1.0

data/lib/rookout/logger.rb

@@ -0,0 +1,158 @@
+module Rookout
+  require "fileutils"
+  require "English"
+
+  require_relative "config"
+
+  class Logger
+    require "singleton"
+    include Singleton
+
+    LOG_LEVELS = [:DEBUG, :INFO, :WARNING, :ERROR].freeze
+
+    def initialize
+      @verbosity = LOG_LEVELS.index(Config.logger_log_level) || LOG_LEVELS.index(:INFO)
+
+      @output = nil
+      @handlers = []
+      build_handlers
+    end
+
+    def register_output output
+      @output = output
+    end
+
+    def remove_output _output
+      @output = nil
+    end
+
+    def debug message, *args
+      log :DEBUG, message, args
+    end
+
+    def info message, *args
+      log :INFO, message, args
+    end
+
+    def warning message, *args
+      log :WARNING, message, args
+    end
+
+    def error message, *args
+      log :ERROR, message, args
+    end
+
+    def exception message, exc
+      # TODO: REVIEW HOW TO REPORT EXCEPTIONS
+      error message, exc
+    end
+
+    private
+
+    class LogRecord
+      def initialize level, message, arguments
+        @level = level
+        @time = Time.new
+        @message = message
+        @formatted_message = message % arguments
+        @arguments = arguments
+        set_caller
+      end
+
+      attr_reader :level, :time, :filename, :lineno, :message, :formatted_message, :arguments
+
+      def format
+        "#{@time} #{Process.pid}:#{Thread.current.name}-" \
+          "#{File.basename @filename}:#{@label}@#{lineno} - #{@level} - #{formatted_message}"
+      end
+
+      private
+
+      def set_caller
+        @filename = nil
+        @lineno = nil
+        @label = nil
+
+        caller_locations(4, 7).each do |caller|
+          next if caller.absolute_path.end_with? "lib/rookout/logger.rb"
+
+          @filename = caller.path
+          @lineno = caller.lineno
+          @label = caller.label
+          break
+        end
+      end
+    end
+
+    def log level, message, args
+      level_no = LOG_LEVELS.index level
+      if level_no.nil?
+        level = :ERROR
+        level_no = LOG_LEVELS.index level
+      end
+
+      return if level_no < @verbosity
+
+      record = LogRecord.new level, message, args
+      @handlers.each { |handler| handler.call record }
+    end
+
+    def build_handlers
+      @handlers.push new_file_handler unless Config.logger_filename.nil? || Config.logger_filename.empty?
+      @handlers.push new_stderr_handler if Config.logger_log_to_stderr
+      @handlers.push new_remote_handler
+    end
+
+    def new_file_handler
+      log_file_path = calculate_log_file_path
+      directory = File.dirname log_file_path
+
+      begin
+        FileUtils.mkdir_p directory
+        file = File.open log_file_path, "a"
+      rescue SystemCallError => e
+        file = nil
+
+        if Config.debug
+          STDERR.puts "[Rookout] Failed to open log file: #{log_file_path}"
+          STDERR.puts e.backtrace
+        end
+      end
+
+      ->(record) { file.write record.format + "\n" if file }
+    end
+
+    def calculate_log_file_path
+      return Config.logger_filename if absolute_path? Config.logger_filename
+
+      if RUBY_PLATFORM.include? "darwin"
+        File.join ENV["HOME"], Config.logger_filename
+      elsif RUBY_PLATFORM.match?(/cygwin|mswin|mingw|bccwin|wince|emx/)
+        File.join ENV["USERPROFILE"], Config.logger_filename
+      else
+        File.join "/var/log", Config.logger_filename
+      end
+    end
+
+    def new_stderr_handler
+      ->(record) { STDERR.puts record.format }
+    end
+
+    def new_remote_handler
+      lambda do |record|
+        return unless @output
+        @output.send_log_message record.level,
+                                 record.time,
+                                 record.filename,
+                                 record.lineno,
+                                 record.message,
+                                 record.formatted_message,
+                                 record.arguments
+      end
+    end
+
+    def absolute_path? path
+      path == File.absolute_path(path)
+    end
+  end
+end

data/lib/rookout/processor/namespace_serializer.rb

@@ -0,0 +1,26 @@
+module Rookout
+  module Processor
+    module NamespaceSerializer
+      require_relative "../logger"
+
+      require_relative "../protobuf/variant_pb"
+
+      module_function
+
+      def dump namespace, log_errors = true
+        namespace.dump log_errors
+      rescue StandardError => e
+        message = "Failed to serialize namespace"
+        variant = Com::Rookout::Variant.new variant_type: :VARIANT_ERROR
+
+        if log_errors
+          Logger.instance.exception message, e
+
+          error = RookError.new e, message
+          variant = error.dumps
+        end
+        variant
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Rookout
+  module Processor
+    module Namespaces
+      require_relative "namespace"
+      require_relative "ruby_object_namespace"
+
+      require_relative "../../exceptions"
+
+      require_relative "../../protobuf/variant_pb"
+
+      class ContainerNamespace < Namespace
+        def initialize hash = {}
+          @hash = hash
+        end
+
+        def call_method name, args
+          return RubyObjectNamespace.new @hash.length if name == "size"
+          super
+        end
+
+        def read_attribute name
+          raise Exceptions::RookAttributeNotFound, name unless @hash.key? name
+          @hash[name]
+        end
+
+        def write_attribute name, value
+          @hash[name] = value
+        end
+
+        def dump log_object_errors
+          variant = Com::Rookout::Variant.new variant_type: :VARIANT_NAMESPACE,
+                                              namespace_value: Com::Rookout::Variant::Namespace.new
+
+          @hash.each do |key, value|
+            dumped_value = value.dump log_object_errors
+            namespace = Com::Rookout::Variant::NamedValue.new name: key, value: dumped_value
+            variant.namespace_value.attributes << namespace
+          end
+
+          variant
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Rookout
+  module Processor
+    module Namespaces
+      require_relative "namespace"
+      require_relative "ruby_object_namespace"
+      require_relative "container_namespace"
+      require_relative "../../exceptions"
+
+      class FrameNamespace < Namespace
+        def initialize binding
+          @binding = binding
+        end
+
+        def read_attribute name
+          raise Exceptions::RookAttributeNotFound, name unless @binding.local_variable_defined? name
+          RubyObjectNamespace.new @binding.local_variable_get name
+        end
+
+        def call_method name, args
+          case name
+          when "filename"
+            RubyObjectNamespace.new @binding.source_location[0]
+          when "line"
+            RubyObjectNamespace.new @binding.source_location[1]
+          when "function"
+            RubyObjectNamespace.new @binding.eval("__method__").to_s
+          when "module"
+            RubyObjectNamespace.new @binding.source_location[0]
+          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]),
+              "locals" => locals(args)
+            }
+            ContainerNamespace.new result
+          else
+            super
+          end
+        end
+
+        def locals args
+          dump_config = nil
+          unless args.nil?
+            dump_config = OBJECT_DUMP_TABLE[args.downcase]
+          end
+
+          hash = {}
+          local_variables = @binding.local_variables
+          local_variables.each do |var|
+            value = @binding.local_variable_get var
+            hash[var.to_s] = RubyObjectNamespace.new value, dump_config
+          end
+
+          hash["self"] = RubyObjectNamespace.new @binding.receiver, dump_config
+
+          ContainerNamespace.new hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Rookout
+  module Processor
+    module Namespaces
+      class Namespace
+        require_relative "../../exceptions"
+        def call_method name, _args
+          raise Exceptions::RookMethodNotFound, self.class.to_s, name
+        end
+
+        def read_attribute name
+          raise Exceptions::RookAttributeNotFound, name
+        end
+
+        def write_attribute name, _value
+          raise Exceptions::RookWriteAttributeNotSupported, self.class.to_s, name
+        end
+
+        def read_key key
+          raise Exceptions::RookKeyNotFound, key
+        end
+
+        def dump _log_object_errors
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Rookout
+  module Processor
+    module Namespaces
+      require_relative "namespace"
+      require_relative "ruby_object_namespace"
+
+      require_relative "../../protobuf/variant_pb"
+
+      class RubyUtilsNamespace < Namespace
+        def initialize
+          super
+        end
+
+        def call_method _name, _args
+          RubyObjectNamespace nil
+        end
+
+        def read_attribute _name
+          RubyObjectNamespace nil
+        end
+
+        def read_key _key
+          RubyObjectNamespace nil
+        end
+
+        def dump _log_object_errors
+          Com::Rookout::Variant.new variant_type: :VARIANT_NONE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Rookout
+  module Processor
+    module Namespaces
+      require "bigdecimal"
+      require "google/protobuf/well_known_types"
+
+      require_relative "../../exceptions"
+
+      require_relative "namespace"
+      require_relative "ruby_object_serializer"
+
+      class ObjectDumpConfig
+        def initialize max_depth, max_width, max_collection_depth, max_string
+          @max_depth = max_depth
+          @max_width = max_width
+          @max_collection_depth = max_collection_depth
+          @max_string = max_string
+        end
+
+        attr_reader :max_depth, :max_width, :max_collection_depth, :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_STRING = ObjectDumpConfig.new 1, 0, 0, 64 * 1024
+      OBJECT_DUMP_CONFIG_COLLECTION = ObjectDumpConfig.new 4, 100, 2, 512
+
+      OBJECT_DUMP_TABLE = {
+        "" => OBJECT_DUMP_CONFIG_DEFAULT,
+        "strict" => OBJECT_DUMP_CONFIG_STRICT,
+        "default" => OBJECT_DUMP_CONFIG_DEFAULT,
+        "tolerant" => OBJECT_DUMP_CONFIG_TOLERANT
+      }.freeze
+
+      class RubyObjectNamespace < Namespace
+        include RubyObjectSerializer
+
+        def initialize obj, dump_config = OBJECT_DUMP_CONFIG_DEFAULT
+          @obj = obj
+          @dump_config = dump_config
+        end
+
+        attr_reader :obj, :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)
+            @dump_config = OBJECT_DUMP_CONFIG_COLLECTION
+          end
+          self
+        end
+
+        def read_attribute name
+          attributes = @obj.instance_variables
+          raise RookAttributeNotFound, name unless attributes.include? name.to_sym
+          RubyObjectNamespace.new @obj.instance_variable_get(name)
+        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
+          else
+            raise Exceptions::RookInvalidObjectForAccess.new(obj.class.to_s, "ReadKey")
+          end
+        end
+
+        def call_method name, args
+          case name
+          when "type"
+            RubyObjectNamespace.new @obj.class.to_s
+          when "size"
+            RubyObjectNamespace.new @obj.length
+          else
+            super
+          end
+        end
+
+        def dump log_object_errors
+          dump_raw_object @obj, 0, @dump_config, log_object_errors
+        end
+      end
+    end
+  end
+end