ougai 1.6.3 → 1.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a3a13441e1374f9f227801a4fa3b01992e05c7f
-  data.tar.gz: 0e2a39093027b4a0ad7c82b2626460ae07225e1a
+  metadata.gz: 023fe0a75fea490d495f73f3ba484240d1b9de15
+  data.tar.gz: e91f1dbf146eafb6e889b2a8efd87e93c13da3c1
 SHA512:
-  metadata.gz: 62426a676338318a26d1c37e72bd9f5221d8f980fc810bb939ac6a19631b77c9a44193f43dc21e31f362e62194f3ee99e4f2fc15e54c9781336beaea571f7802
-  data.tar.gz: 2b027dbbc7bbeff72e7069e0cdf899609a3ca45ec0e0c241349af5025c7b6f2e4e34b93a1401a3edd1677bfcd6c69f1aadc63bfca78c8e4a87090e6f2ab6137f
+  metadata.gz: 27498f3e30636bc343f07d70c088c5801f72d859c93039505f7d566a5c73c0c4443486f6a3d2075ccae1dd7cee38fa009d64413b0d8f3f835e6bd07bd70c7752
+  data.tar.gz: f6600fda8275ffd90f48a0720c768c64cc7d8e0e35c9992dd8d3c496910d64160a445525c53ad6ce0449068d2571d7b5192ec3e23be9ef1cbb93d71ee72e1b0d

data/Gemfile

@@ -6,5 +6,6 @@ gemspec
 group :test do
   gem 'awesome_print'
   gem 'simplecov', require: false
+  gem 'timecop'
   gem 'yard'
 end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ougai (1.6.3)
+    ougai (1.6.4)
       oj (~> 3.4)
 
 GEM
@@ -31,6 +31,7 @@ GEM
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.1)
+    timecop (0.9.1)
     yard (0.9.12)
 
 PLATFORMS
@@ -43,6 +44,7 @@ DEPENDENCIES
   rake (~> 10.0)
   rspec (~> 3.0)
   simplecov
+  timecop
   yard
 
 BUNDLED WITH

data/lib/ougai/formatters/bunyan.rb

@@ -1,16 +1,11 @@
 require 'ougai/formatters/base'
-require 'oj'
 
 module Ougai
   module Formatters
     # A JSON formatter compatible with node-bunyan
-    # @attr [Boolean] jsonize Whether log should converts JSON
-    # @attr [Boolean] with_newline Whether tailing NL should be appended
     class Bunyan < Base
       include ForJson
 
-      attr_accessor :jsonize, :with_newline
-
       # Intialize a formatter
       # @param [String] app_name application name (execution program name if nil)
       # @param [String] hostname hostname (hostname if nil)
@@ -23,8 +18,7 @@ module Ougai
       def initialize(app_name = nil, hostname = nil, opts = {})
         aname, hname, opts = Base.parse_new_params([app_name, hostname, opts])
         super(aname, hname, opts)
-        @jsonize = opts.fetch(:jsonize, true)
-        @with_newline = opts.fetch(:with_newline, true)
+        init_opts_for_json(opts)
       end
 
       def _call(severity, time, progname, data)
@@ -38,17 +32,8 @@ module Ougai
         }.merge(data))
       end
 
-      private
-
-      OJ_OPTIONS = { mode: :custom, time_format: :xmlschema,
-                     use_as_json: true, use_to_hash: true, use_to_json: true }
-
-      def dump(data)
-        return data unless @jsonize
+      def convert_time(data)
         data[:time] = format_datetime(data[:time])
-        str = Oj.dump(data, OJ_OPTIONS)
-        str << "\n" if @with_newline
-        str
       end
     end
   end

data/lib/ougai/formatters/for_json.rb

@@ -1,6 +1,19 @@
+require 'oj'
+
 module Ougai
-  # The features for JSON
+  # The features for JSON formatter
+  # @attr [Boolean] jsonize Whether log should converts JSON
+  # @attr [Boolean] with_newline Whether tailing NL should be appended
   module Formatters::ForJson
+    attr_accessor :jsonize, :with_newline
+
+    protected
+
+    def init_opts_for_json(opts)
+      @jsonize = opts.fetch(:jsonize, true)
+      @with_newline = opts.fetch(:with_newline, true)
+    end
+
     def to_level(severity)
       case severity
       when 'TRACE'
