ougai 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54135d508028ceae123d4ac6554fdcfce52709c5
-  data.tar.gz: 9e7701c90d42b6db02d05d2c845687ac62bd60a5
+  metadata.gz: 457d3322926c875ce7c6b72b7ae0f192a96788fe
+  data.tar.gz: eb2e3121f6a0b6367d7608b72344ca27ecb764ed
 SHA512:
-  metadata.gz: 4a52e06b9b082e80e7df479a073e390df104e5066ce434eb4c12edb8bbf56250c7ef46908cee56cb6130724da7671c3a4f86a52e297b5f983379cd18839b4f23
-  data.tar.gz: 3a84a43bbd5d6207b102794d210cc4dd9fdb74426dc3890663d12f6b40b8a326211c56d3510b76c88626481718782da5aff69692ee17b42de707f3f5bdb4d91a
+  metadata.gz: eb7ebaf9a4b3bd092410aef5778152f378e53a2a059cb450170e536bea78c6a64919be9325cc285e6b9978dfbf51d551e21155d544c492f9ea58904652acb5e6
+  data.tar.gz: 0f0d12daf3ad7959e8fb7c65599d07af6b427bdd8be262904b87781d6a439a9ba453a738387a496ee3bf677471609de9e6ebe64f7ea125dd957d1964c150a649

data/README.md

