contrast-agent 3.12.2 → 3.15.0

data/lib/contrast/agent/require_state.rb

@@ -1,61 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-module Contrast
-  module Agent
-    # Thread local way to access the current RequireState. Used as a convenient
-    # wrapper to ensure specific key is used and that we handle the case when
-    # we try to enter a previously unset require scope.
-    # (Note that 'require scopes' track nested requires.  This is distinct
-    # from 'contrast scope', which tracks instrumentation.)
-    module RequireStates
-      class << self
-        KEY = :thread_local_contrast_require_scope
-
-        def enter
-          scope = current_scope
-          unless current_scope
-            scope = RequireState.new
-            Thread.current[KEY] = scope
-          end
-          scope.enter
-        end
-
-        def exit
-          current_scope.exit
-        end
-
-        def current_scope
-          Thread.current[KEY]
-        end
-
-        def status
-          current_scope&.scope.to_s
-        end
-
-        def in_scope?
-          scope = current_scope
-          scope && scope.scope > 1
-        end
-      end
-    end
-
-    # Simple counter class for tracking how deep in nested requires / file
-    # load operations we currently are.
-    class RequireState
-      attr_reader :scope
-
-      def initialize
-        @scope = 0
-      end
-
-      def enter
-        @scope += 1
-      end
-
-      def exit
-        @scope -= 1
-      end
-    end
-  end
-end

data/lib/contrast/agent/socket_client.rb

@@ -1,134 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'socket'
-cs__scoped_require 'uri'
-
-cs__scoped_require 'contrast/api/speedracer'
-cs__scoped_require 'contrast/api/tcp_socket'
-cs__scoped_require 'contrast/api/unix_socket'
-cs__scoped_require 'contrast/api/connection_status'
-cs__scoped_require 'contrast/components/interface'
-
-module Contrast
-  module Agent
-    # SocketClient acts as a interface between the agent and the service. It instantiates a
-    # service proxy and tracks the state of that proxy.
-    class SocketClient
-      include Contrast::Components::Interface
-
-      access_component :app_context, :contrast_service, :logging
-
-      attr_reader :speedracer, :status
-
-      def initialize
-        @status = Contrast::Api::ConnectionStatus.new
-        @speedracer = Contrast::Api::Speedracer.new(init_connection)
-        @ensure_running = Mutex.new
-      end
-
-      def service_unavailable?
-        speedracer.nil?
-      end
-
-      def connection_established?
-        status.connected?
-      end
-
-      # Attempt to send the passed message to SpeedRacer. If we're using bundled
-      # service config option, we must first start up the service. Afterwards, we
-      # must send agent startup messages no matter what the config options are.
-      #
-      # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event
-      #   field of Contrast::Api::Dtm::Message
-      # @return [Array<Contrast::Api::Settings::AgentSettings>] the response from SpeedRacer or nil
-      #   if it failed to send or the service is unavailable.
-      def send_to_speedracer event
-        return if service_unavailable?
-
-        @ensure_running.synchronize do
-          if CONTRAST_SERVICE.use_bundled_service?
-            return unless start_or_restart
-          end
-          build_service_context unless status.startup_messages_sent?
-        end
-
-        logger.debug_with_time(event.cs__class.name) do
-          response = speedracer.send_one event
-          status.success!
-          response
-        end
-      rescue StandardError => e
-        status.failure!
-        logger.error('Unable to send message.', e,
-                     event_id: event.__id__,
-                     event_type: event.cs__class.name)
-        nil
-      end
-
-      private
-
-      def init_connection
-        if CONTRAST_SERVICE.use_tcp?
-          Contrast::Api::TcpSocket.new(CONTRAST_SERVICE.host, CONTRAST_SERVICE.port)
-        else
-          Contrast::Api::UnixSocket.new(CONTRAST_SERVICE.socket_path)
-        end
-      end
-
-      def restart?
-        status.was_connected? && status.failed?
-      end
-
-      # Now that we know we're running with bundled service option, we can tell SpeedRacer that we're
-      # ready for it to be started up.
-      #
-      # @return [Boolean] true if the service is started, false if the service is still offline after
-      # we've attempted to start it up.
-      def start_or_restart
-        if restart?
-          logger.info('Attempting to restart service.')
-          return speedracer.start_service
-        elsif !status.was_connected?
-          logger.info('Attempting to start service.')
-          return speedracer.start_service
-        end
-
-        true
-      end
-
-      def build_service_context
-        agent_startup_msg = APP_CONTEXT.build_agent_startup_message
-        app_startup_msg = APP_CONTEXT.build_app_startup_message
-
-        # 1 initial attempt, + 3 potential retries.
-        # The agent-service-api REQUIREMENTS.md spec mandates this #.
-        4.times do
-          log_send_event(agent_startup_msg)
-          next unless (agent_response = speedracer.send_one(agent_startup_msg))
-
-          # Connection was successful
-          log_send_event(app_startup_msg)
-          app_response = speedracer.send_one(app_startup_msg)
-          [agent_response, app_response].each do |msg|
-            Contrast::Utils::ServiceResponseUtil.process_response msg
-          end
-          status.success!
-          logger.debug('Successfully sent startup messages to service.')
-          return
-        end
-
-        logger.error('Could not send agent startup message context')
-      rescue StandardError => e
-        logger.error('Could not build service context', e)
-        raise # re-raise the error to be caught by SocketClient#send_to_speedracer
-      end
-
-      def log_send_event event
-        logger.debug('Immediately sending event.',
-                     event_id: event.__id__,
-                     event_type: event.cs__class.name)
-      end
-    end
-  end
-end

data/lib/contrast/api/connection_status.rb

@@ -1,49 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-module Contrast
-  module Api
-    # Keeps track of the state of connections to the service.
-    class ConnectionStatus
-      def initialize
-        @last_success = nil
-        @last_failure = nil
-        @startup_messages_sent = false
-      end
-
-      # Whether we have sent startup message to the service. True after successfully
-      # sending startup messages to service and reset to false if we lose connection
-      # to the service.
-      def startup_messages_sent?
-        @startup_messages_sent
-      end
-
-      # A message was successfully sent to the service at some point
-      def was_connected?
-        @last_success
-      end
-
-      # The last message sent was successful
-      def connected?
-        @last_success && (@last_failure.nil? || @last_success > @last_failure)
-      end
-
-      # The last message sent was unsuccessful
-      def failed?
-        @last_failure && (@last_success.nil? || @last_failure > @last_success)
-      end
-
-      # The current state of the service is active with a successful message sent
-      def success!
-        @startup_messages_sent = true
-        @last_success = Time.now.to_f
-      end
-
-      # The service may be in some sort of error state
-      def failure!
-        @startup_messages_sent = false
-        @last_failure = Time.now.to_f
-      end
-    end
-  end
-end

data/lib/contrast/api/socket.rb

@@ -1,43 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-module Contrast
-  module Api
-    # Behavior common to all sockets used
-    # to communicate with the Contrast Service.
-    module Socket
-      SOCKET_MONITOR = Monitor.new
-
-      # Send a message across the socket and read back the response.
-      # @param marshaled [String] some marshaled form of data to be sent across
-      #   the socket. Typically an encoded form of Contrast::Api::Dtm::Message.
-      # @return [String] some marshalled form of data returned by the socket.
-      #   Typically an encoded form of Contrast::Api::Settings::AgentSettings.
-      def send_marshaled marshaled
-        SOCKET_MONITOR.synchronize do
-          socket = new_socket
-
-          # write message length
-          len = marshaled.length
-          socket.write([len].pack(Contrast::Api::ENCODING_STRING))
-
-          # write the entire message
-          socket.write(marshaled)
-          socket.close_write
-
-          # read the response length
-          len = socket.read(4).unpack1(Contrast::Api::ENCODING_STRING)
-
-          # read expected response to end
-          socket.read(len)
-        end
-      end
-
-      # Override this method to return a socket.
-      # Should be interface compatible with TCPSocket, UNIXSocket, etc.
-      def new_socket
-        raise NotImplementedError, 'This is abstract, override it.'
-      end
-    end
-  end
-end

data/lib/contrast/api/speedracer.rb

@@ -1,188 +0,0 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
-# frozen_string_literal: true
-
-cs__scoped_require 'contrast/utils/object_share'
-cs__scoped_require 'contrast/utils/os'
-cs__scoped_require 'contrast/components/interface'
-
-module Contrast
-  module Api
-    # This class acts as the interface for the communication between the Agent
-    # and the Service (SpeedRacer) as well as functions as a way for the Agent
-    # to manage the bundled Service.
-    class Speedracer
-      include Contrast::Components::Interface
-      access_component :app_context, :contrast_service, :logging
-
-      attr_reader :client_number,
-                  :host,
-                  :port,
-                  :socket,
-                  :connection
-
-      @instance_count = 0
-      @instance_mutex = Mutex.new
-
-      def self.next_client_number
-        @instance_mutex.synchronize do
-          @instance_count += 1
-        # Rollover things
-        rescue StandardError
-          @instance_count = 1
-        end
-      end
-
-      def self.read_only_instance_count
-        @instance_count.dup
-      end
-
-      def initialize connection
-        @client_number = Contrast::Api::Speedracer.next_client_number
-        @messages_total = 0
-
-        @pid = Process.pid.to_i
-        @ppid = Process.ppid.to_i
-        @connection = connection
-      end
-
-      # Allow for the start of a Service, but block so that we only attempt to
-      # start the service one try at a time in the case multiple threads are
-      # trying to send messages.
-      def start_service
-        zombie_check
-        service_starter_thread.join(5)
-        is_service_started = Contrast::Utils::OS.running?
-        logger.error('The bundled service could not be started. The agent will not function properly.') unless is_service_started
-        is_service_started
-      end
-
-      # Wrap the given DTM in a Contrast::Api::Dtm::Message and send it to the
-      # Service for processing
-      #
-      # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event field of
-      #   Contrast::Api::Dtm::Message
-      def send_one event
-        msg = build_message(event)
-        send_message(msg)
-      end
-
-      private
-
-      # check if there's a zombie service that exists, and wait on it if so.
-      # currently, this only happens when trying to initialize speedracer
-      def zombie_check
-        zombie_pid_list = Contrast::Utils::OS.zombie_pids
-        zombie_pid_list.each do |pid|
-          Process.wait(pid.to_i)
-        end
-      end
-
-      def determine_startup_options
-        return { out: :out, err: :err } if CONTRAST_SERVICE.logger_path == 'STDOUT'
-
-        { out: File::NULL, err: File::NULL }
-      end
-
-      # This is a separate method so we can overwrite it globally in specs
-      def spawn_service
-        options = determine_startup_options
-        spawn 'contrast_service', options
-      end
-
-      def service_starter_thread
-        Contrast::Agent::Thread.new do
-          # Always check to see if it already started
-          unless Contrast::Utils::OS.running?
-            # Spawn the service process
-            spawn_service
-            # Block until service is running
-            sleep(0.1) until Contrast::Utils::OS.running?
-          end
-        end
-      end
-
-      # Wrap the given event in a Contrast::Api::Dtm::Message
-      #
-      # @param event [Contrast::Api::Dtm] One of the DTMs valid for the event field of
-      #   Contrast::Api::Dtm::Message
-      # @return Contrast::Api::Dtm::Message
-      def build_message event
-        message = base_message
-        case event
-        when Contrast::Api::Dtm::ServerActivity
-          message.server_activity = event
-        when Contrast::Api::Dtm::AgentStartup
-          message.agent_startup = event
-        when Contrast::Api::Dtm::ApplicationCreate
-          message.application_create = event
-        when Contrast::Api::Dtm::ApplicationUpdate
-          message.application_update = event
-        when Contrast::Api::Dtm::Activity
-          message.activity = event
-        when Contrast::Api::Dtm::HttpRequest
-          message.prefilter = event
-        when Contrast::Api::Dtm::HttpResponse
-          message.postfilter = event
-        when Contrast::Api::Dtm::Poll
-          message.poll = event
-        when Contrast::Api::Dtm::ObservedRoute
-          message.observed_route = event
-        else
-          logger.error('Unknown event type received. Unsure how to send.', event_type: event.cs__class.name)
-          return
-        end
-        logger.debug('Wrapping event in message',
-                     msg_id: message.__id__,
-                     p_id: message.pid,
-                     msg_count: message.message_count,
-                     event_id: event.__id__,
-                     event_type: event.cs__class.name)
-        message
-      end
-
-      def base_message
-        msg               = Contrast::Api::Dtm::Message.new
-        msg.app_name      = APP_CONTEXT.name
-        msg.app_path      = APP_CONTEXT.path
-        msg.app_language  = Contrast::Utils::ObjectShare::RUBY
-        msg.client_id     = APP_CONTEXT.client_id
-        msg.client_number = client_number
-        msg.client_total  = Contrast::Api::Speedracer.read_only_instance_count
-        msg.message_count = (@messages_total += 1)
-        msg.pid           = APP_CONTEXT.pid
-        msg.ppid          = APP_CONTEXT.ppid
-        msg
-      end
-
-      def send_message msg
-        return unless msg
-
-        logger.debug('Sending message.',
-                     msg_id: msg.__id__,
-                     p_id: msg.pid,
-                     msg_count: msg.message_count)
-        to_service = Contrast::Api::Dtm::Message.encode(msg)
-        from_service = send_marshaled(to_service)
-        response = Contrast::Api::Settings::AgentSettings.decode(from_service)
-        logger.debug('Received response.',
-                     msg_id: msg.__id__,
-                     p_id: msg.pid,
-                     msg_count: msg.message_count,
-                     response_id: response&.__id__)
-        response
-      rescue StandardError => e
-        logger.error('Sending failed for message.',
-                     e,
-                     msg_id: msg.__id__,
-                     p_id: msg.pid,
-                     msg_count: msg.message_count,
-                     response_id: response&.__id__)
-        raise e # reraise to let SocketClient manage the connection
-      end
-
-      def send_marshaled marshaled
-        connection.send_marshaled(marshaled)
-      end
-    end
-  end
-end