tty-logger 0.0.0 → 0.1.0

data/lib/tty/logger.rb

@@ -1,10 +1,216 @@
 # frozen_string_literal: true
 
+require_relative "logger/config"
+require_relative "logger/event"
+require_relative "logger/formatters/json"
+require_relative "logger/formatters/text"
+require_relative "logger/handlers/console"
+require_relative "logger/handlers/null"
+require_relative "logger/handlers/stream"
+require_relative "logger/levels"
 require_relative "logger/version"
 
 module TTY
   class Logger
+    include Levels
+
+    # Error raised by this logger
     class Error < StandardError; end
 
+    # Logger configuration instance
+    #
+    # @api public
+    def self.config
+      @config ||= Config.new
+    end
+
+    # Global logger configuration
+    #
+    # @api public
+    def self.configure
+      yield config
+    end
+
+    # Create a logger instance
+    #
+    # @example
+    #   logger = TTY::Logger.new(output: $stdout)
+    #
+    # @api public
+    def initialize(output: nil, fields: {})
+      @fields = fields
+      @config = if block_given?
+                  conf = Config.new
+                  yield(conf)
+                  conf
+                else
+                  self.class.config
+                end
+      @level = @config.level
+      @handlers = @config.handlers
+      @output = output || @config.output
+      @ready_handlers = []
+
+      @handlers.each do |handler|
+        add_handler(handler)
+      end
+    end
+
+    # Add handler for logging messages
+    #
+    # @example
+    #   add_handler(:console)
+    #
+    # @api public
+    def add_handler(handler)
+      h, options = *(handler.is_a?(Array) ? handler : [handler, {}])
+      name = coerce_handler(h)
+      global_opts = { output: @output, config: @config }
+      opts = global_opts.merge(options)
+      ready_handler = name.new(opts)
+      @ready_handlers << ready_handler
+    end
+
+    # Remove log events handler
+    #
+    # @example
+    #   remove_handler(:console)
+    #
+    # @api public
+    def remove_handler(handler)
+      @ready_handlers.delete(handler)
+    end
+
+    # Coerce handler name into object
+    #
+    # @example
+    #   coerce_handler(:console)
+    #   # => TTY::Logger::Handlers::Console
+    #
+    # @raise [Error] when class cannot be coerced
+    #
+    # @return [Class]
+    #
+    # @api private
+    def coerce_handler(name)
+      case name
+      when String, Symbol
+        Handlers.const_get(name.capitalize)
+      when Class
+        name
+      else
+        raise_handler_error
+      end
+    rescue NameError
+      raise_handler_error
+    end
+
+    # Raise error when unknown handler name
+    #
+    # @api private
+    def raise_handler_error
+      raise Error, "Handler needs to be a class name or a symbol name"
+    end
+
+    # Add structured data
+    #
+    # @example
+    #   logger = TTY::Logger.new
+    #   logger.with(app: "myenv", env: "prod").debug("Deplying")
+    #
+    # @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)
+    end
+
+    # Check current level against another
+    #
+    # @return [Symbol]
+    #
+    # @api public
+    def log?(level, other_level)
+      compare_levels(level, other_level) != :gt
+    end
+
+    # Log a message given the severtiy level
+    #
+    # @api public
+    def log(current_level, *msg, **scoped_fields)
+      if msg.empty? && block_given?
+        msg = [yield]
+      end
+      loc = caller_locations(2,1)[0]
+      metadata = {
+        level: current_level,
+        time: Time.now,
+        pid: Process.pid,
+        name: caller_locations(1,1)[0].label,
+        path: loc.path,
+        lineno: loc.lineno,
+        method: loc.base_label
+      }
+      event = Event.new(msg, @fields.merge(scoped_fields), metadata)
+      @ready_handlers.each do |handler|
+        level = handler.respond_to?(:level) ? handler.level : @config.level
+        handler.(event) if log?(level, current_level)
+      end
+      self
+    end
+
+    # Log a message at :debug level
+    #
+    # @api public
+    def debug(*msg, &block)
+      log(:debug, *msg, &block)
+    end
+
+    # Log a message at :info level
+    #
+    # @examples
+    #   logger.info "Successfully deployed"
+    #   logger.info { "Dynamically generated info" }
+    #
+    # @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)
+    end
+
+    # Log a message at :fatal level
+    #
+    # @api public
+    def fatal(*msg, &block)
+      log(:fatal, *msg, &block)
+    end
+
+    # Log a message with a success label
+    #
+    # @api public
+    def success(*msg, &block)
+      log(:info, *msg, &block)
+    end
+
+    # Log a message with a wait label
+    #
+    # @api public
+    def wait(*msg, &block)
+      log(:info, *msg, &block)
+    end
   end # Logger
 end # TTY

