ougai 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 234c84c3f7a6eaf7d2dd0ab32c55d4ffa8afda98
-  data.tar.gz: 98776af529bf24129daa4826d19d490946fea410
+  metadata.gz: 7662273f5608fda137ffbfb6286a7361cef52dc5
+  data.tar.gz: f500797dfdcd3b6c75b58c17c7644df8fb786430
 SHA512:
-  metadata.gz: 370dfb4b6d00241c264f29832347ec9184ce453f2287cc62392cbd8338d0110e0676da2b42ae48fe4c97e1a0f4ed8ee4433b13eb056e566354d41b9766e71925
-  data.tar.gz: 637d1b0e58e79d4531b2981728cd8f4109f64b7a8e28ee188fa34f31b11f51e3d86e7abbff3c66d38900752801addde63a0b3f0d07891bfaf9c9befe1d8c43f7
+  metadata.gz: 4d7247de5ed99e0a7cfb45bd99e4da264262ea237e0ab0c4e1720396bd8acd973d0f93f2880841f62f0ffcfaf7f9b089bf966b349d59434823b871bfaa4a49f9
+  data.tar.gz: af91ab240776919d8a17262f7a3cc5dee143041c04fb2cbb303f9515b2b06abdb50bf224928f210e1864ffae6f9ed7f6a8cd541b58e236da849386af1ee4d788

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/coverage/

data/Gemfile

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

data/README.md

@@ -3,6 +3,8 @@ Ougai
 
 [![Gem Version](https://badge.fury.io/rb/ougai.svg)](https://badge.fury.io/rb/ougai)
 [![Build Status](https://travis-ci.org/tilfin/ougai.svg?branch=master)](https://travis-ci.org/tilfin/ougai)
+[![Code Climate](https://codeclimate.com/github/tilfin/ougai/badges/gpa.svg)](https://codeclimate.com/github/tilfin/ougai)
+[![Test Coverage](https://codeclimate.com/github/tilfin/ougai/badges/coverage.svg)](https://codeclimate.com/github/tilfin/ougai/coverage)
 
 A JSON logging system is capable of handling a message, data or an exception easily.
 It is compatible with [Bunyan](https://github.com/trentm/node-bunyan) for Node.js.

data/lib/ougai/formatters/bunyan.rb

@@ -25,6 +25,8 @@ module Ougai
           50
         when 'FATAL'
           60
+        when 'ANY'
+          70
         else # DEBUG
           20
         end

data/lib/ougai/logger.rb

@@ -14,51 +14,37 @@ module Ougai
 
     def debug(message = nil, ex = nil, data = nil, &block)
       return true if level > DEBUG
-      if block_given?
-        args = yield
-      else
-        args = [message, ex, data]
-      end
-      super(to_item(args), &nil)
+      args = block ? yield : [message, ex, data]
+      add(DEBUG, to_item(args))
     end
 
-    def info(message = nil, ex = nil, data = nil)
+    def info(message = nil, ex = nil, data = nil, &block)
       return true if level > INFO
-      if block_given?
-        args = yield
-      else
-        args = [message, ex, data]
-      end
-      super(to_item(args), &nil)
+      args = block ? yield : [message, ex, data]
+      add(INFO, to_item(args))
     end
 
-    def warn(message = nil, ex = nil, data = nil)
+    def warn(message = nil, ex = nil, data = nil, &block)
       return true if level > WARN
-      if block_given?
-        args = yield
-      else
-        args = [message, ex, data]
-      end
-      super(to_item(args), &nil)
+      args = block ? yield : [message, ex, data]
+      add(WARN, to_item(args))
     end
 
-    def error(message = nil, ex = nil, data = nil)
+    def error(message = nil, ex = nil, data = nil, &block)
       return true if level > ERROR
-      if block_given?
-        args = yield
-      else
-        args = [message, ex, data]
-      end
-      super(to_item(args), &nil)
+      args = block ? yield : [message, ex, data]
+      add(ERROR, to_item(args))
     end
 
-    def fatal(message = nil, ex = nil, data = nil)
-      if block_given?
-        args = yield
-      else
-        args = [message, ex, data]
-      end
-      super(to_item(args), &nil)
+    def fatal(message = nil, ex = nil, data = nil, &block)
+      return true if level > FATAL
+      args = block ? yield : [message, ex, data]
+      add(FATAL, to_item(args))
+    end
+
+    def unknown(message = nil, ex = nil, data = nil, &block)
+      args = block ? yield : [message, ex, data]
+      add(UNKNOWN, to_item(args))
     end
 
     def self.broadcast(logger)
@@ -85,39 +71,55 @@ module Ougai
     def to_item(args)
       msg, ex, data = args
 
+      if ex.nil?
+        create_item_with_1arg(msg)
+      elsif data.nil?
+        create_item_with_2args(msg, ex)
+      elsif msg
+        create_item_with_3args(msg, ex, data)
+      else # No args
+        { msg: @default_message }
+      end
+    end
+
+    def create_item_with_1arg(msg)
       item = {}
-      if ex.nil?       # 1 arg
+      if msg.is_a?(Exception)
+        item[:msg] = msg.to_s
+        set_exc(item, msg)
+      elsif msg.is_a?(Hash)
+        item[:msg] = @default_message unless msg.key?(:msg)
+        item.merge!(msg)
+      else
+        item[:msg] = msg.to_s
+      end
+      item
+    end
+
+    def create_item_with_2args(msg, ex)
+      item = {}
+      if ex.is_a?(Exception)
+        item[:msg] = msg.to_s
+        set_exc(item, ex)
+      elsif ex.is_a?(Hash)
+        item.merge!(ex)
         if msg.is_a?(Exception)
-          item[:msg] = msg.to_s
           set_exc(item, msg)
-        elsif msg.is_a?(Hash)
-          item[:msg] = @default_message unless msg.key?(:msg)
-          item.merge!(msg)
         else
           item[:msg] = msg.to_s
         end
-      elsif data.nil?  # 2 args
-        if ex.is_a?(Exception)
-          item[:msg] = msg.to_s
-          set_exc(item, ex)
-        elsif ex.is_a?(Hash)
-          item.merge!(ex)
-          if msg.is_a?(Exception)
-            set_exc(item, msg)
-          else
-            item[:msg] = msg.to_s
-          end
-        end
-      elsif msg        # 3 args
-        set_exc(item, ex) if ex.is_a?(Exception)
-        item.merge!(data) if data.is_a?(Hash)
-        item[:msg] = msg.to_s
-      else             # No args
-        item[:msg] = @default_message
       end
       item
     end
 
+    def create_item_with_3args(msg, ex, data)
+      item = {}
+      set_exc(item, ex) if ex.is_a?(Exception)
+      item.merge!(data) if data.is_a?(Hash)
+      item[:msg] = msg.to_s
+      item
+    end
+
     def set_exc(item, exc)
       item[@exc_key] = @formatter.serialize_exc(exc)
     end

data/lib/ougai/version.rb

@@ -1,3 +1,3 @@
 module Ougai
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/spec/formatters/base_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Ougai::Formatters::Base do
+  subject { described_class.new(app_name, hostname) }
+
+  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
+end

data/spec/formatters/readable_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Ougai::Formatters::Readable do
+  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
+
+  context 'when severity is DEBUG' do
+    subject { described_class.new.call('DEBUG', Time.now, nil, data) }
+
+    it 'includes valid strings' do
+      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 { described_class.new.call('INFO', Time.now, nil, data) }
+
+    it 'includes valid strings' do
+      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 { described_class.new.call('WARN', Time.now, nil, data) }
+
+    it 'includes valid strings' do
+      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 { described_class.new.call('ERROR', Time.now, nil, data.merge({ err: err })) }
+
+    it 'includes valid strings' do
+      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 { described_class.new.call('FATAL', Time.now, nil, { msg: 'TheEnd', err: err }) }
+    it 'includes valid strings' do
+      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
+end

data/spec/logger_spec.rb

@@ -0,0 +1,461 @@
+require 'spec_helper'
+require 'stringio'
+require 'json'
+
+describe Ougai::Logger 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
+
+  matcher :include_data do |data|
+    match do |actual|
+      data.each do |key, expected|
+        return false unless actual[key] == expected
+      end
+      true
+    end
+  end
+
+  matcher :include_error do |expected|
+    match do |actual|
+      err = actual[:err]
+      err[:message] == expected \
+        && err[:name] = 'StandardError' \
+        && err[:stack].include?('ougai/spec')
+    end
+  end
+
+  let(:io) { StringIO.new }
+  let(:logger) { described_class.new(io) }
+
+  let(:item) do
+    log_str = io.string
+    begin
+      JSON.parse(log_str, symbolize_names: true)
+    rescue Exception => e
+      nil
+    end 
+  end
+
+  shared_examples 'log' do
+    context 'with message' do
+      it 'outputs valid' do
+        logger.send(method, log_msg)
+        expect(item).to be_log_message(log_msg, log_level)
+      end
+
+      it 'outputs valid by block' do
+        logger.send(method) { log_msg }
+        expect(item).to be_log_message(log_msg, log_level)
+      end
+    end
+
+    context 'with exception' do
+      it 'outputs valid' do
+        begin
+          raise StandardError, 'errmsg'
+        rescue => ex
+          logger.send(method, ex)
+        end
+
+        expect(item).to be_log_message('errmsg', log_level)
+        expect(item).to include_error('errmsg')
+      end
+
+      it 'outputs valid by block' do
+        begin
+          raise StandardError, 'errmsg'
+        rescue => ex
+          logger.send(method) { ex }
+        end
+
+        expect(item).to be_log_message('errmsg', log_level)
+        expect(item).to include_error('errmsg')
+      end
+    end
+
+    context 'with data that contains msg' do
+      it 'outputs valid' do
+        logger.send(method, { msg: log_msg, data_id: 108, action: 'dump' })
+        expect(item).to be_log_message(log_msg, log_level)
+        expect(item).to include_data(data_id: 108, action: 'dump')
+      end
+
+      it 'outputs valid by block' do
+        logger.send(method) do
+          { msg: log_msg, data_id: 108, action: 'dump' }
+        end
+        expect(item).to be_log_message(log_msg, log_level)
+        expect(item).to include_data(data_id: 108, action: 'dump')
+      end
+    end
+
+    context 'with data that does not contain msg' do
+      it 'outputs valid' do
+        logger.send(method, { data_id: 109, action: 'dump' })
+        expect(item).to be_log_message('No message', log_level)
+        expect(item).to include_data(data_id: 109, action: 'dump')
+      end
+
+      it 'outputs valid by block' do
+        logger.send(method) do
+          { data_id: 109, action: 'dump' }
+        end
+        expect(item).to be_log_message('No message', log_level)
+        expect(item).to include_data(data_id: 109, action: 'dump')
+      end
+    end
+
+    context 'with message and data' do
+      it 'outputs valid' do
+        logger.send(method, log_msg, data_id: 99, action: 'insert')
+        expect(item).to be_log_message(log_msg, log_level)
+        expect(item).to include_data(data_id: 99, action: 'insert')
+      end
+
+      it 'outputs valid by block' do
+        logger.send(method) { [log_msg, data_id: 99, action: 'insert'] }
+        expect(item).to be_log_message(log_msg, log_level)
+        expect(item).to include_data(data_id: 99, action: 'insert')
+      end
+    end
+
+    context 'with message and exception' do
+      it 'outputs valid' do
+        begin
+          raise StandardError, 'errmsg'
+        rescue => ex
+          logger.send(method, log_msg, ex)
+        end
+
+        expect(item).to be_log_message(log_msg, log_level)
+        expect(item).to include_error('errmsg')
+      end
+
+      it 'outputs valid by block' do
+        begin
+          raise StandardError, 'errmsg'
+        rescue => ex
+          logger.send(method) { [log_msg, ex] }
+        end
+
+        expect(item).to be_log_message(log_msg, log_level)
+        expect(item).to include_error('errmsg')
+      end
+    end
+
+    context 'with exception and data' do
+      it 'outputs valid' do
+        begin
+          raise StandardError, 'errmsg'
+        rescue => ex
+          logger.send(method, ex, something: { name: 'bar' })
+        end
+
+        expect(item).to include_error('errmsg')
+        expect(item).to include_data(something: { name: 'bar' })
+      end
+
+      it 'outputs valid by block' do
+        begin
+          raise StandardError, 'errmsg'
+        rescue => ex
+          logger.send(method) do
+            [ex, something: { name: 'bar' }]
+          end
+        end
+
+        expect(item).to include_error('errmsg')
+        expect(item).to include_data(something: { name: 'bar' })
+      end
+    end
+
+    context 'with message, exception and data' do
+      it 'outputs valid' do
+        begin
+          raise StandardError, 'errmsg'
+        rescue => ex
+          logger.send(method, log_msg, ex, something: { name: 'foo' })
+        end
+
+        expect(item).to be_log_message(log_msg, log_level)
+        expect(item).to include_error('errmsg')
+        expect(item).to include_data(something: { name: 'foo' })
+      end
+
+      it 'outputs valid by block' do
+        begin
+          raise StandardError, 'errmsg'
+        rescue => ex
+          logger.send(method) do
+            [log_msg, ex, something: { name: 'foo' }]
+          end
+        end
+
+        expect(item).to be_log_message(log_msg, log_level)
+        expect(item).to include_error('errmsg')
+        expect(item).to include_data(something: { name: 'foo' })
+      end
+    end
+  end
+
+  describe '#debug' do
+    let(:log_level) { 20 }
+    let(:log_msg) { 'debug message' }
+    let(:method) { 'debug' }
+
+    it_behaves_like 'log'
+  end
+
+  describe '#info' do
+    let(:log_level) { 30 }
+    let(:log_msg) { 'info message' }
+    let(:method) { 'info' }
+
+    it_behaves_like 'log'
+  end
+
+  describe '#warn' do
+    let(:log_level) { 40 }
+    let(:log_msg) { 'info message' }
+    let(:method) { 'warn' }
+
+    it_behaves_like 'log'
+  end
+
+  describe '#error' do
+    let(:log_level) { 50 }
+    let(:log_msg) { 'error message' }
+    let(:method) { 'error' }
+
+    it_behaves_like 'log'
+  end
+
+  describe '#fatal' do
+    let(:log_level) { 60 }
+    let(:log_msg) { 'fatal message' }
+    let(:method) { 'fatal' }
+
+    it_behaves_like 'log'
+  end
+
+  describe '#level' do
+    context 'DEBUG' do
+      let(:log_msg) { 'log message' }
+      before { 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
+
+      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
+
+      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 'INFO' do
+      let(:log_msg) { 'log message' }
+      before { 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
+
+      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
+
+      it 'outputs unknown message' do
+        logger.unknown(log_msg)
+        expect(item).to be_log_message(log_msg, 70)
+      end
+    end
+
+    context 'WARN' do
+      let(:log_msg) { 'log message' }
+      before { logger.level = Logger::WARN }
+
+      it 'does not output debug message' do
+        logger.debug(log_msg)
+        expect(item).to be_nil
+      end
+
+      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
+
+      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 'ERROR' do
+      let(:log_msg) { 'log message' }
+      before { logger.level = Logger::ERROR }
+
+      it 'does not output debug message' do
+        logger.debug(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'does not output info message' do
+        logger.info(log_msg)
+        expect(item).to be_nil
+      end
+
+      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
+
+      it 'outputs unknown message' do
+        logger.unknown(log_msg)
+        expect(item).to be_log_message(log_msg, 70)
+      end
+    end
+
+    context 'FATAL' do
+      let(:log_msg) { 'log message' }
+      before { logger.level = Logger::FATAL }
+
+      it 'does not output debug message' do
+        logger.debug(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'does not output info message' do
+        logger.info(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'does not output warning message' do
+        logger.warn(log_msg)
+        expect(item).to be_nil
+      end
+
+      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 { logger.level = Logger::UNKNOWN }
+
+      it 'does not output debug message' do
+        logger.debug(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'does not output info message' do
+        logger.info(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'does not output warning message' do
+        logger.warn(log_msg)
+        expect(item).to be_nil
+      end
+
+      it 'does not output error message' do
+        logger.error(log_msg)
+        expect(item).to be_nil
+      end
+
+      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
+end

data/spec/ougai_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Ougai do
+  it 'has a version number' do
+    expect(Ougai::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'ougai'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ougai
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Toshimitsu Takahashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-24 00:00:00.000000000 Z
+date: 2017-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -62,9 +62,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".rspec"
-- ".travis.yml"
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -74,7 +73,11 @@ files:
 - lib/ougai/formatters/readable.rb
 - lib/ougai/logger.rb
 - lib/ougai/version.rb
-- ougai.gemspec
+- spec/formatters/base_spec.rb
+- spec/formatters/readable_spec.rb
+- spec/logger_spec.rb
+- spec/ougai_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/tilfin/ougai
 licenses:
 - MIT
@@ -99,4 +102,9 @@ rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: JSON logger compatible with node-bunyan is capable of handling data easily.
-test_files: []
+test_files:
+- spec/formatters/base_spec.rb
+- spec/formatters/readable_spec.rb
+- spec/logger_spec.rb
+- spec/ougai_spec.rb
+- spec/spec_helper.rb

data/.rspec

@@ -1,2 +0,0 @@
---format documentation
---color

data/.travis.yml

@@ -1,7 +0,0 @@
-language: ruby
-rvm:
-  - 2.1.0
-  - 2.2.3
-  - 2.3.4
-  - 2.4.1
-before_install: gem install bundler -v 1.11.2

data/ougai.gemspec

@@ -1,28 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'ougai/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "ougai"
-  spec.version       = Ougai::VERSION
-  spec.authors       = ["Toshimitsu Takahashi"]
-  spec.email         = ["toshi@tilfin.com"]
-
-  spec.summary       = %q{JSON logger compatible with node-bunyan is capable of handling data easily.}
-  spec.description = <<-EOF
-    A JSON logging system is capable of handling a message, data or an exception easily.
-    It is compatible with Bunyan for Node.js and can also output human readable format for console.
-  EOF
-  spec.homepage      = "https://github.com/tilfin/ougai"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  spec.require_paths = ['lib']
-
-  spec.required_ruby_version = '>= 2.1.0'
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-end