rookout 0.1.40 → 0.1.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7605e9deab6fab2b1456185132e9db8100f143e0486a6cbef13a20a368047ad1
-  data.tar.gz: 900c58be123cfad2b749a16dce8ed3e6fa572af1177ee3778fe9318c02a2f81b
+  metadata.gz: 72f208b3a47ef61e59b2123afe3e666a2f3efa8295ddec10950e221e5547770a
+  data.tar.gz: 216a478be4998de21db6b2df156123d6cde587a54369914d93ba2f3ef8f9b5a7
 SHA512:
-  metadata.gz: 0d4bf7792481a091c0110353cf727f44486b08dd099bba996ce83c7b05e88213f8a714dcbfb2840944876a49a8a794f2496c501c1c19ec5c341f1493ab925ace
-  data.tar.gz: 5069a96af2a1a11b0e7d07be6def3a42bdbf0b94658bc16ff652d06ae623295f5c9b4ea02cbee21cae3d68a236f283568d0136d04edcc51937c68c4a31ba635b
+  metadata.gz: c9c2e1c91cba199a499fb360f519dcce9081f9c5693cf9919aaff369cd2389534900be7b580e03a3b9ef24e91394db0eec9d25e3968163de87a9390aec288392
+  data.tar.gz: 476c8d023ae8e04214693c3b929d0dae31bcf364cf23cc443bf3aab2c29bd05f08db4646a366cb54b4b5208d188df22024886bd35421849c73e331db720eb960

data/lib/rookout/augs/aug.rb

@@ -16,6 +16,7 @@ module Rookout
         @condition = condition
         @limits_manager = limits_manager
 
+        @executed = false
         @enabled = true
         @status = nil
         @log_cache = []
@@ -27,14 +28,16 @@ module Rookout
         return unless @enabled
 
         if output.user_messages_queue_full?
-          Logger.instance.warning "Skipping aug-\t#{id} execution because the queue is full"
+          output.send_output_queue_full_warning @id
           return
         end
 
         namespace = create_namespaces frame, extracted
         return if @condition && !@condition.evaluate(namespace)
 
-        @limits_manager.with_limit do
+        should_skip_limiters = @condition.nil? && !@executed
+        @limits_manager.with_limit should_skip_limiters do
+          @executed = true
           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

@@ -68,7 +68,9 @@ module Rookout
         limiters = []
         if global_rate_limiter.nil?
           rate_limit = parse_rate_limit configuration["rateLimit"], configuration["rateLimitModifier"], 200, 5000
-          limiters.append AugRateLimiter.new(*rate_limit)
+          unless rate_limit.nil?
+            limiters.append AugRateLimiter.new(*rate_limit)
+          end
         else
           limiters.append global_rate_limiter
         end
@@ -77,8 +79,20 @@ module Rookout
       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
+        if @global_rate_limiter.nil? && Rookout::Config.global_rate_limit != ""
+          begin
+            rate_limit = parse_rate_limit Rookout::Config.global_rate_limit,
+                                          "0", 0, 0
+            if rate_limit.nil?
+              raise Exceptions::RookInvalidRateLimitConfiguration, Rookout::Config.global_rate_limit
+            end
+          rescue Exceptions::RookInvalidRateLimitConfiguration => e
+            Logger.instance.warning "Failed to create global rate limiter: #{e.message}"
+            err = Processor::RookError.new e
+            UserWarnings.notify_error err
+            return nil
+          end
+
           @global_rate_limiter = AugRateLimiter.new(*rate_limit)
           Logger.instance.debug "Using global rate limiter with configuration: #{rate_limit}"
           Rookout::Config.using_global_rate_limiter = true
@@ -93,7 +107,9 @@ module Rookout
 
         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?
+          unless rate_limit_split.length == 2 && \
+                 Utils.is_number?(rate_limit_split[0]) && \
+                 Utils.is_number?(rate_limit_split[1])
             raise Exceptions::RookInvalidRateLimitConfiguration, config
           end
 
