sqreen-kit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: feacd9986438ad22e08e0e752a59058956dd63ddfe00b90bdfd094e030db4ced
+  data.tar.gz: 318d9d80e07bcc4336740effe1b243e1f279fdbb5bef84be9dab3425884ae7e0
+SHA512:
+  metadata.gz: f43f0e22c84f9d15d749ad4ffaf9078ac9b0d1357d24f8f866cd7af5dfaf395489bd5fb913fdaeacc6b74a195491c42292b34b7c075271c3f4e788d95b105e4d
+  data.tar.gz: 91879a34437077558e6efb76196a9dd6b71fbdb0bdcc00c1c5d9e348035d749e8c0fd3b9537e8ec189737c7a0df1c0a5813b4ef0afd20c6fb0858b00aae2620c

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0
+
+* Extracted code from Ruby agent

data/LICENSE

@@ -0,0 +1,3 @@
+Sqreen for Ruby is free-to-use, proprietary software.
+
+Please refer to our terms for more information: https://www.sqreen.com/terms.html

data/lib/sqreen-kit.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'sqreen/kit'

data/lib/sqreen.rb

@@ -0,0 +1 @@
+module Sqreen; end

data/lib/sqreen/kit.rb

@@ -0,0 +1,76 @@
+require 'sqreen/kit/configuration'
+require 'sqreen/kit/retry_policy'
+require 'sqreen/kit/http_client'
+require 'sqreen/kit/http_client/authentication_error'
+require 'sqreen/kit/signals/batch_collector'
+require 'sqreen/kit/signals/auth_signals_client'
+require 'sqreen/kit/signals/signals_client'
+
+module Sqreen; end
+
+module Sqreen
+  module Kit
+    # Factories using the global configuration
+    class << self
+      def version
+        @version ||= Gem.loaded_specs['sqreen-kit'].version
+      end
+
+      def auth_signals_client
+        @auth_signals_client ||=
+          Signals::AuthSignalsClient.new(
+            signals_client,
+            session_key: Configuration.session_key,
+            api_key: Configuration.api_key,
+            app_name: Configuration.app_name,
+          )
+      end
+
+      def signals_client
+        @signals_client ||=
+          Signals::SignalsClient.new(http_client)
+      end
+
+      def batch_collector
+        @batch_collector ||=
+          Signals::BatchCollector.new(
+            auth_signals_client,
+            flush_size: Configuration.batch_flush_size,
+            max_batch_size: Configuration.batch_max_size,
+            max_delay_s: Configuration.batch_max_delay_s,
+          )
+      end
+
+      def reset
+        @auth_signals_client = nil
+        @signals_client = nil
+        @batch_collector = nil
+        @http_client = nil
+        @retry_policy = nil
+      end
+
+      private
+
+      def http_client
+        @http_client ||=
+          HttpClient.new(Configuration.ingestion_url,
+                         retry_policy,
+                         proxy_address: Configuration.proxy_address,
+                         proxy_port: Configuration.proxy_port,
+                         proxy_user: Configuration.proxy_user,
+                         proxy_pass: Configuration.proxy_pass,
+                         connect_timeout: Configuration.connect_timeout,
+                         read_timeout: Configuration.read_timeout)
+      end
+
+      def retry_policy
+        @retry_policy ||=
+          RetryPolicy.new(
+            max_retries: Configuration.retry_max_retries,
+            wait_s: Configuration.retry_max_retries,
+            fatal_exceptions: [Sqreen::Kit::HttpClient::AuthenticationError],
+          )
+      end
+    end
+  end
+end

data/lib/sqreen/kit/configuration.rb

@@ -0,0 +1,67 @@
+require 'logger'
+
+module Sqreen
+  module Kit
+    class Configuration
+      class << self
+        attr_accessor :logger
+
+        # http client related
+        attr_accessor :ingestion_url,
+                      :proxy_address,
+                      :proxy_port,
+                      :proxy_user,
+                      :proxy_pass,
+                      :connect_timeout,
+                      :read_timeout
+
+        # retry policy
+        attr_accessor :retry_max_retries,
+                      :retry_wait_s
+
+        # authentication
+        attr_accessor :session_key,
+                      :api_key,
+                      :app_name
+
+        # batch collector
+        attr_accessor :batch_max_delay_s,
+                      :batch_flush_size,
+                      :batch_max_size
+
+        # @param [String] url
+        def proxy_url=(url)
+          if url.nil?
+            self.proxy_address =
+              self.proxy_port =
+                self.proxy_user =
+                  self.proxy_pass = nil
+            return
+          end
+
+          parsed = URI.parse(url)
+          raise ArgumentError, 'only http proxies are supported' unless parsed.scheme == 'http'
+
+          self.proxy_address = parsed.host
+          self.proxy_port = parsed.port
+          self.proxy_user = parsed.user
+          self.proxy_port = parsed.port
+        end
+      end
+
+      # default values
+      def self.set_defaults
+        instance_variables.each do |ia|
+          instance_variable_set(ia, nil)
+        end
+        self.logger = ::Logger.new(STDERR)
+        logger.level = ::Logger::WARN
+        logger.progname = 'sqreen-kit'
+
+        self.ingestion_url = 'https://ingestion.sqreen.com/'
+      end
+
+      set_defaults
+    end
+  end
+end

