twiglet 2.0.0.pre.alpha.1 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2bb718963cc1602d548f4f80bbf03a932feac4ceaa5b11bc3b6d19a1ee58e10
-  data.tar.gz: 6ee69671edd4a487a905c45dec2833141fc6a4a7b8702bdffdc2dc0b81e6e9e4
+  metadata.gz: 3cb9302ac1ae427b94de457a976ace7c30d30b875676f43e91b4e206056cedf9
+  data.tar.gz: e436939ff209613f1a4f0c64c33f06a0cb3dcf36c9faa20b25bfc8c829946a26
 SHA512:
-  metadata.gz: 3ccecc55b8320608406a0dfec87f617e12501dbdebbe62de7b74881afde44439ba789c59b80c1530c9e4325dc424a202c1ea71958adf32ce1bda020103b38a48
-  data.tar.gz: 2762f0a75ac22ae69ef30de4afa022dc91e1504e578ce0fcf3198291e0f4963adbda2ab57e7e5b8a852ff2bfe6f058f3478d23c622a09a0eef98cc2821881c4b
+  metadata.gz: 06f15914e02513b777e473c6472186f1d189dae59df2e8e59a5f00efad3d7a45d4cf053b96e862c0b9337b70c2c672de12fe73d9e766ceaa047d483005f5000b
+  data.tar.gz: 35fbe15d0b18895fdb5443e2493d212c66989fea77eea204b2cb900535da78133e001c638981e856deacca3c905427222fa2a7073f895c1b26dbb270b63397c8

data/.github/CODEOWNERS

@@ -1,4 +1,3 @@
 # Add your project owners info here
 # More information: https://help.github.com/articles/about-codeowners/
 * @simplybusiness/application-tooling
-*

data/.github/workflows/ruby.yml

@@ -3,8 +3,6 @@ name: Ruby CI
 on:
   push:
     branches:
-      - '*'         # matches every branch
-      - '*/*'       # matches every branch containing a single '/'
 
 jobs:
   build:
@@ -30,3 +28,6 @@ jobs:
     - name: Run all tests
       run: bundle exec rake test
       shell: bash
+    - name: Run example_app
+      run: bundle exec ruby example_app.rb
+      shell: bash

data/.rubocop.yml

@@ -8,7 +8,7 @@ AllCops:
   Documentation:
     Enabled: false
 Metrics/BlockLength:
-  Max: 200
+  Max: 250
 Metrics/AbcSize:
   Max: 20
 Metrics/MethodLength:

data/Gemfile.lock

@@ -25,7 +25,7 @@ GEM
     parallel (1.19.1)
     parser (2.7.1.3)
       ast (~> 2.4.0)
-    rack (2.2.2)
+    rack (2.2.3)
     rainbow (3.0.0)
     rake (13.0.1)
     rexml (3.2.4)

data/README.md

@@ -40,6 +40,24 @@ This will write to STDOUT a JSON string:
 
 Obviously the timestamp will be different.
 
+Alternatively, if you just want to log some error message in text format
+```ruby
+logger.error( "Emergency! There's an Emergency going on")
+```
+
+This will write to STDOUT a JSON string:
+
+```json
+{"service":{"name":"service name"},"@timestamp":"2020-05-14T10:54:59.164+01:00","log":{"level":"error"}, "message":"Emergency! There's an Emergency going on"}
+```
+
+Errors can be logged as well, and this will log the error message and backtrace in the relevant ECS compliant fields:
+
+```ruby
+db_err = StandardError.new('Connection timed-out')
+logger.error({ message: 'DB connection failed.' }, db_err)
+```
+
 Add log event specific information simply as attributes in a hash:
 
 ```ruby
@@ -61,6 +79,18 @@ This writes:
 {"service":{"name":"service name"},"@timestamp":"2020-05-14T10:56:49.527+01:00","log":{"level":"info"},"event":{"action":"HTTP request"},"message":"GET /pets success","trace":{"id":"1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb"},"http":{"request":{"method":"get"},"response":{"status_code":200}},"url":{"path":"/pets"}}
 ```
 
+Similar to error you can use text logging here as:
+
+```
+logger.info('GET /pets success')
+```
+This writes:
+
+```json
+{"service":{"name":"service name"},"@timestamp":"2020-05-14T10:56:49.527+01:00","log":{"level":"info"}}
+```
+
+
 It may be that when making a series of logs that write information about a single event, you may want to avoid duplication by creating an event specific logger that includes the context:
 
 ```ruby
@@ -126,7 +156,7 @@ First: Please read our project [Code of Conduct](../CODE_OF_CONDUCT.md).
 Second: run the tests and make sure your changes don't break anything:
 
 ```bash
