chili_logger 0.0.3 → 0.0.9

data/chili_logger.gemspec

@@ -11,9 +11,9 @@ 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'
-  spec.add_dependency 'bunny', '~> 2.15.0'
-  spec.add_dependency 'httparty', '~> 0.18.1'
+  spec.add_dependency 'aws-sdk', '~> 2.9', '>= 2.9.0'
+  spec.add_dependency 'bunny'
+  spec.add_dependency 'httparty'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

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)
@@ -80,7 +80,7 @@ class ChiliLogger
     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.3'
+  VERSION = "0.0.9"
 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,36 +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 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.
+      '
+      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