rookout 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 17eda3a68e52adf758e353e65066c8e68e65c5df18e67299c95e111a60717260
+  data.tar.gz: fd7cadcf2f2890130e9d92c6f56312c7c1a6bf1ad55efc84a83c39ad67f68020
+SHA512:
+  metadata.gz: c1968166a99e6c85d7476de449bea06d7105bd9b0b71681c8c4263ccc33d88440e2a956a1d29d4681db44af1d6a8ea5e1cfb142895c182bb1388868c6f920035
+  data.tar.gz: f805c321af5605bade4d443557b3c575d7f432afa392820c4589bc8023af8a971e7a7d72f851ff2899ae7c4aca5fd3864f4e35dd0fb5e942cc4c3e570402cbdc

data/LICENSE

@@ -0,0 +1,12 @@
+This software is a proprietary product of Rookout, and is protected under copyright laws and international copyright treaties. Any use of the software is subject to and governed by the license conditions below:
+1. You may run, execute or otherwise actively use this software (whether as a whole or portions of it) only if you have entered into a separate software-as-a-service agreement with Rookout.
+2. You may republish and redistribute this software but only within the same code repository it is found in.
+3. All other uses, reproductions, copies, distributions or publications of this software are strictly prohibited.
+4. You may not use this software to breach the security of the Rookout software-as-a-service, to circumvent, manipulate, impair or disrupt its operation, or perform any benchmark or penetration testing of the Rookout software-as-a-service.
+5. YOU MAY NOT USE THIS SOFTWARE FOR ANY ACTIVITY THAT CONSTITUTES, OR ENCOURAGES CONDUCT THAT WOULD CONSTITUTE, A CRIMINAL OFFENSE, GIVE RISE TO CIVIL LIABILITY OR OTHERWISE VIOLATE ANY APPLICABLE LAW.
+Any use of this software is further subject to and governed by the following limitations:
+THIS SOFTWARE IS PROVIDED TO YOU “AS IS”. ROOKOUT DOES NOT GUARANTEE, MAKES NO REPRESENTATION, AND PROVIDES NO WARRANTY ABOUT THIS SOFTWARE, INCLUDING ON QUALITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT.
+TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, ROOKOUT AND ITS STAFF WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL, SPECIAL, STATUTORY OR PUNITIVE DAMAGES, LOSSES ARISING FROM, OR IN CONNECTION, WITH YOUR USE OF, OR RELIANCE UPON, THIS SOFTWARE.
+IF YOU ARE ESTABLISHED OR LOCATED IN THE UNITED STATES OF AMERICA, THEN THIS LICENSE IS BY ROOKOUT, INC., A DELAWARE CORPORATE.
+IF YOU ARE ESTABLISHED OR LOCATED ELSEWHERE THAN THE UNITED STATES OF AMERICA, THEN THIS LICENSE IS BY ROOKOUT, LTD., AN ISRAELI COMPANY.
+© 2018 Rookout. All rights reserved.

data/bin/rookout

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+def rookout_test
+  puts "[Rookout] Testing connection to agent"
+
+  debug = ARGV.include? "-v"
+
+  require "rookout/config"
+  Rookout::Config.agent_com_timeout = 10
+
+  begin
+    require "rookout"
+    Rookout.start debug: debug, throw_errors: true
+
+    success = true
+  rescue StandardError => e
+    puts e.full_message
+    success = false
+  end
+
+  if success
+    puts "[Rookout] Test Finished Successfully"
+    exit 0
+  else
+    puts "[Rookout] Test Failed"
+    exit 1
+  end
+end
+
+rookout_test

data/lib/rookout.rb

@@ -0,0 +1,18 @@
+module Rookout
+  module_function
+
+  def start options = {}
+    require_relative "rookout/interface"
+    Interface.instance.start options
+  end
+
+  def flush
+    require_relative "rookout/interface"
+    Interface.instance.flush
+  end
+
+  def stop
+    require_relative "rookout/interface"
+    Interface.instance.stop
+  end
+end

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

@@ -0,0 +1,11 @@
+module Rookout
+  module Augs
+    module Actions
+      class Action
+        def execute _aug_id, _report_id, _namespace, _output
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require_relative "action"
+
+module Rookout
+  module Augs
+    module Actions
+      class ActionRunProcessor < Action
+        def initialize arguments, processor_factory
+          @processor = processor_factory.create_processor arguments["operations"]
+
+          post_operations = arguments["post_operations"]
+          if post_operations
+            @post_processor = processor_factory.create_processor post_operations
+          else
+            @post_processor = nil
+          end
+        end
+
+        def execute aug_id, report_id, namespace, _output
+          @processor.process namespace
+          @output.send_user_message aug_id, report_id, namespace.read_attribute("store")
+          return unless @post_processor
+
+          @output.flush_message
+          @post_processor.process namespace
+        end
+      end
+    end
+  end
+end

data/lib/rookout/augs/aug.rb

@@ -0,0 +1,121 @@
+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 "../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
+
+        @id = aug_id
+        @location = location
+        @action = action
+        @condition = condition
+        @rate_limiter = rate_limiter
+        @output = output
+
+        @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
+
+    def execute frame, extracted
+      return unless @enabled
+
+      UserWarnings.with self do
+        begin
+          namespace = create_namespaces frame, 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
+        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
+    end
+  end
+end