@@ -105,6 +121,14 @@ module Rookout
         window_size_ns = Utils.milliseconds_to_nanoseconds window_size
         rate_limit_modifier = modifier_config.to_i || 5
 
+        if window_quota_ns == 0
+          return nil
+        end
+
+        if window_quota_ns >= window_size_ns
+          raise Exceptions::RookInvalidRateLimitConfiguration, config
+        end
+
         [window_quota_ns, window_size_ns, rate_limit_modifier]
       end
     end

data/lib/rookout/augs/limits_manager.rb

@@ -5,13 +5,14 @@ module Rookout
         @limiters = limiters
       end
 
-      def with_limit start_time = nil
+      def with_limit skip_limiters, start_time = nil
         start_time ||= Time.now
         can_execute = true
         after_execute = []
 
         @limiters.each do |limiter|
-          if limiter.before_run start_time
+          limiter_passed = limiter.before_run start_time
+          if limiter_passed || skip_limiters
             after_execute.append -> { limiter.after_run start_time }
           else
             can_execute = false

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

@@ -53,7 +53,7 @@ module Rookout
         def notify_warning error
           return if silence_log? error
 
-          Logger.instance.warning error.message
+          Logger.instance.warning error.message, error.exception
 
           # For easier testing
           return if @output.nil?

data/lib/rookout/com_ws/agent_com_ws.rb

@@ -26,8 +26,12 @@ module Rookout
       attr_reader :pending_messages
 
       def initialize output, agent_host, agent_port, proxy, token, labels, print_on_connect
-        agent_host_with_protocl = agent_host.include?("://") ? agent_host : "ws://#{agent_host}"
-        @uri = "#{agent_host_with_protocl}:#{agent_port}/v1"
+        if agent_host.nil? || agent_host.empty?
+          @uri = ""
+        else
+          agent_host_with_protocl = agent_host.include?("://") ? agent_host : "ws://#{agent_host}"
+          @uri = "#{agent_host_with_protocl}:#{agent_port}/v1"
+        end
         if proxy.nil? || proxy.empty?
           @proxy = nil
         else
@@ -57,14 +61,7 @@ module Rookout
         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 #{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
+          raise Exceptions::RookOutputQueueFull
         end
 
         @pending_messages.push envelope_wrapper
@@ -108,7 +105,6 @@ module Rookout
 
       private
 
-      # rubocop:disable Style/StderrPuts
       def connection_thread
         backoff = Backoff.new
 
@@ -118,7 +114,8 @@ module Rookout
 
             if @print_on_initial_connection
               @print_on_initial_connection = false
-              $stderr.puts "[Rookout] Successfully connected to controller"
+              Utils.quiet_puts "[Rookout] Successfully connected to controller."
+              Logger.instance.debug "[Rookout] Agent ID is #{@agent_id}"
             end
             Logger.instance.debug "WebSocket connected successfully"
             Logger.instance.info "Finished initialization"
@@ -142,13 +139,11 @@ module Rookout
       rescue Exception => e
         Logger.instance.error "Unexpected error in connection_thread", e
       end
-      # rubocop:enable Style/StderrPuts
 
       def open_new_connection
         client = WebsocketClient.new @uri, @proxy, @token
         client.connect
 
-        Logger.instance.info "Registering agent with id #{@agent_id}"
         msg = Com::Rookout::NewAgentMessage.new agent_info: @info.pack
         client.send_frame wrap_in_envelope(msg)
 

data/lib/rookout/com_ws/envelope_wrapper.rb

@@ -29,17 +29,26 @@ class Variant2EnvelopeWrapper < EnvelopeWrapperBase
                                                              report_id: report_id
     @serializer = Rookout::Processor::NamespaceSerializer2.new
     @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
