rookout 0.1.0 → 0.1.56

data/lib/rookout/exceptions.rb

@@ -11,9 +11,6 @@ module Rookout
     end
 
     class RookInterfaceException < ToolException
-      def initialize message
-        super message
-      end
     end
 
     class RookVersionNotSupported < ToolException
@@ -31,7 +28,7 @@ module Rookout
 
     class RookAttributeNotFound < ToolException
       def initialize attribute
-        super "Failed to get attribute #{attribute}", { attribute: attribute }
+        super "Failed to get attribute #{attribute}", { "attribute" => attribute }
       end
     end
 
@@ -84,37 +81,68 @@ module Rookout
 
     class RookNonPrimitiveObjectType < ToolException
       def initialize path
-        super "Object %s must be of primitive type, such as: string, int, long etc: #{path}", { path: path }
+        super "Object #{path} must be of primitive type, such as: string, int, long etc",
+              { "path" => path }
       end
     end
 
     class RookMessageSizeExceeded < ToolException
       def initialize message_size, max_message_size
         super "Message size of #{message_size} exceeds max size limit of #{max_message_size}. " \
-                  "Change the depth of collection or change the default by setting ROOKOUT_MAX_MESSAGE_SIZE " \
-                  "as environment variable or system property",
-              { message_size: message_size, max_message_size: max_message_size }
+              "Change the depth of collection or change the default by setting ROOKOUT_MAX_MESSAGE_SIZE " \
+              "as environment variable or system property",
+              { "message_size" => message_size, "max_message_size" => max_message_size }
+      end
+    end
+
+    class RookOutputQueueFull < ToolException
+      def initialize
+        super "Breakpoint triggered but output queue is full. " \
+              "Data collection will be disabled until the queue has emptied."
       end
     end
 
-    class RookRuleRateLimited < ToolException
+    class RookRuleAugRateLimited < ToolException
       def initialize
         super "Breakpoint was disabled due to rate-limiting. " \
-                   "For more information: https://docs.rookout.com/docs/breakpoints-tasks.html#rate-limiting"
+              "For more information: https://docs.rookout.com/docs/breakpoints-tasks.html#rate-limiting"
+      end
+    end
+
+    class RookRuleGlobalRateLimited < ToolException
+      def initialize
+        super "Breakpoint was disabled due to global rate-limiting. " \
+              "For more information: https://docs.rookout.com/docs/breakpoints-tasks.html#rate-limiting"
+      end
+    end
+
+    class RookRuleRateLimited
+      def self.create
+        if Rookout::Config.using_global_rate_limiter
+          return RookRuleGlobalRateLimited.new
+        end
+        RookRuleAugRateLimited.new
       end
     end
 
     class RookInvalidToken < ToolException
-      def initialize token
+      def initialize token = ""
         super "The Rookout token supplied #{token[0..6]} is not valid; please check the token and try again",
               { token: token[0...6] }
       end
     end
 
+    class RookWebSocketError < ToolException
+      def initialize http_status
+        super "Received HTTP status #{http_status} from the controller," \
+              "Please make sure WebSocket is enabled on the load balancer."
+      end
+    end
+
     class RookSourceFilePathSuggestion < ToolException
       def initialize wanted_path, matching_path
         super "Rookout found alternative file path: #{matching_path}",
-              { wanted_path: wanted_path, matching_path: matching_path }
+              { "wanted_path" => wanted_path, "matching_path" => matching_path }
       end
     end
 
@@ -125,6 +153,13 @@ module Rookout
       end
     end
 
+    class RookInvalidPositionException < ToolException
+      def initialize filename, line
+        super "Invalid code position for TracePoint: #{filename}:#{line}",
+              { filename: filename, line: line }
+      end
+    end
+
     class RookObjectCannotBeSerialized < ToolException
       def initialize object, message
         super message, { "class" => object.class.to_s }
@@ -136,5 +171,105 @@ module Rookout
         super "No Rookout token was supplied. Make sure to pass the Rookout Token when starting the rook"
       end
     end