data/lib/sqreen/kit/http_client.rb

@@ -0,0 +1,160 @@
+require 'net/http'
+require 'uri'
+
+require 'sqreen/kit/loggable'
+require 'sqreen/kit/retry_policy'
+require 'sqreen/kit/http_client/authentication_error'
+require 'sqreen/kit/http_client/unexpected_status_error'
+
+module Sqreen
+  module Kit
+    # An http client doing JSON requests
+    class HttpClient
+      include Loggable
+
+      DEFAULT_CONNECT_TIMEOUT_S = 5
+      DEFAULT_READ_TIMEOUT_S = 30
+
+      attr_reader :http
+
+      # @return [URI]
+      attr_reader :base_url
+
+      # @param server_url [String]
+      # @param retry_policy [Sqreen::Kit::RetryPolicy]
+      def initialize(server_url, retry_policy, opts = {})
+        @base_url = parse_uri(server_url)
+
+        @retry_policy = retry_policy
+
+        @http = ::Net::HTTP.new(@base_url.host, @base_url.port,
+                                opts[:proxy_address] || :ENV,
+                                opts[:proxy_port], opts[:proxy_user],
+                                opts[:proxy_pass])
+        @http.use_ssl = @base_url.scheme.downcase == 'https'
+        @http.verify_mode = OpenSSL::SSL::VERIFY_NONE if ENV['SQREEN_SSL_NO_VERIFY'] # for testing
+
+        @http.open_timeout = opts[:connect_timeout] || DEFAULT_CONNECT_TIMEOUT_S
+        @http.ssl_timeout = opts[:read_timeout] || DEFAULT_READ_TIMEOUT_S
+        @http.read_timeout = opts[:read_timeout] || DEFAULT_READ_TIMEOUT_S
+
+        @req_nb = 1
+
+        @static_headers = init_static_headers
+      end
+
+      # @param path [String]
+      # @param data [String]
+      # @param headers [Hash{String=>String}]
+      def post(path, data, headers = {})
+        request(:POST, path, data, headers)
+      end
+
+      def get(path, headers = {})
+        request(:GET, path, nil, headers)
+      end
+
+      private
+
+      # @return [URI::HTTP]
+      def parse_uri(uri)
+        # This regexp is the Ruby constant URI::PATTERN::HOSTNAME augmented
+        # with the _ character that is frequent in Docker linked containers.
+        re = '(?:(?:[a-zA-Z\\d](?:[-_a-zA-Z\\d]*[a-zA-Z\\d])?)\\.)*(?:[a-zA-Z](?:[-_a-zA-Z\\d]*[a-zA-Z\\d])?)\\.?'
+        parser = URI::Parser.new HOSTNAME: re
+        uri += '/' unless uri.end_with? '/'
+        parser.parse(uri)
+      end
+
+      def with_retry(&block)
+        @retry_policy.execute(&block)
+      end
+
+      def connect
+        return if connected?
+        logger.warn { "Connecting to #{base_url}..." }
+
+        begin
+          with_retry do
+            http.start
+          end
+        rescue StandardError => e
+          logger.warn "Cannot connect to #{base_url}: #{e.message}"
+          raise
+        else
+          logger.warn 'Connection success'
+        end
+      end
+
+      def connected?
+        http.started?
+      end
+
+      def disconnect
+        http.finish if connected?
+      end
+
+      def init_static_headers
+        platform = RUBY_PLATFORM
+        platform += " #{ENV_JAVA['java.runtime.version']}" if defined?(ENV_JAVA)
+        ua_string = "sqreen-kit/#{Sqreen::Kit.version} " \
+                    "(#{platform}) ruby/#{RUBY_VERSION}"
+        ua_string += " jruby/#{JRUBY_VERSION}" if defined?(JRUBY_VERSION)
+        { 'User-Agent' => ua_string }
+      end
+
+      def request(method, path, data, headers = {})
+        connect
+
+        now = Time.now
+
+        headers = @static_headers.merge(headers)
+        @req_nb += 1
+
+        path = (base_url + path).path
+
+        with_retry do
+          logger.debug do
+            format('%s %s %s (%s)',
+                   method, path, data.inspect, headers.inspect)
+          end
+
+          resp = case method
+                 when :GET
+                   http.get(path, headers)
+                 when :POST
+                   http.post(path, data, headers)
+                 end
+
+          result = process_response resp
+
+          logger.debug do
+            format('%s %s (DONE: %s in %f ms)',
+                   method, path, resp && resp.code, (Time.now - now) * 1000)
+          end
+
+          result
+        end # end with_retry
+      end
+
+      # @param [Net::HTTPResponse] resp
+      def process_response(resp)
+        body = resp.body
+        logger.debug { "Body of response: #{body}" }
+
+        if resp.code == '401' || resp.code == '403'
+          raise AuthenticationError.new(resp.code, body)
+        end
+
+        unless %w[200 201 202].include?(resp.code)
+          raise UnexpectedStatusError.new(resp.code, body)
+        end
+
+        {
+          code: resp.code,
+          body: body,
+        }
+      end
+    end
+  end
+end

data/lib/sqreen/kit/http_client/authentication_error.rb

@@ -0,0 +1,13 @@
+require 'sqreen/kit/http_client/unexpected_status_error'
+
+module Sqreen
+  module Kit
+    class HttpClient
+      class AuthenticationError < UnexpectedStatusError
+        def initialize(*args)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/kit/http_client/unexpected_status_error.rb

@@ -0,0 +1,18 @@
+module Sqreen
+  module Kit
+    class HttpClient
+      class UnexpectedStatusError < StandardError
+        attr_reader :code, :body
+
+        def initialize(code, body = nil)
+          @code = code
+          @body = body
+        end
+
+        def message
+          "Unexpected status #{code}: #{body}"
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/kit/loggable.rb

@@ -0,0 +1,14 @@
+require 'sqreen/kit/configuration'
+
+module Sqreen
+  module Kit
+    module Loggable
+      private
+
+      # @return [::Logger]
+      def logger
+        Configuration.logger
+      end
+    end
+  end
+end

data/lib/sqreen/kit/retry_policy.rb

@@ -0,0 +1,56 @@
+require 'sqreen/kit/loggable'
+
+module Sqreen
+  module Kit
+    class RetryPolicy
+      include Loggable
+
+      DEFAULT_RETRIES = 2
+      DEFAULT_WAITS_S = 3
+      DEFAULT_FATAL_EXCEPTIONS = [].freeze
+
+      attr_reader :max_retries, :wait_s, :fatal_exceptions
+
+      # @param opts the parameters of the retry policy
+      # @option opts [Integer] the maximum number of tries
+      # @option opts [Float] wait_s wait these seconds before a retry
+      # @option opts [Array<Class>] exception classes for which no retry will
+      #                             be attempted, besides non-StandardError
+      def initialize(opts = {})
+        @max_retries = opts[:max_retries] || DEFAULT_RETRIES
+        @wait_s = opts[:wait_s] || DEFAULT_WAITS_S
+        @fatal_exceptions = opts[:fatal_exceptions] || DEFAULT_FATAL_EXCEPTIONS
+      end
+
+      def execute
+        attempt = 1
+        begin
+          yield
+        rescue ::Exception => e # rubocop:disable Lint/RescueException
+          logger.warn { "Error on attempt ##{attempt}: #{e.message}" }
+          logger.debug { e.backtrace }
+          if fatal?(e)
+            logger.debug { "Not retrying after seeing exception #{e.class}" }
+            raise
+          end
+          if attempt > max_retries
+            logger.debug { "Not retrying anymore after #{attempt} attempts" }
+            raise
+          end
+
+          logger.debug { "Will retry after #{wait_s} seconds" }
+          sleep(wait_s) unless wait_s.zero?
+          attempt += 1
+          retry
+        end
+      end
+
+      private
+
+      def fatal?(exception)
+        !exception.is_a?(StandardError) ||
+          fatal_exceptions.any? { |ec| exception.is_a?(ec) }
+      end
+    end
+  end
+end

data/lib/sqreen/kit/signals/actor.rb

@@ -0,0 +1,26 @@
+require 'sqreen/kit/signals/dto_helper'
+
+module Sqreen
+  module Kit
+    module Signals
+      class Actor
+        include DtoHelper
+
+        add_mandatory_attrs :ip_addresses
+
+        # mandatory
+        # @return [Array<String>]
+        attr_accessor :ip_addresses
+
+        # @return String
+        attr_accessor :user_agent
+
+        # @return [Hash{String=>String}]
+        attr_accessor :identifiers
+
+        # @return [Hash{String=>String}]
+        attr_accessor :traits
+      end
+    end
+  end
+end