data/lib/rookout/augs/aug_factory.rb

@@ -0,0 +1,69 @@
+module Rookout
+  module Augs
+    require_relative "../exceptions"
+    require_relative "../config"
+    require_relative "../processor/processor_factory"
+
+    require_relative "actions/action_run_processor"
+    require_relative "conditions/condition"
+    require_relative "aug_rate_limiter"
+
+    class AugFactory
+      def initialize output
+        @output = output
+        @factory = Processor::ProcessorFactory.new
+      end
+
+      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
+
+        action_configuration = configuration["action"]
+        raise Exceptions.RookAugInvalidKey "action", configuration unless action_configuration.is_a? Hash
+        action = Actions.ActionRunProcess.new action_configuration, @factory
+
+        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
+
+        rate_limit = create_rate_limit configuration
+
+        Aug.new aug_id, location, action, condition, rate_limit, max_aug_time, @output
+      end
+
+      private
+
+      def create_location configuration
+        name = configuration["name"]
+        raise Exceptions.RookObjectNameMissing if name.nil?
+        raise Exceptions.RookUnsupportedLocation if name != "file_line"
+
+        Locations.LocationFileLine.new configuration, @factory
+      end
+
+      def create_rate_limit configuration
+        window_quota = 200
+        window_size = 5000
+
+        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]
+          end
+        end
+
+        rate_limit_modifier = configuration["rateLimitModifier"] || 5
+
+        AugRateLimiter.new window_quota, window_size, rate_limit_modifier
+      end
+    end
+  end
+end

data/lib/rookout/augs/aug_rate_limiter.rb

@@ -0,0 +1,96 @@
+module Rookout
+  module Augs
+    require_relative "../exceptions"
+
+    class AugRateLimiter
+      def initialize quota, window_size, active_limit
+        @quota = quota
+        @window_size = window_size
+        @active_weight = quota / active_limit
+
+        @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
+          end
+        end
+
+        begin
+          yield
+        ensure
+          @mutex.synchronize { record_usage current_window_key, (Time.now - start_time) * 1000 } if @quota
+        end
+      ensure
+        # Reduce active count
+        @mutex.synchronize { @active_count -= 1 } if active
+      end
+
+      private
+
+      def current_usage now_ms, current_window_key, prev_window_key
+        # Get usage information
+        current_window_usage = @windows[current_window_key]
+        if current_window_usage.nil?
+          # Create new window
+          current_window_usage = @windows[current_window_key] = 0
+        end
+        prev_window_usage = @windows[prev_window_key] || 0
+
+        # Previous window weight
+        prev_weight = 1 - (now_ms - current_window_key) / @window_size.to_f
+
+        # Final weighted usage
+        (prev_window_usage * prev_weight) + (@active_count * @active_weight) + current_window_usage
+      end
+
+      def record_usage current_window_key, duration
+        # windows might be cleared while aug is running (unlikely)
+        prev_value = @windows[current_window_key]
+        return if prev_value.nil?
+
+        # Add value to quota
+        @windows[current_window_key] += max(duration, 5).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
+      end
+    end
+  end
+end

data/lib/rookout/augs/augs_manager.rb

@@ -0,0 +1,77 @@
+module Rookout
+  module Augs
+    require_relative "../logger"
+
+    require_relative "aug_factory"
+
+    class AugsManager
+      def initialize trigger_services, output
+        @trigger_services = trigger_services
+        @output = output
+        @aug_factory = AugFactory.new @output
+        @augs = []
+      end
+
+      def initialize_augs augs
+        leftovers = @augs.clone
+
+        augs.each do |aug|
+          begin
+            aug_id = aug["id"]
+          rescue KeyError
+            next
+          end
+
+          leftovers.delete aug_id
+
+          add_aug aug
+        end
+
+        leftovers.each { |aug_id| remove_aug aug_id }
+      end
+
+      def add_aug configuration
+        begin
+          aug = @aug_factory.create_aug configuration
+        rescue StandardError => e
+          message = "Failed to parse aug"
+          Logger.instance.exception message, e
+
+          begin
+            aug_id = configuration["id"]
+          rescue StandardError
+            return
+          end
+
+          error = RookError.new e, message
+          @output.send_rule_status aug_id, "Error", error
+          return
+        end
+
+        if @augs.include? aug.id
+          Logger.instance.debug "Aug already set - #{aug.id}"
+          return
+        end
+
+        Logger.instance.debug "Adding aug-\t#{aug.id}"
+
+        aug.add_aug @trigger_services
+        @augs.push aug.id
+      end
+
+      def remove_aug aug_id
+        Logger.instance.debug "Removing aug-\t#{aug_id}"
+
+        @trigger_services.remove_aug aug_id
+        @augs.delete aug_id
+      end
+
+      def clear_augs
+        Logger.instance.debug "Clearing all augs"
+
+        @augs.clone.each { |aug| remove_aug aug }
+        @trigger_services.clear_augs
+      end
+    end
+  end
+end