tty-logger 0.0.0 → 0.1.0

data/lib/tty/logger/config.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "handlers/console"
+
+module TTY
+  class Logger
+    class Config
+      # The format used for date display
+      attr_accessor :date_format
+
+      # The format used for time display
+      attr_accessor :time_format
+
+      # The format used for displaying structured data
+      attr_accessor :formatter
+
+      # The handlers used to display logging info. Defaults to [:console]
+      attr_accessor :handlers
+
+      # The level to log messages at. Default to :info
+      attr_accessor :level
+
+      # 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
+      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`
+      attr_accessor :output
+
+      # Create a configuration instance
+      #
+      # @api private
+      def initialize(**options)
+        @max_bytes = options.fetch(:max_bytes) { 2**13 }
+        @max_depth = options.fetch(:max_depth) { 3 }
+        @level = options.fetch(:level) { :info }
+        @metadata = options.fetch(:metadata) { [] }
+        @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 }
+      end
+
+      # Hash representation of this config
+      #
+      # @return [Hash[Symbol]]
+      #
+      # @api public
+      def to_h
+        {
+          date_format: date_format,
+          formatter: formatter,
+          handlers: handlers,
+          level: level,
+          max_bytes: max_bytes,
+          max_depth: max_depth,
+          metadata: metadata,
+          output: output,
+          time_format: time_format
+        }
+      end
+    end # Config
+  end # Logger
+end # TTY

data/lib/tty/logger/event.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module TTY
+  class Logger
+    class Event
+      attr_reader :message
+
+      attr_reader :fields
+
+      attr_reader :metadata
+
+      attr_reader :backtrace
+
+      def initialize(message, fields, metadata)
+        @message = message
+        @fields = fields
+        @metadata = metadata
+        @backtrace = []
+
+        evaluate_message
+      end
+
+      private
+
+      # Extract backtrace information if message contains exception
+      #
+      # @api private
+      def evaluate_message
+        @message.each do |msg|
+          case msg
+          when Exception
+            @backtrace = msg.backtrace
+          else
+            msg
+          end
+        end
+      end
+    end # Event
+  end # Logger
+end # TTY

data/lib/tty/logger/formatters/json.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "json"
+
+module TTY
+  class Logger
+    module Formatters
+      # Format data suitable for data exchange
+      class JSON
+        ELLIPSIS = "..."
+
+        # Dump data into a JSON formatted string
+        #
+        # @param [Hash] obj
+        #   the object to serialize as JSON
+        #
+        # @return [String]
+        #
+        # @api public
+        def dump(obj, max_bytes: 2**12, max_depth: 3)
+          bytesize = 0
+
+          hash = obj.reduce({}) do |acc, (k, v)|
+            str = (k.to_json + v.to_json)
+            items = acc.keys.size - 1
+
+            if bytesize + str.bytesize + items + ELLIPSIS.bytesize > max_bytes
+              acc[k] = ELLIPSIS
+              break acc
+            else
+              bytesize += str.bytesize
+              acc[k] = dump_val(v, max_depth)
+            end
+            acc
+          end
+          ::JSON.generate(hash)
+        end
+
+        private
+
+        def dump_val(val, depth)
+          case val
+          when Hash then enc_obj(val, depth - 1)
+          when Array then enc_arr(val, depth - 1)
+          else
+            val
+          end
+        end
+
+        def enc_obj(obj, depth)
+          return ELLIPSIS if depth.zero?
+
+          obj.reduce({}) { |acc, (k, v)| acc[k] = dump_val(v, depth); acc }
+        end
+
+        def enc_arr(obj, depth)
+          return ELLIPSIS if depth.zero?
+
+          obj.reduce([]) { |acc, v| acc << dump_val(v, depth); acc }
+        end
+      end # JSON
+    end # Formatters
+  end # Logger
+end # TTY

data/lib/tty/logger/formatters/text.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module TTY
+  class Logger
+    module Formatters
+      # Format data suitable for text reading
+      class Text
+        SPACE = " "
+        LPAREN = "("
+        RPAREN = ")"
+        LBRACE = "{"
+        RBRACE = "}"
+        LBRACKET = "["
+        RBRACKET = "]"
+        ELLIPSIS = "..."
+        LITERAL_TRUE = "true"
+        LITERAL_FALSE = "false"
+        LITERAL_NIL = "nil"
+        SINGLE_QUOTE_REGEX = /'/.freeze
+        ESCAPE_DOUBLE_QUOTE = "\""
+        ESCAPE_STR_REGEX = /[ ="|{}()\[\]^$+*?.-]/.freeze
+        NUM_REGEX = /^-?\d*(?:\.\d+)?\d+$/.freeze
+
+        # Dump data in a single formatted line
+        #
+        # @param [Hash] obj
+        #   the object to serialize as text
+        #
+        # @return [String]
+        #
+        # @api public
+        def dump(obj, max_bytes: 2**12, max_depth: 3)
+          bytesize = 0
+
+          line = obj.reduce([]) do |acc, (k, v)|
+            str = "#{dump_key(k)}=#{dump_val(v, max_depth)}"
+            items = acc.size - 1
+
+            if bytesize + str.bytesize + items > max_bytes
+              if bytesize + items + (acc[-1].bytesize - ELLIPSIS.bytesize) > max_bytes
+                acc.pop
+              end
+              acc << ELLIPSIS
+              break acc
+            else
+              bytesize += str.bytesize
+              acc << str
+            end
+            acc
+          end
+          line.join(SPACE)
+        end
+
+        private
+
+        def dump_key(key)
+          key = key.to_s
+          case key
+          when SINGLE_QUOTE_REGEX
+            key.inspect
+          when ESCAPE_STR_REGEX
+            ESCAPE_DOUBLE_QUOTE + key.inspect[1..-2] + ESCAPE_DOUBLE_QUOTE
+          else
+            key
+          end
+        end
+
+        def dump_val(val, depth)
+          case val
+          when Hash           then enc_obj(val, depth - 1)
+          when Array          then enc_arr(val, depth - 1)
+          when String, Symbol then enc_str(val)
+          when Complex        then enc_cpx(val)
+          when Float          then enc_float(val)
+          when Numeric        then enc_num(val)
+          when Time           then enc_time(val)
+          when TrueClass      then LITERAL_TRUE
+          when FalseClass     then LITERAL_FALSE
+          when NilClass       then LITERAL_NIL
+          else
+            val
+          end
+        end
+
+        def enc_obj(obj, depth)
+          return LBRACE + ELLIPSIS + RBRACE if depth.zero?
+
+          LBRACE +
+            obj.map { |k, v| "#{dump_key(k)}=#{dump_val(v, depth)}" }.join(SPACE) +
+            RBRACE
+        end
+
+        def enc_arr(array, depth)
+          return LBRACKET + ELLIPSIS + RBRACKET if depth.zero?
+
+          LBRACKET + array.map { |v| dump_val(v, depth) }.join(SPACE) + RBRACKET
+        end
+
+        def enc_cpx(val)
+          LPAREN + val.to_s + RPAREN
+        end
+
+        def enc_float(val)
+          ("%f" % val).sub(/0*?$/, "")
+        end
+
+        def enc_num(val)
+          val
+        end
+
+        def enc_str(str)
+          str = str.to_s
+          case str
+          when SINGLE_QUOTE_REGEX
+            str.inspect
+          when ESCAPE_STR_REGEX, LITERAL_TRUE, LITERAL_FALSE, LITERAL_NIL, NUM_REGEX
+            ESCAPE_DOUBLE_QUOTE + str.inspect[1..-2] + ESCAPE_DOUBLE_QUOTE
+          else
+            str
+          end
+        end
+
+        def enc_time(time)
+          time.strftime("%FT%T%:z")
+        end
+      end # Text
+    end # Formatters
+  end # Logger
+end # TTY

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module TTY
+  class Logger
+    module Handlers
+      module Base
+        # Coerce formatter name into constant
+        #
+        # @api private
+        def coerce_formatter(name)
+          case name
+          when String, Symbol
+            const_name = if Formatters.const_defined?(name.upcase)
+                           name.upcase
+                         else
+                           name.capitalize
+                         end
+            Formatters.const_get(const_name)
+          when Class
+            name
+          else
+            raise_formatter_error(name)
+          end
+        rescue NameError
+          raise_formatter_error(name)
+        end
+
+        # Raise error when unknown formatter name
+        #
+        # @api private
+        def raise_formatter_error(name)
+          raise Error, "Unrecognized formatter name '#{name.inspect}'"
+        end
+
+        # Metadata for the log event
+        #
+        # @return [Array[Symbol]]
+        #
+        # @api private
+        def metadata
+          if config.metadata.include?(:all)
+            [:pid, :date, :time, :file]
+          else
+            config.metadata
+          end
+        end
+
+        # Format path from event metadata
+        #
+        # @return [String]
+        #
+        # @api private
+        def format_filepath(event)
+          "%s:%d:in`%s`" % [event.metadata[:path], event.metadata[:lineno],
+                            event.metadata[:method]]
+        end
+      end # Base
+    end # Handlers
+  end # Logger
+end # TTY

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+require_relative "base"
+
+module TTY
+  class Logger
+    module Handlers
+      class Console
+        include Base
+
+        ARROW = "›"
+
+        STYLES = {
+          debug: {
+            label: "debug",
+            symbol: "•",
+            color: :cyan,
+            levelpad: 2
+          },
+          info: {
+            label: "info",
+            symbol: "ℹ",
+            color: :green,
+            levelpad: 3
+          },
+          warn: {
+            label: "warning",
+            symbol: "⚠",
+            color: :yellow,
+            levelpad: 0
+          },
+          error: {
+            label: "error",
+            symbol: "⨯",
+            color: :red,
+            levelpad: 2
+          },
+          fatal: {
+            label: "fatal",
+            symbol: "!",
+            color: :red,
+            levelpad: 2
+          },
+          success: {
+            label: "success",
+            symbol: "✔",
+            color: :green,
+            levelpad: 0
+          },
+          wait: {
+            label: "waiting",
+            symbol: "…",
+            color: :cyan,
+            levelpad: 0
+          }
+        }
+
+        attr_reader :output
+
+        attr_reader :config
+
+        attr_reader :level
+
+        def initialize(output: $stderr, formatter: nil, config: nil, level: nil,
+                       styles: {})
+          @output = Array[output].flatten
+          @formatter = coerce_formatter(formatter || config.formatter).new
+          @config = config
+          @styles = styles
+          @level = level || @config.level
+          @mutex = Mutex.new
+          @pastel = Pastel.new
+        end
+
+        # Handle log event output in format
+        #
+        # @param [Event] event
+        #   the current event logged
+        #
+        # @api public
+        def call(event)
+          @mutex.lock
+
+          style = configure_styles(event)
+          color = configure_color(style)
+
+          fmt = []
+          metadata.each do |meta|
+            case meta
+            when :date
+              fmt << @pastel.white("[" + event.metadata[:time].
+                                   strftime(config.date_format) + "]")
+            when :time
+              fmt << @pastel.white("[" + event.metadata[:time].
+                                   strftime(config.time_format) + "]")
+            when :file
+              fmt << @pastel.white("[#{format_filepath(event)}]")
+            when :pid
+              fmt << @pastel.white("[%d]" % event.metadata[:pid])
+            else
+              raise "Unknown metadata `#{meta}`"
+            end
+          end
+          fmt << ARROW unless config.metadata.empty?
+          fmt << color.(style[:symbol])
+          fmt << color.(style[:label]) + (" " * style[:levelpad])
+          fmt << "%-25s" % event.message.join(" ")
+          unless event.fields.empty?
+            fmt << @formatter.dump(event.fields, max_bytes: config.max_bytes,
+                                   max_depth: config.max_depth).
+                                   gsub(/(\S+)(?=\=)/, color.("\\1")).
+                                   gsub(/\"([^,]+?)\"(?=:)/, "\"" + color.("\\1") + "\"")
+          end
+          unless event.backtrace.empty?
+            fmt << "\n" + format_backtrace(event)
+          end
+
+          output.each { |out| out.puts fmt.join(" ") }
+        ensure
+          @mutex.unlock
+        end
+
+        private
+
+        def format_backtrace(event)
+          indent = " " * 4
+          event.backtrace.map do |bktrace|
+            indent + bktrace.to_s
+          end.join("\n")
+        end
+
+        # Merge default styles with custom style overrides
+        #
+        # @return [Hash[String]]
+        #   the style matching log type
+        #
+        # @api private
+        def configure_styles(event)
+          style = STYLES[event.metadata[:name].to_sym].dup
+          (@styles[event.metadata[:name].to_sym] || {}).each do |k, v|
+            style[k] = v
+          end
+          style
+        end
+
+        def configure_color(style)
+          color = style.fetch(:color) { :cyan }
+          @pastel.send(color).detach
+        end
+      end # Console
+    end # Handlers
+  end # Logger
+end # TTY

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TTY
+  class Logger
+    module Handlers
+      class Null
+        def initialize(*)
+        end
+
+        def call(*)
+          # noop
+        end
+      end # Null
+    end # Handlers
+  end # Logger
+end # TTY

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module TTY
+  class Logger
+    module Handlers
+      class Stream
+        include Base
+
+        attr_reader :output
+
+        attr_reader :config
+
+        attr_reader :level
+
+        def initialize(output: $stderr, formatter: nil, config: nil, level: nil)
+          @output = Array[output].flatten
+          @formatter = coerce_formatter(formatter || config.formatter).new
+          @config = config
+          @level = level || @config.level
+          @mutex = Mutex.new
+        end
+
+        # @api public
+        def call(event)
+          @mutex.lock
+
+          data = {}
+          metadata.each do |meta|
+            case meta
+            when :date
+              data["date"] = event.metadata[:time].strftime(config.date_format)
+            when :time
+              data["time"] = event.metadata[:time].strftime(config.time_format)
+            when :file
+              data["path"] = format_filepath(event)
+            when :pid
+              data["pid"] = event.metadata[:pid]
+            else
+              raise "Unknown metadata `#{meta}`"
+            end
+          end
+          data["level"] = event.metadata[:level]
+          data["message"] = event.message.join(' ')
+          unless event.fields.empty?
+            data.merge!(event.fields)
+          end
+          unless event.backtrace.empty?
+            data.merge!("backtrace" => event.backtrace.join(","))
+          end
+
+          output.each do |out|
+            out.puts @formatter.dump(data, max_bytes: config.max_bytes,
+                                     max_depth: config.max_depth)
+          end
+        ensure
+          @mutex.unlock
+        end
+      end # Stream
+    end # Handlers
+  end # Logger
+end # TTY

