chili_logger 0.0.5 → 0.0.9.1

data/chili_logger.gemspec

@@ -11,7 +11,7 @@ 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'
+  spec.add_dependency 'aws-sdk', '~> 2.9', '>= 2.9.0'
   spec.add_dependency 'bunny'
   spec.add_dependency 'httparty'
 

data/lib/brokers/rabbit_broker.rb

@@ -1,6 +1,5 @@
 require 'bunny'
-require 'errors/error_messages/rabbitmq_error'
-require 'errors/logging_error_handler/logging_error_handler'
+require 'brokers/sqs_broker'
 
 # class for centralizing Creative's logging logic
 class ChiliLogger
@@ -18,7 +17,7 @@ class ChiliLogger
       @ip = config[:ip]
       @port = config[:port]
       @exchange_name = config[:exchange_name]
-      @routing_key_overwriter = config[:routing_key]
+      @routing_key_overwriter = config[:routing_key_overwriter]
 
       connect
     end
@@ -48,6 +47,7 @@ class ChiliLogger
       # temporary solution so we can force configure ChiliLogger to use a specific routing_key
       key = @routing_key_overwriter || routing_key
       @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)
@@ -64,23 +64,18 @@ class ChiliLogger
     end
 
     def connection_config
-      # shouldn't try to recover connection,
-      # it may cause app in production to collapse if reconnection doesn't work or takes too many attempts!!!
-      recovery_attempts = 0
-
       {
         user: @user,
         password: @password,
         host: @ip,
-        port: @port,
-        recovery_attempts: recovery_attempts
+        port: @port
       }
     end
 
     def validate_config(config)
       raise(ChiliLogger::ConfigError, invalid_config_format_error) unless config.is_a?(Hash)
 
-      main_config_keys = %i[user password ip port exchange_name routing_key]
+      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] }
     end
   end

data/lib/{errors/logging_error_handler/sqs_handler.rb → brokers/sqs_broker.rb}

@@ -1,21 +1,21 @@
 require 'aws-sdk'
-require 'errors/error_messages/rabbitmq_error'
 
 # class for centralizing Creative's logging logic
 class ChiliLogger
   # module with classes using Amazon Web Services services
   module AWS
     # class that handles errors when message broker can't be reached, etc...
-    class SqsHandler
+    class SqsBroker
       def initialize(config)
         @sqs_config = validate_config(config)
         @queue_name = config[:queue_name]
+        @default = ChiliLogger::Values::Default.new
 
         @sqs = Aws::SQS::Client.new(@sqs_config)
       end
 
-      def handle_error(error = StandardError.new, log = 'not_specified')
-        message_body = message_body(error, log)
+      def publish(message = @default.sqs_message)
+        message_body = { body: message }
         queue_message = queue_message(message_body)
 
         @sqs.send_message(queue_message)
@@ -32,16 +32,6 @@ class ChiliLogger
         }
       end
 
-      def message_body(error, log)
-        message_body = {
-          error_type: error.class.name,
-          error_message: error.message,
-          log: log
-        }
-
-        { body: message_body }
-      end
-
       def queue_url(queue_name)
         @sqs.get_queue_url(queue_name: queue_name).queue_url
       end

data/lib/chili_logger.rb

@@ -1,9 +1,14 @@
 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 'errors/logging_error_handler/logging_error_handler'
+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'
 
 # class for centralizing Creative's logging logic
@@ -14,6 +19,13 @@ class ChiliLogger
   # initialize it with ChiliLogger.instance
   include Singleton
 
+  def initialize
+    @default = ChiliLogger::Values::Default.new
+    @user_uniformizer = ChiliLogger::Values::TypeUniformizer::User.new
+    @desc_uniformizer = ChiliLogger::Values::TypeUniformizer::Desc.new
+    @main_content_uniformizer = ChiliLogger::Values::TypeUniformizer::MainContent.new
+  end
+
   def config(config)
     @deactivated = config[:deactivated] || false # ChilLogger can be deactivated for test environents
 
@@ -28,19 +40,26 @@ class ChiliLogger
     @current_log_accessor
   end
 
-  def start_new_log(new_desc = nil, new_agent = nil, new_main_content = nil)
+  def start_new_log(**options)
     current_log.clear_log_info
 
-    current_log.overwrite_desc(new_desc)
-    current_log.overwrite_agent(new_agent)
-    current_log.overwrite_main_content(new_main_content)
+    current_log.update_desc(options[:desc])
+    current_log.update_user(options[:user])
+    current_log.update_main_content(options[:main_content])
 
     current_log
   end
 
-  def publish_instant_log(desc, agent, main_content)
-    message = @msg_writer.write(desc, agent, main_content)
-    routing_key = @msg_writer.write_description_tag(desc)
+  def publish_instant_log(**options)
+    # enforces that all attributes have valid primitive types
+    if options
+      options[:desc] = @desc_uniformizer.desc(options[:desc])
+      options[:user] = @user_uniformizer.user(options[:user])
+      options[:main_content] = @main_content_uniformizer.main_content(options[:main_content])
+    end
+
+    message = @msg_writer.write(options)
+    routing_key = @msg_writer.write_description_tag(options[:desc])
 
     @msg_broker.publish(message, routing_key)
   end
@@ -48,11 +67,11 @@ class ChiliLogger
   private
 
   def config_logging_error_handler(general_config)
-    return @logging_error_handler = nil if @deactivated 
+    return @logging_error_handler = nil if @deactivated
 
-    error_handler_name = general_config[:error_handler]
-    handler_config = general_config[:error_handler_config]
-    @logging_error_handler = LoggingErrorHandler.new(error_handler_name, handler_config)
+    fallback_name = general_config[:fallback_broker]
+    fallback_config = general_config[:fallback_broker_config]
+    @logging_error_handler = LoggingErrorHandler.new(fallback_name, fallback_config)
   end
 
   def config_msg_writer(general_config)
@@ -67,8 +86,8 @@ class ChiliLogger
   end
 
   def config_msg_broker(general_config)
-    msg_broker_name = general_config[:msg_broker_name] || :rabbitmq
-    msg_broker_config = general_config[:msg_broker_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
 

data/lib/chili_logger/version.rb

@@ -1,3 +1,3 @@
 class ChiliLogger
-  VERSION = '0.0.5'
+  VERSION = "0.0.9.1"
 end

data/lib/current_log_accessor.rb

@@ -1,4 +1,8 @@
 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'
 require 'byebug'
 
 # class for centralizing Creative's logging logic
@@ -8,14 +12,16 @@ class ChiliLogger
     def initialize(msg_broker, msg_writer)
       @msg_broker = msg_broker
       @msg_writer = msg_writer
+      @default = ChiliLogger::Values::Default.new
+      @user_uniformizer = ChiliLogger::Values::TypeUniformizer::User.new
+      @desc_uniformizer = ChiliLogger::Values::TypeUniformizer::Desc.new
+      @main_content_uniformizer = ChiliLogger::Values::TypeUniformizer::MainContent.new
     end
 
-    def publish(new_desc = nil, new_agent = nil, new_main_content = nil)
-      overwrite_desc(new_desc) if new_desc
-      overwrite_agent(new_agent) if new_agent
-      overwrite_main_content(new_main_content) if new_main_content
+    def publish(**options)
+      update_current_log(options)
 
-      message = @msg_writer.write(desc, agent, main_content)
+      message = @msg_writer.write(desc: desc, user: user, main_content: main_content)
       routing_key = @msg_writer.write_description_tag(desc)
 
       @msg_broker.publish(message, routing_key)
@@ -23,98 +29,116 @@ class ChiliLogger
     end
 
     # ACCESSOR METHODS BELOW
-    # all relevant infos for the current log are stored in thread variables,
-    # so they can be accessed anywhere (controllers, models, tasks, etc...)
-    def agent
-      Thread.current[:current_log_agent] ||= 'not_specified'
+    # current log infos are stored in thread variables, so they can be accessed anywhere(controllers, models, tasks...)
+    def user
+      Thread.current[:current_log_user] ||= @default.user
     end
 
-    def overwrite_agent(agent)
-      Thread.current[:current_log_agent] = agent
-      agent
+    def update_user(new_user)
+      return Thread.current[:current_log_user] = nil if new_user.nil?
+
+      uniformized_user = @user_uniformizer.user(new_user)
+      Thread.current[:current_log_user] = user.merge(uniformized_user)
     end
 
     def desc
-      Thread.current[:current_log_desc] ||= { type: 'not_specified', service: 'not_specified', action: 'not_specified' }
+      Thread.current[:current_log_desc] ||= @default.desc
     end
 
-    def overwrite_type(new_type_name)
-      desc[:type] = new_type_name || 'not_specified'
+    def update_type(new_type_name)
+      desc[:type] = @desc_uniformizer.type(new_type_name)
     end
 
-    def overwrite_service(new_service_name)
-      desc[:service] = new_service_name || 'not_specified'
+    def update_service(new_service_name)
+      desc[:service] = @desc_uniformizer.service(new_service_name)
     end
 
-    def overwrite_action(new_action_name)
-      desc[:action] = new_action_name || 'not_specified'
+    def update_action(new_action_name)
+      desc[:action] = @desc_uniformizer.action(new_action_name)
     end
 
-    def overwrite_desc(new_desc)
+    def update_desc(new_desc)
       return Thread.current[:current_log_desc] = nil if new_desc.nil?
-      return unless new_desc.is_a?(Hash)
 
-      overwrite_desc_items(new_desc, valid_desc_items)
-      desc
+      uniformized_desc = @desc_uniformizer.desc(new_desc)
+      Thread.current[:current_log_desc] = desc.merge(uniformized_desc)
     end
 
     def main_content
-      Thread.current[:current_log_main_content] ||= {}
+      Thread.current[:current_log_main_content] ||= @default.main_content
     end
 
-    def overwrite_main_content(new_main_content)
-      return Thread.current[:current_log_main_content] = nil if new_main_content.nil?
-      return unless new_main_content.is_a?(Hash)
+    def update_main_content(new_content)
+      return Thread.current[:current_log_main_content] = nil if new_content.nil?
+
+      uniform_content = @main_content_uniformizer.main_content(new_content)
+      uniform_recs = @main_content_uniformizer.modified_records(uniform_content[:modified_records])
+      uniform_errors = @main_content_uniformizer.errors(uniform_content[:errors])
 
-      Thread.current[:current_log_main_content] = new_main_content
+      # only overwrite if key was explicitly set
+      main_content[:modified_records] = uniform_recs if uniform_content.key?(:modified_records)
+      main_content[:errors] = uniform_errors if uniform_content.key?(:errors)
     end
 
     def add_to_main_content(new_content)
-      return unless new_content.is_a?(Hash)
+      uniform_content = @main_content_uniformizer.main_content(new_content)
+      uniform_recs = uniform_content[:modified_records]
+      uniform_errs = uniform_content[:errors]
 
-      Thread.current[:current_log_main_content] = main_content.merge(new_content)
+      # only overwrite if key was explicitly set
+      main_content[:modified_records] = modified_records.merge(uniform_recs) if uniform_recs
+      main_content[:errors] = errors + uniform_errs if uniform_errs
     end
 
     def modified_records
-      main_content[:modified_records] ||= {}
+      main_content[:modified_records] ||= @default.modified_records
     end
 
-    def overwrite_modified_records(modified_records)
-      return Thread.current[:current_log_main_content] = nil if modified_records.nil?
-      return unless modified_records.is_a?(Hash)
+    def overwrite_modified_records(new_mod_recs)
+      return main_content[:modified_records] = nil if new_mod_recs.nil?
 
-      main_content[:modified_records] = modified_records
+      uniformized_recs = @main_content_uniformizer.modified_records(new_mod_recs)
+      main_content[:modified_records] = uniformized_recs
     end
 
-    def add_modified_record(table_name, modified_record_hash)
-      return unless table_name
+    def add_modified_record(table_name, new_mod_rec)
       return unless table_name.is_a?(String)
-      return unless modified_record_hash
-      return unless modified_record_hash.is_a?(Hash)
 
+      uniformized_rec = @main_content_uniformizer.modified_record(new_mod_rec)
       modified_records[table_name] ||= []
-      modified_records[table_name] = modified_records[table_name].push(modified_record_hash)
+      modified_records[table_name] = modified_records[table_name].push(uniformized_rec)
     end
 
-    def clear_log_info
-      overwrite_desc(nil)
-      overwrite_agent(nil)
-      overwrite_main_content(nil)
+    def errors
+      main_content[:errors] ||= @default.log_errors
     end
 
-    private
+    def overwrite_errors(new_errors)
+      return main_content[:errors] = nil if new_errors.nil?
 
-    def valid_desc_items
-      %i[type service action]
+      uniformized_errors = @main_content_uniformizer.errors(new_errors)
+      main_content[:errors] = uniformized_errors
     end
 
-    def overwrite_desc_items(new_desc, item_names)
-      item_names.each do |item_name|
-        next unless new_desc.keys.include?(item_name)
+    def add_error(error)
+      uniformized_error = @main_content_uniformizer.error(error)
+
+      main_content[:errors] = errors.push(uniformized_error)
+      errors
+    end
+
+    def clear_log_info
+      update_desc(nil)
+      update_user(nil)
+      update_main_content(nil)
+    end
+
+    private
 
-        item = new_desc[item_name]
-        desc[item_name] = item || 'not_specified'
-      end
+    def update_current_log(options)
+      update_desc(options[:desc]) if options[:desc]
+      update_user(options[:user]) if options[:user]
+      update_main_content(options[:main_content]) if options[:main_content]
     end
   end
 end

data/lib/errors/logging_error_handler/logging_error_handler.rb

@@ -1,44 +1,53 @@
-require 'errors/logging_error_handler/sqs_handler'
+require 'brokers/sqs_broker'
 require 'errors/error_messages/config_error'
 
 # class for centralizing Creative's logging logic
 class ChiliLogger
   # class that handles errors when message broker can't be reached, etc...
   class LoggingErrorHandler
-    def initialize(name, config)
-      raise(ChiliLogger::ConfigError, ':error_handler_config must be present and be a hash') unless config.is_a?(Hash)
+    def initialize(fallback_name, config)
+      raise(ChiliLogger::ConfigError, ':fallback_broker_config must be present and be a hash') unless config.is_a?(Hash)
 
-      name = name.to_sym if name
-      error_handler_class = supported_error_handlers[name]
-      unsupported_handler_error unless error_handler_class
+      fallback_name = fallback_name.to_sym if fallback_name
+      fallback_broker_class = supported_fallback_brokers[fallback_name]
+      unsupported_fallback_broker_error unless fallback_broker_class
 
-      @error_handler = error_handler_class.new(config)
+      @fallback_broker = fallback_broker_class.new(config)
     end
 
     def handle_error(error, log = nil)
-      @error_handler.handle_error(error, log)
+      message = message(error, log)
+      @fallback_broker.publish(message)
     rescue StandardError => e
       puts '
-        There was a problem with both the Message Broker and the Logging Error Handler simultaneously.
+        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 permanatly lost.
+        Please note that logs are being permanently lost.
       '
       puts e
     end
 
     private
 
-    def unsupported_handler_error
-      error_handlers = supported_error_handlers.keys.join(', ')
+    def message(error, log)
+      {
+        error_type: error.class.name,
+        error_message: error.message,
+        log: log
+      }
+    end
+
+    def unsupported_fallback_broker_error
+      error_handlers = supported_fallback_brokers.keys.join(', ')
       unsupported_err = ":error_handler must be present and have one of the following values: #{error_handlers}"
 
       raise(ChiliLogger::ConfigError, unsupported_err)
     end
 
-    def supported_error_handlers
+    def supported_fallback_brokers
       {
-        aws_sqs: AWS::SqsHandler
+        aws_sqs: AWS::SqsBroker
       }
     end
   end