@@ -184,6 +184,35 @@ logger.info('Hello!', user: { name: 'Jiro' }, version: '2.3')
 ```
 
 If any field of with_fields is specified in each log, the field is overridden.
+But if the field's type is *Array*, both with_field value and logging value are merged with `concat` and `uniq`.
+
+### Create a child logger
+
+`logger.child(with_fields)` creates a child logger of self. Its argument `with_fields` add to all logs the child logger outputs. A child logger can also create its child logger.
+
+```ruby
+logger = Ougai::Logger.new(STDOUT)
+logger.with_fields = { app: 'yourapp', tags: ['service'], kind: 'main' }
+
+child_logger = logger.child({ tags:['user'], kind: 'logic' })
+logger.info('Created child logger')
+
+child_logger.info('Created a user', name: 'Mike')
+
+gc_logger = child_logger.child({ kind: 'detail' })
+child_logger.info('Created grand child logger')
+
+gc_logger.debug('something detail', age: 34, weight: 72)
+```
+
+```json
+{"name":"main","hostname":"mint2","pid":8342,"level":30,"time":"2017-08-01T22:07:20.400+09:00","v":0,"app":"yourapp","tags":["service"],"kind":"main","msg":"Created child logger"}
+{"name":"Mike","hostname":"mint2","pid":8342,"level":30,"time":"2017-08-01T22:07:20.400+09:00","v":0,"app":"yourapp","tags":["service","user"],"kind":"logic","msg":"Created a user"}
+{"name":"main","hostname":"mint2","pid":8342,"level":30,"time":"2017-08-01T22:07:20.400+09:00","v":0,"app":"yourapp","tags":["service","user"],"kind":"logic","msg":"Created grand child logger"}
+{"name":"main","hostname":"mint2","pid":8342,"level":20,"time":"2017-08-01T22:07:20.400+09:00","v":0,"app":"yourapp","tags":["service","user"],"kind":"detail","age":34,"weight":72,"msg":"something detail"}
+```
+
+If any field exists in both parent log and child log, the parent value is overridden or merged by child value.
 
 ## View log by node-bunyan
 

data/lib/ougai.rb

@@ -1,5 +1,8 @@
+require 'logger'
 require 'ougai/version'
 require 'ougai/formatters/base'
 require 'ougai/formatters/bunyan'
 require 'ougai/formatters/readable'
+require 'ougai/logging'
+require 'ougai/child_logger'
 require 'ougai/logger'

data/lib/ougai/child_logger.rb

@@ -0,0 +1,24 @@
+module Ougai
+  class ChildLogger
+    include Logging
+
+    def initialize(parent, fields)
+      @parent = parent
+      @with_fields = fields
+    end
+
+    def level
+      @parent.level
+    end
+
+    def chain(severity, args, fields)
+      @parent.chain(severity, args, merge_fields(@with_fields, fields))
+    end
+
+    protected
+
+    def append(severity, args)
+      @parent.chain(severity, args, @with_fields)
+    end
+  end
+end

data/lib/ougai/logger.rb

@@ -1,9 +1,8 @@
-require 'ougai/formatters/bunyan'
-require 'logger'
-
 module Ougai
   class Logger < ::Logger
-    attr_accessor :default_message, :exc_key, :with_fields
+    include Logging
+
+    attr_accessor :default_message, :exc_key
 
     def initialize(*args)
       super(*args)
@@ -13,41 +12,6 @@ module Ougai
       @formatter = create_formatter
     end
 
-    def debug(message = nil, ex = nil, data = nil, &block)
-      return true if level > DEBUG
-      args = block ? yield : [message, ex, data]
-      add(DEBUG, build_log(args))
-    end
-
-    def info(message = nil, ex = nil, data = nil, &block)
-      return true if level > INFO
-      args = block ? yield : [message, ex, data]
-      add(INFO, build_log(args))
-    end
-
-    def warn(message = nil, ex = nil, data = nil, &block)
-      return true if level > WARN
-      args = block ? yield : [message, ex, data]
-      add(WARN, build_log(args))
-    end
-
-    def error(message = nil, ex = nil, data = nil, &block)
-      return true if level > ERROR
-      args = block ? yield : [message, ex, data]
-      add(ERROR, build_log(args))
-    end
-
-    def fatal(message = nil, ex = nil, data = nil, &block)
-      return true if level > FATAL
-      args = block ? yield : [message, ex, data]
-      add(FATAL, build_log(args))
-    end
-
-    def unknown(message = nil, ex = nil, data = nil, &block)
-      args = block ? yield : [message, ex, data]
-      add(UNKNOWN, build_log(args))
-    end
-
     def self.broadcast(logger)
       Module.new do |mdl|
         ::Logger::Severity.constants.each do |severity|
@@ -61,16 +25,22 @@ module Ougai
       end
     end
 
+    def chain(severity, args, fields)
+      write(severity, args, merge_fields(@with_fields, fields))
+    end
+
     protected
 
+    def append(severity, args)
+      write(severity, args, @with_fields)
+    end
+
     def create_formatter
       Formatters::Bunyan.new
     end
 
-    private
-
-    def build_log(args)
-      @with_fields.merge(to_item(args))
+    def write(severity, args, fields)
+      add(severity, merge_fields(fields, to_item(args)))
     end
 
     def to_item(args)
@@ -87,6 +57,8 @@ module Ougai
       end
     end
 
+    private
+
     def create_item_with_1arg(msg)
       item = {}
       if msg.is_a?(Exception)

data/lib/ougai/logging.rb

@@ -0,0 +1,64 @@
+module Ougai
+  module Logging
+    attr_accessor :with_fields
+
+    def debug(message = nil, ex = nil, data = nil, &block)
+      return true if level > Logger::DEBUG
+      args = block ? yield : [message, ex, data]
+      append(Logger::DEBUG, args)
+    end
+
+    def info(message = nil, ex = nil, data = nil, &block)
+      return true if level > Logger::INFO
+      args = block ? yield : [message, ex, data]
+      append(Logger::INFO, args)
+    end
+
+    def warn(message = nil, ex = nil, data = nil, &block)
+      return true if level > Logger::WARN
+      args = block ? yield : [message, ex, data]
+      append(Logger::WARN, args)
+    end
+
+    def error(message = nil, ex = nil, data = nil, &block)
+      return true if level > Logger::ERROR
+      args = block ? yield : [message, ex, data]
+      append(Logger::ERROR, args)
+    end
+
+    def fatal(message = nil, ex = nil, data = nil, &block)
+      return true if level > Logger::FATAL
+      args = block ? yield : [message, ex, data]
+      append(Logger::FATAL, args)
+    end
+
+    def unknown(message = nil, ex = nil, data = nil, &block)
+      args = block ? yield : [message, ex, data]
+      append(Logger::UNKNOWN, args)
+    end
+
+    def child(fields = {})
+      ChildLogger.new(self, fields)
+    end
+
+    def chain(severity, args, fields)
+      raise NotImplementedError
+    end
+
+    protected
+
+    def append(severity, args)
+      raise NotImplementedError
+    end
+
+    def merge_fields(base_data, new_data)
+      base_data.merge(new_data) do |_, base_val, new_val|
+        if base_val.is_a?(Array) and new_val.is_a?(Array)
+          (base_val + new_val).uniq
+        else
+          new_val
+        end
+      end
+    end
+  end
+end

data/lib/ougai/version.rb

@@ -1,3 +1,3 @@
 module Ougai
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/spec/child_logger_spec.rb

@@ -0,0 +1,300 @@
+require 'spec_helper'
+require 'stringio'
+require 'json'
+
+describe Ougai::ChildLogger do
+  let(:pid) { Process.pid }
+
+  matcher :be_log_message do |message, level|
+    match do |actual|
+      actual[:name] == 'rspec' \
+       && actual[:msg] == message \
+       && actual[:level] == level \
+       && actual[:pid] == pid \
+       && actual[:v] == 0
+    end
+  end
+
+  let(:io) { StringIO.new }
+  let(:parent_logger) { Ougai::Logger.new(io) }
+
+  let(:items) do
+    io.rewind
+    io.readlines.map do |line|
+      JSON.parse(line.chomp, symbolize_names: true)
+    end
+  end
+
+  let(:item) {
+    items[0]
+  }
+
+  describe '#level propagated from parent one' do
+    let(:logger) { parent_logger.child }
+
+    context 'DEBUG' do
+      let(:log_msg) { 'log message' }
+      before { parent_logger.level = Logger::DEBUG }
+
+      it 'outputs debug message' do
+        logger.debug(log_msg)
+        expect(item).to be_log_message(log_msg, 20)
+      end
+
+      it 'outputs info message' do
+        logger.info(log_msg)
+        expect(item).to be_log_message(log_msg, 30)
+      end
+    end
+
+    context 'INFO' do
+      let(:log_msg) { 'log message' }
+      before { parent_logger.level = Logger::INFO }
+
+      it 'does not output debug message' do
+        logger.debug(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'outputs info message' do
+        logger.info(log_msg)
+        expect(item).to be_log_message(log_msg, 30)
+      end
+
+      it 'outputs warning message' do
+        logger.warn(log_msg)
+        expect(item).to be_log_message(log_msg, 40)
+      end
+    end
+
+    context 'WARN' do
+      let(:log_msg) { 'log message' }
+      before { parent_logger.level = Logger::WARN }
+
+      it 'does not output info message' do
+        logger.info(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'outputs warning message' do
+        logger.warn(log_msg)
+        expect(item).to be_log_message(log_msg, 40)
+      end
+
+      it 'outputs error message' do
+        logger.error(log_msg)
+        expect(item).to be_log_message(log_msg, 50)
+      end
+    end
+
+    context 'ERROR' do
+      let(:log_msg) { 'log message' }
+      before { parent_logger.level = Logger::ERROR }
+
+      it 'does not output warning message' do
+        logger.warn(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'outputs error message' do
+        logger.error(log_msg)
+        expect(item).to be_log_message(log_msg, 50)
+      end
+
+      it 'outputs fatal message' do
+        logger.fatal(log_msg)
+        expect(item).to be_log_message(log_msg, 60)
+      end
+    end
+
+    context 'FATAL' do
+      let(:log_msg) { 'log message' }
+      before { parent_logger.level = Logger::FATAL }
+
+      it 'does not output error message' do
+        logger.error(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'outputs fatal message' do
+        logger.fatal(log_msg)
+        expect(item).to be_log_message(log_msg, 60)
+      end
+
+      it 'outputs unknown message' do
+        logger.unknown(log_msg)
+        expect(item).to be_log_message(log_msg, 70)
+      end
+    end
+
+    context 'UNKNOWN' do
+      let(:log_msg) { 'log message' }
+      before { parent_logger.level = Logger::UNKNOWN }
+
+      it 'does not output fatal message' do
+        logger.fatal(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'outputs unknown message' do
+        logger.unknown(log_msg)
+        expect(item).to be_log_message(log_msg, 70)
+      end
+    end
+  end
+
+  describe '#chain' do
+    let(:log_level) { 30 }
+    let(:log_msg) { 'log message' }
+    let(:parent_log_msg) { 'parent log message' }
+
+    context 'parent with fields, child with fields' do
+      before do
+        parent_logger.with_fields = { foo: 1, pos: 'parent' }
+      end
+
+      let(:logger) { parent_logger.child(bar: '1', pos: 'child') }
+
+      it 'outputs with merged parent and child fields' do
+        logger.info(log_msg)
+        parent_logger.info(parent_log_msg)
+
+        expect(items[0]).to be_log_message(log_msg, log_level)
+        expect(items[0]).to include(foo: 1, bar: '1', pos: 'child')
+        expect(items[1]).to be_log_message(parent_log_msg, log_level)
+        expect(items[1]).to include(foo: 1, pos: 'parent')
+        expect(items[1]).not_to include(:bar)
+      end
+
+      context 'after updating with_fieldses of parent and child' do
+        before do
+          parent_logger.with_fields = { foo: 11 }
+          logger.with_fields = { bar: '11' }
+        end
+ 
+        it 'outputs with child fields' do
+          logger.info(log_msg)
+          parent_logger.info(parent_log_msg)
+
+          expect(items[0]).to be_log_message(log_msg, log_level)
+          expect(items[0]).to include(foo: 11, bar: '11')
+          expect(items[0]).not_to include(:pos)
+          expect(items[1]).to be_log_message(parent_log_msg, log_level)
+          expect(items[1]).to include(foo: 11)
+          expect(items[1]).not_to include(:bar, :pos)
+        end
+      end
+    end
+
+    context 'parent with fields, child without fields' do
+      before do
+        parent_logger.with_fields = { foo: 2, pos: 'parent' }
+      end
+
+      let(:logger) { parent_logger.child }
+
+      it 'output valid' do
+        logger.info(log_msg)
+        parent_logger.info(parent_log_msg)
+
+        expect(items[0]).to be_log_message(log_msg, log_level)
+        expect(items[0]).to include(foo: 2, pos: 'parent')
+        expect(items[1]).to be_log_message(parent_log_msg, log_level)
+        expect(items[1]).to include(foo: 2, pos: 'parent')
+      end
+
+      context 'after updating parent logger with_fields' do
+        before do
+          parent_logger.with_fields = { foo: 22 }
+        end
+ 
+        it 'output with new parent fields' do
+          logger.info(log_msg)
+          parent_logger.info(parent_log_msg)
+
+          expect(items[0]).to be_log_message(log_msg, log_level)
+          expect(items[0]).to include(foo: 22)
+          expect(items[0]).not_to include(:pos)
+          expect(items[1]).to be_log_message(parent_log_msg, log_level)
+          expect(items[1]).to include(foo: 22)
+          expect(items[1]).not_to include(:pos)
+        end
+      end
+    end
+
+    context 'parent without fields, child with fields' do
+      before do
+        parent_logger.with_fields = {}
+      end
+
+      let(:logger) { parent_logger.child(bar: '3', pos: 'child') }
+
+      it 'output valid' do
+        logger.info(log_msg)
+        parent_logger.info(parent_log_msg)
+
+        expect(items[0]).to be_log_message(log_msg, log_level)
+        expect(items[0]).to include(bar: '3', pos: 'child')
+        expect(items[1]).to be_log_message(parent_log_msg, log_level)
+        expect(items[1]).not_to include(:bar, :pos)
+      end
+
+      context 'after updating child logger with_fields' do
+        before do
+          logger.with_fields = { bar: '33' }
+        end
+ 
+        it 'output valid' do
+          logger.info(log_msg)
+          parent_logger.info(parent_log_msg)
+
+          expect(items[0]).to be_log_message(log_msg, log_level)
+          expect(items[0]).to include(bar: '33')
+          expect(items[0]).not_to include(:pos)
+          expect(items[1]).to be_log_message(parent_log_msg, log_level)
+          expect(items[1]).not_to include(:bar, :pos)
+        end
+      end
+    end
+
+    context 'grandchild logger' do
+      before do
+        parent_logger.with_fields = { tag: 'parent', tags: ['parent'] }
+      end
+
+      let(:logger) { parent_logger.child(tag: 'child', tags: ['child']) }
+      let(:grand_logger) { logger.child(tag: 'grandchild', tags: ['grandchild']) }
+
+      it 'outputs with all merged fields' do
+        grand_logger.info('Hi', foo: 3)
+        logger.info(log_msg, foo: 2)
+        parent_logger.info(parent_log_msg, foo: 10)
+        parent_logger.info('Good evening!', foo: 11)
+
+        expect(items[0]).to be_log_message('Hi', log_level)
+        expect(items[0]).to include(tag: 'grandchild', tags: ['parent', 'child', 'grandchild'], foo: 3)
+
+        expect(items[1]).to be_log_message(log_msg, log_level)
+        expect(items[1]).to include(tag: 'child', tags: ['parent', 'child'], foo: 2)
+
+        expect(items[2]).to be_log_message(parent_log_msg, log_level)
+        expect(items[2]).to include(tag: 'parent', tags: ['parent'], foo: 10)
+        expect(items[3]).to be_log_message('Good evening!', log_level)
+        expect(items[3]).to include(tag: 'parent', tags: ['parent'], foo: 11)
+      end
+
+      context 'after updating child logger with_fields' do
+        before do
+          logger.with_fields = { bar: '33' }
+        end
+ 
+        it 'outputs with child fields' do
+          logger.info(log_msg)
+          expect(items[0]).to be_log_message(log_msg, log_level)
+          expect(items[0]).to include(bar: '33')
+          expect(items[0]).not_to include(:pos)
+        end
+      end
+    end
+  end
+end

data/spec/logging_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Ougai::Logging do
+  describe '#merge_fields' do
+    let(:target) { m = described_class; Class.new{ include m }.new }
+
+    it 'merges with unique elements in array' do
+      result = nil
+      target.instance_eval do
+        result = merge_fields({ foo: [1, 2], bar: 'base', baz: ['A'] },
+                              { foo: [2, 3], bar: 'over', baz: ['B'] })
+      end
+      expect(result[:foo]).to eq([1, 2, 3])
+      expect(result[:bar]).to eq('over')
+      expect(result[:baz]).to eq(['A', 'B'])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ougai
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Toshimitsu Takahashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-24 00:00:00.000000000 Z
+date: 2017-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,14 +68,18 @@ files:
 - README.md
 - Rakefile
 - lib/ougai.rb
+- lib/ougai/child_logger.rb
 - lib/ougai/formatters/base.rb
 - lib/ougai/formatters/bunyan.rb
 - lib/ougai/formatters/readable.rb
 - lib/ougai/logger.rb
+- lib/ougai/logging.rb
 - lib/ougai/version.rb
+- spec/child_logger_spec.rb
 - spec/formatters/base_spec.rb
 - spec/formatters/readable_spec.rb
 - spec/logger_spec.rb
+- spec/logging_spec.rb
 - spec/ougai_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/tilfin/ougai
@@ -105,6 +109,8 @@ summary: JSON logger compatible with node-bunyan is capable of handling data eas
 test_files:
 - spec/formatters/base_spec.rb
 - spec/formatters/readable_spec.rb
+- spec/child_logger_spec.rb
+- spec/logging_spec.rb
 - spec/logger_spec.rb
 - spec/ougai_spec.rb
 - spec/spec_helper.rb