data/spec/spec_helper.rb

@@ -1,3 +1,20 @@
+# frozen_string_literal: true
+
+if ENV['COVERAGE'] || ENV['TRAVIS']
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ])
+
+  SimpleCov.start do
+    command_name 'spec'
+    add_filter 'spec'
+  end
+end
+
 require "bundler/setup"
 require "tty-logger"
 

data/spec/unit/add_handler_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger, "#add_handler" do
+  let(:output) { StringIO.new }
+  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
+
+  it "dynamically adds and removes a handler object" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.handlers = []
+    end
+
+    logger.info("No handler")
+
+    logger.add_handler :console
+
+    logger.info("Console handler")
+
+    logger.remove_handler :console
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Console handler          \n"].join)
+  end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger::Config do
+  let(:output) { StringIO.new }
+  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
+
+  it "defaults :max_bytes to 8192" do
+    config = described_class.new
+    expect(config.max_bytes).to eq(8192)
+  end
+
+  it "defaults :max_depth to 3" do
+    config = described_class.new
+    expect(config.max_depth).to eq(3)
+  end
+
+  it "defaults :level to :info" do
+    config = described_class.new
+    expect(config.level).to eq(:info)
+  end
+
+  it "sets :max_bytes" do
+    config = described_class.new
+    config.max_bytes = 2**8
+    expect(config.max_bytes).to eq(256)
+  end
+
+  it "defaults metadata to empty array" do
+    config = described_class.new
+    expect(config.metadata).to eq([])
+  end
+
+  it "defaults handlers to console" do
+    config = described_class.new
+    expect(config.handlers).to eq([:console])
+  end
+
+  it "defaults formatter to text" do
+    config = described_class.new
+    expect(config.formatter).to eq(:text)
+  end
+
+  it "defaults date format to %F" do
+    config = described_class.new
+    expect(config.date_format).to eq("%F")
+  end
+
+  it "defaults output to stderr" do
+    config = described_class.new
+    expect(config.output).to eq($stderr)
+  end
+
+  it "serializes data into hash" do
+    config = described_class.new
+    expect(config.to_h).to eq({
+      date_format: "%F",
+      formatter: :text,
+      handlers: [:console],
+      level: :info,
+      max_bytes: 8192,
+      max_depth: 3,
+      metadata: [],
+      output: $stderr,
+      time_format: "%T.%3N"
+    })
+  end
+
+  it "yields configuration instance" do
+    config = double(:config)
+    allow(TTY::Logger).to receive(:config).and_return(config)
+    expect { |block|
+      TTY::Logger.configure(&block)
+    }.to yield_with_args(config)
+  end
+
+  it "configures output size" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.max_bytes = 2**4
+      config.level = :debug
+    end
+
+    logger.debug("Deploying", app: "myapp", env: "prod")
+
+    expect(output.string).to eq([
+      "\e[36m#{styles[:debug][:symbol]}\e[0m ",
+      "\e[36mdebug\e[0m   ",
+      "Deploying                 ",
+      "\e[36mapp\e[0m=myapp ...\n"
+    ].join)
+  end
+
+  it "configures maximum depth of structured data" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.max_depth = 1
+      config.level = :debug
+    end
+
+    logger.debug("Deploying", app: "myapp", env: { name: "prod" })
+
+    expect(output.string).to eq([
+      "\e[36m#{styles[:debug][:symbol]}\e[0m ",
+      "\e[36mdebug\e[0m   ",
+      "Deploying                 ",
+      "\e[36mapp\e[0m=myapp \e[36menv\e[0m={...}\n"
+    ].join)
+  end
+end

