rookout 0.1.0 → 0.1.56

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17eda3a68e52adf758e353e65066c8e68e65c5df18e67299c95e111a60717260
-  data.tar.gz: fd7cadcf2f2890130e9d92c6f56312c7c1a6bf1ad55efc84a83c39ad67f68020
+  metadata.gz: c8fa5b3d059bebfddb806d412ee19edc5680ace455a7e69d947533d91fb68a74
+  data.tar.gz: eac042dc2b354ce73a66220b6ae7623be14824e540fc306b6b84a2fc9c5b304d
 SHA512:
-  metadata.gz: c1968166a99e6c85d7476de449bea06d7105bd9b0b71681c8c4263ccc33d88440e2a956a1d29d4681db44af1d6a8ea5e1cfb142895c182bb1388868c6f920035
-  data.tar.gz: f805c321af5605bade4d443557b3c575d7f432afa392820c4589bc8023af8a971e7a7d72f851ff2899ae7c4aca5fd3864f4e35dd0fb5e942cc4c3e570402cbdc
+  metadata.gz: 28c4a962c4478dfeda21ad68e3eceb88f1bb0596a6eb885d741ab483b7ca00e34ee4827d84095b60827c46b8bd2f0adab662fc718cd0ed32fe3ac1feb6a511f1
+  data.tar.gz: 6f56418601b7e1fc343f6699fa9fd605860751cacec89368382c1e38fa5ab265af9a9c5ff7e7947bce8d65151365dbee01e2dfb4f4960458243345bd30aabccd

data/lib/rookout/atfork.rb

@@ -0,0 +1,73 @@
+module Rookout
+  class ForkManager
+    require "singleton"
+    include Singleton
+
+    def initialize
+      @active = false
+    end
+
+    def activate!
+      @active = true
+    end
+
+    def disable!
+      @active = false
+    end
+
+    def active?
+      @active
+    end
+
+    def fork_hook original_fork
+      if block_given?
+        original_fork.call do
+          post_fork_child if active?
+          yield
+        end
+      else
+        res = original_fork.call
+        post_fork_child if active? && !res
+        res
+      end
+    end
+
+    def post_fork_child
+      require_relative "rookout_singleton"
+      require_relative "interface"
+
+      RookoutSingleton.instance.post_fork_clean
+      Interface.instance.stop
+      Interface.instance.start post_fork: true
+
+      # Disable fork handler in child process
+      disable!
+    end
+  end
+end
+
+alias _rookout_original_fork fork
+
+def self.fork &block
+  Rookout::ForkManager.instance.fork_hook method(:_rookout_original_fork), &block
+end
+
+def fork &block
+  Rookout::ForkManager.instance.fork_hook method(:_rookout_original_fork), &block
+end
+
+module Kernel
+  alias _rookout_original_fork fork
+
+  def self.fork &block
+    Rookout::ForkManager.instance.fork_hook method(:_rookout_original_fork), &block
+  end
+end
+
+module Process
+  alias _rookout_original_fork fork
+
+  def self.fork &block
+    Rookout::ForkManager.instance.fork_hook method(:_rookout_original_fork), &block
+  end
+end

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"]
@@ -15,12 +16,12 @@ module Rookout
           end
         end
 
-        def execute aug_id, report_id, namespace, _output
+        def execute aug_id, report_id, namespace, output
           @processor.process namespace
-          @output.send_user_message aug_id, report_id, namespace.read_attribute("store")
+          output.send_user_message aug_id, report_id, namespace.read_attribute("store")
           return unless @post_processor
 
-          @output.flush_message
+          output.flush_message
           @post_processor.process namespace
         end
       end

data/lib/rookout/augs/aug.rb

@@ -1,121 +1,63 @@
-require_relative "../logger"
-require_relative "../user_warnings"
-require_relative "../processor/rook_error"
-
 module Rookout
   module Augs
-    require "securerandom"
-    require "concurrent-ruby/concurrent/atom"
+    require_relative "../utils"
 
     require_relative "../processor/namespaces/frame_namespace"
     require_relative "../processor/namespaces/stack_namespace"
     require_relative "../processor/namespaces/container_namespace"
     require_relative "../processor/namespaces/ruby_utils_namespace"
     require_relative "../processor/namespaces/noop_namespace"
-
     require_relative "../logger"
 
-    MAX_LOG_CACHE_SIZE = 10
-
     class Aug