+
+    class RookInvalidOptions < ToolException
+    end
+
+    class RookInvalidLabel < ToolException
+      def initialize label_name
+        super "Invalid label: must not start with the '$' character (#{label_name})"
+      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
+
+    class RookProxyException < ToolException
+      def initialize error
+        super "Error from proxy #{error}", { "error" => error }
+      end
+    end
+
+    class RookBadProtobuf < ToolException
+      def initialize
+        super 'Bad protobuf version. Please execute "bundle config force_ruby_platform true" before "bundler install".'
+      end
+    end
+
+    class RookBadProtobufPlatform < ToolException
+      def initialize platform
+        super "Bad protobuf platform: #{platform}"
+      end
+    end
+
+    class RookObjectNameMissing < ToolException
+      def initialize configuration
+        super "Failed to find object name",
+              {
+                "configuration" => configuration
+              }
+      end
+    end
+
+    class RookUnsupportedLocation < ToolException
+      def initialize location
+        super "Unsupported aug location was specified: #{location}",
+              {
+                "location" => location
+              }
+      end
+    end
+
+    class RookInvalidRateLimitConfiguration < ToolException
+      def initialize config
+        super "Invalid rate limit configuration: #{config}",
+              {
+                "config" => config
+              }
+      end
+    end
+
+    class RookUnsupportedLiveLogger < ToolException
+      def initialize
+        super "Live Logger is not supported. Try using Rookout Live Debugger instead."
+      end
+    end
+
+    class RookLocalsUnavailable < ToolException
+      def initialize
+        super "Can't collect local variables up the stack"
+      end
+    end
   end
 end

data/lib/rookout/interface.rb

@@ -4,10 +4,18 @@ module Rookout
     include Singleton
 
     require_relative "config"
+    require_relative "utils"
     require_relative "exceptions"
+    include Exceptions
 
     def initialize
       @rook = nil
+      @start_options = nil
+    end
+
+    def print_debug_messages
+      puts "[Rookout] Running in debug mode"
+      puts "[Rookout] Rookout SDK for ruby: #{Config.rookout_version}"
     end
 
     def start options = {}
@@ -15,28 +23,31 @@ module Rookout
       throw_errors = options[:throw_errors] == true
       Config.debug = evaluate_flag options[:debug], "ROOKOUT_DEBUG"
 
-      begin
-        require_relative "rookout_singleton"
-
-        configure_logging options
-        labels = options[:labels] || parse_labels(ENV["ROOKOUT_LABELS"])
-        validate_labels labels
+      print_debug_messages if Config.debug
 
-        configure_git options
-
-        com = configure_com options
+      begin
+        verify_env
 
-        async_start = true? ENV["ROOKOUT_ASYNC_START"]
-        fork = evaluate_flag options[:fork], "ROOKOUT_ENABLE_FORK"
+        require_relative "rookout_singleton"
 
-        print_config com, labels: labels, async_start: async_start, fork: fork if Config.debug
+        configure 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
+        @start_options[throw_errors: throw_errors]
+        rook.connect(**@start_options)
+      rescue LoadError
+        raise if throw_errors
+        $stderr.puts "[Rookout] Failed to load Rookout. Please make sure to force build native extensions by setting" \
+                     "'bundle config force_ruby_platform true'"
+      rescue RookMissingToken, RookInvalidToken, RookInvalidOptions,
+             RookVersionNotSupported, RookBadProtobuf, RookWebSocketError => e
+        raise if throw_errors
+        $stderr.puts "[Rookout] Failed to start Rookout: #{e.message}"
+      rescue RookCommunicationException => e
+        raise if throw_errors
+        Logger.instance.warning "[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
@@ -56,10 +67,42 @@ module Rookout
 
     TRUE_VALUE = [true, "y", "Y", "yes", "Yes", "YES", "true", "True", "TRUE", "1"].freeze
 
-    def configure_logging options
+    def configure options
+      # If we are running post fork, use previous start_options
+      if options[:post_fork]
+        # Don't re-enable the fork handler
+        @start_options[:fork] = false
+      else
+        configure_globals options
+
+        @start_options = configure_start_options options
+        print_config @start_options
+      end
+    end
+
+    def verify_env
+      # Only test alpine
+      return unless File.exist? "/etc/alpine-release"
+
+      # Make sure protobuf is built from source
+      protobuf = Gem::Specification.find_by_path "google/protobuf"
+      $stderr.puts RookBadProtobuf.new.message if protobuf.nil?
+      return unless protobuf.platform != "ruby"
+
+      error = RookBadProtobufPlatform.new protobuf.platform
+      $stderr.puts error.message
+    end
+
+    def configure_scm options
+      Config.user_git_origin = options[:git_origin] if options[:git_origin]
+      Config.user_git_commit = options[:git_commit] if options[:git_commit]
+      Config.user_git_sources = options[:git_sources] if options[:git_sources] && options[:git_sources].is_a?(Hash)
+    end
+
+    def configure_globals 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"]
@@ -70,23 +113,30 @@ module Rookout
       Config.logger_log_to_stderr = log_to_stderr unless log_to_stderr.nil?
       Config.logger_filename = log_file unless log_file.nil?
       Config.logger_log_level = log_level unless log_level.nil?
