fluent-logger 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ebb952132e3bf5135cccf95edb35c73e15faa33
-  data.tar.gz: 5cbeb4614a25258758ba62d0dbdf795ce9b41579
+  metadata.gz: b697bc01bf042c2ecafc345c71dd0c133d08519f
+  data.tar.gz: 490cf5426952cca33f6a6a98cd4d150ef2ddad43
 SHA512:
-  metadata.gz: 092f6edfdc24d9561c9fa280c4dc9833c78fff5043f53c97c0f08e83f69a1d0875b317a9eba778394a45e6f6c3dbc3e399b28cce0a2e3990c42fa79e29ca4ba1
-  data.tar.gz: d31116dab4915fb1c0817f1ac424c25b1ae85fe548f8a30eb4988cf9ca30359bee2fda9a7e499ec7a50720fc0a040ad4415b78e77b0e070ad65bc2d253dd5ca5
+  metadata.gz: d72fb3e957716c2003be82e669da0d14902631f98c710e32b530a5c099bbd56ec1e91e4cc392da55c00c0aaf11de08431682458e5ef32fbcaa6c78bda2efa371
+  data.tar.gz: 16783931f838a10cf82346f918faff6d8bab0f47172eaaf1bbc991a01549f2e704a3c45fa32f379b6133a481ca6b9b3a2b54793e473cbec321773df05d41944c

data/.travis.yml

@@ -3,12 +3,29 @@ rvm:
  - 2.0.0
  - 2.1
  - 2.2
- - 2.3.0
- - rbx
+ - 2.3.1
+ - ruby-head
+
+gemfile:
+ - Gemfile
+ - Gemfile.v0.12
 
 before_install: gem update bundler
 script: bundle exec rake spec
 
+sudo: false
+
 matrix:
   allow_failures:
-    - rvm: rbx
+    - rvm: ruby-head
+  exclude:
+    - rvm: 1.9.3
+      gemfile: Gemfile
+    - rvm: 2.0.0
+      gemfile: Gemfile
+    - rvm: 2.2
+      gemfile: Gemfile.v0.12
+    - rvm: 2.3.1
+      gemfile: Gemfile.v0.12
+    - rvm: ruby-head
+      gemfile: Gemfile.v0.12

data/ChangeLog

@@ -1,3 +1,12 @@
+Release 0.6.1 - 2016/11/02
+
+  * Add LevelFluentLogger: Standard Logger compatible interface
+
+Release 0.6.0 - 2016/10/15
+
+  * Relax msgpack dependency
+  * ConsoleLogger: close io if io is stdout
+
 Release 0.5.1 - 2015/11/24
 
   * Allow injection of buffer overflow handler

data/Gemfile

@@ -1,10 +1,11 @@
 
 source 'https://rubygems.org/'
 
+gem "fluentd", :github => 'fluent/fluentd'
+
 gemspec
 
 gem "simplecov", :require => false
 gem "simplecov-vim"
 
-gem "fluentd"
 gem 'test-unit'

data/Gemfile.v0.12

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gem 'json', '= 1.8.3'
+gem 'fluentd', '~> 0.12.0'
+
+gemspec

data/README.md

@@ -39,6 +39,63 @@ log.post("access", {"agent"=>"foo"})
 # output: myapp.access {"agent":"foo"}
 ```
 
+### Standard ::Logger compatible interface
+
+#### Example1
+
+```ruby
+require 'fluent-logger'
+f = Fluent::Logger::LevelFluentLogger.new('fluent')
+
+f.info("some application running.")
+# output: fluent.info: {"level":"INFO","message":"some application running."}
+
+f.warn("some application running.")
+# output: fluent.warn: {"level":"WARN","message":"some application running."}
+```
+
+#### Example2(add progname)
+
+```ruby
+require 'fluent-logger'
+f = Fluent::Logger::LevelFluentLogger.new('fluent')
+f.info("some_application"){"some application running."}
+# output: fluent.info: {"level":"INFO","message":"some application running.","progname":"some_application"}
+```
+
+#### Example3(set log level)
+
+```ruby
+require 'fluent-logger'
+f = Fluent::Logger::LevelFluentLogger.new('fluent')
+f.level = Logger::WARN
+f.info("some_application"){"some application running."}
+```
+
+Log level is ERROR so no output.
+
+default log level is debug.
+
+
+#### Example4(customize format for Rails)
+
+```ruby
+require 'fluent-logger'
+f = Fluent::Logger::LevelFluentLogger.new('fluent')
+
+f.formatter = proc do |severity, datetime, progname, message|
+  map = { level: severity.class == Fixnum ? %w(DEBUG INFO WARN ERROR FATAL ANY)[severity] : severity }
+  map[:message] = message if message
+  map[:progname] = progname if progname
+  map[:stage] = ENV['RAILS_ENV']
+  map[:service_name] = "SomeApp"
+  map
+end
+
+f.info("some_application"){"some application running."}
+# output: fluent.info: {"level":"INFO","message":"some application running.","progname":"some_application","stage":"production","service_name":"SomeApp"}
+```
+
 ## Loggers
 
 ### Fluent
@@ -82,6 +139,8 @@ Fluent::Logger::FluentLogger.new(nil,
   :buffer_overflow_handler => handler)
 ```
 
