twiglet 2.0.0 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f7e6901994e7715bab639be94853dbbcce697e16da26f2f8340404ebe4c0211
-  data.tar.gz: 1758572f62c689a68642cfb8887dc2ea380a3602332cf2321b06d51e80a7066d
+  metadata.gz: 9bd7e1ea9d6464abb4dcb96e8d2679ce6c82ebc289c55cb5989d8f8f657f065f
+  data.tar.gz: 2b2d8e963cf250c0b746dd9d56c40368e31f67b1deaf6cd63c9dee9a731ce804
 SHA512:
-  metadata.gz: 808fb4ddbdaff2287331e022ec4a593469335a40476fa59cb0546facd126113c6b564f7538c3366984bb40ed178a131861b0a97e9ea571640caa68db0354a906
-  data.tar.gz: 83913e66900495ee39ba12d8f38e16e83fbc3621c4caf7bdaa128c6b44568f82face4498f1b2081e798ff6265b79a7758dd97eff08bd6224e8b0b7d077e8cb81
+  metadata.gz: 8277fd64f609bb4edbf6c95e0f97dc56784a1ea63415c1b261dd9649a69fd6cfee54abbb0c91dfb2232f78f0a14b9c539592d4ca58d57d566350f2a0dbceb648
+  data.tar.gz: e9daae207235db6582162e7d2682cf69ea59e5dc09796b7d804bed6f31775ff07ceaff4b38518dd7c6d6a1ec40759c20dadcbebd388417187bcccb66c09fe793

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/.gitignore

@@ -1,4 +1,5 @@
 *.gem
+Gemfile.lock
 *.rbc
 /.config
 /coverage/

data/.rubocop.yml

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

data/README.md

@@ -40,6 +40,17 @@ 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
@@ -68,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

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,40 +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
-
-    alias_method :warn, :warning
-
-    def error(message, error = nil)
+    def error(message = {}, error = nil, &block)
       if error
-        message = message.merge({
-                                  'error': {
-                                    'message': error.message,
-                                    'stack_trace': error.backtrace.join("\n")
-                                  }
-                                })
+        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)
@@ -62,30 +48,13 @@ module Twiglet
                  output: @output)
     end
 
-    private
-
-    def log(level:, message:)
-      raise 'Message must be a Hash' unless message.is_a?(Hash)
+    alias_method :warning, :warn
+    alias_method :critical, :fatal
 
-      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')
-
-      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'
+  VERSION = '2.2.2'
 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,191 +13,297 @@ 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'}
+                                     })
+
+      # 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
 
-  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 log 'message' string property" do
+      message = {}
+      message['message'] = 'Guinea pigs arrived'
+      @logger.debug(message)
+      log = read_json(@buffer)
 
-  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
+      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 with backtrace' do
-    begin
-      1 / 0
-    rescue StandardError => e
+    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
 
-    actual_log = read_json(@buffer)
+    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 '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
+        assert_equal attrs[:level], actual_log[:log][:level]
+        assert_equal 'a log message', actual_log[:message]
+      end
+    end
   end
 
-  levels = [
-    { method: :debug, level: 'debug' },
-    { method: :info, level: 'info' },
-    { method: :warning, level: 'warning' },
-    { method: :warn, level: 'warning' },
-    { method: :error, level: 'error' }
-  ]
+  describe 'text logging' do
+    it 'should throw an error with an empty message' do
+      assert_raises RuntimeError do
+        @logger.info('')
+      end
+    end
 
-  levels.each do |attrs|
-    it "should correctly log level when calling #{attrs[:method]}" do
-      @logger.public_send(attrs[:method], {message: 'a log message'})
+    it 'should log mandatory attributes' do
+      @logger.error('Out of pets exception')
       actual_log = read_json(@buffer)
 
-      assert_equal attrs[:level], actual_log[:log][:level]
-      assert_equal 'a log message', actual_log[:message]
+      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
 
@@ -207,3 +314,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
+  version: 2.2.2
 platform: ruby
 authors:
 - Simply Business
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-05 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies: []
 description: Like a log, only smaller.
 email:
@@ -24,15 +24,16 @@ files:
 - ".ruby-version"
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - RATIONALE.md
 - README.md
 - 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

data/Gemfile.lock

@@ -1,62 +0,0 @@
-GIT
-  remote: https://github.com/simplybusiness/simplycop.git
-  revision: 02b417277e3ff9eeab34d6b7c30a95a17d876731
-  specs:
-    simplycop (0.5.4)
-      rubocop (~> 0.80.0)
-      rubocop-rails
-      rubocop-rspec
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (6.0.3.1)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
-    ast (2.4.0)
-    concurrent-ruby (1.1.6)
-    i18n (1.8.2)
-      concurrent-ruby (~> 1.0)
-    jaro_winkler (1.5.4)
-    minitest (5.14.0)
-    parallel (1.19.1)
-    parser (2.7.1.3)
-      ast (~> 2.4.0)
-    rack (2.2.2)
-    rainbow (3.0.0)
-    rake (13.0.1)
-    rexml (3.2.4)
-    rubocop (0.80.1)
-      jaro_winkler (~> 1.5.1)
-      parallel (~> 1.10)
-      parser (>= 2.7.0.1)
-      rainbow (>= 2.2.2, < 4.0)
-      rexml
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 1.7)
-    rubocop-rails (2.5.2)
-      activesupport
-      rack (>= 1.1)
-      rubocop (>= 0.72.0)
-    rubocop-rspec (1.39.0)
-      rubocop (>= 0.68.1)
-    ruby-progressbar (1.10.1)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
-    unicode-display_width (1.6.1)
-    zeitwerk (2.3.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  minitest
-  rake
-  simplycop!
-
-BUNDLED WITH
-   2.1.4