-    end
 
-    def configure_git options
-      Config.user_git_origin = options[:git_origin] if options[:git_origin]
-      Config.user_git_commit = options[:git_commit] if options[:git_commit]
+      configure_scm options
     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_specified options)
       verify_token token if token
 
-      { host: host, port: port, proxy: proxy, token: token }
+      labels = stringify_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 host_specified options
+      !options[:host].nil? || !ENV["ROOKOUT_CONTROLLER_HOST"].nil? || !ENV["ROOKOUT_AGENT_HOST"].nil?
     end
 
     def evaluate_flag argument, env_var_name
@@ -104,6 +154,18 @@ module Rookout
       default
     end
 
+    def stringify_labels labels
+      return nil unless labels
+
+      stringified_labels = {}
+
+      labels.each do |label_name, label_value|
+        stringified_labels[label_name.to_s] = label_value.to_s
+      end
+
+      stringified_labels
+    end
+
     def parse_labels raw_labels
       labels = {}
       return labels if raw_labels.nil?
@@ -120,21 +182,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,15 @@ module Rookout
     LOG_LEVELS = [:DEBUG, :INFO, :WARNING, :ERROR].freeze
 
     def initialize
+      # Detect unit tests
+      if (Config.debug ||
+          $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 +52,6 @@ module Rookout
     end
 
     def exception message, exc
-      # TODO: REVIEW HOW TO REPORT EXCEPTIONS
       error message, exc
     end
 
@@ -54,12 +62,25 @@ 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
 
-      attr_reader :level, :time, :filename, :lineno, :message, :formatted_message, :arguments
+      attr_reader :level
+      attr_reader :time
+      attr_reader :filename
+      attr_reader :lineno
+      attr_reader :message
+      attr_reader :formatted_message
+      attr_reader :arguments
 
       def format
         "#{@time} #{Process.pid}:#{Thread.current.name}-" \
@@ -84,6 +105,7 @@ module Rookout
       end
     end
 
+    # rubocop:disable Style/RescueStandardError
     def log level, message, args
       level_no = LOG_LEVELS.index level
       if level_no.nil?
@@ -95,11 +117,18 @@ module Rookout
 
       record = LogRecord.new level, message, args
       @handlers.each { |handler| handler.call record }
+    rescue
+      # Log may never throw
+      nil
     end
+    # rubocop:enable Style/RescueStandardError
 
     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
+      if Config.logger_log_to_stderr
+        @handlers.push new_file_handler unless Config.logger_filename.nil? || Config.logger_filename.empty?
+        @handlers.push new_stderr_handler
+      end
+
       @handlers.push new_remote_handler
     end
 
@@ -114,19 +143,19 @@ module Rookout
         file = nil
 
         if Config.debug
-          STDERR.puts "[Rookout] Failed to open log file: #{log_file_path}"
-          STDERR.puts e.backtrace
+          $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 }
+      ->(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
+        File.join Dir.home, Config.logger_filename
       elsif RUBY_PLATFORM.match?(/cygwin|mswin|mingw|bccwin|wince|emx/)
         File.join ENV["USERPROFILE"], Config.logger_filename
       else
@@ -135,7 +164,7 @@ module Rookout
     end
 
     def new_stderr_handler
-      ->(record) { STDERR.puts record.format }
+      ->(record) { $stderr.puts record.format }
     end
 
     def new_remote_handler

data/lib/rookout/processor/namespace_serializer.rb

@@ -7,7 +7,7 @@ module Rookout
 
       module_function
 
-      def dump namespace, log_errors = true
+      def dump namespace, log_errors
         namespace.dump log_errors
       rescue StandardError => e
         message = "Failed to serialize namespace"
@@ -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