-      def initialize aug_id, location, action, condition, rate_limiter, _max_aug_time, output
-        # NOTE: max_aux_time is not implemented
-
+      def initialize aug_id, action, condition, limits_manager, _max_aug_time
         @id = aug_id
-        @location = location
         @action = action
         @condition = condition
-        @rate_limiter = rate_limiter
-        @output = output
+        @limits_manager = limits_manager
 
+        @executed = false
         @enabled = true
         @status = nil
         @log_cache = []
       end
-    end
-
-    attr_reader :id
 
-    def add_aug trigger_services
-      @location.add_aug trigger_services, self
-    rescue SystemExit
-      raise
-    rescue Exception => e
-      message = "Exception when adding aug"
-      Logger.instance.error message, e
-      notify_error RookError.new e, message
-    end
+      attr_reader :id
 
-    def execute frame, extracted
-      return unless @enabled
+      def execute frame_binding, stack_trace, extracted, output
+        return unless @enabled
 
-      UserWarnings.with self do
-        begin
-          namespace = create_namespaces frame, extracted
+        if output.user_messages_queue_full?
+          output.send_output_queue_full_warning @id
+          return
+        end
 
-          return if @condition && !@condition.evaluate(namespace)
+        namespace = create_namespaces frame_binding, stack_trace, extracted
+        return if @condition && !@condition.evaluate(namespace)
 
-          @rate_limiter.with_limit do
-            report_id = SecureRandom.uuid
-            @action.execute @aug_id, report_id, namespace, @output
-          end
-        rescue SystemExit
-          raise
-        rescue Exception => e
-          message = "Exception while processing Aug"
-          error = RookError.new e, message
-          notify_warning error unless silence_log? error
+        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
         end
       end
-    end
-
-    def notify_active
-      send_rule_status :Active
-    end
-
-    def notify_pending
-      send_rule_status :Pending
-    end
-
-    def notify_removed
-      send_rule_status :Deleted
-    end
-
-    def notify_error error
-      send_rule_status :Error, error
-    end
-
-    def notify_warning error
-      return if silence_log? error
-      send_rule_status :Warning, error
-    end
-
-    private
-
-    def create_namespaces frame, extracted
-      ContainerNamespace.new("frame": Processor::Namespaces::FrameNamespace.new(frame[1]),
-                             "stack": Processor::Namespaces::StackNamespace.new(frame, 1),
-                             "extracted": Processor::Namespaces::ContainerNamespace.new(extracted),
-                             "store": Processor::Namespaces::ContainerNamespace.new,
-                             "temp": Processor::Namespaces::ContainerNamespace.new,
-                             "utils": Processor::Namespaces::RubyUtisNamespace.new,
-                             "trace": Processor::Namespaces::NoopNamespace.new)
-    end
-
-    def silence_log? error
-      return true if @log_cache.length >= MAX_LOG_CACHE_SIZE || @log_cache.include(error.message)
-
-      @log_cache << error.message
-      false
-    end
 
-    def send_rule_status status, error = nil
-      return unless @status != status
-
-      Logger.instance.info "Updating rule status for #{@id} to #{status}"
-      @status = status
-
-      @output.send_rule_status @id, status, error
+      private
+
+      def create_namespaces frame_binding, stack_trace, extracted
+        Processor::Namespaces::ContainerNamespace.new(
+          "frame" => Processor::Namespaces::FrameNamespace.new(frame_binding, stack_trace[0]),
+          "stack" => Processor::Namespaces::StackNamespace.new(stack_trace),
+          "extracted" => Processor::Namespaces::ContainerNamespace.new(extracted),
+          "store" => Processor::Namespaces::ContainerNamespace.new,
+          "temp" => Processor::Namespaces::ContainerNamespace.new,
+          "utils" => Processor::Namespaces::RubyUtilsNamespace.new,
+          "trace" => Processor::Namespaces::NoopNamespace.new,
+          "state" => Processor::Namespaces::NoopNamespace.new
+        )
+      end
     end
   end
 end

data/lib/rookout/augs/aug_factory.rb

@@ -6,7 +6,13 @@ module Rookout
 
     require_relative "actions/action_run_processor"
     require_relative "conditions/condition"
+    require_relative "locations/location_file_line"
+    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
@@ -16,53 +22,114 @@ module Rookout
 
       def create_aug configuration
         aug_id = configuration["id"]
