rookout 0.1.0

data/lib/rookout/com_ws/output.rb

@@ -0,0 +1,135 @@
+module Rookout
+  module ComWs
+    require_relative "../logger"
+    require_relative "../config"
+
+    require_relative "../protobuf/messages_pb"
+
+    require_relative "../processor/namespaces/ruby_object_namespace"
+    require_relative "../processor/namespace_serializer"
+
+    require_relative "token_bucket"
+
+    class Output
+      def initialize
+        @agent_id = nil
+        @agent_com = nil
+
+        @rule_status_update_bucket = TokenBucket.new Config.output_max_status_updates,
+                                                     Config.output_bucket_refresh_rate do
+          Logger.instance.error "Limit reached, dropping status updates"
+        end
+
+        @user_message_bucket = TokenBucket.new Config.output_max_aug_messages,
+                                               Config.output_bucket_refresh_rate do
+          Logger.instance.error "Limit reached, dropping aug report messages"
+        end
+
+        @log_message_bucket = TokenBucket.new Config.output_max_log_items,
+                                              Config.output_bucket_refresh_rate do
+          internal_send_log_message 3,
+                                    Time.new,
+                                    __FILE__,
+                                    0,
+                                    text,
+                                    "Limit reached, dropping log messages",
+                                    "Limit reached, dropping log messages"
+        end
+
+        Logger.instance.register_output self
+
+        @closing = false
+      end
+
+      attr_accessor :agent_id, :agent_com
+
+      def close
+        @closing = true
+
+        Logger.instance.remove_output self
+      end
+
+      def send_warning rule_id, error
+        send_rule_status rule_id, :Warning, error
+      end
+
+      def send_rule_status rule_id, active, error
+        return if @closing || !@agent_com
+
+        @rule_status_update_bucket.if_available do
+          protobuf_error = nil
+          if error
+            protobuf_error = Com::Rookout::Error.new message: error.messsage,
+                                                     type: error.type
+            protobuf_error.parameters.copy_from error.parameters
+            protobuf_error.exc.copy_from error.exc
+            protobuf_error.traceback.copy_from error.traceback
+          end
+
+          status = Com::Rookout::RuleStatusMessage.new agent_id: @agent_id,
+                                                       rule_id: rule_id,
+                                                       active: active,
+                                                       error: protobuf_error
+          @agent_com.add status
+        end
+      end
+
+      def send_user_message aug_id, report_id, arguments
+        return if @closing || !@agent_com
+
+        @user_message_bucket.if_available do
+          if arguments.nil? || arguments.call_method("size", "") == 0
+            protobuf_arguments = nil
+          else
+            protobuf_arguments = Processor::NamespaceSerializer.dump arguments
+          end
+
+          msg = Com::Rookout::AugReportMessage.new agent_id: @agent_id,
+                                                   aug_id: aug_id,
+                                                   report_id: report_id,
+                                                   arguments: protobuf_arguments
+          @agent_com.add msg
+        end
+      end
+
+      def send_log_message level, time, filename, lineno, text, formatted_message, arguments
+        return if @closing || !@agent_com
+        @log_message_bucket.if_available do
+          internal_send_log_message level, time, filename, lineno, text, formatted_message, arguments
+        end
+      end
+
+      def flush_messages
+        return unless @agent_com
+        @agent_com.flush
+      end
+
+      private
+
+      def internal_send_log_message level, time, filename, lineno, text, formatted_message, arguments
+        return if @closing || !@agent_com
+
+        timestamp = Google::Protobuf::Timestamp.new
+        timestamp.from_time time
+
+        if arguments.nil? || arguments.empty?
+          protobuf_arguments = nil
+        else
+          protobuf_arguments = Processor::NamespaceSerializer.dump(
+            Processor::Namespaces::RubyObjectNamespace.new(arguments)
+          )
+        end
+
+        msg = Com::Rookout::LogMessage.new timestamp: timestamp,
+                                           agent_id: @agent_id,
+                                           level: level,
+                                           filename: filename,
+                                           line: lineno,
+                                           text: text,
+                                           formatted_message: formatted_message,
+                                           legacy_arguments: protobuf_arguments
+        @agent_com.add msg
+      end
+    end
+  end
+end

data/lib/rookout/com_ws/token_bucket.rb

