tty-logger 0.1.0 → 0.2.0

data/examples/child.rb

@@ -0,0 +1,9 @@
+require_relative "../lib/tty/logger"
+
+logger = TTY::Logger.new(fields: {app: "parent", env: "prod"})
+child_logger = logger.copy(app: "child") do |config|
+  config.filters = ["logging"]
+end
+
+logger.info("Parent logging")
+child_logger.warn("Child logging")

data/examples/console.rb

@@ -1,15 +1,15 @@
 require_relative "../lib/tty/logger"
 
 TTY::Logger.configure do |config|
-  config.max_bytes = 2**5
-  config.metadata = [:all]
-  config.handlers = [[:console, formatter: :text]]
+  # config.max_bytes = 2**5
+  # config.metadata = [:all]
+  # config.handlers = [[:console, formatter: :text]]
   config.level = :debug
 end
 
 logger = TTY::Logger.new(fields: {app: "myapp", env: "prod"})
 
-logger.with(path: "/var/www/example.com").info("Deploying", "code")
+logger.copy(path: "/var/www/example.com").info("Deploying", "code")
 
 puts "Levels:"
 

data/examples/custom_type.rb

@@ -0,0 +1,27 @@
+require_relative "../lib/tty/logger"
+
+logger = TTY::Logger.new do |config|
+  config.types = {thanks: {level: :info}, done: {level: :info}}
+  config.handlers = [
+    [:console, {
+      styles: {
+        thanks: {
+          symbol: "❤️ ",
+          label: "thanks",
+          color: :magenta,
+          levelpad: 0
+        },
+        done: {
+          symbol: "!!",
+          label: "done",
+          color: :green,
+          levelpad: 2
+        }
+      }
+    }]
+  ]
+end
+
+logger.info("This is info!")
+logger.thanks("Great work!")
+logger.done("Work done!")

data/examples/log.rb

@@ -0,0 +1,9 @@
+require_relative "../lib/tty/logger"
+
+logger = TTY::Logger.new do |config|
+  config.level = :debug
+end
+
+def success
+  logger.log(:debug, "Deploying...")
+end

data/examples/stream.rb

@@ -1,7 +1,7 @@
 require_relative "../lib/tty/logger"
 
 TTY::Logger.configure do |config|
-  config.max_bytes = 2**5
+  config.max_bytes = 2**7
   config.metadata = [:all]
   config.handlers = [[:stream, formatter: :text]]
   config.level = :debug
@@ -9,7 +9,7 @@ end
 
 logger = TTY::Logger.new(fields: {app: "myapp", env: "prod"})
 
-logger.with(path: "/var/www/example.com").info("Deploying", "code")
+logger.copy(path: "/var/www/example.com").info("Deploying", "code")
 
 puts "Levels:"
 

data/lib/tty/logger.rb

@@ -17,6 +17,45 @@ module TTY
     # Error raised by this logger
     class Error < StandardError; end
 
+    FILTERED = "[FILTERED]"
+
+    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
@@ -36,6 +75,12 @@ module TTY
     # @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
@@ -51,11 +96,28 @@ module TTY
       @output = output || @config.output
       @ready_handlers = []
 
+      @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 respond_to?(name)
+        raise Error, "Already defined log type #{name.inspect}"
+      end
+      self.class.define_level(name, log_level)
+    end
+
     # Add handler for logging messages
     #
     # @example
@@ -112,18 +174,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
@@ -137,22 +205,35 @@ module TTY
 
     # 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)
+      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: /<top\s+\(required\)>|<main>/ =~ label ? current_level : label,
         path: loc.path,
         lineno: loc.lineno,
         method: loc.base_label
       }