-        raise Exceptions.RookAugInvalidKey "id", configuration unless aug_id.is_a? String
-
-        location_configuration = configuration["location"]
-        raise Exceptions.RookAugInvalidKey "location", configuration unless location_configuration.is_a? Hash
-        location = create_location location_configuration
+        raise Exceptions::RookAugInvalidKey.new("id", configuration) unless aug_id.is_a? String
 
         action_configuration = configuration["action"]
-        raise Exceptions.RookAugInvalidKey "action", configuration unless action_configuration.is_a? Hash
-        action = Actions.ActionRunProcess.new action_configuration, @factory
+        raise Exceptions::RookAugInvalidKey.new("action", configuration) unless action_configuration.is_a? Hash
+        action = Actions::ActionRunProcessor.new action_configuration, @factory
 
-        max_aug_time = configuration["maxAugTime"] || Config.INSTRUMENTATION_MAX_AUG_TIME
+        max_aug_time = configuration["maxAugTime"] || Config.instrumentation_max_aug_time
 
         condition_configuration = configuration["conditional"]
-        raise Exceptions.RookAugInvalidKey "conditional", configuration unless condition_configuration.is_a? String
-        condition = Conditions.Condition.new condition_configuration
+        unless condition_configuration.nil? || condition_configuration.is_a?(String)
+          raise Exceptions::RookAugInvalidKey.new("conditional", configuration)
+        end
+        condition = condition_configuration.nil? ? nil : Conditions::Condition.new(condition_configuration)
 
-        rate_limit = create_rate_limit configuration
+        limits_manager = create_limits_manager configuration
 
-        Aug.new aug_id, location, action, condition, rate_limit, max_aug_time, @output
+        max_aug_time_ns = Utils.milliseconds_to_nanoseconds max_aug_time
+        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
+        create_location location_configuration, aug
       end
 
       private
 
-      def create_location configuration
+      def create_location configuration, aug
         name = configuration["name"]
-        raise Exceptions.RookObjectNameMissing if name.nil?
-        raise Exceptions.RookUnsupportedLocation if name != "file_line"
+        raise Exceptions::RookObjectNameMissing, configuration if name.nil?
+
+        case name
+        when "file_line"
+          Locations::LocationFileLine.new configuration, @output, aug
+        when "exception_handler"
+          Locations::LocationExceptionHandler.new configuration, @output, aug
+        when "log_handler"
+          raise Exceptions::RookUnsupportedLiveLogger
+        else
+          raise Exceptions::RookUnsupportedLocation, configuration if name != "file_line"
+        end
+      end
 
-        Locations.LocationFileLine.new configuration, @factory
+      def create_limits_manager configuration
+        limiters = []
+        if global_rate_limiter.nil?
+          rate_limit = parse_rate_limit configuration["rateLimit"], configuration["rateLimitModifier"], 200, 5000
+          unless rate_limit.nil?
+            limiters.append AugRateLimiter.new(*rate_limit)
+          end
+        else
+          limiters.append global_rate_limiter
+        end
+
+        LimitsManager.new limiters
       end
 
-      def create_rate_limit configuration
-        window_quota = 200
-        window_size = 5000
+      def global_rate_limiter
+        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
 
-        rate_limit = configuration["rate_limit"]
-        if rate_limit
-          rate_limit_splitted = rate_limit.split "/"
-          if rate_limit_splitted.length == 2
-            window_quota = rate_limit_splitted[0]
-            window_size = rate_limit_splitted[1]
+          @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
+        end
+
+        @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 && \
+                 Utils.is_number?(rate_limit_split[0]) && \
+                 Utils.is_number?(rate_limit_split[1])
+            raise Exceptions::RookInvalidRateLimitConfiguration, config
           end
+
+          window_quota = rate_limit_split[0].to_i
+          window_size = rate_limit_split[1].to_i
         end
 
-        rate_limit_modifier = configuration["rateLimitModifier"] || 5
+        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
+
+        if window_quota_ns == 0
+          return nil
+        end
+
+        if window_quota_ns >= window_size_ns
+          raise Exceptions::RookInvalidRateLimitConfiguration, config
+        end
 
-        AugRateLimiter.new window_quota, window_size, rate_limit_modifier
+        [window_quota_ns, window_size_ns, rate_limit_modifier]
       end
     end
   end

data/lib/rookout/augs/aug_rate_limiter.rb

@@ -1,61 +1,72 @@
 module Rookout
   module Augs
     require_relative "../exceptions"