-for file in test/*test.rb; do ruby $file; done
+bundle exec rake test
 ```
 
 Then please feel free to submit a PR.

data/example_app.rb

@@ -17,6 +17,9 @@ logger.info({
               }
             })
 
+# Use text logging
+logger.info("Ready to go, listening on port #{PORT}")
+#
 # We get a request
 request_logger = logger.with({
                                event: {

data/lib/twiglet/formatter.rb

@@ -0,0 +1,69 @@
+require 'logger'
+require_relative '../hash_extensions'
+
+module Twiglet
+  class Formatter < ::Logger::Formatter
+    Hash.include HashExtensions
+
+    def initialize(service_name,
+                   default_properties: {},
+                   now: -> { Time.now.utc })
+      @service_name = service_name
+      @now = now
+      @default_properties = default_properties
+
+      super()
+    end
+
+    def call(severity, _time, _progname, msg)
+      level = severity.downcase
+      log(level: level, message: msg)
+    end
+
+    private
+
+    def log(level:, message:)
+      case message
+      when String
+        log_text(level, message: message)
+      when Hash
+        log_object(level, message: message)
+      else
+        raise('Message must be String or Hash')
+      end
+    end
+
+    def log_text(level, message:)
+      raise('The \'message\' property of log object must not be empty') if message.strip.empty?
+
+      message = { message: message }
+      log_message(level, message: message)
+    end
+
+    def log_object(level, message:)
+      message = message.transform_keys(&:to_sym)
+      message.key?(:message) || raise('Log object must have a \'message\' property')
+      message[:message].strip.empty? && raise('The \'message\' property of log object must not be empty')
+
+      log_message(level, message: message)
+    end
+
+    def log_message(level, message:)
+      base_message = {
+        "@timestamp": @now.call.iso8601(3),
+        service: {
+          name: @service_name
+        },
+        log: {
+          level: level
+        }
+      }
+
+      base_message
+        .deep_merge(@default_properties.to_nested)
+        .deep_merge(message.to_nested)
+        .to_json
+        .concat("\n")
+    end
+  end
+end

data/lib/twiglet/logger.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require 'logger'
 require 'time'
 require 'json'
+require_relative 'formatter'
 require_relative '../hash_extensions'
 
 module Twiglet
-  class Logger
+  class Logger < ::Logger
     Hash.include HashExtensions
 
     def initialize(
@@ -19,36 +21,24 @@ module Twiglet
       @output = output
 
       raise 'Service name is mandatory' \
-        unless @service_name.is_a?(String) && !@service_name.strip.empty?
+        unless service_name.is_a?(String) && !service_name.strip.empty?
 
-      @default_properties = default_properties
+      formatter = Twiglet::Formatter.new(service_name, default_properties: default_properties, now: now)
+      super(output, formatter: formatter)
     end
 
-    def debug(message)
-      log(level: 'debug', message: message)
-    end
-
-    def info(message)
-      log(level: 'info', message: message)
-    end
-
-    def warning(message)
-      log(level: 'warning', message: message)
-    end
-
-    def error(message, error = nil)
+    def error(message = {}, error = nil, &block)
       if error
-        message = message.merge({
-                                  error_name: error.message,
-                                  backtrace: error.backtrace
-                                })
+        error_fields = {
+          'error': {
+            'message': error.message
+          }
+        }
+        add_stack_trace(error_fields, error)
+        message.is_a?(Hash) ? message.merge!(error_fields) : error_fields.merge!(message: message)
       end
 
-      log(level: 'error', message: message)
-    end
-
-    def critical(message)
-      log(level: 'critical', message: message)
+      super(message, &block)
     end
 
     def with(default_properties)
@@ -58,30 +48,13 @@ module Twiglet
                  output: @output)
     end
 
-    private
-
-    def log(level:, message:)
-      raise 'Message must be a Hash' unless message.is_a?(Hash)
-
-      message = message.transform_keys(&:to_sym)
-      message.key?(:message) || raise('Log object must have a \'message\' property')
+    alias_method :warning, :warn
+    alias_method :critical, :fatal
 
-      message[:message].strip.empty? && raise('The \'message\' property of log object must not be empty')
-
-      base_message = {
-        service: {
-          name: @service_name
-        },
-        "@timestamp": @now.call.iso8601(3),
-        log: {
-          level: level
-        }
-      }
+    private
 
-      @output.puts base_message
-                     .deep_merge(@default_properties.to_nested)
-                     .deep_merge(message.to_nested)
-                     .to_json
+    def add_stack_trace(hash_to_add_to, error)
+      hash_to_add_to[:error][:stack_trace] = error.backtrace.join("\n") if error.backtrace
     end
   end
 end

data/lib/twiglet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Twiglet
-  VERSION = '2.0.0-alpha.1'
+  VERSION = '2.2.1'
 end

data/test/formatter_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'json'
+require_relative '../lib/twiglet/formatter'
+
+describe Twiglet::Formatter do
+  before do
+    @now = -> { Time.utc(2020, 5, 11, 15, 1, 1) }
+    @formatter = Twiglet::Formatter.new('petshop', now: @now)
+  end
+
+  it 'initializes an instance of a Ruby Logger Formatter' do
+    assert @formatter.is_a?(::Logger::Formatter)
+  end
+
+  it 'returns a formatted log from a string message' do
+    msg = @formatter.call('warn', nil, nil, 'shop is running low on dog food')
+    expected_log = {
+      "@timestamp" => '2020-05-11T15:01:01.000Z',
+      "service" => {
+        "name" => 'petshop'
+      },
+      "log" => {
+        "level" => 'warn'
+      },
+      "message" => 'shop is running low on dog food'
+    }
+    assert_equal JSON.parse(msg), expected_log
+  end
+end

data/test/logger_test.rb

@@ -3,6 +3,7 @@
 require 'minitest/autorun'
 require_relative '../lib/twiglet/logger'
 
+# rubocop:disable Metrics/BlockLength
 describe Twiglet::Logger do
   before do
     @now = -> { Time.utc(2020, 5, 11, 15, 1, 1) }
@@ -12,174 +13,296 @@ describe Twiglet::Logger do
                                   output: @buffer)
   end
 
+  LEVELS = [
+    { method: :debug, level: 'debug' },
+    { method: :info, level: 'info' },
+    { method: :warning, level: 'warn' },
+    { method: :warn, level: 'warn' },
+    { method: :critical, level: 'fatal' },
+    { method: :fatal, level: 'fatal' },
+    { method: :error, level: 'error' }
+  ].freeze
+
   it 'should throw an error with an empty service name' do
     assert_raises RuntimeError do
       Twiglet::Logger.new('  ')
     end
   end
 
-  it 'should throw an error with an empty message' do
-    assert_raises RuntimeError do
-      @logger.info('')
+  it 'conforms to the standard Ruby Logger API' do
+    [:debug, :debug?, :info, :info?, :warn, :warn?, :fatal, :fatal?, :error, :error?,
+     :level, :level=, :sev_threshold=].each do |call|
+      assert @logger.respond_to?(call), "Logger does not respond to #{call}"
     end
   end
 
-  it 'should log mandatory attributes' do
-    @logger.error({message: 'Out of pets exception'})
-    actual_log = read_json(@buffer)
-
-    expected_log = {
-      message: 'Out of pets exception',
-      "@timestamp": '2020-05-11T15:01:01.000Z',
-      service: {
-        name: 'petshop'
-      },
-      log: {
-        level: 'error'
+  describe 'JSON logging' do
+    it 'should throw an error with an empty message' do
+      assert_raises RuntimeError do
+        @logger.info({message: ''})
+      end
+    end
+
+    it 'should log mandatory attributes' do
+      @logger.error({message: 'Out of pets exception'})
+      actual_log = read_json(@buffer)
+
+      expected_log = {
+        message: 'Out of pets exception',
+        "@timestamp": '2020-05-11T15:01:01.000Z',
+        service: {
+          name: 'petshop'
+        },
+        log: {
+          level: 'error'
+        }
       }
-    }
 
-    assert_equal expected_log, actual_log
-  end
+      assert_equal expected_log, actual_log
+    end
 
-  it 'should log the provided message' do
-    @logger.error({event:
-                     {action: 'exception'},
-                   message: 'Emergency! Emergency!'})
-    log = read_json(@buffer)
+    it 'should log the provided message' do
+      @logger.error({event:
+                       {action: 'exception'},
+                     message: 'Emergency! Emergency!'})
+      log = read_json(@buffer)
 
-    assert_equal 'exception', log[:event][:action]
-    assert_equal 'Emergency! Emergency!', log[:message]
-  end
+      assert_equal 'exception', log[:event][:action]
+      assert_equal 'Emergency! Emergency!', log[:message]
+    end
 
-  it 'should log scoped properties defined at creation' do
-    extra_properties = {
-      trace: {
-        id: '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb'
-      },
-      service: {
-        type: 'shop'
-      },
-      request: {method: 'get'},
-      response: {status_code: 200}
-    }
-
-    output = StringIO.new
-    logger = Twiglet::Logger.new('petshop',
-                                 now: @now,
-                                 output: output,
-                                 default_properties: extra_properties)
-
-    logger.error({message: 'GET /cats'})
-    log = read_json output
-
-    assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', log[:trace][:id]
-    assert_equal 'petshop', log[:service][:name]
-    assert_equal 'shop', log[:service][:type]
-    assert_equal 'get', log[:request][:method]
-    assert_equal 200, log[:response][:status_code]
-  end
+    it 'should log scoped properties defined at creation' do
+      extra_properties = {
+        trace: {
+          id: '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb'
+        },
+        service: {
+          type: 'shop'
+        },
+        request: {method: 'get'},
+        response: {status_code: 200}
+      }
 
-  it "should be able to add properties with '.with'" do
-    # Let's add some context to this customer journey
-    purchase_logger = @logger.with({
-                                     trace: {id: '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb'},
-                                     customer: {full_name: 'Freda Bloggs'},
-                                     event: {action: 'pet purchase'}
-                                   })
-
-    # do stuff
-    purchase_logger.info({
-                           message: 'customer bought a dog',
-                           pet: {name: 'Barker', species: 'dog', breed: 'Bitsa'}
-                         })
-
-    log = read_json @buffer
-
-    assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', log[:trace][:id]
-    assert_equal 'Freda Bloggs', log[:customer][:full_name]
-    assert_equal 'pet purchase', log[:event][:action]
-    assert_equal 'customer bought a dog', log[:message]
-    assert_equal 'Barker', log[:pet][:name]
-  end
+      output = StringIO.new
+      logger = Twiglet::Logger.new('petshop',
+                                   now: @now,
+                                   output: output,
+                                   default_properties: extra_properties)
 
-  it "should log 'message' string property" do
-    message = {}
-    message['message'] = 'Guinea pigs arrived'
-    @logger.debug(message)
-    log = read_json(@buffer)
+      logger.error({message: 'GET /cats'})
+      log = read_json output
 
-    assert_equal 'Guinea pigs arrived', log[:message]
-  end
+      assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', log[:trace][:id]
+      assert_equal 'petshop', log[:service][:name]
+      assert_equal 'shop', log[:service][:type]
+      assert_equal 'get', log[:request][:method]
+      assert_equal 200, log[:response][:status_code]
+    end
 
-  it 'should be able to convert dotted keys to nested objects' do
-    @logger.debug({
-                    "trace.id": '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb',
-                    message: 'customer bought a dog',
-                    "pet.name": 'Barker',
-                    "pet.species": 'dog',
-                    "pet.breed": 'Bitsa'
-                  })
-    log = read_json(@buffer)
-
-    assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', log[:trace][:id]
-    assert_equal 'customer bought a dog', log[:message]
-    assert_equal 'Barker', log[:pet][:name]
-    assert_equal 'dog', log[:pet][:species]
-    assert_equal 'Bitsa', log[:pet][:breed]
-  end
+    it "should be able to add properties with '.with'" do
+      # Let's add some context to this customer journey
+      purchase_logger = @logger.with({
+                                       trace: {id: '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb'},
+                                       customer: {full_name: 'Freda Bloggs'},
+                                       event: {action: 'pet purchase'}
+                                     })
 
-  it 'should be able to mix dotted keys and nested objects' do
-    @logger.debug({
-                    "trace.id": '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb',
-                    message: 'customer bought a dog',
-                    pet: {name: 'Barker', breed: 'Bitsa'},
-                    "pet.species": 'dog'
-                  })
-    log = read_json(@buffer)
-
-    assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', log[:trace][:id]
-    assert_equal 'customer bought a dog', log[:message]
-    assert_equal 'Barker', log[:pet][:name]
-    assert_equal 'dog', log[:pet][:species]
-    assert_equal 'Bitsa', log[:pet][:breed]
-  end
+      # do stuff
+      purchase_logger.info({
+                             message: 'customer bought a dog',
+                             pet: {name: 'Barker', species: 'dog', breed: 'Bitsa'}
+                           })
 
-  it 'should work with mixed string and symbol properties' do
-    log = {
-      "trace.id": '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb'
-    }
-    event = {}
-    log['event'] = event
-    log['message'] = 'customer bought a dog'
-    pet = {}
-    pet['name'] = 'Barker'
-    pet['breed'] = 'Bitsa'
-    pet[:species] = 'dog'
-    log[:pet] = pet
-
-    @logger.debug(log)
-    actual_log = read_json(@buffer)
-
-    assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', actual_log[:trace][:id]
-    assert_equal 'customer bought a dog', actual_log[:message]
-    assert_equal 'Barker', actual_log[:pet][:name]
-    assert_equal 'dog', actual_log[:pet][:species]
-    assert_equal 'Bitsa', actual_log[:pet][:breed]
-  end
+      log = read_json @buffer
 
-  it 'should log an error with backtrace' do
-    begin
-      1 / 0
-    rescue StandardError => e
+      assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', log[:trace][:id]
+      assert_equal 'Freda Bloggs', log[:customer][:full_name]
+      assert_equal 'pet purchase', log[:event][:action]
+      assert_equal 'customer bought a dog', log[:message]
+      assert_equal 'Barker', log[:pet][:name]
+    end
+
+    it "should log 'message' string property" do
+      message = {}
+      message['message'] = 'Guinea pigs arrived'
+      @logger.debug(message)
+      log = read_json(@buffer)
+
+      assert_equal 'Guinea pigs arrived', log[:message]
+    end
+
+    it "should log multiple messages properly" do
+      @logger.debug({message: 'hi'})
+      @logger.info({message: 'there'})
+
+      expected_output =
+        '{"@timestamp":"2020-05-11T15:01:01.000Z","service":{"name":"petshop"},"log":{"level":"debug"},"message":"hi"}'\
+        "\n"\
+        '{"@timestamp":"2020-05-11T15:01:01.000Z","service":{"name":"petshop"},"log":{"level":"info"},"message":"there"}'\
+        "\n"\
+
+      assert_equal expected_output, @buffer.string
+    end
+
+    it 'should be able to convert dotted keys to nested objects' do
+      @logger.debug({
+                      "trace.id": '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb',
+                      message: 'customer bought a dog',
+                      "pet.name": 'Barker',
+                      "pet.species": 'dog',
+                      "pet.breed": 'Bitsa'
+                    })
+      log = read_json(@buffer)
+
+      assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', log[:trace][:id]
+      assert_equal 'customer bought a dog', log[:message]
+      assert_equal 'Barker', log[:pet][:name]
+      assert_equal 'dog', log[:pet][:species]
+      assert_equal 'Bitsa', log[:pet][:breed]
+    end
+
+    it 'should be able to mix dotted keys and nested objects' do
+      @logger.debug({
+                      "trace.id": '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb',
+                      message: 'customer bought a dog',
+                      pet: {name: 'Barker', breed: 'Bitsa'},
+                      "pet.species": 'dog'
+                    })
+      log = read_json(@buffer)
+
+      assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', log[:trace][:id]
+      assert_equal 'customer bought a dog', log[:message]
+      assert_equal 'Barker', log[:pet][:name]
+      assert_equal 'dog', log[:pet][:species]
+      assert_equal 'Bitsa', log[:pet][:breed]
+    end
+
+    it 'should work with mixed string and symbol properties' do
+      log = {
+        "trace.id": '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb'
+      }
+      event = {}
+      log['event'] = event
+      log['message'] = 'customer bought a dog'
+      pet = {}
+      pet['name'] = 'Barker'
+      pet['breed'] = 'Bitsa'
+      pet[:species] = 'dog'
+      log[:pet] = pet
+
+      @logger.debug(log)
+      actual_log = read_json(@buffer)
+
+      assert_equal '1c8a5fb2-fecd-44d8-92a4-449eb2ce4dcb', actual_log[:trace][:id]
+      assert_equal 'customer bought a dog', actual_log[:message]
+      assert_equal 'Barker', actual_log[:pet][:name]
+      assert_equal 'dog', actual_log[:pet][:species]
+      assert_equal 'Bitsa', actual_log[:pet][:breed]
+    end
+
+    it 'should log an error with backtrace' do
+      begin
+        1 / 0
+      rescue StandardError => e
+        @logger.error({message: 'Artificially raised exception'}, e)
+      end
+
+      actual_log = read_json(@buffer)
+
+      assert_equal 'Artificially raised exception', actual_log[:message]
+      assert_equal 'divided by 0', actual_log[:error][:message]
+      assert_match 'logger_test.rb', actual_log[:error][:stack_trace].lines.first
+    end
+
+    it 'should log an error without backtrace' do
+      e = StandardError.new('Connection timed-out')
       @logger.error({message: 'Artificially raised exception'}, e)
+
+      actual_log = read_json(@buffer)
+
+      assert_equal 'Artificially raised exception', actual_log[:message]
+      assert_equal 'Connection timed-out', actual_log[:error][:message]
+      refute actual_log[:error].key?(:stack_trace)
+    end
+
+    LEVELS.each do |attrs|
+      it "should correctly log level when calling #{attrs[:method]}" do
+        @logger.public_send(attrs[:method], {message: 'a log message'})
+        actual_log = read_json(@buffer)
+
+        assert_equal attrs[:level], actual_log[:log][:level]
+        assert_equal 'a log message', actual_log[:message]
+      end
+    end
+  end
+
+  describe 'text logging' do
+    it 'should throw an error with an empty message' do
+      assert_raises RuntimeError do
+        @logger.info('')
+      end
     end
 
-    actual_log = read_json(@buffer)
+    it 'should log mandatory attributes' do
+      @logger.error('Out of pets exception')
+      actual_log = read_json(@buffer)
 
-    assert_equal 'Artificially raised exception', actual_log[:message]
-    assert_equal 'divided by 0', actual_log[:error_name]
-    assert_match 'logger_test.rb', actual_log[:backtrace].first
+      expected_log = {
+        message: 'Out of pets exception',
+        "@timestamp": '2020-05-11T15:01:01.000Z',
+        service: {
+          name: 'petshop'
+        },
+        log: {
+          level: 'error'
+        }
+      }
+
+      assert_equal expected_log, actual_log
+    end
+
+    it 'should log the provided message' do
+      @logger.error('Emergency! Emergency!')
+      log = read_json(@buffer)
+
+      assert_equal 'Emergency! Emergency!', log[:message]
+    end
+
+    LEVELS.each do |attrs|
+      it "should correctly log level when calling #{attrs[:method]}" do
+        @logger.public_send(attrs[:method], 'a log message')
+        actual_log = read_json(@buffer)
+
+        assert_equal attrs[:level], actual_log[:log][:level]
+        assert_equal 'a log message', actual_log[:message]
+      end
+    end
+  end
+
+  describe 'logging with a block' do
+    LEVELS.each do |attrs|
+      it "should correctly log the block when calling #{attrs[:method]}" do
+        block = proc { 'a block log message' }
+        @logger.public_send(attrs[:method], &block)
+        actual_log = read_json(@buffer)
+
+        assert_equal attrs[:level], actual_log[:log][:level]
+        assert_equal 'a block log message', actual_log[:message]
+      end
+    end
+  end
+
+  describe 'logger level' do
+    [
+      { expression: :info, level: 1 },
+      { expression: 'warn', level: 2 },
+      { expression: Logger::DEBUG, level: 0 }
+    ].each do |args|
+      it "sets the severity threshold to level #{args[:level]}" do
+        @logger.level = args[:expression]
+        assert_equal args[:level], @logger.level
+      end
+    end
   end
 
   private
@@ -189,3 +312,4 @@ describe Twiglet::Logger do
     JSON.parse(buffer.read, symbolize_names: true)
   end
 end
+# rubocop:enable Metrics/BlockLength

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twiglet
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.1
+  version: 2.2.1
 platform: ruby
 authors:
 - Simply Business
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-03 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies: []
 description: Like a log, only smaller.
 email:
@@ -31,8 +31,10 @@ files:
 - Rakefile
 - example_app.rb
 - lib/hash_extensions.rb
+- lib/twiglet/formatter.rb
 - lib/twiglet/logger.rb
 - lib/twiglet/version.rb
+- test/formatter_test.rb
 - test/hash_extensions_test.rb
 - test/logger_test.rb
 - twiglet.gemspec
@@ -51,9 +53,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.2
 signing_key: