tty-logger 0.0.0 → 0.1.0

data/spec/unit/handler_spec.rb

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

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

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

data/spec/unit/handlers/stream_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger, "#log" do
+  let(:output) { StringIO.new }
+
+  it "logs message with fields in text format" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.handlers = [:stream]
+    end
+
+    logger.info("Successfully deployed", app: 'myapp', env: 'prod')
+
+    expect(output.string).to eq([
+      "level=info message=\"Successfully deployed\" ",
+      "app=myapp env=prod\n"
+    ].join)
+  end
+
+  it "logs message with all metadata in text format" do
+    time_now = Time.new(2019, 7, 21, 14, 04, 35, "+02:00")
+    allow(Time).to receive(:now).and_return(time_now)
+
+    logger = TTY::Logger.new(output: output) do |config|
+      config.handlers = [:stream]
+      config.metadata = [:all]
+    end
+
+    logger.info("Successfully deployed", app: 'myapp', env: 'prod')
+
+    expect(output.string).to eq([
+      "pid=#{Process.pid} ",
+      "date=\"2019-07-21\" ",
+      "time=\"14:04:35.000\" ",
+      "path=\"#{__FILE__}:#{__LINE__ - 6}:in`<top (required)>`\" ",
+      "level=info message=\"Successfully deployed\" ",
+      "app=myapp env=prod\n"
+    ].join)
+  end
+
+  it "logs message with fields in JSON format" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.handlers = [[:stream, formatter: :json]]
+    end
+
+    logger.info("Successfully deployed", app: 'myapp', env: 'prod')
+
+    expect(output.string).to eq([
+      "{\"level\":\"info\",\"message\":\"Successfully deployed\",",
+      "\"app\":\"myapp\",\"env\":\"prod\"}\n"
+    ].join)
+  end
+
+  it "logs message with all metadata in json format" do
+    time_now = Time.new(2019, 7, 21, 14, 04, 35, "+02:00")
+    allow(Time).to receive(:now).and_return(time_now)
+
+    logger = TTY::Logger.new(output: output) do |config|
+      config.handlers = [[:stream, formatter: :json]]
+      config.metadata = [:all]
+    end
+
+    logger.info("Successfully deployed")
+
+    expect(output.string).to eq([
+      "{\"pid\":#{Process.pid},",
+      "\"date\":\"2019-07-21\",",
+      "\"time\":\"14:04:35.000\",",
+      "\"path\":\"#{__FILE__}:#{__LINE__ - 6}:in`<top (required)>`\",",
+      "\"level\":\"info\",\"message\":\"Successfully deployed\"}\n"
+    ].join)
+  end
+end

data/spec/unit/levels_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger, 'levels' do
+  it "fails when unknown level" do
+    logger = TTY::Logger.new
+    expect {
+      logger.compare_levels(:error, :unknown)
+    }.to raise_error(ArgumentError, "Invalid level :unknown")
+  end
+
+  it "compares names with equal level" do
+    logger = TTY::Logger.new
+    expect(logger.compare_levels(:info, :info)).to eq(:eq)
+  end
+
+  it "compares names with equal level" do
+    logger = TTY::Logger.new
+    expect(logger.compare_levels("INFO", "INFO")).to eq(:eq)
+  end
+
+  it "compares numbers with equal level" do
+    logger = TTY::Logger.new
+    expect(logger.compare_levels(TTY::Logger::INFO_LEVEL, TTY::Logger::INFO_LEVEL)).to eq(:eq)
+  end
+
+  it "compares names with lower level" do
+    logger = TTY::Logger.new
+    expect(logger.compare_levels(:debug, :warn)).to eq(:lt)
+  end
+
+  it "compares numbers with lower level" do
+    logger = TTY::Logger.new
+    expect(logger.compare_levels(TTY::Logger::DEBUG_LEVEL, TTY::Logger::WARN_LEVEL)).to eq(:lt)
+  end
+
+  it "compares names with greater level" do
+    logger = TTY::Logger.new
+    expect(logger.compare_levels(:error, :info)).to eq(:gt)
+  end
+end

