chili_logger 0.0.11 → 0.1.5

data/Rakefile

@@ -1,6 +1,6 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/chili_logger.gemspec

@@ -11,7 +11,8 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://gitlab.com/chiligumdev/chili_logger'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
-  spec.add_dependency 'aws-sdk', '~> 2.9', '>= 2.9.0'
+  spec.add_dependency 'aws-sdk-sqs', '~> 1.30.0'
+  spec.add_dependency 'aws-sdk-secretsmanager', '~> 1.36.0'
   spec.add_dependency 'bunny'
   spec.add_dependency 'httparty'
 

data/lib/brokers/main_broker.rb

@@ -0,0 +1,49 @@
+require 'errors/error_messages/config_error'
+require 'brokers/rabbit_broker'
+
+# class for centralizing Creative's logging logic
+class ChiliLogger
+  # class that configures and manages all supported brokers
+  class MainBroker
+    def initialize(broker_name, broker_config, logging_error_handler)
+      return if ChiliLogger.instance.deactivated
+
+      @default = ChiliLogger::Values::Default.new
+      @logging_error_handler = logging_error_handler
+      broker_config ||= {}
+      validate_config(broker_config)
+
+      broker_name ||= @default.msg_broker
+      broker_class = supported_brokers[broker_name.to_sym]
+      unsupported_broker_error(broker_name) unless broker_class
+
+      @broker = broker_class.new(broker_config)
+    end
+
+    def publish(message)
+      return if ChiliLogger.instance.deactivated
+
+      @broker.publish(message)
+    rescue StandardError => e
+      @logging_error_handler.handle_error(e, message)
+    end
+
+    private
+
+    def validate_config(config)
+      invalid_config_err = ':msg_broker_config must be a hash'
+      raise(ChiliLogger::ConfigError, invalid_config_err) unless [Hash, NilClass].include?(config.class)
+    end
+
+    def unsupported_broker_error(broker_name)
+      err_msg = "'#{broker_name}' is not a supported broker_name. Supported broker_names: #{supported_brokers}"
+      raise(ConfigError, err_msg)
+    end
+
+    def supported_brokers
+      {
+        rabbitmq: RabbitBroker
+      }
+    end
+  end
+end

data/lib/brokers/rabbit_broker.rb

@@ -1,23 +1,21 @@
 require 'bunny'
 require 'brokers/sqs_broker'
+require 'helpers/values/secrets/secrets'
 
 # class for centralizing Creative's logging logic
 class ChiliLogger
   # class that configures and manages the RabbitMQ client
   class RabbitBroker
-    def initialize(logging_error_handler)
-      @logging_error_handler = logging_error_handler
-    end
-
-    def config(config)
-      validate_config(config)
+    def initialize(custom_config = {})
+      custom_config ||= {}
+      config = rabbit_config(custom_config)
 
       @user = config[:user]
       @password = config[:password]
       @ip = config[:ip]
       @port = config[:port]
       @exchange_name = config[:exchange_name]
-      @routing_key_overwriter = config[:routing_key_overwriter]
+      @routing_key_overwriter = custom_config[:routing_key_overwriter]
 
       connect
     end
@@ -30,39 +28,22 @@ class ChiliLogger
 
       @channel = @connection.create_channel
       @exchange = @channel.topic(@exchange_name, durable: true)
-
     rescue StandardError => e
       puts 'Could not connect to RabbitMQ due to the following error:'
       puts e
     end
 
-    def disconnect
-      @connection.close
-    end
-
-    def publish(message, routing_key)
+    def publish(message)
       return if ChiliLogger.instance.deactivated
 
-      # if no routing_key was provided when configuring RabbitBroker, than use the one received by the method here
-      # temporary solution so we can force configure ChiliLogger to use a specific routing_key
-      key = @routing_key_overwriter || routing_key
+      # if no routing_key was provided when configuring RabbitBroker, than use the message's description tag
+      key = @routing_key_overwriter || message[:desc] || message['desc']
       @exchange.publish(message.to_json, routing_key: key)
       puts "sent message to #{@exchange_name}, with routing_key = '#{key}'"
-
-    rescue StandardError => e
-      @logging_error_handler.handle_error(e, message)
     end
 
     private
 
-    def invalid_config_format_error
-      'The configuration object must be a Hash'
-    end
-
-    def config_attr_error(attr)
-      "The configuration object must include a ':#{attr}' attribute"
-    end
-
     def connection_config
       {
         user: @user,
@@ -72,11 +53,16 @@ class ChiliLogger
       }
     end
 
-    def validate_config(config)
-      raise(ChiliLogger::ConfigError, invalid_config_format_error) unless config.is_a?(Hash)
+    def rabbit_config(custom_config)
+      default_secrets = Values::Secrets.new.get_secrets_collection('ChiliLoggerRabbitCredentials')
+      default_keys = %i[user password ip port exchange_name]
+      config = {}
+
+      default_keys.each do |key|
+        config[key] = custom_config[key] || default_secrets[key.to_s]
+      end
 
-      main_config_keys = %i[user password ip port exchange_name]
-      main_config_keys.each { |key| raise(ChiliLogger::ConfigError, config_attr_error(key)) unless config[key] }
+      config
     end
   end
 end

data/lib/brokers/sqs_broker.rb

@@ -1,4 +1,4 @@
-require 'aws-sdk'
+require 'aws-sdk-sqs'
 
 # class for centralizing Creative's logging logic
 class ChiliLogger
@@ -6,21 +6,50 @@ class ChiliLogger
   module AWS
     # class that handles errors when message broker can't be reached, etc...
     class SqsBroker
-      def initialize(config)
-        @sqs_config = validate_config(config)
-        @queue_name = config[:queue_name]
+      def initialize(custom_config = {})
+        custom_config ||= {}
+
+        @default_secrets = Values::Secrets.new.get_secrets_collection('ChiliLoggerSQSCredentials')
         @default = ChiliLogger::Values::Default.new
+        @queue_name = custom_config[:queue_name] || @default_secrets['queue_name']
 
+        @sqs_config = sqs_config(custom_config)
         @sqs = Aws::SQS::Client.new(@sqs_config)
+
+        ENV['AWS_REGION'] = @sqs_config[:region] # Aws::SQS::QueuePoller requires region as an env variable
+        @poller = Aws::SQS::QueuePoller.new(queue_url(@queue_name), skip_delete: true)
       end
 
       def publish(message = @default.sqs_message)
+        return if ChiliLogger.instance.deactivated
+
         message_body = { body: message }
         queue_message = queue_message(message_body)
 
         @sqs.send_message(queue_message)
       end
 
+      def fetch_messages
+        return if ChiliLogger.instance.deactivated
+
+        messages = []
+        remaining_msgs = num_of_msgs_in_queue
+        return messages unless remaining_msgs.positive?
+
+        @poller.poll do |sqs_msg|
+          messages << { fallback_broker_msg: sqs_msg, log: JSON.parse(sqs_msg.body)['body']['log'] }
+
+          remaining_msgs -= 1
+          throw :stop_polling if remaining_msgs <= 0 # prevents infinite loop
+        end
+
+        messages
+      end
+
+      def delete_message(msg)
+        @poller.delete_messages([msg])
+      end
+
       private
 
       def queue_message(message_body)
@@ -36,25 +65,20 @@ class ChiliLogger
         @sqs.get_queue_url(queue_name: queue_name).queue_url
       end
 
-      def invalid_config_format_error
-        'The :error_hanldler_config object must be a Hash'
+      def num_of_msgs_in_queue
+        sqs_queue_attrs = @sqs.get_queue_attributes(queue_url: queue_url(@queue_name), attribute_names: ['All'])
+        sqs_queue_attrs.attributes['ApproximateNumberOfMessages'].to_i
       end
 
-      def config_attr_error(attr)
-        "The configuration object must include a ':#{attr}' attribute"
-      end
+      def sqs_config(custom_config)
+        default_keys = %i[region access_key_id secret_access_key]
+        config = {}
 
-      def validate_config(config)
-        raise(ChiliLogger::ConfigError, invalid_config_format_error) unless config.is_a?(Hash)
+        default_keys.each do |key|
+          config[key] = custom_config[key] || @default_secrets[key.to_s]
+        end
 
