rookout 0.1.0

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

@@ -0,0 +1,15 @@
+module Rookout
+  module Augs
+    module Conditions
+      class Condition
+        def initialize condition
+          @path = ArithmeticPath.new condition
+        end
+
+        def evaluate namespace
+          @path.read_from(namespace).object == true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Rookout
+  module Augs
+    module Locations
+      class Location
+        def add_aug _trigger_services, _aug
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Rookout
+  module Augs
+    module Locations
+      require_relative "location"
+
+      class LocationFileLine < Location
+        NAME = "file_line".freeze
+
+        def initialize arguments, _processor_factory
+          @filename = arguments["filename"]
+          @lineno = arguments["lineno"]
+
+          @file_hash = arguments["sha256"]
+          @line_crc = arguments["line_crc32_2"]
+          @line_unique = arguments["line_unique"] != 0
+        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
+        end
+      end
+    end
+  end
+end

data/lib/rookout/com_ws/agent_com_ws.rb

@@ -0,0 +1,221 @@
+module Rookout
+  module ComWs
+    require "securerandom"
+    require "kontena-websocket-client"
+    require "event_emitter"
+    require "google/protobuf/well_known_types"
+    require "concurrent"
+
+    require_relative "../config"
+    require_relative "../logger"
+    require_relative "../user_warnings"
+    require_relative "../exceptions"
+
+    require_relative "../processor/rook_error"
+
+    require_relative "../protobuf/messages_pb"
+    require_relative "../protobuf/envelope_pb"
+
+    require_relative "backoff"
+    require_relative "information"
+
+    class AgentComWs
+      include EventEmitter
+
+      def initialize output, agent_host, agent_port, proxy, token, labels
+        agent_host_with_protocl = agent_host.include?("://") ? agent_host : "ws://#{agent_host}"
+        @uri = "#{agent_host_with_protocl}:#{agent_port}/v1"
+        if proxy.nil? || proxy.empty?
+          @proxy = nil
+        else
+          @proxy = proxy.include?("://") ? proxy : "http://#{proxy}"
+        end
+
+        @token = token
+        @token_valid = false
+
+        @output = output
+        @info = Information.new labels
+        reset_id
+
+        @thread = nil
+        @pending_messages = Queue.new
+
+        @running = false
+        @ready_event = Concurrent::Event.new
+        once("Com::Rookout::InitialAugsCommand") { @ready_event.set }
+      end
+
+      def add message
+        buffer = wrap_in_envelope message
+        if buffer.length > Config.agent_com_max_message_limit
+          exc = Exceptions::RookMessageSizeExceeded.new buffer.length, Coonfig.agent_com_max_message_limit
+          warning = RookError.new exc, message
+          UserWarnings.notify_warning warning
+
+          Logger.instance.warn "Dropping message, size was #{buffer.length} which is over the message size limit"
+          return
+        end
+
+        @pending_messages.push buffer if @pending_messages.length < Config.agent_com_max_queued_messages
+      end
+
+      def connect
+        @running = true
+
+        @thread = Thread.new { connection_thread }
+        @thread.name = "rookout-connection-thread"
+      end
+
+      def wait_for_ready
+        @ready_event.wait Config.agent_com_timeout
+        raise @connection_error if @connection_error
+      end
+
+      def flush_all_messages
+        flush = FlushMessage
+        @pending_messages.push flush
+        flush.event.wait Config.agent_com_flush_timeout
+      end
+
+      private
+
+      def connection_thread
+        backoff = Backoff.new
+
+        while @running
+          begin
+            backoff.before_connection_attempt
+            Kontena::Websocket::Client.connect(@uri, **create_options) do |client|
+              register client
+
+              Logger.instance.debug "WebSocket connected successfully"
+              @token_valid = true
+              backoff.after_connect
+
+              connection_pump client
+            end
+          rescue Exception => e
+            if !@token_valid && e.is_a?(Kontena::Websocket::ProtocolError) && e.message.include?("403")
+              @connection_error = Exceptions::RookInvalidToken.new @token
+              @ready_event.set
+            end
+
+            Logger.instance.info "Connection failed; reason = #{e.message}"
+          end
+
+          backoff.after_disconnect
+          Logger.instance.debug "Reconnecting"
+        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 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)
+      end
+
+      ACCEPTED_MESSAGE_TYPES = [
+        Com::Rookout::InitialAugsCommand,
+        Com::Rookout::AddAugCommand,
+        Com::Rookout::ClearAugsCommand,
+        Com::Rookout::PingMessage,
+        Com::Rookout::RemoveAugCommand
+      ].freeze
+
+      def connection_pump client
+        on_outgoing_exit = proc { client.disconnect }
+        send_thread = Thread.new { outgoing client, on_outgoing_exit }
+        send_thread.name = "rookout-outgoing-thread"
+
+        client.read do |raw_message|
+          envelope = Com::Rookout::Envelope.decode raw_message.pack("c*")
+
+          ACCEPTED_MESSAGE_TYPES.each do |klass|
+            next unless envelope.msg.is klass
+            emit klass.name, envelope.msg.unpack(klass)
+          end
+        end
+
+        Logger.instance.debug "Incoming loop - socket disconnected"
+
+        @pending_messages.push ExitMessage.new(send_thread)
+        send_thread.join
+      end
+
+      def outgoing client, on_exit
+        loop do
+          begin
+            msg = @pending_messages.pop true
+          rescue ThreadError
+            sleep 0.25
+            next
+          end
+
+          if msg.is_a? ExitMessage
+            break if msg.thread == Thread.current
+          elsif msg.is_a? FlushMessage
+            msg.event.set
+          else
+            begin
+              client.send msg
+            rescue RuntimeError
+              @queue << msg
+              break
+            end
+          end
+        end
+      rescue Exception => e
+        Logger.instance.exception "Outgoing thread failed", e
+      ensure
+        on_exit.call
+      end
+
+      def wrap_in_envelope message
+        any_message = Google::Protobuf::Any.pack message
+        timestamp = Google::Protobuf::Timestamp.new
+        timestamp.from_time Time.new
+        envelope = Com::Rookout::Envelope.new msg: any_message, timestamp: timestamp
+        envelope.to_proto.bytes
+      end
+
+      def reset_id
+        @agent_id = SecureRandom.uuid
+        @output.agent_id = @agent_id
+        @info.agent_id = @agent_id
+      end
+
+      class ExitMessage
+        def initialize thread
+          @thread = thread
+        end
+
+        attr_reader :thread
+      end
+
+      class FlushMessage
+        def initialize
+          @event = Concurrent::Event.new
+        end
+
+        attr_reader :event
+      end
+    end
+  end
+end

data/lib/rookout/com_ws/backoff.rb

@@ -0,0 +1,35 @@
+module Rookout
+  module ComWs
+    require_relative "../config"
+
+    class Backoff
+      def initialize
+        @connected = false
+        @last_successful_connection = Time.mktime 1970
+        reset_backoff
+      end
+
+      def before_connection_attempt
+        return unless Time.new > @last_successful_connection + Config.backoff_reset_time
+        reset_backoff
+      end
+
+      def after_disconnect
+        @connected = false
+        sleep @next_backoff
+        @next_backoff = [@next_backoff * 2, Config.backoff_max_time].min
+      end
+
+      def after_connect
+        @connected = true
+        @last_successful_connection = Time.now
+      end
+
+      private
+
+      def reset_backoff
+        @next_backoff = Config.backoff_factor
+      end
+    end
+  end
+end

data/lib/rookout/com_ws/command_handler.rb

@@ -0,0 +1,22 @@
+module Rookout
+  module ComWs
+    require "json"
+
+    class CommandHandler
+      def initialize agent_com, augs_manager
+        agent_com.on "Com::Rookout::InitialAugsCommand" do |initial_augs|
+          augs = initial_augs.augs.map { |aug_json| JSON.parse aug_json }
+          augs_manager.initialize_augs augs
+        end
+
+        agent_com.on "Com::Rookout::AddAugCommand" do |command|
+          augs_manager.add_aug JSON.parse(command.aug_json)
+        end
+
+        agent_com.on "Com::Rookout::RemoveAugCommand" do |command|
+          augs_manager.remove_aug command.aug_id
+        end
+      end
+    end
+  end
+end

data/lib/rookout/com_ws/git.rb

@@ -0,0 +1,53 @@
+module Rookout
+  module ComWs
+    module Git
+      GIT_FOLDER = ".git".freeze
+      GIT_HEAD = "HEAD".freeze
+      GIT_CONFIG = "config".freeze
+
+      REMOTE_ORIGINS = /\[remote "origin"\]\s*url\s*=\s*(\S*)/.freeze
+
+      def find_root path
+        # Return if found
+        return path if git? path
+
+        # Get next, fail if there's no next
+        next_path = File.dirname path
+        return nil if next_path == path
+
+        # Recursive call
+        find_root next_path
+      end
+
+      def revision path
+        follow_sym_links File.join(path, GIT_FOLDER), GIT_HEAD
+      end
+
+      def remote_origin path
+        git_config_path = File.join path, GIT_FOLDER, GIT_CONFIG
+        git_config_contents = File.read git_config_path
+        match = git_config_contents.match REMOTE_ORIGINS
+        return "" if match.captures.empty?
+
+        match.captures[0]
+      end
+
+      def git? path
+        potential_git_folder = File.join path, GIT_FOLDER
+        File.directory? potential_git_folder
+      end
+
+      def follow_sym_links root, link
+        link_path = File.join root, link
+        link_contents = File.read link_path
+
+        if link_contents.start_with? "ref:"
+          next_link = (link_contents.split " ")[1].strip
+          follow_sym_links root, next_link
+        else
+          link_contents.strip
+        end
+      end
+    end
+  end
+end

data/lib/rookout/com_ws/information.rb

@@ -0,0 +1,85 @@
+module Rookout
+  module ComWs
+    require "socket"
+    require "English"
+
+    require_relative "../config"
+
+    require_relative "../protobuf/agent_info_pb"
+
+    class Information
+      require_relative "git"
+      include Git
+
+      def initialize labels
+        @agent_id = nil
+        @labels = labels.clone
+        @labels["rookout_debug"] = "on"
+
+        @ip_addr = local_ip
+
+        @scm_info = create_scm_information
+      end
+
+      def pack
+        version_info = Com::Rookout::VersionInformation.new version: Config.rookout_version,
+                                                            commit: Config.rookout_commit
+
+        network_info = Com::Rookout::NetworkInformation.new ip_addr: @ip_addr
+
+        system_info = Com::Rookout::SystemInformation.new hostname: Socket.gethostname,
+                                                          os: RUBY_PLATFORM,
+                                                          os_version: "",
+                                                          distro: "",
+                                                          arch: ""
+
+        platform_info = Com::Rookout::PlatformInformation.new platform: "ruby",
+                                                              version: RUBY_VERSION,
+                                                              variant: RUBY_ENGINE
+
+        Com::Rookout::AgentInformation.new agent_id: @agent_id,
+                                           version: version_info,
+                                           network: network_info,
+                                           system: system_info,
+                                           platform: platform_info,
+                                           executable: $PROGRAM_NAME,
+                                           command_arguments: ARGV,
+                                           process_id: Process.pid,
+                                           labels: @labels,
+                                           scm: @scm_info
+      end
+
+      attr_accessor :agent_id
+
+      private
+
+      # rubocop:disable Style/ParallelAssignment
+      def local_ip
+        orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
+        UDPSocket.open do |s|
+          s.connect "10.255.255.255", 1
+          s.addr.last
+        end
+      ensure
+        Socket.do_not_reverse_lookup = orig
+      end
+      # rubocop:enable Style/ParallelAssignment
+
+      def create_scm_information
+        user_git_origin = Config.user_git_origin || ENV["ROOKOUT_ORIGIN"]
+        user_git_commit = Config.user_git_commit || ENV["ROOKOUT_COMMIT"]
+
+        if user_git_origin.nil? && user_git_commit.nil?
+          search_path = File.dirname File.absolute_path($PROGRAM_NAME)
+          git_root = find_root search_path
+          if git_root
+            user_git_origin = remote_origin git_root
+            user_git_commit = revision git_root
+          end
+        end
+
+        Com::Rookout::SCMInformation.new origin: user_git_origin, commit: user_git_commit
+      end
+    end
+  end
+end