chili_logger 0.0.1 → 0.0.8

data/chili_logger.gemspec

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

data/lib/brokers/rabbit_broker.rb

@@ -1,10 +1,14 @@
 require 'bunny'
-require 'errors/rabbitmq_error'
+require 'brokers/sqs_broker'
 
 # 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)
 
@@ -13,7 +17,7 @@ class ChiliLogger
       @ip = config[:ip]
       @port = config[:port]
       @exchange_name = config[:exchange_name]
-      @routing_key = config[:routing_key]
+      @routing_key_overwriter = config[:routing_key_overwriter]
 
       connect
     end
@@ -21,15 +25,15 @@ class ChiliLogger
     def connect
       return if ChiliLogger.instance.deactivated
 
-      @connection = Bunny.new("amqp://#{@user}:#{@password}@#{@ip}:#{@port}")
+      @connection = Bunny.new(connection_config)
       @connection.start
 
       @channel = @connection.create_channel
       @exchange = @channel.topic(@exchange_name, durable: true)
 
-    # wraps errors in a ChiliLogger class, so it's easier for user to see that the problem happened in chili_logger gem
-    rescue Bunny::Exception => e
-      raise(ChiliLogger::RabbitMQError, e.message)
+    rescue StandardError => e
+      puts 'Could not connect to RabbitMQ due to the following error:'
+      puts e
     end
 
     def disconnect
@@ -40,25 +44,48 @@ class ChiliLogger
       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 test, while we don't implement correct routing_keys in logstash/elasticsearch
-      key = @routing_key || routing_key
+      # temporary solution so we can force configure ChiliLogger to use a specific routing_key
+      key = @routing_key_overwriter || routing_key
+      puts key
+      puts key
+      puts key
+      puts key
+      puts key
+      puts key
       @exchange.publish(message.to_json, routing_key: key)
+
+    rescue StandardError => e
+      @logging_error_handler.handle_error(e, message)
     end
 
     private
 
     def invalid_config_format_error
-      'The configuration object must include a Hash'
+      '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
+      # 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
+      }
+    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/brokers/sqs_broker.rb

@@ -0,0 +1,61 @@
+require 'aws-sdk'
+
+# 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 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 publish(message = @default.sqs_message)
+        message_body = { body: message }
+        queue_message = queue_message(message_body)
+
+        @sqs.send_message(queue_message)
+      end
+
+      private
+
+      def queue_message(message_body)
+        {
+          queue_url: queue_url(@queue_name),
+          message_body: message_body.to_json,
+          message_group_id: SecureRandom.hex(8).to_s,
+          message_deduplication_id: SecureRandom.hex(8).to_s
+        }
+      end
+
+      def queue_url(queue_name)
+        @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'
+      end
+
+      def config_attr_error(attr)
+        "The configuration object must include a ':#{attr}' attribute"
+      end
+
+      def validate_config(config)
+        raise(ChiliLogger::ConfigError, invalid_config_format_error) unless config.is_a?(Hash)
+
+        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]
+        }
+      end
+    end
+  end
+end

data/lib/chili_logger.rb

@@ -1,8 +1,14 @@
 require 'chili_logger/version'
 require 'current_log_accessor'
-require 'errors/config_error'
+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'
 
 # class for centralizing Creative's logging logic
@@ -13,9 +19,17 @@ 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
 
+    config_logging_error_handler(config)
     config_msg_writer(config)
     config_msg_broker(config)
 
@@ -26,25 +40,40 @@ 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
 
   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)
+  end
+
   def config_msg_writer(general_config)
     msg_writer_config = {
       env: general_config[:log_env],
@@ -56,12 +85,17 @@ class ChiliLogger
     @msg_writer = MessageWriter.new(msg_writer_config)
   end
 
-  def config_msg_broker(config)
-    msg_broker_name = config[:msg_broker_name] || :rabbitmq
-    msg_broker_config = config[:msg_broker_config] || {}
+  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.config(msg_broker_config)
   end
 
@@ -71,7 +105,7 @@ class ChiliLogger
 
   def supported_msg_brokers
     {
-      rabbitmq: RabbitBroker.new
+      rabbitmq: RabbitBroker.new(@logging_error_handler)
     }
   end
 end

data/lib/chili_logger/version.rb

@@ -1,3 +1,3 @@
 class ChiliLogger
-  VERSION = '0.0.1'
+  VERSION = "0.0.8"
 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