rookout 0.1.0 → 0.1.1

data/lib/rookout/com_ws/information.rb

@@ -14,7 +14,7 @@ module Rookout
       def initialize labels
         @agent_id = nil
         @labels = labels.clone
-        @labels["rookout_debug"] = "on"
+        @labels["rookout_debug"] = "on" if Config.debug
 
         @ip_addr = local_ip
 

data/lib/rookout/com_ws/pinger.rb

@@ -0,0 +1,36 @@
+module Rookout
+  module ComWs
+    require_relative "../logger"
+
+    class Pinger
+      def initialize connection, interval, timeout
+        @interval = interval
+        @timeout = timeout
+        @connection = connection
+
+        @last_pong = Time.now
+        @last_ping = Time.now
+      end
+
+      def repeat
+        loop do
+          if Time.now - @last_ping > @interval
+            Logger.instance.debug "Sending Ping"
+            @last_ping = Time.now
+            @connection.ping Time.now.to_s do
+              Logger.instance.debug "Got Ping reply"
+              @last_pong = Time.now
+            end
+          end
+
+          if Time.now - @last_pong > @timeout
+            Logger.instance.debug "Ping timeout"
+            break
+          end
+
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/rookout/com_ws/websocket_client.rb

@@ -0,0 +1,143 @@
+module Rookout
+  module ComWs
+    require "openssl"
+    require "websocket/driver"
+
+    require_relative "../config"
+    require_relative "../logger"
+    require_relative "../exceptions"
+
+    class WebsocketClient
+      def initialize url, proxy, token
+        @token = token
+        @connection = WebsocketConnection.new url, proxy
+        @driver = nil
+        @error = nil
+        @last_ping = nil
+      end
+
+      def connect
+        # TODO: add proxy support
+        @connection.connect
+        @driver = WebSocket::Driver.client @connection
+
+        headers.each do |key, value|
+          @driver.set_header key, value
+        end
+
+        @driver.on :error do |error|
+          @error = error
+        end
+
+        # Connect to the remote server
+        @driver.start
+        # TODO: ADD CONNECT TIMEOUT
+        while @driver.state == :connecting
+          recv_data = @connection.read_char
+          @driver.parse recv_data
+        end
+
+        raise Exceptions::RookWebsocketException, @error if @driver.state != :open
+      end
+
+      def connection_pump message_handler
+        @driver.on :message do |e|
+          message_handler.call e.data
+        end
+
+        until @driver.state == :closed
+          recv_data = @connection.read_char
+          @driver.parse recv_data
+        end
+      end
+
+      def send_frame msg
+        @driver.binary msg
+      end
+
+      def ping message, &callback
+        @driver.ping message, &callback
+      end
+
+      def close
+        return if @driver.nil?
+
+        @driver.close
+        @connection.close
+      end
+
+      private
+
+      def headers
+        result = {
+          "User-Agent" => "RookoutAgent/#{Config.rookout_version}+#{Config.rookout_commit}"
+        }
+
+        result["X-Rookout-Token"] = @token unless @token.nil?
+
+        result
+      end
+    end
+
+    class WebsocketConnection
+      def initialize url, proxy
+        @url = url
+        @proxy = proxy
+
+        @uri = URI.parse @url
+        @secure = %w[https wss].include? @uri.scheme
+
+        @socket = nil
+      end
+
+      def connect
+        if @secure
+          @socket = ssl_connect
+        else
+          @socket = tcp_connect
+        end
+      end
+
+      attr_reader :url
+
+      def read_char
+        @socket.getc
+      end
+
+      def write buffer
+        @socket << buffer
+      end
+
+      def close
+        return if @socket.nil?
+
+        @socket.close
+        @socket = nil
+      end
+
+      private
+
+      def tcp_connect
+        TCPSocket.new @uri.host,
+                      @uri.port || (@secure ? 443 : 80)
+      end
+
+      def ssl_connect
+        tcp_socket = tcp_connect
+
+        ctx = ::OpenSSL::SSL::SSLContext.new
+        ctx.min_version = ::OpenSSL::SSL::TLS1_2_VERSION
+        cert_store = ::OpenSSL::X509::Store.new
+        cert_store.set_default_paths
+        ctx.cert_store = cert_store
+
+        ssl_socket = ::OpenSSL::SSL::SSLSocket.new tcp_socket, ctx
+        ssl_socket.hostname = @uri.host
+        ssl_socket.sync_close = true
+        ssl_socket.connect
+
+        ssl_socket
+      end
+    end
+  end
+end