@@ -0,0 +1,36 @@
+module Rookout
+  module ComWs
+    class TokenBucket
+      def initialize limit, interval_seconds, &do_once_when_exhausted
+        @initial_limit = limit
+        @remaining = limit
+        @last_reset = Time.new
+        @interval = interval_seconds
+        @do_once_when_exhausted = do_once_when_exhausted
+        @do_once_when_exhausted_performed = false
+      end
+
+      def exhausted?
+        if Time.new - @last_reset > @interval
+          @last_reset = Time.new
+          @remaining = @initial_limit
+          @do_once_when_exhausted_performed = false
+        end
+
+        @remaining < 0
+      end
+
+      def if_available
+        @remaining -= 1
+        if exhausted?
+          return if @do_once_when_exhausted_performed || @do_once_when_exhausted.nil?
+
+          @do_once_when_exhausted.call
+          @do_once_when_exhausted_performed = true
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/rookout/config.rb

@@ -0,0 +1,55 @@
+module Rookout
+  require_relative "version"
+
+  module Config
+    # Magic to allow for module variables to be easily accessible
+    class << self
+      attr_accessor :debug
+      Rookout::Config.debug = false
+
+      attr_accessor :logger_filename, :logger_log_to_stderr, :logger_log_level
+      Rookout::Config.logger_filename = "rookout/ruby-rook.log".freeze
+      Rookout::Config.logger_log_to_stderr = false
+      Rookout::Config.logger_log_level = :info
+
+      attr_accessor :agent_com_configuration_command_thread_name,
+                    :agent_com_max_message_limit,
+                    :agent_com_timeout,
+                    :agent_com_ping_interval,
+                    :agent_com_ping_timeout,
+                    :agent_com_flush_timeout,
+                    :agent_com_max_queued_messages
+      Rookout::Config.agent_com_max_message_limit = 1024 * 1024
+      Rookout::Config.agent_com_timeout = 3
+      Rookout::Config.agent_com_ping_interval = 10
+      Rookout::Config.agent_com_ping_timeout = 30
+      Rookout::Config.agent_com_flush_timeout = 3
+      Rookout::Config.agent_com_max_queued_messages = 500
+
+      attr_accessor :backoff_factor, :backoff_reset_time, :backoff_max_time
+      Rookout::Config.backoff_factor = 0.2
+      Rookout::Config.backoff_max_time = 60
+      Rookout::Config.backoff_reset_time = 3 * 60.0
+
+      attr_accessor :output_max_status_updates,
+                    :output_max_aug_messages,
+                    :output_max_log_items,
+                    :output_bucket_refresh_rate
+      Rookout::Config.output_max_status_updates = 200
+      Rookout::Config.output_max_aug_messages = 100
+      Rookout::Config.output_max_log_items = 200
+      Rookout::Config.output_bucket_refresh_rate = 10
+
+      attr_accessor :instrumentation_max_aug_time
+      Rookout::Config.instrumentation_max_aug_time = 400
+
+      attr_accessor :user_git_commit, :user_git_origin
+      Rookout::Config.user_git_commit = nil
+      Rookout::Config.user_git_origin = nil
+
+      attr_accessor :rookout_version, :rookout_commit
+      Rookout::Config.rookout_version = Rookout::VERSION
+      Rookout::Config.rookout_commit = Rookout::COMMIT
+    end
+  end
+end

data/lib/rookout/exceptions.rb