-      event = Event.new(msg, @fields.merge(scoped_fields), metadata)
+      event = Event.new(filter(*msg), @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 +241,42 @@ 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)
-    end
-
-    # Log a message at :warn level
-    #
-    # @api public
-    def warn(*msg, &block)
-      log(:warn, *msg, &block)
-    end
-
-    # Log a message at :error level
-    #
-    # @api public
-    def error(*msg, &block)
-      log(:error, *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 :fatal level
+    # Filter message parts for any sensitive information and
+    # replace with placeholder.
     #
-    # @api public
-    def fatal(*msg, &block)
-      log(:fatal, *msg, &block)
-    end
-
-    # Log a message with a success label
+    # @param [Array[String]] messages
+    #   the messages to filter
     #
-    # @api public
-    def success(*msg, &block)
-      log(:info, *msg, &block)
-    end
-
-    # Log a message with a wait label
+    # @return [Array[String]]
+    #   the filtered message
     #
-    # @api public
-    def wait(*msg, &block)
-      log(:info, *msg, &block)
+    # @api private
+    def filter(*messages)
+      messages.reduce([]) do |acc, msg|
+        acc << msg.dup.tap do |msg_copy|
+          @config.filters.each do |text, placeholder|
+            msg_copy.gsub!(text, placeholder || FILTERED)
+          end
+        end
+        acc
+      end
     end
   end # Logger
 end # TTY

data/lib/tty/logger/config.rb

@@ -11,6 +11,9 @@ module TTY
       # The format used for time display
       attr_accessor :time_format
 
+      # The storage of placholders to filter sensitive data out from the logs. Defaults to {}
+      attr_accessor :filters
+
       # The format used for displaying structured data
       attr_accessor :formatter
 
@@ -29,9 +32,12 @@ module TTY
       # 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
@@ -40,11 +46,33 @@ module TTY
         @max_depth = options.fetch(:max_depth) { 3 }
         @level = options.fetch(:level) { :info }
         @metadata = options.fetch(:metadata) { [] }
+        @filters  = options.fetch(:filters) { {} }
         @handlers = options.fetch(:handlers) { [:console] }
         @formatter = options.fetch(:formatter) { :text }
         @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
+
+      # Clone settings
+      #
+      # @api public
+      def to_proc
+        -> (config) {
+          config.date_format = @date_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.time_format = @time_format.dup
+          config.types = @types.dup
+          config
+        }
       end
 
       # Hash representation of this config
@@ -55,6 +83,7 @@ module TTY
       def to_h
         {
           date_format: date_format,
+          filters: filters,
           formatter: formatter,
           handlers: handlers,
           level: level,
@@ -62,7 +91,8 @@ module TTY
           max_depth: max_depth,
           metadata: metadata,
           output: output,
-          time_format: time_format
+          time_format: time_format,
+          types: types
         }
       end
     end # Config

data/lib/tty/logger/handlers/base.rb

@@ -4,6 +4,19 @@ module TTY
   class Logger
     module Handlers
       module Base
+        # Change current log level for the duration of the block
+        #
+        # @param [String] tmp_level
+        #   the temporary log level
+        #
+        # @api public
+        def log_at(tmp_level)
+          old_level, @level = level, tmp_level
+          yield
+        ensure
+          @level = old_level
+        end
+
         # Coerce formatter name into constant
         #
         # @api private

data/lib/tty/logger/handlers/console.rb

@@ -138,7 +138,7 @@ module TTY
         #
         # @api private
         def configure_styles(event)
-          style = STYLES[event.metadata[:name].to_sym].dup
+          style = STYLES.fetch(event.metadata[:name].to_sym, {}).dup
           (@styles[event.metadata[:name].to_sym] || {}).each do |k, v|
             style[k] = v
           end

data/lib/tty/logger/levels.rb

@@ -10,35 +10,50 @@ module TTY
       FATAL_LEVEL = 4
 
       LEVEL_NAMES = {
-        DEBUG_LEVEL => :debug,
-        INFO_LEVEL => :info,
-        WARN_LEVEL => :warn,
-        ERROR_LEVEL => :error,
-        FATAL_LEVEL => :fatal
+        debug: DEBUG_LEVEL,
+        info: INFO_LEVEL,
+        warn: WARN_LEVEL,
+        error: ERROR_LEVEL,
+        fatal: FATAL_LEVEL
       }
 
+      # All the default level names
+      #
+      # @return [Array[Symbol]]
+      #
+      # @api private
       def level_names
-        [:debug, :info, :warn, :error, :fatal]
+        LEVEL_NAMES.keys
       end
 
+      # Convert level name to level number
+      #
+      # @param [Symbol] level
+      #
+      # @return [Integer]
+      #
       # @api private
       def level_to_number(level)
-        case level.to_s.downcase
-        when "debug" then DEBUG_LEVEL
-        when "info"  then INFO_LEVEL
-        when "warn"  then WARN_LEVEL
-        when "error" then ERROR_LEVEL
-        when "fatal" then FATAL_LEVEL
-        else
-          raise ArgumentError, "Invalid level #{level.inspect}"
-        end
+        LEVEL_NAMES[level.to_s.downcase.to_sym] ||
+          raise(ArgumentError, "Invalid level #{level.inspect}")
       end
 
+      # Convert level number to level name
+      #
+      # @param [Integer] number
+      #
+      # @return [Symbol]
+      #
       # @api private
-      def number_to_level(level)
-        LEVEL_NAMES[level]
+      def number_to_level(number)
+        LEVEL_NAMES.key(number)
       end
 
+      # Compares two levels by name or number
+      #
+      # @return [Symbol]
+      #   either :lt, :gt or :eq
+      #
       # @api private
       def compare_levels(left, right)
         left = left.is_a?(Integer) ? left : level_to_number(left)