@@ -19,5 +32,17 @@ module Ougai
         70
       end
     end
+
+    OJ_OPTIONS = { mode: :custom, time_format: :xmlschema,
+                   use_as_json: true, use_to_hash: true, use_to_json: true }
+
+    # requires convert_time(data) method
+    def dump(data)
+      return data unless @jsonize
+      convert_time(data)
+      str = Oj.dump(data, OJ_OPTIONS)
+      str << "\n" if @with_newline
+      str
+    end
   end
 end

data/lib/ougai/formatters/pino.rb

@@ -1,16 +1,11 @@
 require 'ougai/formatters/base'
-require 'oj'
 
 module Ougai
   module Formatters
     # A JSON formatter compatible with pino
-    # @attr [Boolean] jsonize Whether log should converts JSON
-    # @attr [Boolean] with_newline Whether tailing NL should be appended
     class Pino < Base
       include ForJson
 
-      attr_accessor :jsonize, :with_newline
-
       # Intialize a formatter
       # @param [String] app_name application name (execution program name if nil)
       # @param [String] hostname hostname (hostname if nil)
@@ -23,8 +18,7 @@ module Ougai
       def initialize(app_name = nil, hostname = nil, opts = {})
         aname, hname, opts = Base.parse_new_params([app_name, hostname, opts])
         super(aname, hname, opts)
-        @jsonize = opts.fetch(:jsonize, true)
-        @with_newline = opts.fetch(:with_newline, true)
+        init_opts_for_json(opts)
         @trace_indent = opts.fetch(:trace_indent, 4)
         @serialize_backtrace = true
       end
@@ -45,8 +39,6 @@ module Ougai
         }.merge(data))
       end
 
-      private
-
       def flat_err(data)
         return unless data.key?(:err)
         err = data.delete(:err)
@@ -58,15 +50,8 @@ module Ougai
         data[:stack] ||= stack
       end
 
-      OJ_OPTIONS = { mode: :custom, time_format: :xmlschema,
-                     use_as_json: true, use_to_hash: true, use_to_json: true }
-
-      def dump(data)
-        return data unless @jsonize
-        data[:time] = data[:time].to_i * 1000
-        str = Oj.dump(data, OJ_OPTIONS)
-        str << "\n" if @with_newline
-        str
+      def convert_time(data)
+        data[:time] = (data[:time].to_f * 1000).to_i
       end
     end
   end

data/lib/ougai/formatters/readable.rb

@@ -14,7 +14,6 @@ module Ougai
       # @param [Hash] opts the initial values of attributes
       # @option opts [String] :trace_indent (4) the value of trace_indent attribute
       # @option opts [String] :trace_max_lines (100) the value of trace_max_lines attribute
-      # @option opts [String] :serialize_backtrace (true) the value of serialize_backtrace attribute
       # @option opts [String] :plain (false) the value of plain attribute
       # @option opts [String] :excluded_fields ([]) the value of excluded_fields attribute
       def initialize(app_name = nil, hostname = nil, opts = {})
@@ -39,7 +38,7 @@ module Ougai
       end
 
       def serialize_backtrace=(value)
-        raise RuntimeError, 'Not support serialize_backtrace'
+        raise NotImplementedError, 'Not support serialize_backtrace'
       end
 
       protected

data/lib/ougai/version.rb

@@ -1,3 +1,3 @@
 module Ougai
-  VERSION = '1.6.3'
+  VERSION = '1.6.4'
 end

data/spec/formatters/base_spec.rb

@@ -4,8 +4,8 @@ describe Ougai::Formatters::Base do
   subject { described_class.new(app_name, hostname) }
 
   context 'default' do
-    let (:app_name) { nil }
-    let (:hostname) { nil }
+    let!(:app_name) { nil }
+    let!(:hostname) { nil }
 
     it 'has datetime format default ISO8601' do
       expect(subject.datetime_format).to match(/^\%FT\%T\.\%3N(Z|\%\:z)$/)
@@ -22,8 +22,8 @@ describe Ougai::Formatters::Base do
   end
 
   context 'without arguments and hostname contains a UTF-8 char' do
-    let (:app_name) { nil }
-    let (:hostname) { nil }
+    let!(:app_name) { nil }
+    let!(:hostname) { nil }
 
     it 'has default app_name and default hostname' do
       myhostname = "Taro\xE2\x80\x99s-MacBook".force_encoding('ASCII-8BIT')