data/spec/unit/event_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger::Event, "event" do
+  it "defaults backtrace to an empty array" do
+    event = described_class.new(["message"], {}, {})
+    expect(event.backtrace).to eq([])
+  end
+
+  it "extracts backtrace if message contains exception" do
+    event = nil
+    error = nil
+
+    begin
+      raise ArgumentError, "Wrong data"
+    rescue => ex
+      error = ex
+      event = described_class.new(["Error", ex], {}, {})
+    end
+
+    expect(event.backtrace.join).to eq(error.backtrace.join)
+  end
+end

data/spec/unit/exception_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger, "exception logging" do
+  let(:output) { StringIO.new }
+  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
+
+  it "handles exception type message when console" do
+    logger = TTY::Logger.new(output: output)
+    error = nil
+
+    begin
+      raise ArgumentError, "Wrong data"
+    rescue => ex
+      error = ex
+      logger.fatal("Error:", error)
+    end
+
+    expect(output.string).to eq([
+      "\e[31m#{styles[:fatal][:symbol]}\e[0m ",
+      "\e[31mfatal\e[0m   ",
+      "Error: Wrong data         \n",
+      "#{error.backtrace.map {|bktrace| bktrace.to_s.insert(0, " " * 4) }.join("\n")}\n"
+    ].join)
+  end
+
+  it "handles exception type message when stream" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.handlers = [:stream]
+    end
+
+    error = nil
+
+    begin
+      raise ArgumentError, "Wrong data"
+    rescue => ex
+      error = ex
+      logger.fatal("Error:", error)
+    end
+
+    expect(output.string).to eq([
+      "level=fatal message=\"Error: Wrong data\" backtrace=\"",
+      "#{error.backtrace.map {|bktrace| bktrace }.join(",")}\"\n"
+    ].join)
+  end
+end

data/spec/unit/formatter_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger, "formatter" do 
+  let(:output) { StringIO.new }
+  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
+
+  it "changes default formatter to JSON as class name" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.formatter = TTY::Logger::Formatters::JSON
+    end
+
+    logger.info("Logging", app: "myapp", env: "prod")
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Logging                   ",
+      "{\"\e[32mapp\e[0m\":\"myapp\",\"\e[32menv\e[0m\":\"prod\"}\n"].join)
+  end
+
+  it "changes default formatter to JSON as name" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.formatter = :json
+    end
+
+    logger.info("Logging", app: "myapp", env: "prod")
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Logging                   ",
+      "{\"\e[32mapp\e[0m\":\"myapp\",\"\e[32menv\e[0m\":\"prod\"}\n"].join)
+  end
+
+  it "changes default formatter for only one handler" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.handlers = [:console,
+                         [:console, {formatter: :JSON}]]
+    end
+
+    logger.info("Logging", app: "myapp", env: "prod")
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Logging                   ",
+      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n",
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Logging                   ",
+      "{\"\e[32mapp\e[0m\":\"myapp\",\"\e[32menv\e[0m\":\"prod\"}\n"].join)
+  end
+
+  it "fails to recognize formatter object type" do
+    expect {
+      TTY::Logger.new(output: output) do |config|
+        config.formatter = true
+      end
+    }.to raise_error(TTY::Logger::Error, "Unrecognized formatter name 'true'")
+  end
+
+  it "fails to recognize formatter name" do
+
+    expect {
+      TTY::Logger.new(output: output) do |config|
+        config.formatter = :unknown
+      end
+    }.to raise_error(TTY::Logger::Error, "Unrecognized formatter name ':unknown'")
+  end
+end