+
+    @estimated_length = @serializer.estimated_pending_bytes
+    @envelope = nil
   end
 
   def envelope
+    if @envelope.nil?
+      @serializer.string_cache.each do |key, value|
+        @aug_report_message.strings_cache[key.encode "UTF-8", invalid: :replace, undef: :replace, replace: "?"] = value
+      end
+      @envelope = wrap_in_envelope @aug_report_message
+
+      @serializer = nil
+      @aug_report_message = nil
+    end
     @envelope
   end
 
   def calculate_size
-    @envelope.length
+    @estimated_length
   end
 end
 

data/lib/rookout/com_ws/output.rb

@@ -11,11 +11,15 @@ module Rookout
     require_relative "token_bucket"
     require_relative "envelope_wrapper"
 
+    require "concurrent"
+
     class Output
       def initialize
         @agent_id = nil
         @agent_com = nil
 
+        @skipped_aug_ids = Concurrent::Set.new
+
         @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"
@@ -55,6 +59,17 @@ module Rookout
         @user_message_bucket.exhausted? || (!@agent_com.nil? && @agent_com.queue_full?)
       end
 
+      def send_output_queue_full_warning aug_id
+        if @skipped_aug_ids.include? aug_id
+          return
+        end
+
+        @skipped_aug_ids.add aug_id
+        error = Processor::RookError.new Exceptions::RookOutputQueueFull.new
+        send_rule_status aug_id, :Warning, error
+        Logger.instance.warning "Skipping aug-\t#{aug_id} execution because the queue is full"
+      end
+
       def send_warning rule_id, error
         send_rule_status rule_id, :Warning, error
       end
@@ -63,6 +78,10 @@ module Rookout
         return if @closing || !@agent_com
 
         @rule_status_update_bucket.if_available do
+          if active == "Deleted"
+            @skipped_aug_ids.delete? rule_id
+          end
+
           status = Com::Rookout::RuleStatusMessage.new agent_id: @agent_id,
                                                        rule_id: rule_id,
                                                        active: active
@@ -73,7 +92,11 @@ module Rookout
 
           envelope_wrapper = EnvelopeWrapper.new status
 
-          @agent_com.add envelope_wrapper
+          begin
+            @agent_com.add envelope_wrapper
+          rescue Exceptions::RookOutputQueueFull
+            # Ignored
+          end
         end
       end
 
@@ -100,7 +123,12 @@ module Rookout
             )
           end
 
-          @agent_com.add envelope_wrapper
+          begin
+            @agent_com.add envelope_wrapper
+            @skipped_aug_ids.delete? aug_id
+          rescue Exceptions::RookOutputQueueFull
+            send_output_queue_full_warning aug_id
+          end
         end
       end
 
@@ -144,7 +172,11 @@ module Rookout
 
         envelope_wrapper = EnvelopeWrapper.new msg
 
-        @agent_com.add envelope_wrapper
+        begin
+          @agent_com.add envelope_wrapper
+        rescue Exceptions::RookOutputQueueFull
+          # Ignored
+        end
       end
     end
   end

data/lib/rookout/commit.rb

@@ -1,3 +1,3 @@
 module Rookout
-  COMMIT = "c62d573f33d1f62ad05aec7d28a4757fafb9a2b4".freeze
+  COMMIT = "9f3ecb29fbadc0c8f66233c9c44be100a912e577".freeze
 end

data/lib/rookout/config.rb

@@ -6,8 +6,10 @@ module Rookout
     # Magic to allow for module variables to be easily accessible
     class << self
       attr_accessor :debug
+      attr_accessor :quiet
 
       Rookout::Config.debug = false
+      Rookout::Config.quiet = false
 
       attr_accessor :logger_filename
       attr_accessor :logger_log_to_stderr
@@ -76,10 +78,14 @@ module Rookout
 
       Rookout::Config.true_values = ["y", "Y", "yes", "Yes", "YES", "true", "True", "TRUE", "1"]
 
+      attr_accessor :global_rate_limit_quota
+      attr_accessor :global_rate_limit_window_size
       attr_accessor :global_rate_limit
       attr_accessor :using_global_rate_limiter
 
-      Rookout::Config.global_rate_limit = nil
+      Rookout::Config.global_rate_limit_quota = ""
+      Rookout::Config.global_rate_limit_window_size = ""
+      Rookout::Config.global_rate_limit = ""
       Rookout::Config.using_global_rate_limiter = false
 
       def update_config configuration
@@ -103,10 +109,15 @@ module Rookout
       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"]
+          quota = configuration["RUBY_GLOBAL_RATE_LIMIT_QUOTA_MS"]
+          window_size = configuration["RUBY_GLOBAL_RATE_LIMIT_WINDOW_SIZE_MS"]
+
+          if quota != "" && !quota.nil? && window_size != "" && !window_size.nil?
+            global_rate_limit = "#{quota}/#{window_size}"
+          end
         end
 
-        return if global_rate_limit.nil?
+        return if global_rate_limit.nil? || global_rate_limit == ""
 
         @global_rate_limit = global_rate_limit
         Logger.instance.info "Updating global rate limit to: #{global_rate_limit}"

data/lib/rookout/exceptions.rb

@@ -95,6 +95,13 @@ module Rookout
       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 RookRuleAugRateLimited < ToolException
       def initialize
         super "Breakpoint was disabled due to rate-limiting. " \
@@ -139,6 +146,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 }
@@ -234,7 +248,7 @@ module Rookout
       def initialize config
         super "Invalid rate limit configuration: #{config}",
               {
-                "rate_limit_config" => config
+                "config" => config
               }
       end
     end

data/lib/rookout/interface.rb

@@ -4,6 +4,7 @@ module Rookout
     include Singleton
 
     require_relative "config"
+    require_relative "utils"
     require_relative "exceptions"
     include Exceptions
 

data/lib/rookout/processor/namespace_serializer2.rb

@@ -16,6 +16,13 @@ module Rookout
         MASH = nil
       end
 
+      begin
+        require "active_support/core_ext/hash/indifferent_access"
+        HASH_WITH_INDIFFERENT_ACCESS = ActiveSupport::HashWithIndifferentAccess
+      rescue LoadError
+        HASH_WITH_INDIFFERENT_ACCESS = nil
+      end
+
       def initialize
         @string_cache = {}
         @estimated_pending_bytes = 0
@@ -37,10 +44,12 @@ module Rookout
 
       def dump_variant_type variant, type
         variant.variant_type_max_depth = type << 1
+        @estimated_pending_bytes += 2 # Field header + short number
       end
 
       def dump_variant_type_max_depth variant, type
         variant.variant_type_max_depth = (type << 1) | 1
+        @estimated_pending_bytes += 2 # Field header + short number
       end
 
       def dump namespace, log_errors
@@ -57,6 +66,7 @@ module Rookout
       rescue StandardError => e
         message = "Failed to serialize namespace"
         variant = Com::Rookout::Variant2.new
+        @estimated_pending_bytes = 0
         dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_ERROR
 
         if log_errors
@@ -77,6 +87,7 @@ module Rookout
       rescue StandardError => e
         message = "Failed to serialize object"
         variant = Com::Rookout::Variant2.new
+        @estimated_pending_bytes = 0
         dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_ERROR
 
         if log_object_errors
@@ -105,7 +116,8 @@ module Rookout
           dump_time obj, variant
         elsif obj.class == Array
           dump_array obj, variant, current_depth, config, log_object_errors
-        elsif obj.class == Hash || (!MASH.nil? && obj.is_a?(MASH))
+        elsif obj.class == Hash || (!MASH.nil? && obj.is_a?(MASH)) ||
+              (!HASH_WITH_INDIFFERENT_ACCESS.nil? && obj.is_a?(HASH_WITH_INDIFFERENT_ACCESS))
           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
@@ -137,20 +149,24 @@ module Rookout
         when true
           dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
           variant.long_value = 1
+          @estimated_pending_bytes += 2 # Header + short number
         when false
           dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_LONG
           variant.long_value = 0
+          @estimated_pending_bytes += 2 # Header + short number
         when Integer
           dump_integer obj, variant
         when Float
           dump_variant_type variant, Com::Rookout::Variant::Type::VARIANT_DOUBLE
           variant.double_value = obj.to_f
+          @estimated_pending_bytes += 7 # Header + 64 bit float
         when BigDecimal
           dump_string obj.to_s, variant, config # TODO: NS: This might cut the decimal value, is that ok?
         when 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
+          @estimated_pending_bytes += 8 # Large header + size + (header + 64 bit float) * 2
         else
           raise Exceptions::RookClassCannotBeSerialized.new(obj.class, "Unknown Numeric Type")
         end
@@ -165,6 +181,7 @@ module Rookout
           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
+        @estimated_pending_bytes += 3 # Header + number
       end
 
       def dump_string obj, variant, config
@@ -178,16 +195,20 @@ module Rookout
         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
+        @estimated_pending_bytes += 6 # Header + number + header + number
       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
+
+        @estimated_pending_bytes += 16 # Header + size + (header + 32 bit number + header + 64 bit number)
       end
 
       def dump_array obj, variant, current_depth, config, log_object_errors
         variant.original_size = obj.length
+        @estimated_pending_bytes += 3 # Header + number
 
         weighted_children_depth = current_depth + 1
         if weighted_children_depth <= config.max_collection_depth
@@ -195,6 +216,7 @@ module Rookout
           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)
+            @estimated_pending_bytes += 3 # Header + size
           end
         else
           dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_LIST
@@ -211,6 +233,7 @@ module Rookout
             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)
+            @estimated_pending_bytes += 6 # Header + size + header + size
           end
         else
           dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_MAP
@@ -221,12 +244,15 @@ module Rookout
         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)
+        @estimated_pending_bytes += 6 # Header + number + header + size
 
         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)
+        @estimated_pending_bytes += 6 # Header + number + header + size
 
         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)
+        @estimated_pending_bytes += 6 # Header + number + header + size
       end
 
       def dump_code_object obj, variant
@@ -247,6 +273,9 @@ module Rookout
         variant.code_values << Com::Rookout::Variant::CodeObject.new(name: name,
                                                                      filename: source_location[0],
                                                                      lineno: source_location[1])
+        # NOTE: This size is probably less, in Python we use the optional fields of CodeObject and in Ruby we don't,
+        # but it is better to estimate more
+        @estimated_pending_bytes += 14 # Header + size + (header + number) * 4
       end
 
       def dump_user_class variant, obj, current_depth, config, log_object_errors
@@ -258,6 +287,7 @@ module Rookout
             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)
+            @estimated_pending_bytes += 6 # Header + number + header + number
           end
         else
           dump_variant_type_max_depth variant, Com::Rookout::Variant::Type::VARIANT_OBJECT
@@ -273,6 +303,8 @@ module Rookout
           variant.attribute_values << dump(value, log_errors)
         end
 
+        @estimated_pending_bytes += 4 # One number (packed field), One header + length
+
         variant
       end
 
@@ -289,6 +321,8 @@ module Rookout
                                                               lineno: frame.source_location[1],
                                                               name: frame.eval("__method__").to_s
           variant.code_values << code_object
+          # See dump_code_object
+          @estimated_pending_bytes += 14 # Header + size + (header + number) * 4
         end
         variant
       end

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

@@ -91,23 +91,23 @@ module Rookout
         def dump log_object_errors
           dump_raw_object @obj, 0, @dump_config, log_object_errors
         end
-      end
 
-      private
+        private
 
-      def read_key_as_int key
-        key_int = key.to_i
-        return RubyObjectNamespace.new @obj[key_int] if key_int >= 0 && key_int < @obj.length
-        raise Exceptions::RookKeyNotFound, key
-      end
+        def read_key_as_int key
+          key_int = key.to_i
+          return RubyObjectNamespace.new @obj[key_int] if key_int >= 0 && key_int < @obj.length
+          raise Exceptions::RookKeyNotFound, key
+        end
 
-      def read_key_from_hash key
-        return RubyObjectNamespace.new @obj[key] if @obj.key? key
-        return RubyObjectNamespace.new @obj[key.to_sym] if @obj.key? key.to_s.to_sym
+        def read_key_from_hash key
+          return RubyObjectNamespace.new @obj[key] if @obj.key? key
+          return RubyObjectNamespace.new @obj[key.to_sym] if @obj.key? key.to_s.to_sym
 
-        @obj.each { |it, value| return RubyObjectNamespace.new value if it.to_s == key }
+          @obj.each { |it, value| return RubyObjectNamespace.new value if it.to_s == key }
 
-        raise Exceptions::RookKeyNotFound, key
+          raise Exceptions::RookKeyNotFound, key
+        end
       end
     end
   end

data/lib/rookout/services/tracer.rb

@@ -21,6 +21,9 @@ module Rookout
           begin
             trace_point.enable target: position.method, target_line: position.lineno
           rescue RuntimeError, ArgumentError => e
+            if e.message.include? "can not enable any hooks"
+              raise Exceptions::RookInvalidPositionException.new(aug.filename, position.lineno)
+            end
             raise Exceptions::RookSetTracepointFailed.new(position.lineno, e)
           end
 

data/lib/rookout/utils.rb

@@ -1,26 +1,34 @@
-module Utils
-  require "securerandom"
+module Rookout
+  module Utils
+    require "securerandom"
+    require_relative "config"
 
-  module_function
+    module_function
 
-  def uuid
-    SecureRandom.uuid.gsub(/-/, "")
-  end
+    def uuid
+      SecureRandom.uuid.gsub(/-/, "")
+    end
 
-  def milliseconds_to_nanoseconds milliseconds
-    nano = milliseconds * (10**6)
-    nano.to_i
-  end
+    def milliseconds_to_nanoseconds milliseconds
+      nano = milliseconds * (10**6)
+      nano.to_i
+    end
 
-  def time_to_nanoseconds time_obj
-    secs = time_obj.to_i
-    nsecs = time_obj.nsec
-    ((10**9) * secs) + nsecs
-  end
-end
+    def time_to_nanoseconds time_obj
+      secs = time_obj.to_i
+      nsecs = time_obj.nsec
+      ((10**9) * secs) + nsecs
+    end
+
+    def quiet_puts msg
+      # rubocop:disable Style/StderrPuts
+      return if Config.quiet
+      $stderr.puts msg
+      # rubocop:enable Style/StderrPuts
+    end
 
-class String
-  def is_number?
-    to_f.to_s == self || to_i.to_s == self
+    def is_number? string
+      true if Float(string) rescue false
+    end
   end
 end

data/lib/rookout/version.rb

@@ -1,3 +1,3 @@
 module Rookout
-  VERSION = "0.1.40".freeze
+  VERSION = "0.1.50".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rookout
 version: !ruby/object:Gem::Version
-  version: 0.1.40
+  version: 0.1.50
 platform: ruby
 authors:
 - Liran Haimovitch
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-11 00:00:00.000000000 Z
+date: 2023-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.19.2
+        version: 3.21.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.19.2
+        version: 3.21.7
 - !ruby/object:Gem::Dependency
   name: google-style
   requirement: !ruby/object:Gem::Requirement
@@ -301,7 +301,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: rookout is the Ruby SDK for the Rookout Debugging Platform