diffend-monitor 0.2.27

data/lib/diffend/config/file_finder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Diffend
+  module Config
+    # Class used to figure out the file from which we should load the settings
+    module FileFinder
+      # Names of the files or paths where we will look for the settings
+      #
+      # @note We do the double dot trick, to look outside of the current dir because when
+      #   executed from a docker container, we copy the local uncommitted settings into the
+      #   dir above the app location not to pollute the reset state of the git repo
+      #
+      # @note Order is important, as for local env we should load from
+      #   local file (if present first)
+      FILE_NAMES = %w[
+        .diffend.yml
+      ].map { |name| ["../#{name}", name] }.tap(&:flatten!).freeze
+
+      private_constant :FILE_NAMES
+
+      class << self
+        # Looks for Diffend settings file for a given env
+        #
+        # @param build_path [String] path of the current build
+        #
+        # @return [String] path to the file from which we should load all the settings
+        def call(build_path)
+          FILE_NAMES
+            .map { |name| File.join(build_path, name) }
+            .map { |name| Dir[name] }
+            .find { |selection| !selection.empty? }
+            .tap { |path| path || raise(Errors::MissingConfigurationFile) }
+            .first
+        end
+      end
+    end
+  end
+end

data/lib/diffend/config/validator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Module for all the components related to setting up the config
+  module Config
+    # Class responsible for validating the config from .diffend.yml
+    module Validator
+      class << self
+        # @param config [OpenStruct] path of the current build
+        def call(config)
+          raise Errors::ProjectIdMissingInConfigurationFile if missing?(config, 'project_id')
+          raise Errors::ShareableIdMissingInConfigurationFile if missing?(config, 'shareable_id')
+          raise Errors::ShareableKeyMissingInConfigurationFile if missing?(config, 'shareable_key')
+          raise Errors::BuildPathMissingInConfigurationFile if missing?(config, 'build_path')
+        end
+
+        private
+
+        def missing?(config, key)
+          config.public_send(key).nil? || config.public_send(key).empty?
+        end
+      end
+    end
+  end
+end

data/lib/diffend/errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Diffend
+  # Build runner app errors
+  module Errors
+    # Base error class from which all the errors should inherit
+    BaseError = Class.new(StandardError)
+    # Raised when we couldn't find a valid configuration file
+    MissingConfigurationFile = Class.new(BaseError)
+    # Raised when configuration file is empty
+    EmptyConfigurationFile = Class.new(BaseError)
+    # Raised when configuration file is malformed
+    MalformedConfigurationFile = Class.new(BaseError)
+    # Raised when project_id is missing in configuration file
+    ProjectIdMissingInConfigurationFile = Class.new(BaseError)
+    # Raised when shareable_id is missing in configuration file
+    ShareableIdMissingInConfigurationFile = Class.new(BaseError)
+    # Raised when shareable_key is missing in configuration file
+    ShareableKeyMissingInConfigurationFile = Class.new(BaseError)
+    # Raised when build_path is missing in configuration file
+    BuildPathMissingInConfigurationFile = Class.new(BaseError)
+    # Raised when server-side error occurs
+    RequestServerError = Class.new(BaseError)
+    # Raised when we had an exception that we know how to handle
+    HandledException = Class.new(BaseError)
+  end
+end

