tty-logger 0.0.0 → 0.5.0

data/lib/tty/logger/data_filter.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module TTY
+  class Logger
+    class DataFilter
+      FILTERED = "[FILTERED]"
+      DOT = "."
+
+      attr_reader :filters, :compiled_filters, :mask
+
+      # Create a data filter instance with filters.
+      #
+      # @example
+      #  TTY::Logger::DataFilter.new(%w[foo], mask: "<SECRET>")
+      #
+      # @param [String] mask
+      #   the mask to replace object with. Defaults to `"[FILTERED]"`
+      #
+      # @api private
+      def initialize(filters = [], mask: nil)
+        @mask = mask || FILTERED
+        @filters = filters
+        @compiled_filters = compile(filters)
+      end
+
+      # Filter object for keys matching provided filters.
+      #
+      # @example
+      #   data_filter = TTY::Logger::DataFilter.new(%w[foo])
+      #   data_filter.filter({"foo" => "bar"})
+      #   # => {"foo" => "[FILTERED]"}
+      #
+      # @param [Object] obj
+      #   the object to filter
+      #
+      # @api public
+      def filter(obj)
+        return obj if filters.empty?
+
+        obj.each_with_object({}) do |(k, v), acc|
+          acc[k] = filter_val(k, v)
+        end
+      end
+
+      private
+
+      def compile(filters)
+        compiled = {
+          regexps: [],
+          nested_regexps: [],
+          blocks: []
+        }
+        strings = []
+        nested_strings = []
+
+        filters.each do |filter|
+          case filter
+          when Proc
+            compiled[:blocks] << filter
+          when Regexp
+            if filter.to_s.include?(DOT)
+              compiled[:nested_regexps] << filter
+            else
+              compiled[:regexps] << filter
+            end
+          else
+            exp = Regexp.escape(filter)
+            if exp.include?(DOT)
+              nested_strings << exp
+            else
+              strings << exp
+            end
+          end
+        end
+
+        if !strings.empty?
+          compiled[:regexps] << /^(#{strings.join("|")})$/
+        end
+
+        if !nested_strings.empty?
+          compiled[:nested_regexps] << /^(#{nested_strings.join("|")})$/
+        end
+
+        compiled
+      end
+
+      def filter_val(key, val, composite = [])
+        return mask if filtered?(key, composite)
+
+        case val
+        when Hash then filter_obj(key, val, composite << key)
+        when Array then filter_arr(key, val, composite)
+        else val
+        end
+      end
+
+      def filtered?(key, composite)
+        composite_key = composite + [key]
+        joined_key = composite_key.join(DOT)
+        @compiled_filters[:regexps].any? { |reg| !!reg.match(key.to_s) } ||
+          @compiled_filters[:nested_regexps].any? { |reg| !!reg.match(joined_key) } ||
+          @compiled_filters[:blocks].any? { |block| block.(composite_key.dup) }
+      end
+
+      def filter_obj(_key, obj, composite)
+        obj.each_with_object({}) do |(k, v), acc|
+          acc[k] = filter_val(k, v, composite)
+        end
+      end
+
+      def filter_arr(key, obj, composite)
+        obj.reduce([]) do |acc, v|
+          acc << filter_val(key, v, composite)
+        end
+      end
+    end # DataFilter
+  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 if msg.backtrace
+          else
+            msg
+          end
+        end
+      end
+    end # Event
+  end # Logger
+end # TTY

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

@@ -0,0 +1,63 @@
+# 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.each_with_object({}) do |(k, v), acc|
+            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
+          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.each_with_object({}) { |(k, v), acc| acc[k] = dump_val(v, depth) }
+        end
+
+        def enc_arr(obj, depth)
+          return ELLIPSIS if depth.zero?
+
+          obj.each_with_object([]) { |v, acc| acc << dump_val(v, depth) }
+        end
+      end # JSON
+    end # Formatters
+  end # Logger
+end # TTY

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

@@ -0,0 +1,130 @@
+# 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.each_with_object([]) do |(k, v), acc|
+            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
+          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,73 @@
+# frozen_string_literal: true
+
+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
+        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,178 @@
+# 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
+          }
+        }.freeze
+
+        TEXT_REGEXP = /([{}()\[\]])?(["']?)(\S+?)(["']?=)/.freeze
+        JSON_REGEXP = /\"([^,]+?)\"(?=:)/.freeze
+
+        COLOR_PATTERNS = {
+          text: [TEXT_REGEXP, ->(c) { "\\1\\2" + c.("\\3") + "\\4" }],
+          json: [JSON_REGEXP, ->(c) { "\"" + c.("\\1") + "\"" }]
+        }.freeze
+
+        # The output stream
+        # @api private
+        attr_reader :output
+
+        # The configuration options
+        # @api private
+        attr_reader :config
+
+        # The logging level
+        # @api private
+        attr_reader :level
+
+        # The format for the message
+        # @api private
+        attr_reader :message_format
+
+        def initialize(output: $stderr, formatter: nil, config: nil, level: nil,
+                       styles: {}, message_format: "%-25s")
+          @output = Array[output].flatten
+          @formatter = coerce_formatter(formatter || config.formatter).new
+          @formatter_name = @formatter.class.name.split("::").last.downcase
+          @color_pattern = COLOR_PATTERNS[@formatter_name.to_sym]
+          @config = config
+          @styles = styles
+          @level = level || @config.level
+          @mutex = Mutex.new
+          @pastel = Pastel.new
+          @message_format = message_format
+        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?
+          unless style.empty?
+            fmt << color.(style[:symbol])
+            fmt << color.(style[:label]) + (" " * style[:levelpad])
+          end
+          fmt << message_format % event.message.join(" ")
+          unless event.fields.empty?
+            pattern, replacement = *@color_pattern
+            fmt << @formatter.dump(event.fields, max_bytes: config.max_bytes,
+                                                 max_depth: config.max_depth)
+                             .gsub(pattern, replacement.(color))
+          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)
+          return {} if event.metadata[:name].nil?
+
+          STYLES.fetch(event.metadata[:name].to_sym, {})
+                .dup
+                .merge!(@styles[event.metadata[:name].to_sym] || {})
+        end
+
+        def configure_color(style)
+          color = style.fetch(:color) { :cyan }
+          @pastel.send(color).detach
+        end
+      end # Console
+    end # Handlers
+  end # Logger
+end # TTY