data/spec/unit/log_metadata_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger, "log metadata" do
+  let(:output) { StringIO.new }
+  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
+
+  it "outputs metadata" do
+    time_now = Time.new(2019, 7, 10, 19, 42, 35, "+02:00")
+    allow(Time).to receive(:now).and_return(time_now)
+
+    logger = TTY::Logger.new(output: output) do |config|
+      config.metadata = [:time, :date, :file]
+    end
+
+    logger.info("Deploying", app: "myapp", env: "prod")
+
+    expected_output = [
+      "\e[37m[19:42:35.000]\e[0m ",
+      "\e[37m[2019-07-10]\e[0m ",
+      "\e[37m[#{__FILE__}:#{__LINE__ - 5}:in`<top (required)>`]\e[0m",
+      " #{TTY::Logger::Handlers::Console::ARROW} ",
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Deploying                 ",
+      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"
+    ].join
+
+    expect(output.string).to eq(expected_output)
+  end
+
+  it "outputs all metadata when :all key used" do
+    time_now = Time.new(2019, 7, 10, 19, 42, 35, "+02:00")
+    allow(Time).to receive(:now).and_return(time_now)
+
+    logger = TTY::Logger.new(output: output) do |config|
+      config.metadata = [:all]
+    end
+
+    logger.info("Deploying", app: "myapp", env: "prod")
+
+    expected_output = [
+      "\e[37m[#{Process.pid}]\e[0m ",
+      "\e[37m[2019-07-10]\e[0m ",
+      "\e[37m[19:42:35.000]\e[0m ",
+      "\e[37m[#{__FILE__}:#{__LINE__ - 6}:in`<top (required)>`]\e[0m",
+      " #{TTY::Logger::Handlers::Console::ARROW} ",
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Deploying                 ",
+      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"
+    ].join
+
+    expect(output.string).to eq(expected_output)
+  end
+end

data/spec/unit/log_spec.rb

@@ -1,7 +1,144 @@
 # frozen_string_literal: true
 
-RSpec.describe TTY::Logger do
-  it "logs a message" do
-    TTY::Logger.new
+RSpec.describe TTY::Logger, "#log" do
+  let(:output) { StringIO.new }
+  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
+
+  it "logs a message at debug level" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.level = :debug
+    end
+
+    logger.debug("Successfully", "deployed")
+
+    expect(output.string).to eq([
+      "\e[36m#{styles[:debug][:symbol]}\e[0m ",
+      "\e[36mdebug\e[0m   ",
+      "Successfully deployed    \n"].join)
+  end
+
+  it "logs a message at info level" do
+    logger = TTY::Logger.new(output: output)
+
+    logger.info("Successfully", "deployed")
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Successfully deployed    \n"].join)
+  end
+
+  it "logs a message at warn level" do
+    logger = TTY::Logger.new(output: output)
+
+    logger.warn("Failed to", "deploy")
+
+    expect(output.string).to eq([
+      "\e[33m#{styles[:warn][:symbol]}\e[0m ",
+      "\e[33mwarning\e[0m ",
+      "Failed to deploy         \n"].join)
+  end
+
+  it "logs a message at error level" do
+    logger = TTY::Logger.new(output: output)
+
+    logger.error("Failed to", "deploy")
+
+    expect(output.string).to eq([
+      "\e[31m#{styles[:error][:symbol]}\e[0m ",
+      "\e[31merror\e[0m   ",
+      "Failed to deploy         \n"].join)
+  end
+
+  it "logs a message at fatal level" do
+    logger = TTY::Logger.new(output: output)
+
+    logger.fatal("Failed to", "deploy")
+
+    expect(output.string).to eq([
+      "\e[31m#{styles[:fatal][:symbol]}\e[0m ",
+      "\e[31mfatal\e[0m   ",
+      "Failed to deploy         \n"].join)
+  end
+
+  it "logs a success message at info level" do
+    logger = TTY::Logger.new(output: output)
+
+    logger.success("Deployed", "successfully")
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:success][:symbol]}\e[0m ",
+      "\e[32msuccess\e[0m ",
+      "Deployed successfully    \n"].join)
+  end
+
+  it "logs a wait message at info level" do
+    logger = TTY::Logger.new(output: output)
+
+    logger.wait("Waiting for", "deploy")
+
+    expect(output.string).to eq([
+      "\e[36m#{styles[:wait][:symbol]}\e[0m ",
+      "\e[36mwaiting\e[0m ",
+      "Waiting for deploy       \n"].join)
+  end
+
+  it "logs a message in a block" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.level = :debug
+    end
+
+    logger.info { "Successfully deployed" }
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Successfully deployed    \n"].join)
+  end
+
+  it "doesn't log when lower level" do
+    logger = TTY::Logger.new(output: output) do |config|
+      config.level = :warn
+    end
+
+    logger.debug("Successfully deployed")
+
+    expect(output.string).to eq("")
+  end
+
+  it "logs message with global fields" do
+    logger = TTY::Logger.new(output: output, fields: {app: 'myapp', env: 'prod'})
+
+    logger.info("Successfully deployed")
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Successfully deployed     ",
+      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"].join)
+  end
+
+  it "logs message with fields" do
+    logger = TTY::Logger.new(output: output)
+
+    logger.with(app: 'myapp', env: 'prod').info("Successfully deployed")
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Successfully deployed     ",
+      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"].join)
+  end
+
+  it "logs message with scoped fields" do
+    logger = TTY::Logger.new(output: output)
+
+    logger.info("Successfully deployed", app: 'myapp', env: 'prod')
+
+    expect(output.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m ",
+      "\e[32minfo\e[0m    ",
+      "Successfully deployed     ",
+      "\e[32mapp\e[0m=myapp \e[32menv\e[0m=prod\n"].join)
   end
 end

