chili_logger 0.0.1 → 0.0.8

data/lib/errors/logging_error_handler/logging_error_handler.rb

@@ -0,0 +1,54 @@
+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(fallback_name, config)
+      raise(ChiliLogger::ConfigError, ':fallback_broker_config must be present and be a hash') unless config.is_a?(Hash)
+
+      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
+
+      @fallback_broker = fallback_broker_class.new(config)
+    end
+
+    def handle_error(error, log = nil)
+      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 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_fallback_brokers
+      {
+        aws_sqs: AWS::SqsBroker
+      }
+    end
+  end
+end

data/lib/{logs_coverage → helpers/logs_coverage}/coverage_writer.rb

@@ -1,16 +1,18 @@
 require 'yaml'
 require 'fileutils'
+require 'helpers/values/default'
 
 # class for centralizing Creative's logging logic
 class ChiliLogger
   # class for keeping logs coverage up to date
   class CoverageWriter
     def self.write(desc, backtrace)
+      default = ChiliLogger::Values::Default.new
       coverage = read_file
 
-      type = desc[:type]
-      service = desc[:service]
-      action = desc[:action]
+      type = desc[:type] || default.type
+      service = desc[:service] || default.service
+      action = desc[:action] || default.action
       keys = [type, service, action]
 
       coverage = add_nested_value(coverage, keys, backtrace)
@@ -18,17 +20,6 @@ class ChiliLogger
       write_file(coverage)
     end
 
-    def self.add_nested_value(object, keys, final_value)
-      return final_value if keys.empty?
-
-      current_key = keys.first
-      nested_object = object[current_key] || {}
-      nested_keys = keys.drop(1)
-      object[current_key] = add_nested_value(nested_object, nested_keys, final_value)
-
-      object
-    end
-
     def self.read_file
       file_exists = File.file?(file_path)
 
@@ -41,6 +32,19 @@ class ChiliLogger
       true
     end
 
+    # private class methods
+
+    def self.add_nested_value(object, keys, final_value)
+      return final_value if keys.empty?
+
+      current_key = keys.first
+      nested_object = object[current_key] || {}
+      nested_keys = keys.drop(1)
+      object[current_key] = add_nested_value(nested_object, nested_keys, final_value)
+
+      object
+    end
+
     def self.dir_name
       'log'
     end
@@ -52,5 +56,7 @@ class ChiliLogger
     def self.file_path
       File.join('.', dir_name, file_name)
     end
+
+    private_class_method :add_nested_value, :dir_name, :file_name, :file_path
   end
 end

data/lib/helpers/values/default.rb

@@ -0,0 +1,92 @@
+# class for centralizing Creative's logging logic
+class ChiliLogger
+  # module responsible for uniformization of values in ChiliLogger 
+  module Values
+    # class for keeping all default values in a single place
+    class Default
+      def msg_broker
+        :rabbitmq
+      end
+
+      def msg_broker_config
+        {}
+      end
+
+      def user
+        {
+          cognito_id: undefined_string,
+          email: undefined_string,
+          company_cognito_id: undefined_string,
+          company_name: undefined_string,
+          ghost_user_cognito_id: undefined_string
+        }
+      end
+
+      def env
+        undefined_string
+      end
+
+      def layer
+        undefined_string
+      end
+
+      def type
+        undefined_string
+      end
+
+      def service
+        undefined_string
+      end
+
+      def action
+        undefined_string
+      end
+
+      def desc
+        { type: type, service: service, action: action }
+      end
+
+      def main_content
+        { modified_records: modified_records, errors: log_errors }
+      end
+
+      def modified_records
+        {}
+      end
+
+      def log_errors
+        []
+      end
+
+      def log_error
+        sentence1 = 'ChiliLogger received an unsupported type of error, so it replaced it with this generic string.'
+        sentence2 = ' Errors must be either a String or a descendant of the Exception class.'
+        sentence1 + sentence2
+      end
+
+      def server_url
+        undefined_string
+      end
+
+      def log
+        {}
+      end
+
+      def sqs_message
+        {
+          error_type: undefined_string,
+          error_message: undefined_string,
+          log: undefined_string
+        }
+      end
+
+      def invalid_string
+        'invalid_format'
+      end
+
+      def undefined_string
+        'not_specified'
+      end
+    end
+  end
+end

data/lib/helpers/values/type_uniformizer/desc.rb

@@ -0,0 +1,64 @@
+# class for centralizing Creative's logging logic
+class ChiliLogger
+  # module responsible for uniformization of values in ChiliLogger
+  module Values
+    # class to enforce consistent typing of values across all classes
+    # this is important because of Elasticsearch. Check README, section ##read-before-contributing to know more about it
+    class TypeUniformizer
+      # responsible for uniformizing log's description primitive types
+      class Desc
+        def initialize
+          @default = ChiliLogger::Values::Default.new
+        end
+
+        def desc(desc)
+          return {} unless desc.is_a?(Hash)
+
+          uniformized_desc = {}
+          valid_desc_attrs.each do |attr_name|
+            # only overwrite if key was explicitly set in desc
+            next unless desc.key?(attr_name)
+
+            desc_attr = desc[attr_name]
+            desc_attr = @default.invalid_string unless valid_desc_attr_formats.include?(desc_attr.class.name)
+            desc_attr ||= @default.undefined_string # if type == nil
+            uniformized_desc[attr_name] = desc_attr
+          end
+
+          uniformized_desc
+        end
+
+        def type(type)
+          return @default.undefined_string if type.nil?
+          return @default.invalid_string unless type.is_a?(String)
+
+          type
+        end
+
+        def service(service)
+          return @default.undefined_string if service.nil?
+          return @default.invalid_string unless service.is_a?(String)
+
+          service
+        end
+
+        def action(action)
+          return @default.undefined_string if action.nil?
+          return @default.invalid_string unless action.is_a?(String)
+
+          action
+        end
+
+        private
+
+        def valid_desc_attrs
+          %i[type service action]
+        end
+
+        def valid_desc_attr_formats
+          %w[String NilClass]
+        end
+      end
+    end
+  end
+end

data/lib/helpers/values/type_uniformizer/main_content.rb

@@ -0,0 +1,62 @@
+# class for centralizing Creative's logging logic
+class ChiliLogger
+  # module responsible for uniformization of values in ChiliLogger
+  module Values
+    # class to enforce consistent typing of values across all classes, this is important because of Elasticsearch
+    # Check README, section ##read-before-contributing, to know more about it
+    class TypeUniformizer
+      # responsible for uniformizing the primitive types of a log's main_content
+      class MainContent
+        def initialize
+          @default = ChiliLogger::Values::Default.new
+        end
+
+        def main_content(content)
+          return {} unless content.is_a?(Hash)
+
+          uniformized_content = {}
+
+          if content.key?(:modified_records) # only overwrite if :modified_records was explicitly set in main_content
+            mod_recs = content[:modified_records]
+            uniformized_content[:modified_records] = modified_records(mod_recs)
+          end
+          # only overwrite if :errors was explicitly set in main_content
+          uniformized_content[:errors] = errors(content[:errors]) if content.key?(:errors)
+ 
+          uniformized_content
+        end
+
+        def modified_records(records)
+          return {} unless records.is_a?(Hash)
+
+          uniformized_recs = {}
+          # modified records should be a hash where each key points to an array of valid modified records
+          records.each do |key, val|
+            val_as_array = val.is_a?(Array) ? val : [].push(val)
+            uniformized_val = val_as_array.map { |record| modified_record(record) }
+            uniformized_recs[key.to_s] = uniformized_val
+          end
+
+          uniformized_recs
+        end
+
+        def modified_record(record)
+          record.is_a?(Hash) ? record : {}
+        end
+
+        def errors(errors)
+          return [] unless errors.is_a?(Array)
+
+          errors.map { |err| error(err) }
+        end
+
+        # a received error must be either a string or Exception descendent(it will be converted to a string)
+        def error(error)
+          error = error.inspect if error.class.ancestors.include?(Exception) # stringifies Exception descendents
+          error = @default.log_error unless error.is_a?(String)
+          error
+        end
+      end
+    end
+  end
+end

data/lib/helpers/values/type_uniformizer/user.rb

@@ -0,0 +1,43 @@
+# class for centralizing Creative's logging logic
+class ChiliLogger
+  # module responsible for uniformization of values in ChiliLogger
+  module Values
+    # class to enforce consistent typing of values across all classes
+    # this is important because of Elasticsearch. Check README, section ##read-before-contributing to know moreabout it
+    class TypeUniformizer
+      # responsible for uniformizing log's primitive types
+      class User
+        def initialize
+          @default = ChiliLogger::Values::Default.new
+        end
+
+        def user(user)
+          return {} unless user.is_a?(Hash)
+
+          uniformized_user = {}
+          valid_user_attrs.each do |attr_name|
+            # don't enforce typing compliance of attrs that weren't explicitly set in user
+            next unless user.key?(attr_name)
+
+            user_attr = user[attr_name]
+            user_attr = @default.invalid_string unless valid_user_attr_formats.include?(user_attr.class.name)
+            user_attr ||= @default.undefined_string # if type == nil
+            uniformized_user[attr_name] = user_attr.to_s
+          end
+
+          uniformized_user
+        end
+
+        private
+
+        def valid_user_attrs
+          %i[cognito_id email company_cognito_id company_name ghost_user_cognito_id]
+        end
+
+        def valid_user_attr_formats
+          %w[String NilClass Fixnum Bignum]
+        end
+      end
+    end
+  end
+end