-        main_config_keys = %i[region access_key_id secret_access_key queue_name]
-        main_config_keys.each { |key| raise(ChiliLogger::ConfigError, config_attr_error(key)) unless config[key] }
-
-        {
-          region: config[:region],
-          access_key_id: config[:access_key_id],
-          secret_access_key: config[:secret_access_key]
-        }
+        config
       end
     end
   end

data/lib/chili_logger.rb

@@ -1,15 +1,14 @@
+require 'singleton'
+require 'brokers/main_broker'
 require 'chili_logger/version'
 require 'current_log_accessor'
-require 'errors/error_messages/config_error'
 require 'errors/logging_error_handler/logging_error_handler'
-require 'brokers/rabbit_broker'
-require 'message_writer/message_writer'
-require 'brokers/sqs_broker'
 require 'helpers/values/default'
 require 'helpers/values/type_uniformizer/desc'
 require 'helpers/values/type_uniformizer/user'
 require 'helpers/values/type_uniformizer/main_content'
-require 'singleton'
+require 'message_writer/message_writer'
+require 'unpublished_logs_manager/unpublished_logs_manager'
 
 # class for centralizing Creative's logging logic
 class ChiliLogger
@@ -32,6 +31,7 @@ class ChiliLogger
     config_logging_error_handler(config)
     config_msg_writer(config)
     config_msg_broker(config)
+    config_unpublished_logs_manager
 
     @current_log_accessor = CurrentLogAccessor.new(@msg_broker, @msg_writer)
   end
@@ -59,16 +59,16 @@ class ChiliLogger
     end
 
     message = @msg_writer.write(options)
-    routing_key = @msg_writer.write_description_tag(options[:desc])
+    @msg_broker.publish(message)
+  end
 
-    @msg_broker.publish(message, routing_key)
+  def republish_unpublished_logs
+    @unpublished_logs_manager.republish
   end
 
   private
 
   def config_logging_error_handler(general_config)
-    return @logging_error_handler = nil if @deactivated
-
     fallback_name = general_config[:fallback_broker]
     fallback_config = general_config[:fallback_broker_config]
     @logging_error_handler = LoggingErrorHandler.new(fallback_name, fallback_config)
@@ -76,8 +76,8 @@ class ChiliLogger
 
   def config_msg_writer(general_config)
     msg_writer_config = {
-      env: general_config[:log_env],
-      layer: general_config[:log_layer],
+      env: general_config[:log_env]&.downcase,
+      layer: general_config[:log_layer]&.downcase,
       server_url: general_config[:server_url],
       cloud_provider: general_config[:cloud_provider]
     }
@@ -86,26 +86,13 @@ class ChiliLogger
   end
 
   def config_msg_broker(general_config)
-    msg_broker_name = general_config[:msg_broker_name] || @default.msg_broker
-    msg_broker_config = general_config[:msg_broker_config] || @default.msg_broker_config
-    @msg_broker = supported_msg_brokers[msg_broker_name.to_sym]
-    raise(ConfigError, broker_name_error(msg_broker_name)) unless @msg_broker
-
-    # TODO: implement MessageBroker class, an interface between ChiliLogger and possible brokers.
-    # TODO: add "supported_msg_broker", "broker_name_error" and "return @msg_broker if @deactivated" to MessageBroker
-    # prevents broker from even starting connection if ChiliLogger is deactivated
-    return @msg_broker if @deactivated
+    msg_broker_name = general_config[:msg_broker_name]
+    msg_broker_config = general_config[:msg_broker_config]
 
-    @msg_broker.config(msg_broker_config)
+    @msg_broker = MainBroker.new(msg_broker_name, msg_broker_config, @logging_error_handler)
   end
 
-  def broker_name_error(msg_broker_name)
-    "#{msg_broker_name} is not supported. Supported msg_broker_names: #{supported_msg_brokers}"
-  end
-
-  def supported_msg_brokers
-    {
-      rabbitmq: RabbitBroker.new(@logging_error_handler)
-    }
+  def config_unpublished_logs_manager
+    @unpublished_logs_manager = UnpublishedLogsManager.new(@msg_broker, @logging_error_handler)
   end
 end