data/lib/tty/logger/levels.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module TTY
+  class Logger
+    module Levels
+      DEBUG_LEVEL = 0
+      INFO_LEVEL  = 1
+      WARN_LEVEL  = 2
+      ERROR_LEVEL = 3
+      FATAL_LEVEL = 4
+
+      LEVEL_NAMES = {
+        DEBUG_LEVEL => :debug,
+        INFO_LEVEL => :info,
+        WARN_LEVEL => :warn,
+        ERROR_LEVEL => :error,
+        FATAL_LEVEL => :fatal
+      }
+
+      def level_names
+        [:debug, :info, :warn, :error, :fatal]
+      end
+
+      # @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
+      end
+
+      # @api private
+      def number_to_level(level)
+        LEVEL_NAMES[level]
+      end
+
+      # @api private
+      def compare_levels(left, right)
+        left = left.is_a?(Integer) ? left : level_to_number(left)
+        right = right.is_a?(Integer) ? right : level_to_number(right)
+
+        return :eq if left == right
+        left < right ? :lt : :gt
+      end
+    end # Levels
+  end # Logger
+end # TTY

data/lib/tty/logger/version.rb

@@ -2,6 +2,6 @@
 
 module TTY
   class Logger
-    VERSION = "0.0.0"
+    VERSION = "0.1.0"
   end
 end