rookout 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17eda3a68e52adf758e353e65066c8e68e65c5df18e67299c95e111a60717260
-  data.tar.gz: fd7cadcf2f2890130e9d92c6f56312c7c1a6bf1ad55efc84a83c39ad67f68020
+  metadata.gz: 874a75dff546e6c6959ecd21b5083d3b6f8a6a0f3c055722221471572d6633c1
+  data.tar.gz: cef6e4460d9a852de5ca2af9dbd1fe865a1ead4cdb7186e62d7383453702402c
 SHA512:
-  metadata.gz: c1968166a99e6c85d7476de449bea06d7105bd9b0b71681c8c4263ccc33d88440e2a956a1d29d4681db44af1d6a8ea5e1cfb142895c182bb1388868c6f920035
-  data.tar.gz: f805c321af5605bade4d443557b3c575d7f432afa392820c4589bc8023af8a971e7a7d72f851ff2899ae7c4aca5fd3864f4e35dd0fb5e942cc4c3e570402cbdc
+  metadata.gz: 3ea95c83e5b19b8279ea1ce829814bebda8425411e926b3b7bcbcbf72d5c9a08bedb87dc2a6ff7e5f10083f9f062d2c1ca85e93364d63d0e35b043dee843498d
+  data.tar.gz: d10b3af2d478bc77f2488d7a86083f6f46bdfda8ea450bc65d17dec194efdaf9495e8c1972381473136e4766e88c805b930ea66ecfba086a54a23876b4fc46fe

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

@@ -15,12 +15,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,11 +1,6 @@
-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"
@@ -13,109 +8,47 @@ module Rookout
     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
+      def initialize aug_id, action, condition, rate_limiter, _max_aug_time
         # 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
+      attr_reader :id
 
-      UserWarnings.with self do
-        begin
-          namespace = create_namespaces frame, extracted
+      def execute frame, extracted, output
+        return unless @enabled
 
-          return if @condition && !@condition.evaluate(namespace)
+        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
+        @rate_limiter.with_limit do
+          report_id = Utils.uuid
+          @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, extracted
+        Processor::Namespaces::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::RubyUtilsNamespace.new,
+          "trace" => Processor::Namespaces::NoopNamespace.new
+        )
+      end
     end
   end
 end

data/lib/rookout/augs/aug_factory.rb

@@ -6,7 +6,9 @@ module Rookout
 
     require_relative "actions/action_run_processor"
     require_relative "conditions/condition"
+    require_relative "locations/location_file_line"
     require_relative "aug_rate_limiter"
+    require_relative "aug"
 
     class AugFactory
       def initialize output
@@ -16,35 +18,36 @@ 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
+        raise Exceptions::RookAugInvalidKey.new("conditional", configuration) unless
+            condition_configuration.nil? || condition_configuration.is_a?(String)
+        condition = condition_configuration.nil? ? nil : Conditions::Condition.new(condition_configuration)
 
         rate_limit = create_rate_limit configuration
 
-        Aug.new aug_id, location, action, condition, rate_limit, max_aug_time, @output
+        aug = Aug.new aug_id, action, condition, rate_limit, max_aug_time
+
+        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"
 
-        Locations.LocationFileLine.new configuration, @factory
+        Locations::LocationFileLine.new configuration, @output, aug
       end
 
       def create_rate_limit configuration

data/lib/rookout/augs/aug_rate_limiter.rb

@@ -15,12 +15,12 @@ module Rookout
 
       def with_limit start_time = nil
         active = false
-        start_time ||= Time.new
+        start_time ||= Time.now
 
         # If quota, verify it
         if @quota
           # Get current time
-          now_ms = (now * 1000).to_i
+          now_ms = (start_time.to_f * 1000).to_i
 
           # Calculate window keys
           current_window_key = (now_ms / @window_size) * @window_size
@@ -77,7 +77,7 @@ 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

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/locations/location.rb

@@ -1,10 +1,84 @@
 module Rookout
   module Augs
     module Locations
+      require_relative "../../processor/rook_error"
+
+      MAX_LOG_CACHE_SIZE = 10
+
       class Location
-        def add_aug _trigger_services, _aug
+        def initialize output, aug
+          @output = output
+          @aug = aug
+          @log_cache = []
+        end
+
+        def add_aug _trigger_services
           raise NotImplementedError
         end
+
+        def id
+          @aug.id
+        end
+
+        def execute frame, extracted
+          UserWarnings.with self do
+            begin
+              @aug.execute frame, extracted, @output
+            rescue SystemExit
+              raise
+            rescue Exception => e
+              message = "Exception while processing Aug"
+              puts e.message + "\n" + e.backtrace.join("\n\t")
+              error = Processor::RookError.new e, message
+              notify_warning 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
+
+          Logger.instance.warning error.message
+
+          send_rule_status :Warning, error
+        end
+
+        private
+
+        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 if @status == status
+
+          Logger.instance.info "Updating rule status for #{@id} to #{status}"
+          @status = status
+
+          # For easier testing
+          return if @output.nil?
+
+          @output.send_rule_status id, status, error
+        end
       end
     end
   end

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

@@ -1,24 +1,36 @@
 module Rookout
   module Augs
+    require_relative "../../logger"
+
+    require_relative "../../processor/rook_error"
+
     module Locations
       require_relative "location"
 
       class LocationFileLine < Location
         NAME = "file_line".freeze
 
-        def initialize arguments, _processor_factory
+        def initialize arguments, output, aug
+          super output, aug
           @filename = arguments["filename"]
           @lineno = arguments["lineno"]
 
+          # NOTE: Hashes are only used for suggestions, not for verification
           @file_hash = arguments["sha256"]
           @line_crc = arguments["line_crc32_2"]