data/lib/diffend/handle_errors/build_exception_payload.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Diffend
+  module HandleErrors
+    # Module responsible for building exception payload
+    module BuildExceptionPayload
+      class << self
+        # Build exception payload
+        #
+        # @param exception [Exception, NilClass] expection that was raised
+        # @param payload [Hash] with versions to check
+        #
+        # @return [Hash]
+        def call(exception, payload)
+          {
+            request_id: SecureRandom.uuid,
+            payload: payload,
+            exception: {
+              class: exception&.class,
+              message: exception&.message,
+              backtrace: exception&.backtrace
+            }
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/diffend/handle_errors/display_to_stdout.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Diffend
+  module HandleErrors
+    # Module responsible for displaying exception payload to stdout
+    module DisplayToStdout
+      class << self
+        # Display exception payload to stdout
+        #
+        # @param exception_payload [Hash]
+        def call(exception_payload)
+          puts exception_payload.to_json
+        end
+      end
+    end
+  end
+end

data/lib/diffend/handle_errors/messages.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Diffend
+  module HandleErrors
+    module Messages
+      PAYLOAD_DUMP = '^^^ Above is the dump of your request ^^^'
+      UNHANDLED_EXCEPTION = <<~MSG
+        \nSomething went really wrong. We recorded this incident in our system and will review it.\n
+        This is a bug, don't hesitate.\n
+        Create an issue at https://github.com/diffend-io/diffend-ruby/issues\n
+      MSG
+      UNSUPPORTED_RESPONSE = <<~MSG
+        \nAPI returned an unsupported response. We recorded this incident in our system and will review it.\n
+        This is a bug, don't hesitate.\n
+        Create an issue at https://github.com/diffend-io/diffend-ruby/issues\n
+      MSG
+      UNSUPPORTED_VERDICT = <<~MSG
+        \nAPI returned an unsupported verdict. We recorded this incident in our system and will review it.\n
+        This is a bug, don't hesitate.\n
+        Create an issue at https://github.com/diffend-io/diffend-ruby/issues\n
+      MSG
+      REQUEST_ERROR = <<~MSG
+        \nWe were unable to process your request at this time. We recorded this incident in our system and will review it.\n
+        If you think that this is a bug, don't hesitate.\n
+        Create an issue at https://github.com/diffend-io/diffend-ruby/issues\n
+      MSG
+    end
+  end
+end

data/lib/diffend/handle_errors/report.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Diffend
+  module HandleErrors
+    # Module responsible for reporting errors to diffend
+    module Report
+      class << self
+        # Execute request to Diffend
+        #
+        # @param exception [Exception] expection that was raised
+        # @param payload [Hash] with versions to check
+        # @param config [OpenStruct] Diffend config
+        # @param message [Symbol] message that we want to display
+        # @param report [Boolean] if true we will report the issue to diffend
+        # @param raise_exception [Boolean] if true we will raise an exception
+        #
+        # @return [Net::HTTPResponse] response from Diffend
+        def call(config:, message:, exception: nil, payload: {}, report: false, raise_exception: true)
+          exception_payload = prepare_exception_payload(exception, payload)
+
+          Bundler.ui.error(Diffend::HandleErrors::Messages::PAYLOAD_DUMP)
+          Bundler.ui.error(Diffend::HandleErrors::Messages.const_get(message.to_s.upcase))
+
+          if report
+            Diffend::Request.call(
+              build_request_object(config, exception_payload)
+            )
+          end
+
+          raise Diffend::Errors::HandledException if raise_exception
+        end
+
+        # @param config [OpenStruct] diffend config
+        # @param payload [Hash]
+        #
+        # @return [Diffend::RequestObject]
+        def build_request_object(config, payload)
+          Diffend::RequestObject.new(
+            config: config,
+            url: errors_url(config.project_id),
+            payload: payload,
+            request_method: :post
+          )
+        end
+
+        # Prepare exception payload and display it to stdout
+        #
+        # @param exception [Exception] expection that was raised
+        # @param payload [Hash] with versions to check
+        #
+        # @return [Hash]
+        def prepare_exception_payload(exception, payload)
+          Diffend::HandleErrors::BuildExceptionPayload
+            .call(exception, payload)
+            .tap(&Diffend::HandleErrors::DisplayToStdout.method(:call))
+        end
+
+        # Provides diffend errors endpoint url
+        #
+        # @param project_id [String] diffend project_id
+        #
+        # @return [String] diffend endpoint
+        def errors_url(project_id)
+          return ENV['DIFFEND_ERROR_URL'] if ENV.key?('DIFFEND_ERROR_URL')
+
+          "https://my.diffend.io/api/projects/#{project_id}/errors"
+        end
+      end
+    end
+  end
+end

data/lib/diffend/monitor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+%w[
+  build_bundler_definition
+  errors
+  config/fetcher
+  config/file_finder
+  config/validator
+  commands
+  handle_errors/messages
+  handle_errors/build_exception_payload
+  handle_errors/display_to_stdout
+  handle_errors/report
+  request_object
+  request
+  voting
+  track
+].each { |file| require "diffend/#{file}" }
+
+%w[
+  versions/local
+  versions/remote
+].each { |file| require "diffend/voting/#{file}" }
+
+Thread.new do
+  track = Diffend::Track.new
+  track.start
+end

data/lib/diffend/request.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+require 'json'
+
+module Diffend
+  # Module responsible for doing request to Diffend
+  module Request
+    # Message displayed when connection issue occured and we will retry
+    CONNECTION_MESSAGE = 'We experienced a connection issue, retrying...'
+    # List of connection exceptions
+    CONNECTION_EXCEPTIONS = [
+      Errno::ECONNRESET,
+      Errno::ENETUNREACH,
+      Errno::EHOSTUNREACH,
+      Errno::ECONNREFUSED
+    ].freeze
+    # Message displayed when timeout occured and we will retry
+    TIMEOUT_MESSAGE = 'We experienced a connection issue, retrying...'
+    # List of timeout exceptions
+    TIMEOUT_EXCEPTIONS = [
+      Net::OpenTimeout,
+      Net::ReadTimeout
+    ].freeze
+    # Message displayed when server issue occured and we will retry
+    SERVER_ERROR_MESSAGE = 'We experienced a server-side issue, retrying...'
+    # List of server issues
+    #
+    # 500 - Internal Server Error
+    # 502 - Bad Gateway
+    # 503 - Service Unavailable
+    # 504 - Gateway Timeout
+    SERVER_ERRORS = [500, 502, 503, 504].freeze
+    # Number of retries
+    RETRIES = 3
+    # Request headers
+    HEADERS = { 'Content-Type': 'application/json' }.freeze
+
+    private_constant :HEADERS
+
+    class << self
+      # Execute request
+      #
+      # @param request_object [Diffend::RequestObject]
+      #
+      # @return [Net::HTTPResponse] response from Diffend
+      def call(request_object)
+        retry_count ||= -1
+
+        build_http(request_object.url) do |http, uri|
+          response = http.request(
+            build_request(
+              uri,
+              request_object.request_method,
+              request_object.config,
+              request_object.payload
+            )
+          )
+
+          if SERVER_ERRORS.include?(response.code.to_i)
+            raise Diffend::Errors::RequestServerError, response.code.to_i
+          end
+
+          response
+        end
+      rescue Diffend::Errors::RequestServerError => e
+        retry_count += 1
+
+        retry if handle_retry(SERVER_ERROR_MESSAGE, retry_count)
+
+        Diffend::HandleErrors::Report.call(
+          exception: e,
+          payload: request_object.payload,
+          config: request_object.config,
+          message: :request_error
+        )
+      rescue *CONNECTION_EXCEPTIONS => e
+        retry_count += 1
+
+        retry if handle_retry(CONNECTION_MESSAGE, retry_count)
+
+        Diffend::HandleErrors::Report.call(
+          exception: e,
+          payload: request_object.payload,
+          config: request_object.config,
+          message: :request_error
+        )
+      rescue *TIMEOUT_EXCEPTIONS => e
+        retry_count += 1
+
+        retry if handle_retry(TIMEOUT_MESSAGE, retry_count)
+
+        Diffend::HandleErrors::Report.call(
+          exception: e,
+          payload: request_object.payload,
+          config: request_object.config,
+          message: :request_error
+        )
+      end
+
+      # Handle retry
+      #
+      # @param message [String] message we want to display
+      # @param retry_count [Integer]
+      def handle_retry(message, retry_count)
+        return false if retry_count == RETRIES
+
+        Bundler.ui.error(message)
+        sleep(exponential_backoff(retry_count))
+
+        retry_count < RETRIES
+      end
+
+      # Builds http connection object
+      #
+      # @param url [String] command endpoint url
+      def build_http(url)
+        uri = URI(url)
+
+        Net::HTTP.start(
+          uri.host,
+          uri.port,
+          use_ssl: uri.scheme == 'https',
+          verify_mode: OpenSSL::SSL::VERIFY_NONE,
+          open_timeout: 5,
+          read_timeout: 5
+        ) { |http| yield(http, uri) }
+      end
+
+      # Build http post request and assigns headers and payload
+      #
+      # @param uri [URI::HTTPS]
+      # @param request_method [Symbol]
+      # @param config [OpenStruct] Diffend config
+      # @param payload [Hash] with versions to check
+      #
+      # @return [Net::HTTP::Post, Net::HTTP::Put]
+      def build_request(uri, request_method, config, payload)
+        pick_request_method(request_method)
+          .new(uri.request_uri, HEADERS)
+          .tap { |request| assign_auth(request, config) }
+          .tap { |request| assign_payload(request, payload) }
+      end
+
+      # Pick request method
+      #
+      # @param request_method [Symbol]
+      #
+      # @return [Net::HTTP::Post, Net::HTTP::Put]
+      def pick_request_method(request_method)
+        case request_method
+        when :post
+          Net::HTTP::Post
+        when :put
+          Net::HTTP::Put
+        end
+      end
+
+      # Assigns basic authorization if provided in the config
+      #
+      # @param request [Net::HTTP::Post] prepared http post
+      # @param config [OpenStruct] Diffend config
+      def assign_auth(request, config)
+        return unless config
+        return unless config.shareable_id
+        return unless config.shareable_key
+
+        request.basic_auth(config.shareable_id, config.shareable_key)
+      end
+
+      # Assigns payload as json
+      #
+      # @param request [Net::HTTP::Post] prepared http post
+      # @param payload [Hash] with versions to check
+      def assign_payload(request, payload)
+        request.body = JSON.dump(payload: payload)
+      end
+
+      def exponential_backoff(retry_count)
+        2**(retry_count + 1)
+      end
+    end
+  end
+end