@@ -34,8 +34,8 @@ describe Ougai::Formatters::Base do
   end
 
   context 'with app_name' do
-    let (:app_name) { 'myapp' }
-    let (:hostname) { nil }
+    let!(:app_name) { 'myapp' }
+    let!(:hostname) { nil }
 
     it 'has specified app_name and default hostname' do
       myhostname = "Hanako's PC".encode('ASCII-8BIT')
@@ -46,8 +46,8 @@ describe Ougai::Formatters::Base do
   end
 
   context 'with hostname' do
-    let (:app_name) { nil }
-    let (:hostname) { 'myhost' }
+    let!(:app_name) { nil }
+    let!(:hostname) { 'myhost' }
 
     it 'has default app_name and specified hostname' do
       expect(subject.app_name).to eq('rspec')
@@ -56,8 +56,8 @@ describe Ougai::Formatters::Base do
   end
 
   context 'with app_name and hostname' do
-    let (:app_name) { 'myapp' }
-    let (:hostname) { 'myhost' }
+    let!(:app_name) { 'myapp' }
+    let!(:hostname) { 'myhost' }
 
     it 'has specified app_name and specified hostname' do
       expect(subject.app_name).to eq('myapp')
@@ -66,9 +66,9 @@ describe Ougai::Formatters::Base do
   end
 
   describe '#serialize_exc' do
-    let (:app_name) { 'myapp' }
-    let (:hostname) { 'myhost' }
-    let (:errmsg) { 'dummy error' }
+    let!(:app_name) { 'myapp' }
+    let!(:hostname) { 'myhost' }
+    let!(:errmsg) { 'dummy error' }
 
     it 'returning data with stack as String' do
       begin

data/spec/formatters/bunyan_spec.rb

@@ -10,130 +10,145 @@ describe Ougai::Formatters::Bunyan do
     }
   end
 
+  let(:stack) { "error1.rb\n  error2.rb" }
+
   let(:err) do
     {
       name: 'DummyError',
       message: 'it is dummy.',
-      stack: "error1.rb\n  error2.rb"
+      stack: stack
     }
   end
 
   let(:formatter) { described_class.new }
 
-  context '#initialize' do
-    let(:appname) { 'dummy app name' }
+  include_examples 'formatter#initialize',
+    default_opts: {
+      trace_indent: 2,
+      trace_max_lines: 100,
+      serialize_backtrace: true,
+      jsonize: true,
+      with_newline: true
+    },
+    options: {
+      jsonize: false,
+      with_newline: false
+    }
 
-    it 'suceeds with arguments' do
-      fmt = described_class.new(appname)
-      expect(fmt.app_name).to eq(appname)
-    end
-  end
+  describe '#call' do
+    subject { formatter.call(severity, Time.now, nil, data) }
 
-  context 'jsonize is true and with_newline is true' do
-    subject { formatter.call('DEBUG', Time.now, nil, data) }
+    context 'jsonize is true and with_newline is true' do
+      let!(:severity) { 'DEBUG' }
 
-    it 'includes valid strings' do
-      expect(subject).to end_with("\n")
-      result = JSON.parse(subject.chomp, symbolize_names: true)
-      expect(result).to include(data.merge(level: 20))
-      expect(result[:time]).to match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
+      it 'includes valid strings' do
+        expect(subject).to end_with("\n")
+        result = JSON.parse(subject.chomp, symbolize_names: true)
+        expect(result).to include(data.merge(pid: $$, level: 20, v: 0))
+        expect(result[:time]).to match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
+      end
     end
-  end
 
-  context 'jsonize is false' do
-    before do
-      formatter.jsonize = false
-    end
+    context 'jsonize is false' do
+      before do
+        formatter.jsonize = false
+      end
 
-    context 'when severity is TRACE' do
-      subject { formatter.call('TRACE', Time.now, nil, data) }
+      context 'when severity is TRACE' do
+        let!(:severity) { 'TRACE' }
 
-      it 'includes valid hash' do
-        expect(subject).to include(data.merge(level: 10))
-        expect(subject[:time]).to be_an_instance_of(Time)
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 10, v: 0))
+          expect(subject[:time]).to be_an_instance_of(Time)
+        end
       end
-    end
 
-    context 'when severity is DEBUG' do
-      subject { formatter.call('DEBUG', Time.now, nil, data) }
+      context 'when severity is DEBUG' do
+        let!(:severity) { 'DEBUG' }
 
-      it 'includes valid hash' do
-        expect(subject).to include(data.merge(level: 20))
-        expect(subject[:time]).to be_an_instance_of(Time)
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 20, v: 0))
+          expect(subject[:time]).to be_an_instance_of(Time)
+        end
       end
-    end
 
-    context 'when severity is INFO' do
-      subject { formatter.call('INFO', Time.now, nil, data) }
+      context 'when severity is INFO' do
+        let!(:severity) { 'INFO' }
 
-      it 'includes valid hash' do
-        expect(subject).to include(data.merge(level: 30))
-        expect(subject[:time]).to be_an_instance_of(Time)
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 30, v: 0))
+          expect(subject[:time]).to be_an_instance_of(Time)
+        end
       end
-    end
 
-    context 'when severity is WARN' do
-      subject { formatter.call('WARN', Time.now, nil, data) }
+      context 'when severity is WARN' do
+        let!(:severity) { 'WARN' }
 
-      it 'includes valid hash' do
-        expect(subject).to include(data.merge(level: 40))
-        expect(subject[:time]).to be_an_instance_of(Time)
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 40, v: 0))
+          expect(subject[:time]).to be_an_instance_of(Time)
+        end
       end
-    end
 
-    context 'when severity is ERROR' do
-      subject { formatter.call('ERROR', Time.now, nil, data.merge({ err: err })) }
+      context 'when severity is ERROR' do
+        let!(:severity) { 'ERROR' }
+
+        before { data.merge!({ err: err }) }
 
-      it 'includes valid hash' do
-        expect(subject).to include(level: 50, err: err)
-        expect(subject[:time]).to be_an_instance_of(Time)
+        it 'includes valid hash' do
+          expect(subject).to include(pid: $$, level: 50, v: 0, err: err)
+          expect(subject[:time]).to be_an_instance_of(Time)
+        end
       end
-    end
 
-    context 'when severity is FATAL' do
-      subject { formatter.call('FATAL', Time.now, nil, { msg: 'TheEnd', err: err }) }
+      context 'when severity is FATAL' do
+        let!(:severity) { 'FATAL' }
+        let!(:data) do
+          { msg: 'TheEnd', err: err }
+        end
 
-      it 'includes valid hash' do
-        expect(subject).to include(level: 60, err: err)
-        expect(subject[:time]).to be_an_instance_of(Time)
+        it 'includes valid hash' do
+          expect(subject).to include(pid: $$, level: 60, v: 0, err: err)
+          expect(subject[:time]).to be_an_instance_of(Time)
+        end
       end
-    end
 
-    context 'when severity is UNKNOWN' do
-      subject { formatter.call('ANY', Time.now, nil, { msg: 'unknown msg' }) }
+      context 'when severity is UNKNOWN' do
+        let!(:severity) { 'ANY' }
+        let!(:data) do
+          { msg: 'unknown msg' }
+        end
 
-      it 'includes valid hash' do
-        expect(subject).to include(level: 70, msg: 'unknown msg')
+        it 'includes valid hash' do
+          expect(subject).to include(pid: $$, level: 70, msg: 'unknown msg', v: 0)
+        end
       end
     end
-  end
 
-  context 'with_newline is false' do
-    before do
-      formatter.with_newline = false
-    end
+    context 'with_newline is false' do
+      let!(:severity) { 'INFO' }
 
-    subject { formatter.call('INFO', Time.now, nil, data) }
+      before do
+        formatter.with_newline = false
+      end
 
-    it 'includes valid strings' do
-      expect(subject).not_to end_with("\n")
-      result = JSON.parse(subject, symbolize_names: true)
-      expect(result).to include(data.merge(level: 30))
-      expect(result[:time]).to match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
+      it 'includes valid strings' do
+        expect(subject).not_to end_with("\n")
+        result = JSON.parse(subject, symbolize_names: true)
+        expect(result).to include(data.merge(pid: $$, level: 30, v: 0))
+        expect(result[:time]).to match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
+      end
     end
   end
 
   describe '#datetime_format' do
-    subject do
-      formatter.call('DEBUG', Time.now, nil, data)
-    end
-
     context 'is time AM/PM format' do
       before do
         formatter.datetime_format = '%I:%M:%S %p'
       end
 
       it 'applys output' do
+        subject = formatter.call('DEBUG', Time.now, nil, data)
         result = JSON.parse(subject, symbolize_names: true)
         expect(result[:time]).to match(/^\d{2}:\d{2}:\d{2} [AP]M$/)
       end

data/spec/formatters/pino_spec.rb

@@ -10,127 +10,153 @@ describe Ougai::Formatters::Pino do
     }
   end
 
+  let(:stack) { "error1.rb\n    error2.rb" }
+
   let(:err) do
     {
       name: 'DummyError',
       message: 'it is dummy.',
-      stack: "error1.rb\n    error2.rb"
+      stack: stack
     }
   end
 
   let(:formatter) { described_class.new }
 
-  context '#initialize' do
-    let(:appname) { 'dummy app name' }
+  include_examples 'formatter#initialize',
+    default_opts: {
+      trace_indent: 4,
+      trace_max_lines: 100,
+      serialize_backtrace: true,
+      jsonize: true,
+      with_newline: true
+    },
+    options: {
+      jsonize: false,
+      with_newline: false
+    }
 
-    it 'suceeds with arguments' do
-      fmt = described_class.new(appname)
-      expect(fmt.app_name).to eq(appname)
-    end
-  end
+  describe '#call' do
+    let!(:time_epoc_msec) { 1518710101026 }
 
-  context 'jsonize is true and with_newline is true' do
-    subject { formatter.call('DEBUG', Time.now, nil, data) }
+    before { Timecop.freeze(Time.at(time_epoc_msec / 1000.0)) }
+    after { Timecop.return }
 
-    it 'includes valid strings' do
-      expect(subject).to end_with("\n")
-      result = JSON.parse(subject.chomp, symbolize_names: true)
-      expect(result).to include(data.merge(level: 20))
-      expect(result[:time]).to be > 1518710101026
-    end
-  end
+    subject { formatter.call(severity, Time.now, nil, data) }
 
-  context 'jsonize is false' do
-    before do
-      formatter.jsonize = false
+    context 'jsonize is true and with_newline is true' do
+      let!(:severity) { 'DEBUG' }
+
+      it 'includes valid strings' do
+        expect(subject).to end_with("\n")
+        result = JSON.parse(subject.chomp, symbolize_names: true)
+        expect(result).to include(data.merge(pid: $$, level: 20, time: time_epoc_msec, v: 1))
+      end
     end
 
-    context 'when severity is TRACE' do
-      subject { formatter.call('TRACE', Time.now, nil, data) }
+    context 'jsonize is false' do
+      let!(:time) { Time.at(time_epoc_msec / 1000.0) }
 
-      it 'includes valid hash' do
-        expect(subject).to include(data.merge(level: 10))
-        expect(subject[:time]).to be_an_instance_of(Time)
+      before do
+        formatter.jsonize = false
       end
-    end
 
-    context 'when severity is DEBUG' do
-      subject { formatter.call('DEBUG', Time.now, nil, data) }
+      context 'when severity is TRACE' do
+        let!(:severity) { 'TRACE' }
 
-      it 'includes valid hash' do
-        expect(subject).to include(data.merge(level: 20))
-        expect(subject[:time]).to be_an_instance_of(Time)
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 10, time: time, v: 1))
+        end
       end
-    end
 
-    context 'when severity is INFO' do
-      subject { formatter.call('INFO', Time.now, nil, data) }
+      context 'when severity is DEBUG' do
+        let!(:severity) { 'DEBUG' }
 
-      it 'includes valid hash' do
-        expect(subject).to include(data.merge(level: 30))
-        expect(subject[:time]).to be_an_instance_of(Time)
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 20, time: time, v: 1))
+        end
       end
-    end
 
-    context 'when severity is WARN' do
-      subject { formatter.call('WARN', Time.now, nil, data) }
+      context 'when severity is INFO' do
+        let!(:severity) { 'INFO' }
 
-      it 'includes valid hash' do
-        expect(subject).to include(data.merge(level: 40))
-        expect(subject[:time]).to be_an_instance_of(Time)
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 30, time: time, v: 1))
+        end
       end
-    end
 