data/spec/unit/formatters/json_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger::Formatters::JSON, "#dump" do
+  it "dumps a log line" do
+    formatter = described_class.new
+    data = {
+      app: "myapp",
+      env: "prod",
+      sql: "SELECT * FROM admins",
+      at: Time.at(123456).utc
+    }
+
+    expect(formatter.dump(data)).to eq("{\"app\":\"myapp\",\"env\":\"prod\",\"sql\":\"SELECT * FROM admins\",\"at\":\"1970-01-02 10:17:36 UTC\"}")
+  end
+
+  [
+    {obj: {a: "aaaaa", b: "bbbbb", c: "ccccc"}, bytes: 3*12+2, want: "{\"a\":\"aaaaa\",\"b\":\"bbbbb\",\"c\":\"ccccc\"}"},
+    {obj: {a: "aaaaa", b: "bbbbb", c: "ccccc"}, bytes: 2*12+4, want: "{\"a\":\"aaaaa\",\"b\":\"bbbbb\",\"c\":\"...\"}"},
+    {obj: {a: "aaaaa", b: "bbbbb", c: "ccccc"}, bytes: 12+4, want: "{\"a\":\"aaaaa\",\"b\":\"...\"}"},
+    {obj: {a: "aaaaa", b: "bbbbb", c: "ccccc"}, bytes: 11, want: "{\"a\":\"...\"}"},
+  ].each do |data|
+    it "truncates #{data[:obj].inspect} to #{data[:want].inspect} of #{data[:bytes]} bytes" do
+      formatter = described_class.new
+      expect(formatter.dump(data[:obj], max_bytes: data[:bytes])).to eq(data[:want])
+    end
+  end
+
+  [
+    {obj: {a: {b: {c: "ccccc"}}}, depth: 1, want: "{\"a\":\"...\"}"},
+    {obj: {a: {b: {c: "ccccc"}}}, depth: 2, want: "{\"a\":{\"b\":\"...\"}}"},
+    {obj: {a: {b: {c: "ccccc"}}}, depth: 3, want: "{\"a\":{\"b\":{\"c\":\"ccccc\"}}}"},
+    {obj: {a: ["b", {c: "ccccc"}]}, depth: 1, want: "{\"a\":\"...\"}"},
+    {obj: {a: ["b", {c: "ccccc"}]}, depth: 2, want: "{\"a\":[\"b\",\"...\"]}"},
+    {obj: {a: ["b", {c: "ccccc"}]}, depth: 3, want: "{\"a\":[\"b\",{\"c\":\"ccccc\"}]}"},
+  ].each do |data|
+    it "truncates nested object #{data[:obj].inspect} to #{data[:want].inspect}" do
+      formatter = described_class.new
+      expect(formatter.dump(data[:obj], max_depth: data[:depth])).to eq(data[:want])
+    end
+  end
+end

data/spec/unit/formatters/text_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger::Formatters::Text, "#dump" do
+
+  [
+    {key: "k", value: "v", want: "k=v"},
+    {key: "k", value: '\n', want: "k=\\n"},
+    {key: "k", value: '\r', want: "k=\\r"},
+    {key: "k", value: '\t', want: "k=\\t"},
+    {key: "k", value: nil, want: "k=nil"},
+    {key: "k", value: "nil", want: "k=\"nil\""},
+    {key: "k", value: "", want: "k="},
+    {key: "k", value: true, want: "k=true"},
+    {key: "k", value: "true", want: "k=\"true\""},
+    {key: "k", value: "false", want: "k=\"false\""},
+    {key: "k", value: 1, want: "k=1"},
+    {key: "k", value: 1.035, want: "k=1.035"},
+    {key: "k", value: 1e-5, want: "k=0.00001"},
+    {key: "k", value: Complex(2,1), want: "k=(2+1i)"},
+    {key: "k", value: "1", want: "k=\"1\""},
+    {key: "k", value: "1.035", want: "k=\"1.035\""},
+    {key: "k", value: "1e-5", want: "k=\"1e-5\""},
+    {key: "k", value: "v v", want: "k=\"v v\""},
+    {key: "k", value: " ", want: 'k=" "'},
+    {key: "k", value: '"', want: 'k="\""'},
+    {key: "k", value: '=', want: 'k="="'},
+    {key: "k", value: "\\", want: "k=\\"},
+    {key: "k", value: "=\\", want: "k=\"=\\\\\""},
+    {key: "k", value: "\\\"", want: "k=\"\\\\\\\"\""},
+    {key: "", value: "", want: "="},
+    {key: '"', value: "v", want: '"\""=v'},
+    {key: "k", value: Time.new(2019, 7, 7, 12, 21, 35, "+02:00"), want: "k=2019-07-07T12:21:35+02:00"},
+    {key: "k", value: {a: 1}, want: "k={a=1}"},
+    {key: "k", value: {a: 1, b: 2}, want: "k={a=1 b=2}"},
+    {key: "k", value: {a: {b: 2}}, want: "k={a={b=2}}"},
+    {key: "k", value: ["a", 1], want: "k=[a 1]"},
+    {key: "k", value: ["a", ["b", 2], 1], want: "k=[a [b 2] 1]"},
+  ].each do |data|
+    it "dumps {#{data[:key].inspect} => #{data[:value].inspect}} as #{data[:want].inspect}" do
+      formatter = described_class.new
+      expect(formatter.dump({data[:key] => data[:value]})).to eq(data[:want])
+    end
+  end
+
+  [
+    {obj: {a: "aaaaa", b: "bbbbb", c: "ccccc"}, bytes: 24, want: "a=aaaaa b=bbbbb c=ccccc"},
+    {obj: {a: "aaaaa", b: "bbbbb", c: "ccccc"}, bytes: 20, want: "a=aaaaa b=bbbbb ..."},
+    {obj: {a: "aaaaa", b: "bbbbb", c: "ccccc"}, bytes: 15, want: "a=aaaaa ..."},
+    {obj: {a: "aaaaa", b: "bbbbb", c: "ccccc"}, bytes: 7, want: "..."},
+  ].each do |data|
+    it "truncates #{data[:obj].inspect} to #{data[:want].inspect} of #{data[:bytes]} bytes" do
+      formatter = described_class.new
+      expect(formatter.dump(data[:obj], max_bytes: data[:bytes])).to eq(data[:want])
+    end
+  end
+
+  [
+    {obj: {a: {b: {c: "ccccc"}}}, depth: 1, want: "a={...}"},
+    {obj: {a: {b: {c: "ccccc"}}}, depth: 2, want: "a={b={...}}"},
+    {obj: {a: {b: {c: "ccccc"}}}, depth: 3, want: "a={b={c=ccccc}}"},
+    {obj: {a: ["b", {c: "ccccc"}]}, depth: 1, want: "a=[...]"},
+    {obj: {a: ["b", {c: "ccccc"}]}, depth: 2, want: "a=[b {...}]"},
+    {obj: {a: ["b", {c: "ccccc"}]}, depth: 3, want: "a=[b {c=ccccc}]"},
+  ].each do |data|
+    it "truncates nested object #{data[:obj].inspect} to #{data[:want].inspect}" do
+      formatter = described_class.new
+      expect(formatter.dump(data[:obj], max_depth: data[:depth])).to eq(data[:want])
+    end
+  end
+
+  it "dumps a log line" do
+    formatter = described_class.new
+    data = {
+      app: "myapp",
+      env: "prod",
+      sql: "SELECT * FROM admins",
+      at: Time.at(123456).utc
+    }
+
+    expect(formatter.dump(data)).to eq("app=myapp env=prod sql=\"SELECT * FROM admins\" at=1970-01-02T10:17:36+00:00")
+  end
+end