rookout 0.1.36 → 0.1.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40c3d2b4b3e7cf49a817115416ff9ac23fb2078c036744f31cbba5a187dd933f
-  data.tar.gz: fc57b64eb454574b754dcbfc6ea4f0fdc7579794f073f4290f4a11b336f76c10
+  metadata.gz: fb5d9fef64ead13081355d267ad49671d0ca9ddf3e916ab5cf556d6d3b5997be
+  data.tar.gz: e114be3eb5224761c01f5a64bd4f367a90effed5d130c61f90ab4a8328152928
 SHA512:
-  metadata.gz: cfb0aca8f7fb82ccb39adb8c8f03f5b5242c22bb43dc23bf68f80b18d300e06e11eec8a4885edc3d8eddba58d792db254bbcb6070c030ca2d9f675557ad8a98d
-  data.tar.gz: fdc04d582ee9a9bc76a7b9e12ffeaa0a04be2e70a6fdfd7a3841d65ae9a088d947f97df3aaf9f65e1cdd26e0f3a4ef111ea992417eb50581dcbddc682c5716bc
+  metadata.gz: 1da019cfc4c4cbeada393163a6fb4fa01826fdfe9d76edfd0926218b40d6dbedafb2291de4c63a558ac521bf6d360fee76a8522b2a10d021ce7d3538ce1ae530
+  data.tar.gz: 0a24f0bee3b44a23c9ad1ab7e1cdd6c6fc694e50358abd9d96b219ab3a5116c6567ebfd94a498de0de3cda523605fe2d0d27617d3aca7a9161689eeaa9132131

data/lib/rookout/augs/actions/action_run_processor.rb

@@ -5,6 +5,7 @@ module Rookout
     module Actions
       class ActionRunProcessor < Action
         def initialize arguments, processor_factory
+          super()
           @processor = processor_factory.create_processor arguments["operations"]
 
           post_operations = arguments["post_operations"]

data/lib/rookout/augs/aug.rb

@@ -10,13 +10,11 @@ module Rookout
     require_relative "../logger"
 
     class Aug
-      def initialize aug_id, action, condition, rate_limiter, _max_aug_time
-        # NOTE: max_aux_time is not implemented
-
+      def initialize aug_id, action, condition, limits_manager, _max_aug_time
         @id = aug_id
         @action = action
         @condition = condition
-        @rate_limiter = rate_limiter
+        @limits_manager = limits_manager
 
         @enabled = true
         @status = nil
@@ -36,7 +34,7 @@ module Rookout
         namespace = create_namespaces frame, extracted
         return if @condition && !@condition.evaluate(namespace)
 
-        @rate_limiter.with_limit do
+        @limits_manager.with_limit do
           report_id = Utils.uuid
           Logger.instance.info "Executing aug-\t#{id} (msg ID #{report_id})"
           @action.execute @id, report_id, namespace, output

data/lib/rookout/augs/aug_factory.rb

@@ -10,7 +10,9 @@ module Rookout
     require_relative "locations/location_exception_handler"
     require_relative "aug_rate_limiter"
     require_relative "aug"
+    require_relative "limits_manager"
     require_relative "../utils"
+    require_relative "../logger"
 
     class AugFactory
       def initialize output
@@ -34,10 +36,10 @@ module Rookout
         end
         condition = condition_configuration.nil? ? nil : Conditions::Condition.new(condition_configuration)
 
-        rate_limit = create_rate_limit configuration
+        limits_manager = create_limits_manager configuration
 
         max_aug_time_ns = Utils.milliseconds_to_nanoseconds max_aug_time
-        aug = Aug.new aug_id, action, condition, rate_limit, max_aug_time_ns
+        aug = Aug.new aug_id, action, condition, limits_manager, max_aug_time_ns
 
         location_configuration = configuration["location"]
         raise Exceptions::RookAugInvalidKey.new("location", configuration) unless location_configuration.is_a? Hash
@@ -52,9 +54,9 @@ module Rookout
 
         case name
         when "file_line"
-          return Locations::LocationFileLine.new configuration, @output, aug
+          Locations::LocationFileLine.new configuration, @output, aug
         when "exception_handler"
-          return Locations::LocationExceptionHandler.new configuration, @output, aug
+          Locations::LocationExceptionHandler.new configuration, @output, aug
         when "log_handler"
           raise Exceptions::RookUnsupportedLiveLogger
         else
@@ -62,25 +64,47 @@ module Rookout
         end
       end
 
-      def create_rate_limit configuration
-        window_quota = 200
-        window_size = 5000
+      def create_limits_manager configuration
+        limiters = []
+        if global_rate_limiter.nil?
+          rate_limit = parse_rate_limit configuration["rateLimit"], configuration["rateLimitModifier"], 200, 5000
+          limiters.append AugRateLimiter.new(*rate_limit)
+        else
+          limiters.append global_rate_limiter
+        end
 
-        rate_limit = configuration["rateLimit"]
-        if rate_limit
-          rate_limit_splitted = rate_limit.split "/"
-          if rate_limit_splitted.length == 2
-            window_quota = rate_limit_splitted[0].to_i
-            window_size = rate_limit_splitted[1].to_i
-          end
+        LimitsManager.new limiters
+      end
+
+      def global_rate_limiter
+        if @global_rate_limiter.nil? && !Rookout::Config.global_rate_limit.nil?
+          rate_limit = parse_rate_limit Rookout::Config.global_rate_limit, "0", 0, 0
+          @global_rate_limiter = AugRateLimiter.new(*rate_limit)
+          Logger.instance.debug "Using global rate limiter with configuration: #{rate_limit}"
         end
 
-        rate_limit_modifier = configuration["rateLimitModifier"] || 5
+        @global_rate_limiter
+      end
+
+      def parse_rate_limit config, modifier_config, default_quota, default_window
+        window_quota = default_quota
+        window_size = default_window
+
+        unless config.nil? || config.empty?
+          rate_limit_split = config.split "/"
+          unless rate_limit_split.length == 2 && rate_limit_split[0].is_number? && rate_limit_split[1].is_number?
+            raise Exceptions::RookInvalidRateLimitConfiguration, config
+          end
+
+          window_quota = rate_limit_split[0].to_i
+          window_size = rate_limit_split[1].to_i
+        end
 
         window_quota_ns = Utils.milliseconds_to_nanoseconds window_quota
         window_size_ns = Utils.milliseconds_to_nanoseconds window_size
+        rate_limit_modifier = modifier_config.to_i || 5
 
-        AugRateLimiter.new window_quota_ns, window_size_ns, rate_limit_modifier
+        [window_quota_ns, window_size_ns, rate_limit_modifier]
       end
     end
   end

data/lib/rookout/augs/aug_rate_limiter.rb

@@ -8,51 +8,50 @@ module Rookout
         @quota = quota
         @has_quota = !@quota.nil? && (@quota > 0)
         @window_size = window_size
-        @active_weight = quota / active_limit
+        if active_limit > 0
+          @active_weight = quota / active_limit
+        else
+          @active_weight = 0
+        end
 
         @mutex = Mutex.new
         @active_count = 0
         @windows = {}
       end
 
-      def with_limit start_time = nil
-        active = false
-        start_time ||= Time.now
-
-        # If quota, verify it
-        if @has_quota
-          # Get current time
-          now_ns = Utils.time_to_nanoseconds start_time
-
-          # Calculate window keys
-          current_window_key, prev_window_key = timestamp_to_window_keys now_ns
-
-          @mutex.synchronize do
-            # Clean old windows
-            cleanup now_ns
-            # Increase active count
-            @active_count += 1
-            active = true
-
-            # If exceeding quota
-            if current_usage(now_ns, current_window_key, prev_window_key) > @quota
-              warning = Processor::RookError.new Exceptions::RookRuleRateLimited.new
-              UserWarnings.notify_warning warning
-              return
-            end
+      def before_run start_time
+        # If no quota, we can safely exit
+        unless @has_quota
+          return true
+        end
+        now_ns = Utils.time_to_nanoseconds start_time
+        current_window_key, prev_window_key = timestamp_to_window_keys now_ns
+
+        @mutex.synchronize do
+          # Clean old windows
+          cleanup now_ns
+          usage = current_usage now_ns, current_window_key, prev_window_key
+          @active_count += 1
+
+          # If exceeding quota
+          if usage > @quota
+            warning = Processor::RookError.new Exceptions::RookRuleRateLimited.new
+            UserWarnings.notify_warning warning
+            return false
           end
+
+          return true
         end
+      end
 
-        begin
-          yield
-        ensure
-          if @has_quota
-            @mutex.synchronize { record_usage current_window_key, Utils.time_to_nanoseconds(Time.now) - now_ns }
-          end
+      def after_run start_time
+        if @has_quota
+          now_ns = Utils.time_to_nanoseconds start_time
+          current_window_key, = timestamp_to_window_keys now_ns
+          @mutex.synchronize { record_usage current_window_key, Utils.time_to_nanoseconds(Time.now) - now_ns }
         end
-      ensure
         # Reduce active count
-        @mutex.synchronize { @active_count -= 1 } if active
+        @mutex.synchronize { @active_count -= 1 }
       end
 
       private
@@ -75,7 +74,7 @@ module Rookout
         prev_window_usage = @windows[prev_window_key] || 0
 
         # Previous window weight
-        prev_weight = 1 - (now_ns - current_window_key) / @window_size.to_f
+        prev_weight = 1 - ((now_ns - current_window_key) / @window_size.to_f)
 
         # Final weighted usage
         (prev_window_usage * prev_weight) + (@active_count * @active_weight) + current_window_usage
@@ -91,7 +90,7 @@ module Rookout
       end
 
       def cleanup now_ns
-        @windows.reject! { |key, _| key < (now_ns - @window_size * 5) } if @windows.length > 10
+        @windows.reject! { |key, _| key < (now_ns - (@window_size * 5)) } if @windows.length > 10
       end
     end
   end

data/lib/rookout/augs/limits_manager.rb

@@ -0,0 +1,31 @@
+module Rookout
+  module Augs
+    class LimitsManager
+      def initialize limiters
+        @limiters = limiters
+      end
+
+      def with_limit start_time = nil
+        start_time ||= Time.now
+        can_execute = true
+        after_execute = []
+
+        @limiters.each do |limiter|
+          if limiter.before_run start_time
+            after_execute.append -> { limiter.after_run start_time }
+          else
+            can_execute = false
+          end
+        end
+
+        if can_execute
+          yield
+        end
+      ensure
+        unless after_execute.nil?
+          after_execute.each(&:call)
+        end
+      end
+    end
+  end
+end

data/lib/rookout/augs/locations/location_file_line.rb

@@ -21,7 +21,11 @@ module Rookout
           @line_unique = arguments["line_unique"] || false
         end
 
-        attr_reader :filename, :lineno, :file_hash, :line_crc, :line_unique
+        attr_reader :filename
+        attr_reader :lineno
+        attr_reader :file_hash
+        attr_reader :line_crc
+        attr_reader :line_unique
 
         def add_aug trigger_services
           trigger_services.get_service("position").add_aug self

data/lib/rookout/com_ws/agent_com_ws.rb

@@ -118,7 +118,7 @@ module Rookout
 
             if @print_on_initial_connection
               @print_on_initial_connection = false
-              STDERR.puts "[Rookout] Successfully connected to controller"
+              $stderr.puts "[Rookout] Successfully connected to controller"
             end
             Logger.instance.debug "WebSocket connected successfully"
             Logger.instance.info "Finished initialization"
@@ -205,9 +205,10 @@ module Rookout
           msg = envelope_wrapper.envelope
           @pending_messages_length -= envelope_wrapper.calculate_size
 
-          if msg.is_a? ExitMessage
+          case msg
+          when ExitMessage
             break if msg.thread == Thread.current
-          elsif msg.is_a? FlushMessage
+          when FlushMessage
             msg.event.set
           else
             begin

data/lib/rookout/com_ws/envelope_wrapper.rb

@@ -8,8 +8,7 @@ class EnvelopeWrapperBase
     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
+    Com::Rookout::Envelope.encode envelope
   end
 
   def envelope
@@ -23,11 +22,13 @@ end
 
 class Variant2EnvelopeWrapper < EnvelopeWrapperBase
   def initialize agent_id, aug_id, report_id, arguments
+    super()
+
     @aug_report_message = Com::Rookout::AugReportMessage.new agent_id: agent_id,
-                                       aug_id: aug_id,
-                                       report_id: report_id
+                                                             aug_id: aug_id,
+                                                             report_id: report_id
     @serializer = Rookout::Processor::NamespaceSerializer2.new
-    @aug_report_message.arguments2 = @serializer.dump arguments
+    @aug_report_message.arguments2 = @serializer.dump arguments, true
     @serializer.string_cache.each { |key, value| @aug_report_message.strings_cache[key] = value }
     @envelope = wrap_in_envelope @aug_report_message
     @aug_report_message = nil
@@ -44,6 +45,7 @@ end
 
 class EnvelopeWrapper < EnvelopeWrapperBase
   def initialize message
+    super()
     @envelope = wrap_in_envelope message
   end
 

data/lib/rookout/com_ws/git.rb

@@ -42,7 +42,7 @@ module Rookout
         link_contents = File.read link_path
 
         if link_contents.start_with? "ref:"
-          next_link = (link_contents.split " ")[1].strip
+          next_link = link_contents.split[1].strip
           follow_sym_links root, next_link
         else
           link_contents.strip

data/lib/rookout/com_ws/information.rb

@@ -56,7 +56,8 @@ module Rookout
                                            scm: @scm_info
       end
 
-      attr_accessor :agent_id, :labels
+      attr_accessor :agent_id
+      attr_accessor :labels
 
       private
 

data/lib/rookout/com_ws/output.rb

@@ -42,7 +42,8 @@ module Rookout
         @closing = false
       end
 
-      attr_accessor :agent_id, :agent_com
+      attr_accessor :agent_id
+      attr_accessor :agent_com
 
       def close
         @closing = true
@@ -86,13 +87,17 @@ module Rookout
             if arguments.nil? || arguments.call_method("size", "") == 0
               protobuf_arguments = nil
             else
-              protobuf_arguments = Processor::NamespaceSerializer.dump arguments
+              protobuf_arguments = Processor::NamespaceSerializer.dump arguments, true
             end
 
-            envelope_wrapper = EnvelopeWrapper.new(Com::Rookout::AugReportMessage.new(agent_id: @agent_id,
-                                                     aug_id: aug_id,
-                                                     report_id: report_id,
-                                                     arguments: protobuf_arguments))
+            envelope_wrapper = EnvelopeWrapper.new(
+              Com::Rookout::AugReportMessage.new(
+                agent_id: @agent_id,
+                aug_id: aug_id,
+                report_id: report_id,
+                arguments: protobuf_arguments
+              )
+            )
           end
 
           @agent_com.add envelope_wrapper
@@ -123,7 +128,8 @@ module Rookout
           protobuf_arguments = nil
         else
           protobuf_arguments = Processor::NamespaceSerializer.dump(
-            Processor::Namespaces::RubyObjectNamespace.new(arguments)
+            Processor::Namespaces::RubyObjectNamespace.new(arguments),
+            true
           )
         end
 

data/lib/rookout/commit.rb

@@ -1,3 +1,3 @@
 module Rookout
-  COMMIT = "2c51b13711b7b94b1a58728d299d8981dc76e18f".freeze
+  COMMIT = "b34115d35e36dcb568599cc5279fc7e934619ef5".freeze
 end

data/lib/rookout/config.rb

@@ -6,21 +6,26 @@ module Rookout
     # 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
+      attr_accessor :logger_filename
+      attr_accessor :logger_log_to_stderr
+      attr_accessor :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_max_queue_messages_length,
-                    :agent_com_timeout,
-                    :agent_com_ping_interval,
-                    :agent_com_ping_timeout,
-                    :agent_com_flush_timeout,
-                    :agent_com_max_queued_messages
+      attr_accessor :agent_com_configuration_command_thread_name
+      attr_accessor :agent_com_max_message_limit
+      attr_accessor :agent_com_max_queue_messages_length
+      attr_accessor :agent_com_timeout
+      attr_accessor :agent_com_ping_interval
+      attr_accessor :agent_com_ping_timeout
+      attr_accessor :agent_com_flush_timeout
+      attr_accessor :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
@@ -29,47 +34,80 @@ module Rookout
       Rookout::Config.agent_com_flush_timeout = 3
       Rookout::Config.agent_com_max_queued_messages = 100
 
-      attr_accessor :backoff_factor, :backoff_reset_time, :backoff_max_time
+      attr_accessor :backoff_factor
+      attr_accessor :backoff_reset_time
+      attr_accessor :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
+      attr_accessor :output_max_status_updates
+      attr_accessor :output_max_aug_messages
+      attr_accessor :output_max_log_items
+      attr_accessor :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
+      attr_accessor :user_git_commit
+      attr_accessor :user_git_origin
+
       Rookout::Config.user_git_commit = nil
       Rookout::Config.user_git_origin = nil
 
-      attr_accessor :rookout_version, :rookout_commit
+      attr_accessor :rookout_version
+      attr_accessor :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"]
 
+      attr_accessor :global_rate_limit
+
+      Rookout::Config.global_rate_limit = nil
 
       def update_config configuration
+        update_var2_config configuration
+        update_global_rate_limit_config configuration
+      end
+
+      def update_var2_config configuration
         is_config_proto2 = configuration["RUBY_PROTOBUF_VERSION_2"]
         return if is_config_proto2.nil?
-        is_env_proto2 = ENV["PROTOBUF_VERSION_2"]
+        is_env_proto2 = ENV["ROOKOUT_Protobuf_Version2"]
         if is_env_proto2.nil?
           @protobuf_version2 = true if @true_values.include? is_config_proto2
         elsif @true_values.include? is_env_proto2
+          Logger.instance.debug "ROOKOUT_Protobuf_Version2 env is preset: #{is_env_proto2}"
           @protobuf_version2 = true
         end
+        Logger.instance.info "Updating ROOKOUT_Protobuf_Version2 value to: #{@protobuf_version2}"
+      end
+
+      def update_global_rate_limit_config configuration
+        global_rate_limit = ENV["ROOKOUT_GLOBAL_RATE_LIMIT"]
+        if global_rate_limit.nil?
+          global_rate_limit = configuration["RUBY_GLOBAL_RATE_LIMIT"]
+        end
+
+        return if global_rate_limit.nil?
+
+        @global_rate_limit = global_rate_limit
+        Logger.instance.info "Updating global rate limit to: #{global_rate_limit}"
       end
     end
   end

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
@@ -92,8 +89,8 @@ module Rookout
     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",
+              "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
@@ -101,7 +98,7 @@ module Rookout
     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"
+              "For more information: https://docs.rookout.com/docs/breakpoints-tasks.html#rate-limiting"
       end
     end
 
@@ -139,9 +136,6 @@ module Rookout
     end
 
     class RookInvalidOptions < ToolException
-      def initialize description
-        super description
-      end
     end
 
     class RookInvalidLabel < ToolException
@@ -220,6 +214,15 @@ module Rookout
       end
     end
 
+    class RookInvalidRateLimitConfiguration < ToolException
+      def initialize config
+        super "Invalid rate limit configuration: #{config}",
+              {
+                "rate_limit_config" => config
+              }
+      end
+    end
+
     class RookUnsupportedLiveLogger < ToolException
       def initialize
         super "Live Logger is not supported. Try using Rookout Live Debugger instead."

data/lib/rookout/interface.rb

@@ -14,7 +14,7 @@ module Rookout
 
     def print_debug_messages
       puts "[Rookout] Running in debug mode"
-      puts "[Rookout] Rookout SDK for ruby: " + Config.rookout_version
+      puts "[Rookout] Rookout SDK for ruby: #{Config.rookout_version}"
     end
 
     def start options = {}
@@ -36,16 +36,16 @@ module Rookout
         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'"
+        $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 => e
         raise if throw_errors
-        STDERR.puts "[Rookout] Failed to start Rookout: #{e.message}"
+        $stderr.puts "[Rookout] Failed to start Rookout: #{e.message}"
       rescue RookCommunicationException => e
         raise if throw_errors
-        Logger.instance.warning "[Rookout] " + e.message
+        Logger.instance.warning "[Rookout] #{e.message}"
       rescue Exception => e
-        STDERR.puts e.full_message if Config.debug
+        $stderr.puts e.full_message if Config.debug
         raise if throw_errors
       end
     end
@@ -82,12 +82,13 @@ module Rookout
       # 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?
+      $stderr.puts RookBadProtobuf.new.message if protobuf.nil?
       return unless protobuf.platform != "ruby"
 
       error = RookBadProtobufPlatform.new protobuf.platform
-      STDERR.puts error.message
+      $stderr.puts error.message
     end
 
     def configure_globals options