-    context 'when severity is ERROR' do
-      subject {
-        data.delete(:msg)
-        formatter.call('ERROR', Time.now, nil, data.merge({ err: err }))
-      }
-
-      it 'includes valid hash' do
-        expect(subject).to include({
-          level: 50, type: 'Error',
-          msg: 'it is dummy.',
-          stack: "DummyError: it is dummy.\n    error1.rb\n    error2.rb"
-        })
-        expect(subject[:time]).to be_an_instance_of(Time)
+      context 'when severity is WARN' do
+        let!(:severity) { 'WARN' }
+
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 40, time: time, v: 1))
+        end
       end
-    end
 
-    context 'when severity is FATAL' do
-      subject { formatter.call('FATAL', Time.now, nil, { msg: 'TheEnd', err: err }) }
+      context 'when severity is ERROR' do
+        let!(:severity) { 'ERROR' }
+
+        before do
+          data.delete(:msg)
+          data.merge!({ err: err })
+        end
+
+        it 'includes valid hash' do
+          expect(subject).to include({
+            pid: $$, level: 50, time: time, v: 1,
+            type: 'Error',
+            msg: 'it is dummy.',
+            stack: "DummyError: it is dummy.\n    #{stack}"
+          })
+        end
+      end
 
-      it 'includes valid hash' do
-        expect(subject).to include({
-          level: 60, type: 'Error',
-          msg: 'TheEnd',
-          stack: "DummyError: it is dummy.\n    error1.rb\n    error2.rb"
-        })
-        expect(subject[:time]).to be_an_instance_of(Time)
+      context 'when severity is FATAL and trace_indent = 2' do
+        let!(:severity) { 'FATAL' }
+
+        let!(:data) do
+          { msg: 'TheEnd', err: err }
+        end
+
+        before do
+          formatter.trace_indent = 2
+          stack.gsub!(/    /, '  ')
+        end
+
+        it 'includes valid hash' do
+          expect(subject).to include({
+            pid: $$, level: 60, time: time, v: 1,
+            type: 'Error',
+            msg: 'TheEnd',
+            stack: "DummyError: it is dummy.\n  #{stack}",
+          })
+        end
       end
-    end
 
-    context 'when severity is UNKNOWN' do
-      subject { formatter.call('ANY', Time.now, nil, { msg: 'unknown msg' }) }
+      context 'when severity is UNKNOWN' do
+        let!(:severity) { 'ANY' }
 
-      it 'includes valid hash' do
-        expect(subject).to include(level: 70, msg: 'unknown msg')
+        let!(:data) do
+          { msg: 'unknown msg' }
+        end
+
+        it 'includes valid hash' do
+          expect(subject).to include(pid: $$, level: 70, time: time, msg: 'unknown msg')
+        end
       end
     end
-  end
 
-  context 'with_newline is false' do
-    before do
-      formatter.with_newline = false
-    end
+    context 'with_newline is false' do
+      let!(:severity) { 'INFO' }
 
-    subject { formatter.call('INFO', Time.now, nil, data) }
+      before do
+        formatter.with_newline = false
+      end
 
-    it 'includes valid strings' do
-      expect(subject).not_to end_with("\n")
-      result = JSON.parse(subject, symbolize_names: true)
-      expect(result).to include(data.merge(level: 30))
-      expect(result[:time]).to be > 1518710101026
+      it 'includes valid strings' do
+        expect(subject).not_to end_with("\n")
+        result = JSON.parse(subject, symbolize_names: true)
+        expect(result).to include(data.merge(level: 30, time: time_epoc_msec))
+      end
     end
   end
 

data/spec/formatters/readable_spec.rb

@@ -22,6 +22,19 @@ describe Ougai::Formatters::Readable do
 
   let(:formatter) { described_class.new }
 
+  include_examples 'formatter#initialize',
+    default_opts: {
+      trace_indent: 4,
+      trace_max_lines: 100,
+      serialize_backtrace: true,
+      plain: false,
+      excluded_fields: []
+    },
+    options: {
+      plain: true,
+      excluded_fields: [:card_number]
+    }
+
   context 'when severity is TRACE' do
     subject { formatter.call('TRACE', Time.now, nil, data) }
 
@@ -120,4 +133,10 @@ describe Ougai::Formatters::Readable do
       end
     end
   end
+
+  describe '#serialize_backtrace' do
+    it 'is not supported' do
+      expect{ formatter.serialize_backtrace = false }.to raise_error(NotImplementedError)
+    end
+  end
 end

data/spec/logging_spec.rb

