rookout 0.1.30 → 0.1.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8bbc125cf28986d8ae700369a4d36c255e3912f0f9abb895ea10206d6090ca8
-  data.tar.gz: 3d20369b3dfe6141454e6a5a262defc0f6a0700d37d7ee6936911e4eaca5b510
+  metadata.gz: 196f2f88ab9aa7682827d18d62bebec26929ce012e6231d6ee80f86969c097dd
+  data.tar.gz: 2adcb1e41cc03e78a2cd0ce7e980ac773d89dcfe6129b3d7996e75cdcb30aaeb
 SHA512:
-  metadata.gz: 939d0c89c0683ca263ca0d0c7980c86537d681462d6e81fb447c0598a323fe7897f6342c3d51add8519e06295c33527d7488964b1a0bb448fcdb3b933c86fe24
-  data.tar.gz: f7d1228b2cdd81f6fe01a042b3aa38d89e7b6f2312c16cff32107dd6e0c40f951fe2aa67cb746b6f7adf076da245e422a1e3dbaa941063aa34af000db65c3aa5
+  metadata.gz: 9c5809942e93ab54c9ec6884703b46eb86e9719dd8f743200f89c3af03dc36364cdb1720b431193ef6b33d11878f2be76cfa00288f8cb21ae731fe48199c810c
+  data.tar.gz: 198b8dc838430f03857031b564011d79ac1b115cd290a4e4b5f94393538c8b7187b0a0e799fbaa923964840926606036807874907f0fad70cb6cba5667603029

data/lib/rookout/com_ws/agent_com_ws.rb

@@ -44,6 +44,7 @@ module Rookout
         @main_thread = nil
         @outgoing_thread = nil
         @pending_messages = Queue.new
+        @pending_messages_length = 0
 
         @running = false
         @ready_event = Concurrent::Event.new
@@ -52,18 +53,21 @@ module Rookout
         @print_on_initial_connection = print_on_connect
       end
 
-      def add message
-        buffer = wrap_in_envelope message
-        if buffer.length > Config.agent_com_max_message_limit
-          exc = Exceptions::RookMessageSizeExceeded.new buffer.length, Config.agent_com_max_message_limit
+      def add envelope_wrapper
+        msg_size = envelope_wrapper.calculate_size
+        if @pending_messages_length + msg_size > Config.agent_com_max_queue_messages_length ||
+           queue_full?
+          exc = Exceptions::RookMessageSizeExceeded.new msg_size, Config.agent_com_max_queue_messages_length
           warning = Processor::RookError.new exc
           UserWarnings.notify_warning warning
 
-          Logger.instance.warning "Dropping message, size was #{buffer.length} which is over the message size limit"
+          Logger.instance.warning "Dropping message, size was #{msg_size}, pedning messages: #{@pending_messages_length}
+                                  which is over the message size limit #{Config.agent_com_max_queue_messages_length},
+                                  queue length: #{@pending_messages.length}"
           return
         end
 
-        @pending_messages.push buffer if @pending_messages.length < Config.agent_com_max_queued_messages
+        @pending_messages.push envelope_wrapper
       end
 
       def queue_full?
@@ -128,7 +132,7 @@ module Rookout
               @ready_event.set
             end
 
-            Logger.instance.warn "Connection failed; reason = #{e.message}"
+            Logger.instance.warning "Connection failed; reason = #{e.message}"
           end
 
           backoff.after_disconnect
@@ -191,12 +195,15 @@ module Rookout
       def outgoing client, on_exit
         Pinger.new(client, Config.agent_com_ping_interval, Config.agent_com_ping_timeout).repeat do
           begin
-            msg = @pending_messages.pop true
+            envelope_wrapper = @pending_messages.pop true
           rescue ThreadError
             sleep 0.25
             next
           end
 
+          msg = envelope_wrapper.envelope
+          @pending_messages_length -= envelope_wrapper.calculate_size
+
           if msg.is_a? ExitMessage
             break if msg.thread == Thread.current
           elsif msg.is_a? FlushMessage

data/lib/rookout/com_ws/command_handler.rb

@@ -5,10 +5,10 @@ module Rookout
     class CommandHandler
       def initialize agent_com, augs_manager
         agent_com.on "Com::Rookout::InitialAugsCommand" do |initial_augs|
+          Config.update_config initial_augs.sdk_configuration
           augs = initial_augs.augs.map { |aug_json| JSON.parse aug_json }
           augs_manager.initialize_augs augs
         end
-
         agent_com.on "Com::Rookout::AddAugCommand" do |command|
           augs_manager.add_aug JSON.parse(command.aug_json)
         end

data/lib/rookout/com_ws/envelope_wrapper.rb

@@ -0,0 +1,57 @@
+require_relative "../protobuf/envelope_pb"
+require_relative "../processor/namespace_serializer2"
+
+
+class EnvelopeWrapperBase
+  def wrap_in_envelope message
+    any_message = Google::Protobuf::Any.pack message
+    timestamp = Google::Protobuf::Timestamp.new
+    timestamp.from_time Time.new
+    envelope = Com::Rookout::Envelope.new msg: any_message, timestamp: timestamp
+    serialized = Com::Rookout::Envelope.encode envelope
+    serialized
+  end
+
+  def envelope
+    raise NotImplementedError
+  end
+
+  def calculate_size
+    raise NotImplementedError
+  end
+end
+
+class Variant2EnvelopeWrapper < EnvelopeWrapperBase
+  def initialize agent_id, aug_id, report_id, arguments
+    @aug_report_message = Com::Rookout::AugReportMessage.new agent_id: agent_id,
+                                       aug_id: aug_id,
+                                       report_id: report_id
+    @serializer = Rookout::Processor::NamespaceSerializer2.new
+    @aug_report_message.arguments2 = @serializer.dump arguments
+  end
+
+  def envelope
+    return @envelope unless @envelope.nil?
+    @serializer.string_cache.each { |key, value| @aug_report_message.strings_cache[key] = value }
+    @envelope = wrap_in_envelope @aug_report_message
+    @aug_report_message = nil
+  end
+
+  def calculate_size
+    @envelope.length + @serializer.estimated_pending_bytes
+  end
+end
+
+class EnvelopeWrapper < EnvelopeWrapperBase
+  def initialize message
+    @envelope = wrap_in_envelope message
+  end
+
+  def envelope
+    @envelope
+  end
+
+  def calculate_size
+    @envelope.length
+  end
+end

data/lib/rookout/com_ws/output.rb

@@ -9,6 +9,7 @@ module Rookout
     require_relative "../processor/namespace_serializer"
 
     require_relative "token_bucket"
+    require_relative "envelope_wrapper"
 
     class Output
       def initialize
@@ -64,11 +65,13 @@ module Rookout
           status = Com::Rookout::RuleStatusMessage.new agent_id: @agent_id,
                                                        rule_id: rule_id,
                                                        active: active
+
+          envelope_wrapper = EnvelopeWrapper.new status
           if error
             status.error = error.dumps
           end
 
-          @agent_com.add status
+          @agent_com.add envelope_wrapper
         end
       end
 
@@ -76,17 +79,22 @@ module Rookout
         return if @closing || !@agent_com
 
         @user_message_bucket.if_available do
-          if arguments.nil? || arguments.call_method("size", "") == 0
-            protobuf_arguments = nil
+          if Config.protobuf_version2
+            envelope_wrapper = Variant2EnvelopeWrapper.new @agent_id, aug_id, report_id, arguments
           else
-            protobuf_arguments = Processor::NamespaceSerializer.dump arguments
+            if arguments.nil? || arguments.call_method("size", "") == 0
+              protobuf_arguments = nil
+            else
+              protobuf_arguments = Processor::NamespaceSerializer.dump arguments
+            end
+
+            envelope_wrapper = EnvelopeWrapper.new(Com::Rookout::AugReportMessage.new(agent_id: @agent_id,
+                                                     aug_id: aug_id,
+                                                     report_id: report_id,
+                                                     arguments: protobuf_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
+          @agent_com.add envelope_wrapper
         end
       end
 
@@ -126,7 +134,10 @@ module Rookout
                                            text: text,
                                            formatted_message: formatted_message,
                                            legacy_arguments: protobuf_arguments
-        @agent_com.add msg
+
+        envelope_wrapper = EnvelopeWrapper.new msg
+
+        @agent_com.add envelope_wrapper
       end
     end
   end

data/lib/rookout/commit.rb

@@ -1,3 +1,3 @@
 module Rookout
-  COMMIT = "a753176d0b434bab7c3ab0467b5a544276d5a7f0".freeze
+  COMMIT = "7482cbb0910012bfede396ef9590766d9dc561aa".freeze
 end

data/lib/rookout/config.rb

@@ -15,12 +15,14 @@ module Rookout
 
       attr_accessor :agent_com_configuration_command_thread_name,
                     :agent_com_max_message_limit,
+                    :agent_com_max_queue_messages_length,
                     :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_max_queue_messages_length = 15 * 1024 * 1024
       Rookout::Config.agent_com_timeout = 3
       Rookout::Config.agent_com_ping_interval = 10
       Rookout::Config.agent_com_ping_timeout = 30
@@ -51,6 +53,24 @@ module Rookout
       attr_accessor :rookout_version, :rookout_commit
       Rookout::Config.rookout_version = Rookout::VERSION
       Rookout::Config.rookout_commit = Rookout::COMMIT
+
+      attr_accessor :protobuf_version2
+      Rookout::Config.protobuf_version2 = false
+
+      attr_accessor :true_values
+      Rookout::Config.true_values = ["y", "Y", "yes", "Yes", "YES", "true", "True", "TRUE", "1"]
+
+
+      def update_config configuration
+        is_config_proto2 = configuration["RUBY_PROTOBUF_VERSION_2"]
+        return if is_config_proto2.nil?
+        is_env_proto2 = ENV[env_var_name]
+        if is_env_proto2.nil?
+          @protobuf_version2 = true if @true_values.includes? is_config_proto2
+        elsif @true_values.includes? is_env_proto2
+          @protobuf_version2 = true
+        end
+      end
     end
   end
 end

data/lib/rookout/interface.rb

@@ -43,7 +43,7 @@ module Rookout
         STDERR.puts "[Rookout] Failed to start Rookout: #{e.message}"
       rescue RookCommunicationException => e
         raise if throw_errors
-        Logger.instance.warn "[Rookout] " + e.message
+        Logger.instance.warning "[Rookout] " + e.message
       rescue Exception => e
         STDERR.puts e.full_message if Config.debug
         raise if throw_errors

data/lib/rookout/processor/namespace_serializer2.rb

@@ -0,0 +1,283 @@
+module Rookout
+  module Processor
+    class NamespaceSerializer2
+      require_relative "../logger"
+
+      require_relative "../protobuf/variant_pb"
+      require_relative "../protobuf/variant2_pb"
+      require_relative "../user_warnings"
+      require_relative "./namespaces/container_namespace"
+      require_relative "./namespaces/traceback_namespace"
+
+      def initialize
+        @string_cache = {}
+        @estimated_pending_bytes = 0
+      end
+
+      attr_reader :string_cache, :estimated_pending_bytes
+
+      def get_string_index_in_cache str
+        if @string_cache.key? str
+          @string_cache[str]
+        else
+          @estimated_pending_bytes += str.length + 5
+          current_size = @string_cache.size
+          @string_cache.store str, current_size
+          current_size
+        end
+      end
+
+      def dump_variant_type variant, type
+        variant.variant_type_max_depth = type << 1
+      end
+
+      def dump_variant_type_max_depth variant, type
+        variant.variant_type_max_depth = (type << 1) | 1
+      end
+
+      def dump namespace, log_errors = true
+        if namespace.is_a? Namespaces::RubyObjectNamespace
+          dump_ruby_object_namespace namespace, log_errors
+        elsif namespace.is_a? Namespaces::ContainerNamespace
+          dump_container_namespace namespace, log_errors
+        elsif namespace.is_a? Namespaces::TracebackNamespace
+          dump_traceback_namespace namespace
+        end
+      rescue StandardError => e
+        message = "Failed to serialize namespace"
+        variant = Com::Rookout::Variant2.new
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_ERROR
+
+        if log_errors
+          Logger.instance.exception message, e
+
+          error = RookError.new e, message
+          UserWarnings.notify_warning error
+        end
+        variant
+      end
+
+      def dump_ruby_object_namespace namespace, log_errors
+        dump_raw_object namespace.obj, 0, namespace.dump_config, log_errors
+      end
+
+      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::Variant2.new
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_ERROR
+
+        if log_object_errors
+          Logger.instance.exception message, e
+
+          error = RookError.new e, message
+          UserWarnings.notify_warning error
+        end
+        variant
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def unsafe_dump_object obj, current_depth, config, log_object_errors
+        variant = Com::Rookout::Variant2.new original_type_index_in_cache: get_string_index_in_cache(obj.class.to_s)
+
+        if obj.nil?
+          dump_nil variant
+        elsif obj.is_a?(Numeric) || obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+          dump_numeric obj, variant, config
+        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.class == Array
+          dump_array obj, variant, current_depth, config, log_object_errors
+        elsif obj.class == 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, obj, current_depth, config, log_object_errors
+        end
+
+        variant
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def dump_nil variant
+        dump_variant_type variant, Com::Rookout::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, config
+        if obj == true
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
+          variant.long_value = 1
+        elsif obj == false
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
+          variant.long_value = 0
+        elsif obj.is_a? Integer
+          dump_integer obj, variant
+        elsif obj.is_a? Float
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_DOUBLE
+          variant.double_value = obj.to_f
+        elsif obj.is_a? BigDecimal
+          dump_string obj.to_s, variant, config # TODO: NS: This might cut the decimal value, is that ok?
+        elsif obj.is_a? Complex
+          dump_variant_type variant, Com::Rookout::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.new(obj.class, "Unknown Numeric Type")
+        end
+        # TODO: ADD SUPPORT FOR RATIONALS
+      end
+
+      def dump_integer obj, variant
+        if obj > INT32_MIN && obj < INT64_MAX
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
+          variant.long_value = obj
+        else
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LARGE_INT
+          variant.bytes_index_in_cache = get_string_index_in_cache obj.to_s
+        end
+      end
+
+      def dump_string obj, variant, config
+        obj = obj.to_s
+        if obj.length > config.max_string
+          final_obj = obj[0...config.max_string]
+        else
+          final_obj = obj
+        end
+
+        variant.original_size = obj.length
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_STRING
+        variant.bytes_index_in_cache = get_string_index_in_cache final_obj
+      end
+
+      def dump_time obj, variant
+        dump_variant_type variant, Com::Rookout::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.original_size = obj.length
+
+        weighted_children_depth = current_depth + 1
+        if weighted_children_depth <= config.max_collection_depth
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LIST
+          obj.each_with_index do |value, index|
+            break if index >= config.max_width
+            variant.collection_values << dump_raw_object(value, weighted_children_depth, config, log_object_errors)
+          end
+        else
+          dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_LIST
+        end
+      end
+
+      def dump_hash obj, variant, current_depth, config, log_object_errors
+        variant.original_size = obj.length
+
+        weighted_children_depth = current_depth + 1
+        if current_depth <= config.max_collection_depth
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_MAP
+          obj.each_with_index do |(key, value), index|
+            break if index >= config.max_width
+            variant.collection_keys << dump_raw_object(key, weighted_children_depth, config, log_object_errors)
+            variant.collection_values << dump_raw_object(value, weighted_children_depth, config, log_object_errors)
+          end
+        else
+          dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_MAP
+        end
+      end
+
+      def dump_exception obj, variant, current_depth, config, log_object_errors
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
+        variant.attribute_names_in_cache << get_string_index_in_cache("message")
+        variant.attribute_values << dump_raw_object(obj.message, current_depth + 1, config, log_object_errors)
+
+        variant.attribute_names_in_cache << get_string_index_in_cache("cause")
+        variant.attribute_values << dump_raw_object(obj.cause, current_depth + 1, config, log_object_errors)
+
+        variant.attribute_names_in_cache << get_string_index_in_cache("backtrace")
+        variant.attribute_values << dump_raw_object(obj.backtrace, current_depth + 1, config, log_object_errors)
+      end
+
+      def dump_code_object obj, variant
+        dump_variant_type variant, Com::Rookout::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_values << Com::Rookout::Variant::CodeObject.new(name: name,
+                                                                     filename: source_location[0],
+                                                                     lineno: source_location[1])
+      end
+
+      def dump_user_class variant, obj, current_depth, config, log_object_errors
+        weighted_children_depth = current_depth + 1
+        if weighted_children_depth <= config.max_collection_depth
+          dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
+
+          obj.instance_variables.each do |name|
+            raw_value = obj.instance_variable_get name
+            variant.attribute_names_in_cache << get_string_index_in_cache(name.to_s)
+            variant.attribute_values << dump_raw_object(raw_value, weighted_children_depth, config, log_object_errors)
+          end
+        else
+          dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
+        end
+      end
+
+      def dump_container_namespace namespace, log_errors
+        variant = Com::Rookout::Variant2.new
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_NAMESPACE
+
+        namespace.hash.each do |key, value|
+          variant.attribute_names_in_cache << get_string_index_in_cache(key.to_s)
+          variant.attribute_values << dump(value, log_errors)
+        end
+
+        variant
+      end
+
+      def dump_traceback_namespace namespace
+        variant = Com::Rookout::Variant2.new
+        dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_TRACEBACK
+
+        namespace.depth.times do |i|
+          position = i + namespace.offset
+          break if position >= namespace.backtrace.length
+          frame = namespace.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
+          variant.code_values << code_object
+        end
+        variant
+      end
+    end
+  end
+end

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

@@ -8,11 +8,15 @@ module Rookout
 
       require_relative "../../protobuf/variant_pb"
 
+
       class ContainerNamespace < Namespace
         def initialize hash = {}
           @hash = hash
         end
 
+        attr_reader :hash
+
+
         def call_method name, args
           return RubyObjectNamespace.new @hash.length if name == "size"
           super

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

@@ -20,12 +20,12 @@ module Rookout
         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_STRICT = ObjectDumpConfig.new 2, 10, 2, 128
+      OBJECT_DUMP_CONFIG_DEFAULT = ObjectDumpConfig.new 4, 15, 4, 512
+      OBJECT_DUMP_CONFIG_TOLERANT = ObjectDumpConfig.new 5, 20, 5, 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_CONFIG_COLLECTION = ObjectDumpConfig.new 4, 100, 4, 512
 
       OBJECT_DUMP_TABLE = {
         "" => OBJECT_DUMP_CONFIG_DEFAULT,
@@ -47,7 +47,7 @@ module Rookout
         def tailor_limits!
           if @obj.is_a? String
             @dump_config = OBJECT_DUMP_CONFIG_STRING
-          elsif @obj.is_a?(Hash) || @obj.is_a?(Array)
+          elsif (@obj.is_a?(Hash) || @obj.is_a?(Array)) && @obj.length > OBJECT_DUMP_CONFIG_TOLERANT.max_width
             @dump_config = OBJECT_DUMP_CONFIG_COLLECTION
           else
             @dump_config = OBJECT_DUMP_CONFIG_TOLERANT

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

@@ -13,6 +13,8 @@ module Rookout
           @depth = depth
         end
 
+        attr_reader :backtrace, :offset, :depth
+
         def read_key key
           FrameNamespace.new @backtrace[key + @offset]
         end

data/lib/rookout/protobuf/controller_info_pb.rb

@@ -18,6 +18,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :platform_release, :string, 10
       optional :platform_version, :string, 11
       optional :platform_string, :string, 12
+      optional :parent_controller_id, :string, 13
     end
   end
 end

data/lib/rookout/protobuf/messages_pb.rb

@@ -4,6 +4,7 @@
 require 'google/protobuf'
 
 require_relative 'variant_pb'
+require_relative 'variant2_pb'
 require_relative 'agent_info_pb'
 require_relative 'controller_info_pb'
 require 'google/protobuf/any_pb'
@@ -87,6 +88,11 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :aug_id, :string, 2
       optional :arguments, :message, 3, "com.rookout.Variant"
       optional :report_id, :string, 4
+      map :strings_cache, :string, :uint32, 5
+      repeated :buffer_cache_buffers, :bytes, 6
+      repeated :buffer_cache_indexes, :uint32, 7
+      optional :arguments2, :message, 8, "com.rookout.Variant2"
+      optional :reverse_list_order, :bool, 9
     end
     add_message "com.rookout.UserMsg" do
       optional :aug_report, :message, 1, "com.rookout.AugReportMessage"
@@ -98,6 +104,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     end
     add_message "com.rookout.InitialAugsCommand" do
       repeated :augs, :string, 1
+      map :sdk_configuration, :string, :string, 2
     end
     add_message "com.rookout.RemoveAugCommand" do
       optional :aug_id, :string, 1
@@ -117,6 +124,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       repeated :connectedAgents, :string, 2
     end
     add_message "com.rookout.DataOnPremTokenRequest" do
+      optional :access_type, :enum, 1, "com.rookout.DataOnPremTokenAccessType"
     end
     add_message "com.rookout.DataOnPremTokenResponse" do
       optional :token, :bytes, 1
@@ -150,6 +158,44 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :message, :message, 2, "google.protobuf.Any"
       optional :error, :string, 3
     end
+    add_message "com.rookout.StartDatastoreConnectivityTestCommand" do
+      optional :orgId, :string, 1
+      optional :controllerId, :string, 2
+      optional :datastoreUrl, :string, 3
+      optional :workspaceId, :string, 4
+    end
+    add_message "com.rookout.DatastoreConnectivityTestC2cResponse" do
+      optional :controllerId, :string, 1
+      optional :TestMessageId, :string, 2
+      optional :isSuccess, :bool, 3
+      optional :errorString, :string, 4
+    end
+    add_message "com.rookout.PingDatastoreCommand" do
+      optional :datastoreUrl, :string, 1
+    end
+    add_message "com.rookout.DatastoreInformation" do
+      optional :version, :string, 1
+      optional :hostname, :string, 2
+      optional :machine_type, :string, 3
+      optional :network, :string, 4
+      optional :ip, :string, 5
+      optional :os, :string, 6
+      optional :os_release, :string, 7
+      optional :os_version, :string, 8
+      optional :os_string, :string, 9
+    end
+    add_message "com.rookout.OrgLanguagesConfigsRequest" do
+    end
+    add_message "com.rookout.LanguageConfig" do
+      map :config, :string, :string, 1
+    end
+    add_message "com.rookout.OrgLanguagesConfigsResponse" do
+      map :OrgConfig, :string, :message, 1, "com.rookout.LanguageConfig"
+    end
+    add_enum "com.rookout.DataOnPremTokenAccessType" do
+      value :WRITE, 0
+      value :READ, 1
+    end
   end
 end
 
@@ -185,5 +231,13 @@ module Com
     HitCountUpdateMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.HitCountUpdateMessage").msgclass
     C2cRpcRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.C2cRpcRequest").msgclass
     C2cRpcResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.C2cRpcResponse").msgclass
+    StartDatastoreConnectivityTestCommand = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.StartDatastoreConnectivityTestCommand").msgclass
+    DatastoreConnectivityTestC2cResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.DatastoreConnectivityTestC2cResponse").msgclass
+    PingDatastoreCommand = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.PingDatastoreCommand").msgclass
+    DatastoreInformation = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.DatastoreInformation").msgclass
+    OrgLanguagesConfigsRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.OrgLanguagesConfigsRequest").msgclass
+    LanguageConfig = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.LanguageConfig").msgclass
+    OrgLanguagesConfigsResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.OrgLanguagesConfigsResponse").msgclass
+    DataOnPremTokenAccessType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.DataOnPremTokenAccessType").enummodule
   end
 end

data/lib/rookout/protobuf/variant2_pb.rb

@@ -0,0 +1,42 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: variant2.proto
+
+require 'google/protobuf'
+
+require 'google/protobuf/timestamp_pb'
+require_relative 'variant_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("variant2.proto", :syntax => :proto3) do
+    add_message "com.rookout.Error2" do
+      optional :message, :string, 1
+      optional :type, :string, 2
+      optional :parameters, :message, 3, "com.rookout.Variant2"
+      optional :exc, :message, 4, "com.rookout.Variant2"
+      optional :traceback, :message, 5, "com.rookout.Variant2"
+    end
+    add_message "com.rookout.Variant2" do
+      optional :variant_type_max_depth, :uint32, 1
+      optional :original_type_index_in_cache, :uint32, 2
+      repeated :attribute_names_in_cache, :uint32, 3
+      repeated :attribute_values, :message, 4, "com.rookout.Variant2"
+      optional :original_size, :uint32, 5
+      optional :long_value, :int64, 6
+      optional :bytes_index_in_cache, :uint32, 7
+      repeated :collection_keys, :message, 8, "com.rookout.Variant2"
+      repeated :collection_values, :message, 9, "com.rookout.Variant2"
+      optional :double_value, :double, 10
+      repeated :code_values, :message, 11, "com.rookout.Variant.CodeObject"
+      optional :time_value, :message, 12, "google.protobuf.Timestamp"
+      optional :error_value, :message, 16, "com.rookout.Error2"
+      optional :complex_value, :message, 17, "com.rookout.Variant.Complex"
+      optional :livetail, :message, 18, "com.rookout.Variant.LiveTailMessage"
+    end
+  end
+end
+
+module Com
+  module Rookout
+    Error2 = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.Error2").msgclass
+    Variant2 = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.Variant2").msgclass
+  end
+end

data/lib/rookout/protobuf/variant_pb.rb

@@ -18,6 +18,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :original_type, :string, 2
       repeated :attributes, :message, 3, "com.rookout.Variant.NamedValue"
       optional :max_depth, :bool, 4
+      optional :original_type_index_in_cache, :uint32, 5
       oneof :value do
         optional :int_value, :int32, 11
         optional :long_value, :int64, 12
@@ -35,6 +36,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
         optional :complex_value, :message, 28, "com.rookout.Variant.Complex"
         optional :enum_value, :message, 31, "com.rookout.Variant.Enumeration"
         optional :traceback, :message, 32, "com.rookout.Variant.Traceback"
+        optional :livetail, :message, 33, "com.rookout.Variant.LiveTailMessage"
       end
     end
     add_message "com.rookout.Variant.NamedValue" do
@@ -48,6 +50,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     add_message "com.rookout.Variant.String" do
       optional :original_size, :int32, 1
       optional :value, :string, 2
+      optional :value_index_in_cache, :uint32, 3
     end
     add_message "com.rookout.Variant.List" do
       optional :type, :string, 1
@@ -73,6 +76,9 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :module, :string, 2
       optional :filename, :string, 3
       optional :lineno, :uint32, 4
+      optional :name_index_in_cache, :uint32, 5
+      optional :module_index_in_cache, :uint32, 6
+      optional :filename_index_in_cache, :uint32, 7
     end
     add_message "com.rookout.Variant.LargeInt" do
       optional :value, :string, 1
@@ -89,6 +95,19 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     add_message "com.rookout.Variant.Traceback" do
       repeated :locations, :message, 1, "com.rookout.Variant.CodeObject"
     end
+    add_message "com.rookout.Variant.LiveTailMessage" do
+      optional :level_name, :string, 1
+      optional :msg, :string, 2
+      optional :formatted_message, :string, 3
+      optional :time, :double, 4
+      optional :filename, :string, 5
+      optional :lineno, :int32, 6
+      optional :function, :string, 7
+      optional :module, :string, 8
+      optional :thread_id, :int64, 9
+      optional :thread_name, :string, 10
+      map :log_context, :string, :string, 11
+    end
     add_enum "com.rookout.Variant.Type" do
       value :VARIANT_NONE, 0
       value :VARIANT_INT, 1
@@ -113,6 +132,8 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       value :VARIANT_DYNAMIC, 20
       value :VARIANT_ENUM, 21
       value :VARIANT_TRACEBACK, 22
+      value :VARIANT_LIVETAIL, 23
+      value :VARIANT_SET, 24
     end
   end
 end
@@ -134,6 +155,7 @@ module Com
     Variant::Complex = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.Variant.Complex").msgclass
     Variant::Enumeration = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.Variant.Enumeration").msgclass
     Variant::Traceback = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.Variant.Traceback").msgclass
+    Variant::LiveTailMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.Variant.LiveTailMessage").msgclass
     Variant::Type = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.rookout.Variant.Type").enummodule
   end
 end

data/lib/rookout/version.rb

@@ -1,3 +1,3 @@
 module Rookout
-  VERSION = "0.1.30".freeze
+  VERSION = "0.1.31".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rookout
 version: !ruby/object:Gem::Version
-  version: 0.1.30
+  version: 0.1.31
 platform: ruby
 authors:
 - Liran Haimovitch
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-10 00:00:00.000000000 Z
+date: 2022-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
@@ -203,6 +203,7 @@ files:
 - lib/rookout/com_ws/agent_com_ws.rb
 - lib/rookout/com_ws/backoff.rb
 - lib/rookout/com_ws/command_handler.rb
+- lib/rookout/com_ws/envelope_wrapper.rb
 - lib/rookout/com_ws/git.rb
 - lib/rookout/com_ws/information.rb
 - lib/rookout/com_ws/output.rb
@@ -215,6 +216,7 @@ files:
 - lib/rookout/interface.rb
 - lib/rookout/logger.rb
 - lib/rookout/processor/namespace_serializer.rb
+- lib/rookout/processor/namespace_serializer2.rb
 - lib/rookout/processor/namespaces/container_namespace.rb
 - lib/rookout/processor/namespaces/frame_namespace.rb
 - lib/rookout/processor/namespaces/namespace.rb
@@ -240,6 +242,7 @@ files:
 - lib/rookout/protobuf/controller_info_pb.rb
 - lib/rookout/protobuf/envelope_pb.rb
 - lib/rookout/protobuf/messages_pb.rb
+- lib/rookout/protobuf/variant2_pb.rb
 - lib/rookout/protobuf/variant_pb.rb
 - lib/rookout/rookout_singleton.rb
 - lib/rookout/services/position.rb