ougai 1.7.1-java

data/spec/formatters/base_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Ougai::Formatters::Base do
+  subject { described_class.new(app_name, hostname) }
+
+  context 'default' do
+    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)$/)
+    end
+
+    it 'has datetime_format accessor' do
+      subject.datetime_format = '%I:%M:%S %p'
+      expect(subject.datetime_format).to eq('%I:%M:%S %p')
+
+      # revert default format by to set nil
+      subject.datetime_format = nil
+      expect(subject.datetime_format).to match(/^\%FT\%T\.\%3N(Z|\%\:z)$/)
+    end
+  end
+
+  context 'without arguments and hostname contains a UTF-8 char' do
+    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')
+      allow(Socket).to receive(:gethostname).and_return(myhostname)
+      expect(subject.app_name).to eq('rspec')
+      expect(subject.hostname).to eq("Taro’s-MacBook")
+    end
+  end
+
+  context 'with app_name' do
+    let!(:app_name) { 'myapp' }
+    let!(:hostname) { nil }
+
+    it 'has specified app_name and default hostname' do
+      myhostname = "Hanako's PC".encode('ASCII-8BIT')
+      allow(Socket).to receive(:gethostname).and_return(myhostname)
+      expect(subject.app_name).to eq('myapp')
+      expect(subject.hostname).to eq("Hanako's PC")
+    end
+  end
+
+  context 'with hostname' do
+    let!(:app_name) { nil }
+    let!(:hostname) { 'myhost' }
+
+    it 'has default app_name and specified hostname' do
+      expect(subject.app_name).to eq('rspec')
+      expect(subject.hostname).to eq('myhost')
+    end
+  end
+
+  context 'with app_name and hostname' do
+    let!(:app_name) { 'myapp' }
+    let!(:hostname) { 'myhost' }
+
+    it 'has specified app_name and specified hostname' do
+      expect(subject.app_name).to eq('myapp')
+      expect(subject.hostname).to eq('myhost')
+    end
+  end
+
+  describe '#serialize_exc' do
+    let!(:app_name) { 'myapp' }
+    let!(:hostname) { 'myhost' }
+    let!(:errmsg) { 'dummy error' }
+
+    it 'returning data with stack as String' do
+      begin
+        raise errmsg
+      rescue => e
+        result = subject.serialize_exc(e)
+      end        
+      expect(result[:message]).to eq(errmsg)
+      expect(result[:stack]).to be_instance_of(String)
+    end
+
+    context 'not serialize backtrace' do
+      it 'returning data with stack as Array' do
+        subject.serialize_backtrace = false
+        subject.trace_max_lines = 6
+        begin
+          raise errmsg
+        rescue => e
+          result = subject.serialize_exc(e)
+        end        
+        expect(result[:message]).to eq(errmsg)
+        expect(result[:stack]).to be_instance_of(Array)
+        expect(result[:stack].size).to eq(6)
+      end
+    end
+  end
+end

data/spec/formatters/bunyan_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Ougai::Formatters::Bunyan do
+  let(:data) do
+    {
+      msg: 'Log Message!',
+      status: 200,
+      method: 'GET',
+      path: '/'
+    }
+  end
+
+  let(:stack) { "error1.rb\n  error2.rb" }
+
+  let(:err) do
+    {
+      name: 'DummyError',
+      message: 'it is dummy.',
+      stack: stack
+    }
+  end
+
+  let(:formatter) { described_class.new }
+
+  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
+    }
+
+  describe '#call' do
+    subject { formatter.call(severity, 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(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
+
+    context 'jsonize is false' do
+      before do
+        formatter.jsonize = false
+      end
+
+      context 'when severity is TRACE' do
+        let!(:severity) { 'TRACE' }
+
+        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
+
+      context 'when severity is DEBUG' do
+        let!(:severity) { 'DEBUG' }
+
+        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
+
+      context 'when severity is INFO' do
+        let!(:severity) { 'INFO' }
+
+        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
+
+      context 'when severity is WARN' do
+        let!(:severity) { 'WARN' }
+
+        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
+
+      context 'when severity is ERROR' do
+        let!(:severity) { 'ERROR' }
+
+        before { data.merge!({ err: err }) }
+
+        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
+
+      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(pid: $$, level: 60, v: 0, err: err)
+          expect(subject[:time]).to be_an_instance_of(Time)
+        end
+      end
+
+      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(pid: $$, level: 70, msg: 'unknown msg', v: 0)
+        end
+      end
+    end
+
+    context 'with_newline is false' do
+      let!(:severity) { 'INFO' }
+
+      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(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
+    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
+    end
+  end
+end

data/spec/formatters/pino_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Ougai::Formatters::Pino do
+  let(:data) do
+    {
+      msg: 'Log Message!',
+      status: 200,
+      method: 'GET',
+      path: '/'
+    }
+  end
+
+  let(:stack) { "error1.rb\n    error2.rb" }
+
+  let(:err) do
+    {
+      name: 'DummyError',
+      message: 'it is dummy.',
+      stack: stack
+    }
+  end
+
+  let(:formatter) { described_class.new }
+
+  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
+    }
+
+  describe '#call' do
+    let!(:time_epoc_msec) { 1518710101026 }
+
+    before { Timecop.freeze(Time.at(time_epoc_msec / 1000.0)) }
+    after { Timecop.return }
+
+    subject { formatter.call(severity, 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(pid: $$, level: 20, time: time_epoc_msec, v: 1))
+      end
+    end
+
+    context 'jsonize is false' do
+      let!(:time) { Time.at(time_epoc_msec / 1000.0) }
+
+      before do
+        formatter.jsonize = false
+      end
+
+      context 'when severity is TRACE' do
+        let!(:severity) { 'TRACE' }
+
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 10, time: time, v: 1))
+        end
+      end
+
+      context 'when severity is DEBUG' do
+        let!(:severity) { 'DEBUG' }
+
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 20, time: time, v: 1))
+        end
+      end
+
+      context 'when severity is INFO' do
+        let!(:severity) { 'INFO' }
+
+        it 'includes valid hash' do
+          expect(subject).to include(data.merge(pid: $$, level: 30, time: time, v: 1))
+        end
+      end
+
+      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
+
+      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
+
+      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
+
+      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(pid: $$, level: 70, time: time, msg: 'unknown msg')
+        end
+      end
+    end
+
+    context 'with_newline is false' do
+      let!(:severity) { 'INFO' }
+
+      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, time: time_epoc_msec))
+      end
+    end
+  end
+
+  describe '#datetime_format' do
+    it 'is not supported' do
+      expect{ formatter.datetime_format = '%I:%M:%S %p' }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/formatters/readable_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Ougai::Formatters::Readable do
+  let!(:re_start_with_datetime) { /^\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}(Z|[\+\-\:0-9]{4,6})\]/ }
+
+  let(:data) do
+    {
+      msg: 'Log Message!',
+      status: 200,
+      method: 'GET',
+      path: '/'
+    }
+  end
+
+  let(:err) do
+    {
+      name: 'DummyError',
+      message: 'it is dummy.',
+      stack: "error1.rb\n  error2.rb"
+    }
+  end
+
+  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) }
+
+    it 'includes valid strings' do
+      expect(subject).to match(re_start_with_datetime)
+      expect(subject).to include("\e[0;34mTRACE\e[0m: Log Message!")
+      expect(subject.gsub(/\e\[([;\d]+)?m/, '')).to include(':status => 200')
+    end
+  end
+
+  context 'when severity is DEBUG' do
+    subject { formatter.call('DEBUG', Time.now, nil, data) }
+
+    it 'includes valid strings' do
+      expect(subject).to match(re_start_with_datetime)
+      expect(subject).to include("\e[0;37mDEBUG\e[0m: Log Message!")
+      expect(subject.gsub(/\e\[([;\d]+)?m/, '')).to include(':status => 200')
+    end
+  end
+
+  context 'when severity is INFO' do
+    subject { formatter.call('INFO', Time.now, nil, data) }
+
+    it 'includes valid strings' do
+      expect(subject).to match(re_start_with_datetime)
+      expect(subject).to include("\e[0;36mINFO\e[0m: Log Message!")
+      expect(subject.gsub(/\e\[([;\d]+)?m/, '')).to include(':method => "GET"')
+    end
+  end
+
+  context 'when severity is WARN' do
+    subject { formatter.call('WARN', Time.now, nil, data) }
+
+    it 'includes valid strings' do
+      expect(subject).to match(re_start_with_datetime)
+      expect(subject).to include("\e[0;33mWARN\e[0m: Log Message!")
+      expect(subject.gsub(/\e\[([;\d]+)?m/, '')).to include(':path => "/"')
+    end
+  end
+
+  context 'when severity is ERROR' do
+    subject { formatter.call('ERROR', Time.now, nil, data.merge({ err: err })) }
+
+    it 'includes valid strings' do
+      expect(subject).to match(re_start_with_datetime)
+      expect(subject).to include("\e[0;31mERROR\e[0m: Log Message!")
+      expect(subject.gsub(/\e\[([;\d]+)?m/, '')).to include('DummyError (it is dummy.):')
+    end
+  end
+
+  context 'when severity is FATAL' do
+    subject { formatter.call('FATAL', Time.now, nil, { msg: 'TheEnd', err: err }) }
+
+    it 'includes valid strings' do
+      expect(subject).to match(re_start_with_datetime)
+      expect(subject).to include("\e[0;35mFATAL\e[0m: TheEnd")
+      expect(subject.gsub(/\e\[([;\d]+)?m/, '')).to include("error1.rb\n  error2.rb")
+    end
+  end
+
+  context 'when severity is UNKNOWN' do
+    subject { formatter.call('ANY', Time.now, nil, { msg: 'unknown msg' }) }
+
+    it 'includes valid strings' do
+      expect(subject).to match(re_start_with_datetime)
+      expect(subject).to include("\e[0;32mANY\e[0m: unknown msg")
+    end
+  end
+
+  context 'when logger has excluded_fields' do
+    subject do
+      described_class.new(excluded_fields: [:status, :method]).call('DEBUG', Time.now, nil, data)
+    end
+
+    it 'includes valid strings' do
+      expect(subject).to include("\e[0;37mDEBUG\e[0m: Log Message!")
+      plain_subject = subject.gsub(/\e\[([;\d]+)?m/, '')
+      expect(plain_subject).to include(':path => "/"')
+      expect(plain_subject).not_to include(':status => 200')
+      expect(plain_subject).not_to include(':method => "GET"')
+    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
+        expect(subject).to match(/^\[\d{2}:\d{2}:\d{2} [AP]M\]/)
+      end
+    end
+  end
+
+  describe '#serialize_backtrace' do
+    it 'is not supported' do
+      expect{ formatter.serialize_backtrace = false }.to raise_error(NotImplementedError)
+    end
+  end
+end