@@ -1,12 +1,15 @@
 require 'spec_helper'
 
 describe Ougai::Logging do
-  describe '#weak_merge!' do
-    let(:target) { m = described_class; Class.new{ include m }.new }
+  subject do
+    m = described_class
+    Class.new { include m }.new
+  end
 
+  describe '#weak_merge!' do
     it 'merges with unique elements in array' do
       result = nil
-      target.instance_eval do
+      subject.instance_eval do
         result = weak_merge!({ foo: [1, 2], bar: 'base', baz: ['A'] },
                              { foo: [2, 3], bar: 'inferior', baz: ['B'] })
       end
@@ -15,4 +18,37 @@ describe Ougai::Logging do
       expect(result[:baz]).to eq(['B', 'A'])
     end
   end
+
+  describe '#child' do
+    let!(:fields) { double('fields') }
+    let!(:child_logger) { double('child logger') }
+
+    context 'block is not given' do
+      it 'returns child logger' do
+        expect(Ougai::ChildLogger).to receive(:new).with(subject, fields).and_return(child_logger)
+        expect(subject.child(fields)).to eq(child_logger)
+      end
+    end
+
+    context 'block is given' do
+      it 'passes child logger' do
+        expect(Ougai::ChildLogger).to receive(:new).with(subject, fields).and_return(child_logger)
+        subject.child(fields) do |cl|
+          expect(cl).to eq(child_logger)
+        end
+      end
+    end
+  end
+
+  describe '#chain' do
+    it 'is not implemented' do
+      expect{ subject.chain(:arg1, :arg2, :arg3, :arg4) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#append' do
+    it 'is not implemented' do
+      expect{ subject.send(:append, :arg1, :arg2) }.to raise_error(NotImplementedError)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+require 'timecop'
 require 'simplecov'
 SimpleCov.start do
   add_filter "/spec/"
@@ -5,3 +6,73 @@ end
 
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'ougai'
+
+RSpec.shared_examples 'formatter#initialize' do |params|
+    describe '#initialize' do
+    let(:app_name) { 'dummy app name' }
+    let(:hostname) { 'dummyhost' }
+    let(:options) { params[:options] }
+
+    subject { described_class.new(*arguments) }
+
+    context 'with app_name' do
+      let!(:arguments) { [app_name] }
+
+      it 'creates an instance with valid app_name and hostname' do
+        expect(subject.app_name).to eq(app_name)
+        expect(subject.hostname).to eq(Socket.gethostname.force_encoding('UTF-8'))
+        params[:default_opts].each do |key, val|
+          expect(subject.send(key)).to eq(val)
+        end
+      end
+    end
+
+    context 'with options' do
+      let!(:arguments) { [options] }
+
+      it 'creates an instance with valid values for attributes' do
+        expect(subject.app_name).to eq('rspec')
+        expect(subject.hostname).to eq(Socket.gethostname.force_encoding('UTF-8'))
+        options.each do |key, val|
+          expect(subject.send(key)).to eq(val)
+        end
+      end
+    end
+
+    context 'with app_name and hostname' do
+      let!(:arguments) { [app_name, hostname] }
+
+      it 'creates an instance with valid app_name and hostname' do
+        expect(subject.app_name).to eq(app_name)
+        expect(subject.hostname).to eq(hostname)
+        params[:default_opts].each do |key, val|
+          expect(subject.send(key)).to eq(val)
+        end
+      end
+    end
+
+    context 'with app_name and options' do
+      let!(:arguments) { [app_name, options] }
+
+      it 'creates an instance with valid values for attributes' do
+        expect(subject.app_name).to eq(app_name)
+        expect(subject.hostname).to eq(Socket.gethostname.force_encoding('UTF-8'))
+        options.each do |key, val|
+          expect(subject.send(key)).to eq(val)
+        end
+      end
+    end
+
+    context 'with app_name, hostname and options' do
+      let!(:arguments) { [app_name, hostname, options] }
+
+      it 'creates an instance with valid values for attributes' do
+        expect(subject.app_name).to eq(app_name)
+        expect(subject.hostname).to eq(hostname)
+        options.each do |key, val|
+          expect(subject.send(key)).to eq(val)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ougai
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.6.4
 platform: ruby
 authors:
 - Toshimitsu Takahashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-15 00:00:00.000000000 Z
+date: 2018-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj