tty-logger 0.2.0 → 0.3.0

data/spec/unit/copy_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger, "#copy" do
-  let(:output) { StringIO.new }
-  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
-
-  it "copies ouptut, fields and configuration over to child logger" do
-    logger = TTY::Logger.new(output: output, 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")
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Parent logging            ",
-      "\e[32mapp\e[0m=parent \e[32menv\e[0m=prod\n",
-      "\e[33m#{styles[:warn][:symbol]}\e[0m ",
-      "\e[33mwarning\e[0m ",
-      "Child [FILTERED]          ",
-      "\e[33mapp\e[0m=child \e[33menv\e[0m=prod\n"
-    ].join)
-  end
-end

data/spec/unit/event_spec.rb

@@ -1,22 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# 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/filter_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger, "filters" do
-  let(:output) { StringIO.new }
-  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
-
-  it "filters a sensitive data from a message" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.filters = ["secret", "password"]
-    end
-
-    logger.info("Super secret info with password")
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Super [FILTERED] info with [FILTERED]\n"].join)
-  end
-
-  it "filters a sensitive data from a message with custom placeholder" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.filters = { "secret" => "<SECRET>" }
-    end
-
-    logger.info("Super secret info")
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Super <SECRET> info      \n"].join)
-  end
-end

data/spec/unit/formatter_spec.rb

@@ -1,70 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,82 +0,0 @@
-# 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

data/spec/unit/handler_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger, 'handlers' do
-  let(:output) { StringIO.new }
-  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
-
-  it "coerces name into handler object" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [:console]
-    end
-
-    logger.info("Logging")
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Logging                  \n"].join)
-  end
-
-  it "coerces class name into handler object" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [TTY::Logger::Handlers::Console]
-    end
-
-    logger.info("Logging")
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m ",
-      "\e[32minfo\e[0m    ",
-      "Logging                  \n"].join)
-  end
-
-  it "changes default handler styling" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [
-        [:console, {styles: {info: {symbol: "+", label: "INFO"}}}]
-      ]
-    end
-
-    logger.info("Logging")
-
-    expect(output.string).to eq([
-      "\e[32m+\e[0m ",
-      "\e[32mINFO\e[0m    ",
-      "Logging                  \n"].join)
-  end
-
-  it "logs different levels for each handler" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [
-        [:console, level: :error],
-        [:console, level: :debug]
-      ]
-    end
-
-    logger.info("Info")
-    logger.error("Error")
-
-    expect(output.string).to eq([
-      "\e[32m#{styles[:info][:symbol]}\e[0m \e[32minfo\e[0m    Info                     \n",
-      "\e[31m#{styles[:error][:symbol]}\e[0m \e[31merror\e[0m   Error                    \n",
-      "\e[31m#{styles[:error][:symbol]}\e[0m \e[31merror\e[0m   Error                    \n",
-    ].join)
-  end
-
-  it "fails to coerce unknown object type into handler object" do
-    expect {
-      TTY::Logger.new do |config|
-        config.handlers = [true]
-      end
-    }.to raise_error(TTY::Logger::Error,
-                     "Handler needs to be a class name or a symbol name")
-  end
-
-  it "fails to coerce name into handler object" do
-    expect {
-      TTY::Logger.new do |config|
-        config.handlers = [:unknown]
-      end
-    }.to raise_error(TTY::Logger::Error,
-                     "Handler needs to be a class name or a symbol name")
-  end
-end

data/spec/unit/handlers/custom_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger::Handlers::Null, "custom handler" do
-  let(:output) { StringIO.new }
-
-  it "logs messages with a custom handler" do
-    stub_const("MyHandler", Class.new do
-      def initialize(output: nil, config: nil, label: nil)
-        @label = label
-        @output = output
-      end
-
-      def call(event)
-        @output.puts "(#{@label}) #{event.message.join}"
-      end
-    end)
-
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [[MyHandler, {label: "myhandler"}]]
-    end
-
-    logger.info("Logging")
-
-    expect(output.string).to eq("(myhandler) Logging\n")
-  end
-end

data/spec/unit/handlers/null_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Logger::Handlers::Null, "null handler" do
-  let(:output) { StringIO.new }
-
-  it "doesn't log with a null handler" do
-    logger = TTY::Logger.new(output: output) do |config|
-      config.handlers = [:null]
-    end
-
-    logger.info("Logging")
-
-    expect(output.string).to eq("")
-  end
-end