data/lib/rookout/config.rb

@@ -1,5 +1,6 @@
 module Rookout
   require_relative "version"
+  require_relative "commit"
 
   module Config
     # Magic to allow for module variables to be easily accessible

data/lib/rookout/exceptions.rb

@@ -136,5 +136,45 @@ module Rookout
         super "No Rookout token was supplied. Make sure to pass the Rookout Token when starting the rook"
       end
     end
+
+    class RookInvalidOptions < ToolException
+      def initialize description
+        super description
+      end
+    end
+
+    class RookCrcMismatchException < ToolException
+      def initialize filepath, expected, calculated
+        super "Line CRC32s do not match! path: #{filepath}, expected: #{expected}, calculated:#{calculated}",
+              {
+                "filepath" => filepath,
+                "expected" => expected,
+                "calculated" => calculated
+              }
+      end
+    end
+
+    class RookLineMoved < ToolException
+      def initialize filepath, old_line_no, new_line_no
+        super "Line has moved! path: #{filepath}, original line no: #{old_line_no}, new line no: #{new_line_no}",
+              {
+                "filepath" => filepath,
+                "old_line_no" => old_line_no,
+                "new_line_no" => new_line_no
+              }
+      end
+    end
+
+    class RookCommunicationException < ToolException
+      def initialize
+        super "Failed to connect to the controller - will continue attempting in the background"
+      end
+    end
+
+    class RookWebsocketException < ToolException
+      def initialize error
+        super "Error from Websocket #{error}", { "error" => error }
+      end
+    end
   end
 end

data/lib/rookout/interface.rb

@@ -5,6 +5,7 @@ module Rookout
 
     require_relative "config"
     require_relative "exceptions"
+    include Exceptions
 
     def initialize
       @rook = nil
@@ -19,24 +20,21 @@ module Rookout
         require_relative "rookout_singleton"
 
         configure_logging options
-        labels = options[:labels] || parse_labels(ENV["ROOKOUT_LABELS"])
-        validate_labels labels
-
         configure_git options
 
-        com = configure_com options
-
-        async_start = true? ENV["ROOKOUT_ASYNC_START"]
-        fork = evaluate_flag options[:fork], "ROOKOUT_ENABLE_FORK"
-
-        print_config com, labels: labels, async_start: async_start, fork: fork if Config.debug
+        start_options = configure_start_options options
+        print_config start_options
 
         rook = RookoutSingleton.instance
-        rook.connect com[:token], com[:host], com[:port], com[:proxy], labels, async_start, fork
-
-        # TODO: ADD DETAILED PROCESSING FOR SPECIFIC ERRORS
+        rook.connect(**start_options)
+      rescue RookMissingToken, RookInvalidToken, RookInvalidOptions, RookVersionNotSupported => e
+        raise if throw_errors
+        STDERR.puts "[Rookout] Failed to start Rookout: #{e.message}"
+      rescue RookCommunicationException => e
+        raise if throw_errors
+        STDERR.puts "[Rookout] " + e.message
       rescue Exception => e
-        puts e.full_message if Config.debug
+        STDERR.puts e.full_message if Config.debug
         raise if throw_errors
       end
     end
@@ -59,7 +57,7 @@ module Rookout
     def configure_logging options
       if Config.debug
         log_to_stderr = true
-        log_level = "DEBUG"
+        log_level = :DEBUG
       else
         log_to_stderr = evaluate_flag options[:log_to_stderr], "ROOKOUT_LOG_TO_STDERR"
         log_level = options[:log_level] || ENV["ROOKOUT_LOG_FILE"]
@@ -77,16 +75,22 @@ module Rookout
       Config.user_git_commit = options[:git_commit] if options[:git_commit]
     end
 
-    def configure_com options
+    def configure_start_options options
       host = evaluate_config options[:host], "ROOKOUT_CONTROLLER_HOST", "wss://control.rookout.com"
       port = evaluate_config options[:port], "ROOKOUT_CONTROLLER_PORT", 443
       proxy = evaluate_config options[:proxy], "ROOKOUT_PROXY"
       token = evaluate_config options[:token], "ROOKOUT_TOKEN"
 
