tty-logger 0.1.0 → 0.6.0

data/lib/tty/logger.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "logger/config"
+require_relative "logger/data_filter"
 require_relative "logger/event"
 require_relative "logger/formatters/json"
 require_relative "logger/formatters/text"
@@ -17,6 +18,43 @@ module TTY
     # Error raised by this logger
     class Error < StandardError; end
 
+    LOG_TYPES = {
+      debug: { level: :debug },
+      info: { level: :info },
+      warn: { level: :warn },
+      error: { level: :error },
+      fatal: { level: :fatal },
+      success: { level: :info },
+      wait: { level: :info }
+    }.freeze
+
+    # Macro to dynamically define log types
+    #
+    # @api private
+    def self.define_level(name, log_level = nil)
+      const_level = (LOG_TYPES[name.to_sym] || log_level)[:level]
+
+      loc = caller_locations(0, 1)[0]
+      if loc
+        file, line = loc.path, loc.lineno + 7
+      else
+        file, line = __FILE__, __LINE__ + 3
+      end
+      class_eval(<<-EOL, file, line)
+        def #{name}(*msg, &block)
+          log(:#{const_level}, *msg, &block)
+        end
+      EOL
+    end
+
+    define_level :debug
+    define_level :info
+    define_level :warn
+    define_level :error
+    define_level :fatal
+    define_level :success
+    define_level :wait
+
     # Logger configuration instance
     #
     # @api public
@@ -31,11 +69,24 @@ module TTY
       yield config
     end
 
+    # Instance logger configuration
+    #
+    # @api public
+    def configure
+      yield @config
+    end
+
     # Create a logger instance
     #
     # @example
     #   logger = TTY::Logger.new(output: $stdout)
     #
+    # @param [IO] output
+    #   the output object, can be stream
+    #
+    # @param [Hash] fields
+    #   the data fields for each log message
+    #
     # @api public
     def initialize(output: nil, fields: {})
       @fields = fields
@@ -50,24 +101,55 @@ module TTY
       @handlers = @config.handlers
       @output = output || @config.output
       @ready_handlers = []
+      @data_filter = DataFilter.new(@config.filters.data,
+                                    mask: @config.filters.mask)
+
+      @types = LOG_TYPES.dup
+      @config.types.each do |name, log_level|
+        add_type(name, log_level)
+      end
 
       @handlers.each do |handler|
         add_handler(handler)
       end
     end
 
+    # Add new log type
+    #
+    # @example
+    #   add_type(:thanks, {level: :info})
+    #
+    # @api private
+    def add_type(name, log_level)
+      if @types.include?(name)
+        raise Error, "Already defined log type #{name.inspect}"
+      end
+
+      @types[name.to_sym] = log_level
+      self.class.define_level(name, log_level)
+    end
+
     # Add handler for logging messages
     #
     # @example
     #   add_handler(:console)
     #
+    # @example
+    #   add_handler(:console, styles: { info: { color: :yellow } })
+    #
+    # @example
+    #   add_handler([:console, message_format: "%-10s"])
+    #
+    # @param [Symbol, Handlers] handler
+    #   the handler name or class
+    #
     # @api public
-    def add_handler(handler)
-      h, options = *(handler.is_a?(Array) ? handler : [handler, {}])
-      name = coerce_handler(h)
+    def add_handler(handler, **options)
+      h, h_opts = *(handler.is_a?(Array) ? handler : [handler, options])
+      handler_type = coerce_handler(h)
       global_opts = { output: @output, config: @config }
-      opts = global_opts.merge(options)
-      ready_handler = name.new(opts)
+      opts = global_opts.merge(h_opts)
+      ready_handler = handler_type.new(**opts)
       @ready_handlers << ready_handler
     end
 
@@ -78,7 +160,8 @@ module TTY
     #
     # @api public
     def remove_handler(handler)
-      @ready_handlers.delete(handler)
+      handler_type = coerce_handler(handler)
+      @ready_handlers.delete_if { |_handler| _handler.is_a?(handler_type) }
     end
 
     # Coerce handler name into object
@@ -112,18 +195,24 @@ module TTY
       raise Error, "Handler needs to be a class name or a symbol name"
     end
 
-    # Add structured data
+    # Copy this logger
     #
     # @example
     #   logger = TTY::Logger.new
-    #   logger.with(app: "myenv", env: "prod").debug("Deplying")
+    #   child_logger = logger.copy(app: "myenv", env: "prod")
+    #   child_logger.info("Deploying")
     #
     # @return [TTY::Logger]
     #   a new copy of this logger
     #
     # @api public
-    def with(new_fields)
-      self.class.new(fields: @fields.merge(new_fields), output: @output)
+    def copy(new_fields)
+      new_config = @config.to_proc.call(Config.new)
+      if block_given?
+        yield(new_config)
+      end
+      self.class.new(fields: @fields.merge(new_fields),
+                     output: @output, &new_config)
     end
 
     # Check current level against another
@@ -135,24 +224,57 @@ module TTY
       compare_levels(level, other_level) != :gt
     end
 
+    # Logs streaming output.
+    #
+    # @example
+    #   logger << "Example output"
+    #
+    # @api public
+    def write(*msg)
+      event = Event.new(filter(*msg))
+
+      @ready_handlers.each do |handler|
+        handler.(event)
+      end
+
+      self
+    end
+    alias << write
+
     # Log a message given the severtiy level
     #
+    # @example
+    #   logger.log(:info, "Deployed successfully")
+    #
+    # @example
+    #   logger.log(:info) { "Deployed successfully" }
+    #
     # @api public
-    def log(current_level, *msg, **scoped_fields)
+    def log(current_level, *msg)
+      scoped_fields = msg.last.is_a?(::Hash) ? msg.pop : {}
+      fields_copy = scoped_fields.dup
       if msg.empty? && block_given?
-        msg = [yield]
+        msg = []
+        Array[yield].flatten(1).each do |el|
+          el.is_a?(::Hash) ? fields_copy.merge!(el) : msg << el
+        end
       end
-      loc = caller_locations(2,1)[0]
+      top_caller = caller_locations(1, 1)[0]
+      loc = caller_locations(2, 1)[0] || top_caller
+      label = top_caller.label
       metadata = {
         level: current_level,
         time: Time.now,
         pid: Process.pid,
-        name: caller_locations(1,1)[0].label,
+        name: @types.include?(label.to_sym) ? label : current_level,
         path: loc.path,
         lineno: loc.lineno,
         method: loc.base_label
       }
-      event = Event.new(msg, @fields.merge(scoped_fields), metadata)
+      event = Event.new(filter(*msg),
+                        @data_filter.filter(@fields.merge(fields_copy)),
+                        metadata)
+
       @ready_handlers.each do |handler|
         level = handler.respond_to?(:level) ? handler.level : @config.level
         handler.(event) if log?(level, current_level)
@@ -160,57 +282,71 @@ module TTY
       self
     end
 
-    # Log a message at :debug level
+    # Change current log level for the duration of the block
     #
-    # @api public
-    def debug(*msg, &block)
-      log(:debug, *msg, &block)
-    end
-
-    # Log a message at :info level
+    # @example
+    #   logger.log_at :debug do
+    #     logger.debug("logged")
+    #   end
     #
-    # @examples
-    #   logger.info "Successfully deployed"
-    #   logger.info { "Dynamically generated info" }
+    # @param [String] tmp_level
+    #   the temporary log level
     #
     # @api public
-    def info(*msg, &block)
-      log(:info, *msg, &block)
+    def log_at(tmp_level, &block)
+      @ready_handlers.each do |handler|
+        handler.log_at(tmp_level, &block)
+      end
     end
 
-    # Log a message at :warn level
+    # Filter message parts for any sensitive information and
+    # replace with placeholder.
     #
-    # @api public
-    def warn(*msg, &block)
-      log(:warn, *msg, &block)
-    end
-
-    # Log a message at :error level
+    # @param [Array[Object]] objects
+    #   the messages to filter
     #
-    # @api public
-    def error(*msg, &block)
-      log(:error, *msg, &block)
-    end
-
-    # Log a message at :fatal level
+    # @return [Array[String]]
+    #   the filtered message
     #
-    # @api public
-    def fatal(*msg, &block)
-      log(:fatal, *msg, &block)
+    # @api private
+    def filter(*objects)
+      objects.map do |obj|
+        case obj
+        when Exception
+          backtrace = Array(obj.backtrace).map { |line| swap_filtered(line) }
+          copy_error(obj, swap_filtered(obj.message), backtrace)
+        else
+          swap_filtered(obj.to_s)
+        end
+      end
     end
 
-    # Log a message with a success label
+    # Create a new error instance copy
     #
-    # @api public
-    def success(*msg, &block)
-      log(:info, *msg, &block)
+    # @param [Exception] error
+    # @param [String] message
+    # @param [Array,nil] backtrace
+    #
+    # @return [Exception]
+    #
+    # @api private
+    def copy_error(error, message, backtrace = nil)
+      new_error = error.exception(message)
+      new_error.set_backtrace(backtrace)
+      new_error
     end
 
-    # Log a message with a wait label
+    # Swap string content for filtered content
     #
-    # @api public
-    def wait(*msg, &block)
-      log(:info, *msg, &block)
+    # @param [String] obj
+    #
+    # @api private
+    def swap_filtered(obj)
+      obj.dup.tap do |obj_copy|
+        @config.filters.message.each do |text|
+          obj_copy.gsub!(text, @config.filters.mask)
+        end
+      end
     end
   end # Logger
 end # TTY

data/lib/tty/logger/config.rb

@@ -5,10 +5,12 @@ require_relative "handlers/console"
 module TTY
   class Logger
     class Config
-      # The format used for date display
+      FILTERED = "[FILTERED]"
+
+      # The format used for date display. uses strftime format
       attr_accessor :date_format
 
-      # The format used for time display
+      # The format used for time display. uses strftime format
       attr_accessor :time_format
 
       # The format used for displaying structured data
@@ -23,15 +25,18 @@ module TTY
       # The maximum message size to be logged in bytes. Defaults to 8192
       attr_accessor :max_bytes
 
-      # The maximum depth for formattin array and hash objects. Defaults to 3
+      # The maximum depth for formatting array and hash objects. Defaults to 3
       attr_accessor :max_depth
 
       # The meta info to display, can be :date, :time, :file, :pid. Defaults to []
       attr_accessor :metadata
 
-      # The output for the log messages. Default to `stderr`
+      # The output for the log messages. Defaults to `stderr`
       attr_accessor :output
 
+      # The new custom log types. Defaults to `{}`
+      attr_accessor :types
+
       # Create a configuration instance
       #
       # @api private
@@ -45,6 +50,57 @@ module TTY
         @date_format = options.fetch(:date_format) { "%F" }
         @time_format = options.fetch(:time_format) { "%T.%3N" }
         @output = options.fetch(:output) { $stderr }
+        @types = options.fetch(:types) { {} }
+      end
+
+      class FiltersProvider
+        attr_accessor :message, :data, :mask
+
+        def initialize
+          @message = []
+          @data = []
+          @mask = FILTERED
+        end
+
+        def to_h
+          { message: @message, data: @data, mask: @mask }
+        end
+
+        def to_s
+          to_h.inspect
+        end
+      end
+
+      # The filters to hide sensitive data from the message(s) and data.
+      #
+      # @return [FiltersProvider]
+      #
+      # @api public
+      def filters
+        @filters ||= FiltersProvider.new
+      end
+
+      # Allow to overwirte filters
+      attr_writer :filters
+
+      # Clone settings
+      #
+      # @api public
+      def to_proc
+        -> (config) {
+          config.date_format = @date_format.dup
+          config.time_format = @time_format.dup
+          config.filters = @filters.dup
+          config.formatter = @formatter
+          config.handlers = @handlers.dup
+          config.level =  @level
+          config.max_bytes = @max_bytes
+          config.max_depth = @max_depth
+          config.metadata = @metadata.dup
+          config.output = @output.dup
+          config.types = @types.dup
+          config
+        }
       end
 
       # Hash representation of this config
@@ -55,6 +111,7 @@ module TTY
       def to_h
         {
           date_format: date_format,
+          filters: filters.to_h,
           formatter: formatter,
           handlers: handlers,
           level: level,
@@ -62,7 +119,8 @@ module TTY
           max_depth: max_depth,
           metadata: metadata,
           output: output,
-          time_format: time_format
+          time_format: time_format,
+          types: types
         }
       end
     end # Config