+    require_relative "../utils"
 
     class AugRateLimiter
       def initialize quota, window_size, active_limit
         @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.new
-
-        # If quota, verify it
-        if @quota
-          # Get current time
-          now_ms = (now * 1000).to_i
-
-          # Calculate window keys
-          current_window_key = (now_ms / @window_size) * @window_size
-          prev_window_key = current_window_key - @window_size
-
-          @mutex.synchronize do
-            # Clean old windows
-            cleanup now_ms
-
-            # Increase active count
-            @active_count += 1
-            active = true
-
-            # If exceeding quota
-            if current_usage(now_ms, current_window_key, prev_window_key) > @quota
-              warning = 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.create
+            UserWarnings.notify_warning warning
+            return false
           end
+
+          return true
         end
+      end
 
-        begin
-          yield
-        ensure
-          @mutex.synchronize { record_usage current_window_key, (Time.now - start_time) * 1000 } if @quota
+      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
+          time_used = Utils.time_to_nanoseconds(Time.now) - now_ns
+          time_recorded = time_used > Config.min_rate_limit_value_ns ? time_used : Config.min_rate_limit_value_ns
+          @mutex.synchronize { record_usage current_window_key, time_recorded }
         end
-      ensure
         # Reduce active count
-        @mutex.synchronize { @active_count -= 1 } if active
+        @mutex.synchronize { @active_count -= 1 }
       end
 
       private
 
-      def current_usage now_ms, current_window_key, prev_window_key
+      attr_reader :windows # will be used only in tests using <OBJ>.send(:windows)
+
+      def timestamp_to_window_keys now_ns
+        current_window_key = (now_ns / @window_size) * @window_size
+        prev_window_key = current_window_key - @window_size
+        [current_window_key, prev_window_key]
+      end
+
+      def current_usage now_ns, current_window_key, prev_window_key
         # Get usage information
         current_window_usage = @windows[current_window_key]
         if current_window_usage.nil?
@@ -65,7 +76,7 @@ module Rookout
         prev_window_usage = @windows[prev_window_key] || 0
 
         # Previous window weight
-        prev_weight = 1 - (now_ms - 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
@@ -77,19 +88,11 @@ module Rookout
         return if prev_value.nil?
 
         # Add value to quota
-        @windows[current_window_key] += max(duration, 5).to_f
+        @windows[current_window_key] += [duration, 5].max.to_f
       end
 
-      def cleanup now_ms
-        # Don't bother with contention
-        return if @mutex.locked?
-
-        @mutex.synchronize do
-          # every 5 windows-times, clear windows older than 10 window-times
-          if @windows.length > 10
-            @windows.reject! { |key, _| key < (now_ms - @window_size * 5) }
-          end
-        end
+      def cleanup now_ns
+        @windows.reject! { |key, _| key < (now_ns - (@window_size * 5)) } if @windows.length > 10
       end
     end
   end

data/lib/rookout/augs/augs_manager.rb

@@ -2,6 +2,8 @@ module Rookout
   module Augs
     require_relative "../logger"
 
+    require_relative "../processor/rook_error"
+
     require_relative "aug_factory"
 
     class AugsManager
@@ -43,7 +45,7 @@ module Rookout
             return
           end
 
-          error = RookError.new e, message
+          error = Rookout::Processor::RookError.new e, message
           @output.send_rule_status aug_id, "Error", error
           return
         end

data/lib/rookout/augs/conditions/condition.rb

@@ -1,13 +1,15 @@
 module Rookout
   module Augs
     module Conditions
+      require_relative "../../processor/paths/arithmetic_path"
+
       class Condition
         def initialize condition
-          @path = ArithmeticPath.new condition
+          @path = Processor::Paths::ArithmeticPath.new condition
         end
 
         def evaluate namespace
-          @path.read_from(namespace).object == true
+          @path.read_from(namespace).obj == true
         end
       end
     end

data/lib/rookout/augs/limits_manager.rb

@@ -0,0 +1,32 @@
+module Rookout
+  module Augs
+    class LimitsManager
+      def initialize limiters
+        @limiters = limiters
+      end
+
+      def with_limit skip_limiters, start_time = nil
+        start_time ||= Time.now
+        can_execute = true
+        after_execute = []
+
+        @limiters.each do |limiter|
+          limiter_passed = limiter.before_run start_time
+          if limiter_passed || skip_limiters
+            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