+## Information
+
 |name|description|
 |---|---|
 |Web site|http://fluentd.org/|

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.6.1

data/lib/fluent/logger.rb

@@ -17,13 +17,14 @@
 #
 module Fluent
   module Logger
-    autoload :ConsoleLogger , 'fluent/logger/console_logger'
-    autoload :FluentLogger  , 'fluent/logger/fluent_logger'
-    autoload :LoggerBase    , 'fluent/logger/logger_base'
-    autoload :TestLogger    , 'fluent/logger/test_logger'
-    autoload :TextLogger    , 'fluent/logger/text_logger'
-    autoload :NullLogger    , 'fluent/logger/null_logger'
-    autoload :VERSION       , 'fluent/logger/version'
+    autoload :ConsoleLogger     , 'fluent/logger/console_logger'
+    autoload :FluentLogger      , 'fluent/logger/fluent_logger'
+    autoload :LevelFluentLogger , 'fluent/logger/level_fluent_logger'
+    autoload :LoggerBase        , 'fluent/logger/logger_base'
+    autoload :TestLogger        , 'fluent/logger/test_logger'
+    autoload :TextLogger        , 'fluent/logger/text_logger'
+    autoload :NullLogger        , 'fluent/logger/null_logger'
+    autoload :VERSION           , 'fluent/logger/version'
 
     @@default_logger = nil
 

data/lib/fluent/logger/level_fluent_logger.rb

@@ -0,0 +1,73 @@
+#
+# Fluent
+#
+# Copyright (C) 2011 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+require 'msgpack'
+require 'socket'
+require 'monitor'
+require 'logger'
+require 'json'
+
+module Fluent
+  module Logger
+    class LevelFluentLogger < ::Logger
+
+      def initialize(tag_prefix = nil, *args)
+        @level = ::Logger::DEBUG
+        @default_formatter = proc do |severity, datetime, progname, message|
+          map = { level: format_severity(severity) }
+          map[:message] = message if message
+          map[:progname] = progname if progname
+          map
+        end
+        @fluent_logger = FluentLogger.new(tag_prefix, *args)
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        severity ||= UNKNOWN
+        if severity < @level
+          return true
+        end
+        progname ||= @progname
+        if message.nil?
+          if block_given?
+            message = yield
+          else
+            message = progname
+            progname = @progname
+          end
+        end
+        map = format_message(severity, Time.now, progname, message)
+        @fluent_logger.post(format_severity(severity).downcase, map)
+        true
+      end
+
+      def close
+        @fluent_logger.close
+      end
+
+      def reopen
+        @fluent_logger.close
+        # we do not call #connect! here because 1) FluentLogger#connect! is not a public method
+        # 2) #post automatically connects if its connection is closed
+      end
+
+      def connect?
+        @fluent_logger.connect?
+      end
+    end
+  end
+end

data/lib/fluent/logger/logger_base.rb

@@ -23,7 +23,7 @@ module Fluent
       end
 
       def post(tag, map)
-        raise ArgumentError.new("Second argument should kind of Hash (tag: #{map})") unless map.kind_of? Hash
+        raise ArgumentError.new("Second argument must be a kind of Hash (#{tag}: #{map})") unless map.kind_of? Hash
         post_with_time(tag, map, Time.now)
       end
 

data/lib/fluent/logger/version.rb

@@ -1,7 +1,7 @@
 module Fluent
 module Logger
 
-VERSION = '0.6.0'
+VERSION = '0.6.1'
 
 end
 end

data/spec/fluent_logger_spec.rb

@@ -1,31 +1,15 @@
 
 require 'spec_helper'
+require 'support/dummy_serverengine'
+require 'support/dummy_fluentd'
 
-require 'fluent/load'
-require 'fluent/test'
-require 'tempfile'
 require 'logger'
-require 'socket'
 require 'stringio'
 require 'fluent/logger/fluent_logger/cui'
-require 'plugin/out_test'
-
-$log = Fluent::Log.new(StringIO.new) # XXX should remove $log from fluentd
 
 describe Fluent::Logger::FluentLogger do
-  WAIT = ENV['WAIT'] ? ENV['WAIT'].to_f : 0.1
-
-  let(:fluentd_port) {
-    port = 60001
-    loop do
-      begin
-        TCPServer.open('localhost', port).close
-        break
-      rescue Errno::EADDRINUSE
-        port += 1
-      end
-    end
-    port
+  let(:fluentd) {
+    DummyFluentd.new
   }
 
   let(:logger) {
@@ -33,7 +17,7 @@ describe Fluent::Logger::FluentLogger do
     logger = ::Logger.new(@logger_io)
     Fluent::Logger::FluentLogger.new('logger-test', {
       :host   => 'localhost',
-      :port   => fluentd_port,
+      :port   => fluentd.port,
       :logger => logger,
       :buffer_overflow_handler => buffer_overflow_handler
     })
@@ -45,72 +29,38 @@ describe Fluent::Logger::FluentLogger do
     @logger_io
   }
 
-  let(:output) {
-    sleep 0.0001 # next tick
-    if Fluent::Engine.respond_to?(:match)
-      Fluent::Engine.match('logger-test').output
-    else
-      Fluent::Engine.root_agent.event_router.match('logger-test')
+  context "running fluentd" do
+    before(:all) do
+      @serverengine = DummyServerengine.new
+      @serverengine.startup
     end
-  }
-
-  let(:queue) {
-    queue = []
-    output.emits.each {|tag, time, record|
-      queue << [tag, record]
-    }
-    queue
-  }
 
-  after(:each) do
-    output.emits.clear rescue nil
-  end
-
-  def wait_transfer
-    sleep WAIT
-  end
-
-  context "running fluentd" do
     before(:each) do
-      @config = Fluent::Config.parse(<<EOF, '(logger-spec)', '(logger-spec-dir)', true)
-<source>
-  type forward
-  port #{fluentd_port}
-</source>
-<match logger-test.**>
-  type test
-</match>
-EOF
-      Fluent::Test.setup
-      Fluent::Engine.run_configure(@config)
-      @coolio_default_loop = nil
-      @thread = Thread.new {
-        @coolio_default_loop = Coolio::Loop.default
-        Fluent::Engine.run
-      }
-      wait_transfer
+      fluentd.startup
     end
 
     after(:each) do
-      @coolio_default_loop.stop
-      Fluent::Engine.send :shutdown
-      @thread.join
+      fluentd.shutdown
+    end
+
+    after(:all) do
+      @serverengine.shutdown
     end
 
     context('Post by CUI') do
       it('post') {
-        args = %W(-h localhost -p #{fluentd_port} -t logger-test.tag -v a=b -v foo=bar)
+        args = %W(-h localhost -p #{fluentd.port} -t logger-test.tag -v a=b -v foo=bar)
         Fluent::Logger::FluentLogger::CUI.post(args)
-        wait_transfer
-        expect(queue.last).to eq ['logger-test.tag', {'a' => 'b', 'foo' => 'bar'}]
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.tag', {'a' => 'b', 'foo' => 'bar'}]
       }
     end
 
     context('post') do
       it ('success') {
         expect(logger.post('tag', {'a' => 'b'})).to be true
-        wait_transfer
-        expect(queue.last).to eq ['logger-test.tag', {'a' => 'b'}]
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.tag', {'a' => 'b'}]
       }
 
       it ('close after post') {
@@ -120,15 +70,15 @@ EOF
 
         logger.post('tag', {'b' => 'c'})
         expect(logger).to be_connect
-        wait_transfer
-        expect(queue.last).to eq ['logger-test.tag', {'b' => 'c'}]
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.tag', {'b' => 'c'}]
       }
 
       it ('large data') {
         data = {'a' => ('b' * 1000000)}
         logger.post('tag', data)
-        wait_transfer
-        expect(queue.last).to eq ['logger-test.tag', data]
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.tag', data]
       }
 
       it ('msgpack unsupport data') {
@@ -138,8 +88,8 @@ EOF
           'proc'   => proc { 1 },
         }
         logger.post('tag', data)
-        wait_transfer
-        logger_data = queue.last.last
+        fluentd.wait_transfer
+        logger_data = fluentd.queue.last.last
         expect(logger_data['time']).to eq '2008-09-01 10:05:00 UTC'
         expect(logger_data['proc']).to be_truthy
         expect(logger_data['object']).to be_truthy
@@ -153,8 +103,8 @@ EOF
           'NaN'    => (0.0/0.0) # JSON don't convert
         }
         logger.post('tag', data)
-        wait_transfer
-        expect(queue.last).to be_nil
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to be_nil
         logger_io.rewind
         logger_io.read =~ /FluentLogger: Can't convert to msgpack:/
       }
@@ -174,21 +124,21 @@ EOF
 
     context "initializer" do
       it "backward compatible" do
-        fluent_logger = Fluent::Logger::FluentLogger.new('logger-test', 'localhost', fluentd_port)
+        fluent_logger = Fluent::Logger::FluentLogger.new('logger-test', 'localhost', fluentd.port)
         host, port = fluent_logger.instance_eval { [@host, @port] }
         expect(host).to eq 'localhost'
-        expect(port).to eq fluentd_port
+        expect(port).to eq fluentd.port
       end
 
       it "hash argument" do
         fluent_logger = Fluent::Logger::FluentLogger.new('logger-test', {
           :host => 'localhost',
-          :port => fluentd_port
+          :port => fluentd.port
         })
 
         host, port = fluent_logger.instance_eval { [@host, @port] }
         expect(host).to eq 'localhost'
-        expect(port).to eq fluentd_port
+        expect(port).to eq fluentd.port
       end
     end
   end
@@ -197,8 +147,8 @@ EOF
     context('fluent logger interface') do
       it ('post & close') {
         expect(logger.post('tag', {'a' => 'b'})).to be false
-        wait_transfer  # even if wait
-        expect(queue.last).to be_nil
+        fluentd.wait_transfer  # even if wait
+        expect(fluentd.queue.last).to be_nil
         logger.close
         logger_io.rewind
         log = logger_io.read
@@ -209,8 +159,8 @@ EOF
       it ('post limit over') do
         logger.limit = 100
         logger.post('tag', {'a' => 'b'})
-        wait_transfer  # even if wait
-        expect(queue.last).to be_nil
+        fluentd.wait_transfer  # even if wait
+        expect(fluentd.queue.last).to be_nil
 
         logger_io.rewind
         expect(logger_io.read).not_to match /Can't send logs to/
@@ -226,9 +176,9 @@ EOF
         expect_any_instance_of(Fluent::Logger::FluentLogger).to receive(:log_reconnect_error).once.and_call_original
 
         logger.post('tag', {'a' => 'b'})
-        wait_transfer  # even if wait
+        fluentd.wait_transfer  # even if wait
         logger.post('tag', {'a' => 'b'})
-        wait_transfer  # even if wait
+        fluentd.wait_transfer  # even if wait
         logger_io.rewind
         expect(logger_io.read).to match /Failed to connect/
       end
@@ -253,8 +203,8 @@ EOF
         logger.limit = 100
         event_1 = {'a' => 'b'}
         logger.post('tag', event_1)
-        wait_transfer  # even if wait
-        expect(queue.last).to be(nil)
+        fluentd.wait_transfer  # even if wait
+        expect(fluentd.queue.last).to be(nil)
 
         logger_io.rewind
         expect(logger_io.read).not_to match(/Can't send logs to/)

data/spec/level_fluent_logger_spec.rb

@@ -0,0 +1,165 @@
+
+require 'spec_helper'
+require 'support/dummy_serverengine'
+require 'support/dummy_fluentd'
+
+require 'logger'
+require 'stringio'
+
+describe Fluent::Logger::FluentLogger do
+  let(:fluentd) {
+    DummyFluentd.new
+  }
+
+  let(:level_logger) {
+    @logger_io = StringIO.new
+    logger = ::Logger.new(@logger_io)
+    Fluent::Logger::LevelFluentLogger.new('logger-test', {
+      :host   => 'localhost',
+      :port   => fluentd.port,
+      :logger => logger,
+      :buffer_overflow_handler => buffer_overflow_handler
+    })
+  }
+
+  let(:buffer_overflow_handler) { nil }
+
+  let(:logger_io) {
+    @logger_io
+  }
+
+  context "running fluentd" do
+
+    before(:all) do
+      @serverengine = DummyServerengine.new
+      @serverengine.startup
+    end
+
+    before(:each) do
+      fluentd.startup
+    end
+
+    after(:each) do
+      fluentd.shutdown
+    end
+
+    after(:all) do
+      @serverengine.shutdown
+    end
+
+    context('::Logger compatible methods') do
+      it ('initialize default value') {
+        level_fluent_logger = Fluent::Logger::LevelFluentLogger.new('logger-test', {
+          :host   => 'localhost',
+          :port   => fluentd.port,
+          :logger => ::Logger.new(StringIO.new),
+          :buffer_overflow_handler => buffer_overflow_handler
+        })
+        expect(level_fluent_logger.level).to eq 0
+        expect(level_fluent_logger.progname).to be_nil
+      }
+
+      it ('close') {
+        expect(level_logger).to be_connect
+        level_logger.close
+        expect(level_logger).not_to be_connect
+      }
+
+      it ('reopen') {
+        expect(level_logger).to be_connect
+        level_logger.reopen
+        expect(level_logger).not_to be_connect
+        expect(level_logger.info('logger reopen test')).to be true
+      }
+    end
+
+    context('add with level') do
+      it ('add progname') {
+        expect(level_logger.info('some_application'){ 'some application running' }).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.info', {'level' => 'INFO', 'message' => 'some application running', 'progname' => 'some_application' }]
+      }
+
+      it ('send log debug') {
+        expect(level_logger.debug('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.debug', {'level' => 'DEBUG', 'message' => 'some_application' }]
+      }
+
+      it ('send log info') {
+        expect(level_logger.info('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.info', {'level' => 'INFO', 'message' => 'some_application' }]
+      }
+
+      it ('send log warn') {
+        expect(level_logger.warn('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.warn', {'level' => 'WARN', 'message' => 'some_application' }]
+      }
+
+      it ('send log error') {
+        expect(level_logger.error('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.error', {'level' => 'ERROR', 'message' => 'some_application' }]
+      }
+
+      it ('send log fatal') {
+        expect(level_logger.fatal('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq ['logger-test.fatal', {'level' => 'FATAL', 'message' => 'some_application' }]
+      }
+
+      it ('not send log debug') {
+        level_logger.level = ::Logger::FATAL
+
+        expect(level_logger.debug('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue).to eq []
+      }
+
+      it ('not send log info') {
+        level_logger.level = ::Logger::FATAL
+
+        expect(level_logger.info('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue).to eq []
+      }
+
+      it ('not send log warn') {
+        level_logger.level = ::Logger::FATAL
+
+        expect(level_logger.warn('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue).to eq []
+      }
+
+      it ('not send log error') {
+        level_logger.level = ::Logger::FATAL
+
+        expect(level_logger.error('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue).to eq []
+      }
+
+      it ('define formatter') {
+        level_logger.level = ::Logger::DEBUG
+        level_logger.formatter = proc do |severity, datetime, progname, message|
+          map = { level: severity.class == Fixnum ? %w(DEBUG INFO WARN ERROR FATAL ANY)[severity] : severity }
+          map[:message] = message if message
+          map[:progname] = progname if progname
+          map[:stage] = "development"
+          map[:service_name] = "some service"
+          map
+        end
+
+        expect(level_logger.error('some_application')).to be true
+        fluentd.wait_transfer
+        expect(fluentd.queue.last).to eq [
+          'logger-test.error',
+          {'level' => 'ERROR', 'message' => 'some_application', 'stage' => 'development', 'service_name' => 'some service'}
+        ]
+      }
+    end
+  end
+end

data/spec/plugin/out_test.rb

@@ -14,11 +14,15 @@
 #    limitations under the License.
 #
 
+require 'fluent/output'
+
 module Fluent
   class TestOutput < Output
     Plugin.register_output('test', self)
 
     def initialize
+      super
+
       @emit_streams = []
       @name = nil
     end
@@ -54,15 +58,19 @@ module Fluent
     end
 
     def configure(conf)
+      super
+
       if name = conf['name']
         @name = name
       end
     end
 
     def start
+      super
     end
 
     def shutdown
+      super
     end
 
     def emit(tag, es, chain)

data/spec/support/dummy_fluentd.rb

@@ -0,0 +1,82 @@
+require 'fluent/load'
+require 'fluent/test'
+require 'socket'
+require 'plugin/out_test'
+require 'stringio'
+
+class DummyFluentd
+  def initialize
+    output.emits.clear rescue nil
+  end
+
+  WAIT = ENV['WAIT'] ? ENV['WAIT'].to_f : 0.1
+
+  def wait_transfer
+    sleep WAIT
+  end
+
+  def port
+    return @port if @port
+    @port = 60001
+    loop do
+      begin
+        TCPServer.open('localhost', @port).close
+        break
+      rescue Errno::EADDRINUSE
+        @port += 1
+      end
+    end
+    @port
+  end
+
+  def output
+    sleep 0.0001 # next tick
+    if Fluent::Engine.respond_to?(:match)
+      Fluent::Engine.match('logger-test').output
+    else
+      Fluent::Engine.root_agent.event_router.match('logger-test')
+    end
+  end
+
+  def queue
+    queue = []
+    output.emits.each {|tag, time, record|
+      queue << [tag, record]
+    }
+    queue
+  end
+
+  def startup
+    config = Fluent::Config.parse(<<EOF, '(logger-spec)', '(logger-spec-dir)', true)
+<source>
+  type forward
+  port #{port}
+</source>
+<match logger-test.**>
+  type test
+</match>
+EOF
+    Fluent::Test.setup
+    Fluent::Engine.run_configure(config)
+    @coolio_default_loop = nil
+    @thread = Thread.new {
+      @coolio_default_loop = Coolio::Loop.default
+      Fluent::Engine.run
+    }
+    wait_transfer
+  end
+
+  def shutdown
+    @coolio_default_loop.stop rescue nil
+    begin
+      Fluent::Engine.stop
+    rescue => e
+      # for v0.12, calling stop may cause "loop not running" by internal default loop
+      if e.message == "loop not running"
+        Fluent::Engine.send :shutdown
+      end
+    end
+    @thread.join
+    @coolio_default_loop = @thread = nil
+  end
+end

data/spec/support/dummy_serverengine.rb

@@ -0,0 +1,18 @@
+class DummyServerengine
+  def initialize
+  end
+
+  def startup
+    @server = nil
+    if defined?(ServerEngine) # for v0.14. in_forward requires socket manager server
+      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
+      @server = ServerEngine::SocketManager::Server.open(socket_manager_path)
+      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
+    end
+    @server
+  end
+
+  def shutdown
+    @server.close if @server
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-logger
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-15 00:00:00.000000000 Z
+date: 2016-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -114,6 +114,7 @@ files:
 - COPYING
 - ChangeLog
 - Gemfile
+- Gemfile.v0.12
 - README.md
 - Rakefile
 - VERSION
@@ -124,6 +125,7 @@ files:
 - lib/fluent/logger/console_logger.rb
 - lib/fluent/logger/fluent_logger.rb
 - lib/fluent/logger/fluent_logger/cui.rb
+- lib/fluent/logger/level_fluent_logger.rb
 - lib/fluent/logger/logger_base.rb
 - lib/fluent/logger/null_logger.rb
 - lib/fluent/logger/test_logger.rb
@@ -131,11 +133,14 @@ files:
 - lib/fluent/logger/version.rb
 - spec/console_logger_spec.rb
 - spec/fluent_logger_spec.rb
+- spec/level_fluent_logger_spec.rb
 - spec/logger_base_spec.rb
 - spec/logger_spec.rb
 - spec/null_logger_spec.rb
 - spec/plugin/out_test.rb
 - spec/spec_helper.rb
+- spec/support/dummy_fluentd.rb
+- spec/support/dummy_serverengine.rb
 - spec/support/timecop.rb
 - spec/test_logger_spec.rb
 homepage: https://github.com/fluent/fluent-logger-ruby
@@ -164,10 +169,13 @@ summary: fluent logger for ruby
 test_files:
 - spec/console_logger_spec.rb
 - spec/fluent_logger_spec.rb
+- spec/level_fluent_logger_spec.rb
 - spec/logger_base_spec.rb
 - spec/logger_spec.rb
 - spec/null_logger_spec.rb
 - spec/plugin/out_test.rb
 - spec/spec_helper.rb
+- spec/support/dummy_fluentd.rb
+- spec/support/dummy_serverengine.rb
 - spec/support/timecop.rb
 - spec/test_logger_spec.rb