data/spec/unit/output_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Logger, "outputs" do
+  let(:styles) { TTY::Logger::Handlers::Console::STYLES }
+
+  it "outputs to multiple streams of the same handler" do
+    stream = StringIO.new
+
+    logger = TTY::Logger.new do |config|
+      config.handlers = [[:stream, formatter: :text]]
+      config.output = [stream, stream]
+    end
+
+    logger.info("logging")
+
+    expect(stream.string).to eq([
+      "level=info message=logging\n",
+      "level=info message=logging\n"
+    ].join)
+  end
+
+  it "outputs each handler to a different stream" do
+    stream = StringIO.new
+
+    logger = TTY::Logger.new do |config|
+      config.handlers = [
+        [:console, output: stream],
+        [:stream, output: stream]
+      ]
+    end
+
+    logger.info("logging")
+
+    expect(stream.string).to eq([
+      "\e[32m#{styles[:info][:symbol]}\e[0m \e[32minfo\e[0m    ",
+      "logging                  \n",
+      "level=info message=logging\n"
+    ].join)
+  end
+end

data/tty-logger.gemspec

@@ -27,6 +27,8 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.0.0'
 
+  spec.add_dependency "pastel", "~> 0.7.0"
+
   spec.add_development_dependency "bundler", ">= 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tty-logger
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-07 00:00:00.000000000 Z
+date: 2019-07-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -63,11 +77,40 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/console.rb
+- examples/error.rb
+- examples/handler.rb
+- examples/output.rb
+- examples/override.rb
+- examples/stream.rb
 - lib/tty-logger.rb
 - lib/tty/logger.rb
+- lib/tty/logger/config.rb
+- lib/tty/logger/event.rb
+- lib/tty/logger/formatters/json.rb
+- lib/tty/logger/formatters/text.rb
+- lib/tty/logger/handlers/base.rb
+- lib/tty/logger/handlers/console.rb
+- lib/tty/logger/handlers/null.rb
+- lib/tty/logger/handlers/stream.rb
+- lib/tty/logger/levels.rb
 - lib/tty/logger/version.rb
 - spec/spec_helper.rb
+- spec/unit/add_handler_spec.rb
+- spec/unit/config_spec.rb
+- spec/unit/event_spec.rb
+- spec/unit/exception_spec.rb
+- spec/unit/formatter_spec.rb
+- spec/unit/formatters/json_spec.rb
+- spec/unit/formatters/text_spec.rb
+- spec/unit/handler_spec.rb
+- spec/unit/handlers/custom_spec.rb
+- spec/unit/handlers/null_spec.rb
+- spec/unit/handlers/stream_spec.rb
+- spec/unit/levels_spec.rb
+- spec/unit/log_metadata_spec.rb
 - spec/unit/log_spec.rb
+- spec/unit/output_spec.rb
 - tasks/console.rake
 - tasks/coverage.rake
 - tasks/spec.rake