data/lib/chili_logger/version.rb

@@ -1,3 +1,3 @@
 class ChiliLogger
-  VERSION = '0.0.11'
+  VERSION = '0.1.5'.freeze
 end

data/lib/current_log_accessor.rb

@@ -1,5 +1,4 @@
 require 'message_writer/message_writer'
-require 'helpers/values/default'
 require 'helpers/values/type_uniformizer/desc'
 require 'helpers/values/type_uniformizer/main_content'
 require 'helpers/values/type_uniformizer/user'
@@ -19,11 +18,9 @@ class ChiliLogger
 
     def publish(**options)
       update_current_log(options)
-
       message = @msg_writer.write(desc: desc, user: user, main_content: main_content)
-      routing_key = @msg_writer.write_description_tag(desc)
+      @msg_broker.publish(message)
 
-      @msg_broker.publish(message, routing_key)
       clear_log_info
     end
 

data/lib/errors/logging_error_handler/logging_error_handler.rb

@@ -5,31 +5,48 @@ require 'errors/error_messages/config_error'
 class ChiliLogger
   # class that handles errors when message broker can't be reached, etc...
   class LoggingErrorHandler
-    def initialize(fallback_name, config)
-      raise(ChiliLogger::ConfigError, ':fallback_broker_config must be present and be a hash') unless config.is_a?(Hash)
+    def initialize(fallback_name = nil, config = {})
+      return if ChiliLogger.instance.deactivated
 
-      fallback_name = fallback_name.to_sym if fallback_name
-      fallback_broker_class = supported_fallback_brokers[fallback_name]
+      @default = ChiliLogger::Values::Default.new
+      config ||= {}
+      validate_config(config)
+
+      fallback_name ||= @default.fallback_broker
+      fallback_broker_class = supported_fallback_brokers[fallback_name.to_sym]
       unsupported_fallback_broker_error unless fallback_broker_class
 
       @fallback_broker = fallback_broker_class.new(config)
     end
 
     def handle_error(error, log = nil)
+      return if ChiliLogger.instance.deactivated
+
       message = message(error, log)
       @fallback_broker.publish(message)
     rescue StandardError => e
-      puts '
-        There was a problem with both the Message Broker and the Fallback Broker simultaneously.
+      puts 'There was a problem with both the Message Broker and the Fallback Broker simultaneously.
         To keep the application running and prevent downtime,
         ChiliLogger will ignore this errors and discard the log it was currently trying to publish.
-        Please note that logs are being permanently lost.
-      '
+        Please note that logs are being permanently lost.'
       puts e
     end
 
+    def fetch_unpublished_logs
+      @fallback_broker.fetch_messages
+    end
+
+    def delete_unpublished_log(msg)
+      @fallback_broker.delete_message(msg)
+    end
+
     private
 
+    def validate_config(config)
+      invalid_config_err = ':fallback_broker_config must be a hash'
+      raise(ChiliLogger::ConfigError, invalid_config_err) unless [Hash, NilClass].include?(config.class)
+    end
+
     def message(error, log)
       {
         error_type: error.class.name,

data/lib/helpers/logs_coverage/coverage_writer.rb

@@ -1,6 +1,6 @@
 require 'yaml'
 require 'fileutils'
-require 'helpers/values/default'
+require 'byebug'
 
 # class for centralizing Creative's logging logic
 class ChiliLogger
@@ -14,16 +14,17 @@ class ChiliLogger
       service = desc[:service] || default.service
       action = desc[:action] || default.action
       keys = [type, service, action]
+      # coverage = add_nested_value(coverage, keys, backtrace)
 
-      coverage = add_nested_value(coverage, keys, backtrace)
-
-      write_file(coverage)
+      # write_file(coverage)
     end
 
     def self.read_file
       file_exists = File.file?(file_path)
+      file = file_exists ? YAML.load_file(file_path) : {}
 
-      file_exists ? YAML.load_file(file_path) : {}
+      # workaround for a bug in YAML lib, in which #load_file returns nil if file is empty, instead of an empty hash
+      file.nil? ? {} : file
     end
 
     def self.write_file(file)