data/lib/message_writer/aws_ops_metadata.rb

@@ -1,6 +1,5 @@
 require 'httparty'
-require 'logs_coverage/coverage_writer'
-require 'helpers/rails_backtrace_cleaner'
+require 'helpers/logs_coverage/coverage_writer'
 require 'message_writer/aws_ops_metadata'
 
 # class for centralizing Creative's logging logic

data/lib/message_writer/message_writer.rb

@@ -1,5 +1,4 @@
-require 'logs_coverage/coverage_writer'
-require 'helpers/rails_backtrace_cleaner'
+require 'helpers/logs_coverage/coverage_writer'
 require 'message_writer/aws_ops_metadata'
 
 # class for centralizing Creative's logging logic
@@ -7,30 +6,36 @@ class ChiliLogger
   # class for writing log messages
   class MessageWriter
     def initialize(config)
-      @env = config[:env] || 'not_specified'
-      @layer = config[:layer] || 'not_specified'
-      @server_url = config[:server_url] || 'not_specified'
+      @default = ChiliLogger::Values::Default.new
+      @env = config[:env] || @default.env
+      @layer = config[:layer] || @default.layer
+      @server_url = config[:server_url] || @default.server_url
       @cloud_provider = config[:cloud_provider]
-      @backtrace_cleaner = RailsBacktraceCleaner.new
     end
 
-    def write(desc = {}, agent = 'not_specified', main_content = {})
+    def write(**options)
       return if ChiliLogger.instance.deactivated
 
-      desc ||= {}
-      main_content ||= {}
+      desc = options[:desc] || @default.desc
+      user = options[:user] || @default.user
+      main_content = options[:main_content] || @default.main_content
 
-      main_content.merge!({ backtrace: @backtrace_cleaner.clean(caller) })
+      main_content[:backtrace] = clean_backtrace(caller)
       update_logs_coverage(desc, main_content)
-      message_hash(desc, agent, main_content)
+      message_hash(desc: desc, user: user, main_content: main_content)
+    end
+
+    def clean_backtrace(backtrace)
+      backtrace.reject! { |line| line =~ %r{bundle\/gems} }
+      backtrace
     end
 
     def write_description_tag(desc)
       env = desc[:env] || @env
       layer = desc[:layer] || @layer
-      type = desc[:type] || 'not_specified'
-      service = desc[:service] || 'not_specified'
-      action = desc[:action] || 'not_specified'
+      type = desc[:type] || @default.type
+      service = desc[:service] || @default.service
+      action = desc[:action] || @default.action
 
       "#{env}.#{layer}.#{type}.#{service}.#{action}"
     end
@@ -39,22 +44,23 @@ class ChiliLogger
 
     # uses message infos to keep logs_coverage up to date with what logs are being generated in the application
     def update_logs_coverage(desc, main_content)
-      backtrace = main_content[:backtrace] || @backtrace_cleaner.clean(caller)
+      backtrace = main_content[:backtrace] || clean_backtrace(caller)
       CoverageWriter.write(desc, backtrace)
     end
 
     # rubocop:disable Metrics/MethodLength
-    def message_hash(desc, agent, main_content)
+    def message_hash(**options)
+      desc = options[:desc]
       {
         desc: write_description_tag(desc),
         env: @env,
         layer: @layer,
-        type: desc[:type] || 'not_specified',
-        service: desc[:service] || 'not_specified',
-        action: desc[:action] || 'not_specified',
-        user_info: agent || 'not_specified',
+        type: desc[:type] || @default.type,
+        service: desc[:service] || @default.service,
+        action: desc[:action] || @default.action,
+        user: options[:user] || @default.undefined_string,
         timestamp: DateTime.now,
-        "#{desc[:type]}": main_content || {},
+        "#{desc[:type]}": options[:main_content] || {},
         ops_metadata: write_ops_metadata
       }
     end
@@ -64,15 +70,18 @@ class ChiliLogger
       return unless @cloud_provider
 
       provider = @cloud_provider.is_a?(String) ? @cloud_provider.to_sym : @cloud_provider
+      cloud_ops_metadata = cloud_metadata[provider]
+      return unless cloud_ops_metadata
+
       {
         server_url: @server_url,
-        cloud: cloud_metadata[provider]
+        cloud: cloud_ops_metadata.write
       }
     end
 
     def cloud_metadata
       {
-        aws: AwsOpsMetadata.write
+        aws: AwsOpsMetadata
       }
     end
   end