@@ -0,0 +1,140 @@
+module Rookout
+  module Exceptions
+    class ToolException < RuntimeError
+      def initialize msg, parameters = {}, cause = nil
+        super msg
+        @parameters = parameters
+        @cause = cause
+      end
+
+      attr_reader :parameters
+    end
+
+    class RookInterfaceException < ToolException
+      def initialize message
+        super message
+      end
+    end
+
+    class RookVersionNotSupported < ToolException
+      def initialize parameter, value
+        super "Rook is not supported in this #{parameter}: #{value}"
+      end
+    end
+
+    class RookAugInvalidKey < ToolException
+      def initialize key, configuration
+        super "Failed to get key #{key} from configuration #{configuration}",
+              { key: key, configuration: configuration }
+      end
+    end
+
+    class RookAttributeNotFound < ToolException
+      def initialize attribute
+        super "Failed to get attribute #{attribute}", { attribute: attribute }
+      end
+    end
+
+    class RookKeyNotFound < ToolException
+      def initialize key
+        super "Failed to get key #{key}", { key: key }
+      end
+    end
+
+    class RookWriteAttributeNotSupported < ToolException
+      def initialize namespace_type, attribute
+        super "Namespace #{namespace_type} does not support write",
+              { namespace: namespace_type, attribute: attribute }
+      end
+    end
+
+    class RookMethodNotFound < ToolException
+      def initialize namespace_type, method
+        super "Namespace method not found #{method}",
+              { namespace: namespace_type, method: method }
+      end
+    end
+
+    class RookInvalidObjectForAccess < ToolException
+      def initialize object_type, access
+        super "Object #{object_type} does not support access #{access}",
+              { object: object_type, access: access }
+      end
+    end
+
+    class RookInvalidArithmeticPath < ToolException
+      def initialize path, cause = nil
+        super "Invalid arithmetic path configuration. configuration: #{path}, innerException: #{cause}",
+              { configuration: path },
+              cause
+      end
+    end
+
+    class RookOperationReadOnly < ToolException
+      def initialize type
+        super "Operation does not support write: #{type}", { operation: type }
+      end
+    end
+
+    class RookExceptionEvaluationFailed < ToolException
+      def initialize expression, cause
+        super "Failed to evaluate expression %s: #{expression}", { expression: expression }, cause
+      end
+    end
+
+    class RookNonPrimitiveObjectType < ToolException
+      def initialize path
+        super "Object %s must be of primitive type, such as: string, int, long etc: #{path}", { 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 }
+      end
+    end
+
+    class RookRuleRateLimited < ToolException
+      def initialize
+        super "Breakpoint was disabled due to rate-limiting. " \
+                   "For more information: https://docs.rookout.com/docs/breakpoints-tasks.html#rate-limiting"
+      end
+    end
+
+    class RookInvalidToken < ToolException
+      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 RookSourceFilePathSuggestion < ToolException
+      def initialize wanted_path, matching_path
+        super "Rookout found alternative file path: #{matching_path}",
+              { wanted_path: wanted_path, matching_path: matching_path }
+      end
+    end
+
+    class RookSetTracepointFailed < ToolException
+      def initialize target_line, error
+        super "Failed to set TracePoint on line #{target_line} due to #{error.message}",
+              { target_line: target_line, error: error }
+      end
+    end
+
+    class RookObjectCannotBeSerialized < ToolException
+      def initialize object, message
+        super message, { "class" => object.class.to_s }
+      end
+    end
+
+    class RookMissingToken < ToolException
+      def initialize
+        super "No Rookout token was supplied. Make sure to pass the Rookout Token when starting the rook"
+      end
+    end
+  end
+end

data/lib/rookout/interface.rb

@@ -0,0 +1,140 @@
+module Rookout
+  class Interface
+    require "singleton"
+    include Singleton
+
+    require_relative "config"
+    require_relative "exceptions"
+
+    def initialize
+      @rook = nil
+    end
+
+    def start options = {}
+      return unless @rook.nil?
+      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
+
+        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
+
+        rook = RookoutSingleton.instance
+        rook.connect com[:token], com[:host], com[:port], com[:proxy], labels, async_start, fork
+
+        # TODO: ADD DETAILED PROCESSING FOR SPECIFIC ERRORS
+      rescue Exception => e
+        puts e.full_message if Config.debug
+        raise if throw_errors
+      end
+    end
+
+    def flush
+      @rook.flush unless @rook.nil?
+    end
+
+    def stop
+      return if @rook.nil?
+
+      @rook.stop
+      @rook = nil
+    end
+
+    private
+
+    TRUE_VALUE = [true, "y", "Y", "yes", "Yes", "YES", "true", "True", "TRUE", "1"].freeze
+
+    def configure_logging options
+      if Config.debug
+        log_to_stderr = true
+        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"]
+      end
+
+      log_file = options[:log_file] || ENV["ROOKOUT_LOG_FILE"]
+
+      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]
+    end
+
+    def configure_com 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"
+      verify_token token if token
+
+      { host: host, port: port, proxy: proxy, token: token }
+    end
+
+    def evaluate_flag argument, env_var_name
+      return true? argument unless argument.nil?
+      true? ENV[env_var_name]
+    end
+
+    def true? value
+      TRUE_VALUE.include? value
+    end
+
+    def evaluate_config argument, env_var_name, default = nil
+      return argument unless argument.nil?
+      return ENV[env_var_name] unless ENV[env_var_name].nil?
+      default
+    end
+
+    def parse_labels raw_labels
+      labels = {}
+      return labels if raw_labels.nil?
+
+      raw_labels.split(",").each do |raw_label|
+        keyvalue = raw_label.gsub(/^[( "')*]/, "").gsub(/[( "')*]$/, "").split(":")
+        if keyvalue.length == 2
+          labels[keyvalue[0]] = keyvalue[1]
+        end
+      end
+      labels
+    end
+
+    def validate_labels labels
+      labels.each do |label_name, _|
+        if label_name.start_with? "$"
+          raise Exceptions::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
+          token.match(/^[0-9a-zA-Z]{0,64}$/)
+    end
+
+    def print_config com, options
+      puts "[Rookout] Communication Options: #{com}"
+      puts "[Rookout] Other Options #{options}"
+    end
+  end
+end