-          @line_unique = arguments["line_unique"] != 0
+          @line_unique = arguments["line_unique"] || false
         end
 
         attr_reader :filename, :lineno, :file_hash, :line_crc, :line_unique
 
-        def add_aug trigger_services, aug
-          trigger_services.get_service("position").add_aug self, aug
+        def add_aug trigger_services
+          trigger_services.get_service("position").add_aug self
+        rescue SystemExit
+          raise
+        rescue Exception => e
+          message = "Exception when adding aug"
+          Logger.instance.error message, e
+          notify_error Processor::RookError.new e, message
         end
       end
     end

data/lib/rookout/com_ws/agent_com_ws.rb

@@ -1,7 +1,5 @@
 module Rookout
   module ComWs
-    require "securerandom"
-    require "kontena-websocket-client"
     require "event_emitter"
     require "google/protobuf/well_known_types"
     require "concurrent"
@@ -10,14 +8,17 @@ module Rookout
     require_relative "../logger"
     require_relative "../user_warnings"
     require_relative "../exceptions"
+    require_relative "../utils"
 
     require_relative "../processor/rook_error"
 
     require_relative "../protobuf/messages_pb"
     require_relative "../protobuf/envelope_pb"
 
+    require_relative "websocket_client"
     require_relative "backoff"
     require_relative "information"
+    require_relative "pinger"
 
     class AgentComWs
       include EventEmitter
@@ -68,7 +69,11 @@ module Rookout
       end
 
       def wait_for_ready
-        @ready_event.wait Config.agent_com_timeout
+        is_finished = @ready_event.wait Config.agent_com_timeout
+        # We didn't finish - will keep trying in the background
+        raise Exceptions::RookCommunicationException unless is_finished
+
+        # We finished - raise if we failed
         raise @connection_error if @connection_error
       end
 
@@ -86,17 +91,15 @@ module Rookout
         while @running
           begin
             backoff.before_connection_attempt
-            Kontena::Websocket::Client.connect(@uri, **create_options) do |client|
-              register client
+            client = open_new_connection
 
-              Logger.instance.debug "WebSocket connected successfully"
-              @token_valid = true
-              backoff.after_connect
+            Logger.instance.debug "WebSocket connected successfully"
+            @token_valid = true
+            backoff.after_connect
 
-              connection_pump client
-            end
+            connection_pump client
           rescue Exception => e
-            if !@token_valid && e.is_a?(Kontena::Websocket::ProtocolError) && e.message.include?("403")
+            if !@token_valid && e.message.include?("403")
               @connection_error = Exceptions::RookInvalidToken.new @token
               @ready_event.set
             end
@@ -109,26 +112,15 @@ module Rookout
         end
       end
 
-      def create_options
-        headers = {
-          "User-Agent" => "RookoutAgent/#{Config.rookout_version}+#{Config.rookout_commit}"
-        }
-
-        headers["X-Rookout-Token"] = @token unless @token.nil?
-
-        # NOTE: WE DONT HAVE PROXY SUPPORT (YET) - THIS WILL PROBABLY REQUIRE FORKING KONTENA
-        { headers: headers,
-          connect_timeout: Config.agent_com_timeout,
-          open_timeout: Config.agent_com_timeout,
-          ping_interval: Config.agent_com_ping_interval,
-          ping_timeout: Config.agent_com_ping_timeout }
-      end
+      def open_new_connection
+        client = WebsocketClient.new @uri, @proxy, @token
+        client.connect
 
-      def register client
         Logger.instance.info "Registering agent with id #{@agent_id}"
-
         msg = Com::Rookout::NewAgentMessage.new agent_info: @info.pack
-        client.send wrap_in_envelope(msg)
+        client.send_frame wrap_in_envelope(msg)
+
+        client
       end
 
       ACCEPTED_MESSAGE_TYPES = [
@@ -140,11 +132,11 @@ module Rookout
       ].freeze
 
       def connection_pump client
-        on_outgoing_exit = proc { client.disconnect }
+        on_outgoing_exit = proc { client.close }
         send_thread = Thread.new { outgoing client, on_outgoing_exit }
         send_thread.name = "rookout-outgoing-thread"
 
-        client.read do |raw_message|
+        message_handler = proc do |raw_message|
           envelope = Com::Rookout::Envelope.decode raw_message.pack("c*")
 
           ACCEPTED_MESSAGE_TYPES.each do |klass|
@@ -153,6 +145,8 @@ module Rookout
           end
         end
 
+        client.connection_pump message_handler
+
         Logger.instance.debug "Incoming loop - socket disconnected"
 
         @pending_messages.push ExitMessage.new(send_thread)
@@ -160,7 +154,7 @@ module Rookout
       end
 
       def outgoing client, on_exit
-        loop do
+        Pinger.new(client, Config.agent_com_ping_interval, Config.agent_com_ping_timeout).repeat do
           begin
             msg = @pending_messages.pop true
           rescue ThreadError
@@ -174,7 +168,7 @@ module Rookout
             msg.event.set
           else
             begin
-              client.send msg
+              client.send_frame msg
             rescue RuntimeError
               @queue << msg
               break
@@ -184,6 +178,7 @@ module Rookout
       rescue Exception => e
         Logger.instance.exception "Outgoing thread failed", e
       ensure
+        Logger.instance.debug "Outgoing thread exiting"
         on_exit.call
       end
 
@@ -196,7 +191,7 @@ module Rookout
       end
 
       def reset_id
-        @agent_id = SecureRandom.uuid
+        @agent_id = Utils.uuid
         @output.agent_id = @agent_id
         @info.agent_id = @agent_id
       end