-      raise Exceptions::RookMissingToken if token.nil? && host == "wss://control.rookout.com"
+      raise RookMissingToken if token.nil? && host == "wss://control.rookout.com"
       verify_token token if token
 
-      { host: host, port: port, proxy: proxy, token: token }
+      labels = options[:labels] || parse_labels(ENV["ROOKOUT_LABELS"])
+      validate_labels labels
+
+      async_start = true? ENV["ROOKOUT_ASYNC_START"]
+      fork = evaluate_flag options[:fork], "ROOKOUT_ENABLE_FORK"
+
+      { host: host, port: port, proxy: proxy, token: token, labels: labels, async_start: async_start, fork: fork }
     end
 
     def evaluate_flag argument, env_var_name
@@ -120,21 +124,22 @@ module Rookout
     def validate_labels labels
       labels.each do |label_name, _|
         if label_name.start_with? "$"
-          raise Exceptions::RookInvalidLabel, label_name
+          raise RookInvalidLabel, label_name
         end
       end
     end
 
     def verify_token token
-      raise Exceptions::RookInvalidOptions, "Rookout token should be a String" unless token.is_a? String
-      raise Exceptions::RookInvalidOptions, "Rookout token should be 64 characters" unless token.length == 64
-      raise Exceptions::RookInvalidOptions, "Rookout token must consist of only hexadecimal characters" unless
+      raise RookInvalidOptions, "Rookout token should be a String" unless token.is_a? String
+      raise RookInvalidOptions, "Rookout token should be 64 characters" unless token.length == 64
+      raise RookInvalidOptions, "Rookout token must consist of only hexadecimal characters" unless
           token.match(/^[0-9a-zA-Z]{0,64}$/)
     end
 
-    def print_config com, options
-      puts "[Rookout] Communication Options: #{com}"
-      puts "[Rookout] Other Options #{options}"
+    def print_config options
+      return unless Config.debug
+
+      puts "[Rookout] Start Options: #{options}"
     end
   end
 end

data/lib/rookout/logger.rb

@@ -11,6 +11,14 @@ module Rookout
     LOG_LEVELS = [:DEBUG, :INFO, :WARNING, :ERROR].freeze
 
     def initialize
+      # Detect unit tests
+      if ($PROGRAM_NAME.end_with?("minitest_runner.rb") ||
+          $PROGRAM_NAME.end_with?("tunit_or_minitest_in_folder_runner.rb")) &&
+         Dir.pwd.end_with?("ruby-sdk")
+        Config.logger_log_level = :DEBUG
+        Config.logger_log_to_stderr = true
+      end
+
       @verbosity = LOG_LEVELS.index(Config.logger_log_level) || LOG_LEVELS.index(:INFO)
 
       @output = nil
@@ -43,7 +51,6 @@ module Rookout
     end
 
     def exception message, exc
-      # TODO: REVIEW HOW TO REPORT EXCEPTIONS
       error message, exc
     end
 
@@ -54,7 +61,14 @@ module Rookout
         @level = level
         @time = Time.new
         @message = message
-        @formatted_message = message % arguments
+        @formatted_message = @message % arguments
+
+        arguments.each do |argument|
+          if argument.is_a? Exception
+            @formatted_message += "\n" + argument.message + "\n" + argument.backtrace.join("\n\t")
+          end
+        end
+
         @arguments = arguments
         set_caller
       end

data/lib/rookout/processor/namespace_serializer.rb

@@ -17,7 +17,7 @@ module Rookout
           Logger.instance.exception message, e
 
           error = RookError.new e, message
-          variant = error.dumps
+          variant.error_value = error.dumps
         end
         variant
       end

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

@@ -4,7 +4,7 @@ module Rookout
       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 +12,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,7 +6,7 @@ module Rookout
 
       require_relative "../../protobuf/variant_pb"
 
-      class RubyUtilsNamespace < Namespace
+      class NoopNamespace < Namespace
         def initialize
           super
         end

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

@@ -17,7 +17,7 @@ module Rookout
             Logger.instance.exception message, e
 
             error = RookError.new e, message
-            variant = error.dumps
+            variant.error_value = error.dumps
           end
           variant
         end
@@ -29,7 +29,7 @@ module Rookout
 
           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
@@ -104,7 +104,7 @@ module Rookout
             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