fluent-logger 0.3.1 → 0.4.0

data/lib/fluent/logger/logger_base.rb

@@ -0,0 +1,34 @@
+#
+# 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.
+#
+module Fluent
+module Logger
+
+class LoggerBase
+  def self.open(*args, &block)
+    Fluent::Logger.open(self, *args, &block)
+  end
+
+  #def post(tag, map, time=nil)
+  #end
+
+  #def close(map)
+  #end
+end
+
+end
+end

data/lib/fluent/logger/null_logger.rb

@@ -0,0 +1,28 @@
+#
+# 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.
+#
+module Fluent
+module Logger
+
+class NullLogger < LoggerBase
+  def post(tag, map, time=nil)
+    false
+  end
+end
+
+end
+end

data/lib/fluent/logger/{test.rb → test_logger.rb}

@@ -18,38 +18,30 @@
 module Fluent
 module Logger
 
-
 class TestLogger < LoggerBase
   def initialize(queue=[])
     @queue = queue
     @max = 1024
-    @close_called = 0
   end
 
   attr_accessor :max
   attr_reader :queue
-  attr_reader :close_called
 
-  def post(tag, map)
-    while @queue.size > @max
+  def post(tag, map, time=nil)
+    while @queue.size > @max-1
       @queue.shift
     end
     (class<<map;self;end).module_eval do
       define_method(:tag) { tag }
+      define_method(:time) { time }
     end
     @queue << map
+    true
   end
 
   def close
-    @close_called += 1
-  end
-
-  def closed?
-    @close_called > 0
   end
 end
 
-
 end
 end
-

data/lib/fluent/logger/text_logger.rb

@@ -0,0 +1,40 @@
+#
+# 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.
+#
+module Fluent
+module Logger
+
+class TextLogger < LoggerBase
+  def initialize
+    require 'yajl'
+    @time_format = "%b %e %H:%M:%S"
+  end
+
+  def post(tag, map, time=nil)
+    time ||= Time.now
+    a = [time.strftime(@time_format), " ", tag, ":"]
+    map.each_pair {|k,v|
+      a << " #{k}="
+      a << Yajl::Encoder.encode(v)
+    }
+    post_text a.join
+    true
+  end
+end
+
+end
+end

data/lib/fluent/logger/version.rb

@@ -1,7 +1,7 @@
 module Fluent
 module Logger
 
-VERSION = '0.3.1'
+VERSION = '0.4.0'
 
 end
 end

data/spec/console_logger_spec.rb

@@ -0,0 +1,69 @@
+
+require 'spec_helper'
+require 'stringio'
+require 'tempfile'
+require 'pathname'
+
+describe Fluent::Logger::ConsoleLogger do
+  before(:each) {
+    Timecop.freeze Time.local(2008, 9, 1, 10, 5, 0)
+  }
+  after(:each) {
+    Timecop.return
+  }
+
+  context "IO output" do
+    let(:io) { StringIO.new }
+    let(:logger) { Fluent::Logger::ConsoleLogger.new(io) }
+
+    subject {
+      io
+    }
+
+    context "post and read" do
+      before do
+        logger.post('example', {:foo => :bar})
+        io.rewind
+      end
+      its(:read)  { should eq %Q!Sep  1 10:05:00 example: foo="bar"\n! }
+    end
+  end
+
+  context "Filename output" do
+    let(:path) {
+      @tmp = Tempfile.new('fluent-logger') # ref instance var because Tempfile.close(true) check GC
+      filename = @tmp.path
+      @tmp.close(true)
+      Pathname.new(filename)
+    }
+    let(:logger) { Fluent::Logger::ConsoleLogger.new(path.to_s) }
+
+    subject { path }
+    after { path.unlink }
+
+    context "post and read" do
+      before do
+        logger.post('example', {:foo => :bar})
+        logger.close
+      end
+      its(:read)  { should eq %Q!Sep  1 10:05:00 example: foo="bar"\n! }
+    end
+
+    context "reopen" do
+      before do
+        logger.post('example', {:foo => :baz})
+        logger.close
+        logger.reopen!
+      end
+      its(:read)  { should eq %Q!Sep  1 10:05:00 example: foo="baz"\n! }
+    end
+  end
+
+  context "Invalid output" do
+    it {
+      expect {
+        Fluent::Logger::ConsoleLogger.new(nil)
+      }.to raise_error
+    }
+  end
+end

data/spec/fluent_logger_spec.rb

@@ -0,0 +1,201 @@
+
+require 'spec_helper'
+if RUBY_VERSION < "1.9.2"
+
+describe Fluent::Logger::FluentLogger do
+  pending "fluentd don't work RUBY < 1.9.2"
+end
+
+else
+
+require 'fluent/load'
+require 'tempfile'
+require 'logger'
+require 'socket'
+require 'stringio'
+
+$log = Fluent::Log.new(StringIO.new) # XXX should remove $log from fluentd 
+
+describe Fluent::Logger::FluentLogger do
+  let(:fluentd_port) {
+    port = 60001
+    loop do
+      begin
+        TCPServer.open('localhost', port).close
+        break
+      rescue Errno::EADDRINUSE
+        port += 1
+      end
+    end
+    port
+  }
+
+  let(:logger) {
+    @logger_io = StringIO.new
+    logger = ::Logger.new(@logger_io)
+    Fluent::Logger::FluentLogger.new('logger-test', {
+      :host   => 'localhost', 
+      :port   => fluentd_port,
+      :logger => logger,
+    })
+  }
+
+  let(:logger_io) {
+    @logger_io
+  }
+
+  let(:output) {
+    sleep 0.0001 # next tick
+    Fluent::Engine.match('logger-test').output
+  }
+
+  let(:queue) {
+    queue = []
+    output.emits.each {|tag,events|
+      events.each {|time,record|
+        queue << [tag, record]
+      }
+    }
+    queue
+  }
+
+    after(:each) do
+      output.emits.clear rescue nil
+    end
+
+
+  context "running fluentd" do
+    before(:each) do
+      tmp = Tempfile.new('fluent-logger-config')
+      tmp.close(false)
+
+      File.open(tmp.path, 'w') {|f|
+        f.puts <<EOF
+<source>
+  type tcp
+  port #{fluentd_port}
+</source>
+<match logger-test.**>
+  type test
+</match>
+EOF
+      }
+      Fluent::Test.setup
+      Fluent::Engine.read_config(tmp.path)
+      @coolio_default_loop = nil
+      Thread.new {
+        @coolio_default_loop = Coolio::Loop.default
+        Fluent::Engine.run
+      }
+      sleep 0.001 # next tick
+    end
+
+    after(:each) do
+      @coolio_default_loop.stop
+      Fluent::Engine.send :shutdown
+    end
+
+    context('post') do
+      it ('success') { 
+        logger.post('tag', {'a' => 'b'}).should be_true
+        queue.last.should == ['logger-test.tag', {'a' => 'b'}]
+      }
+
+      it ('close after post') {
+        logger.should be_connect
+        logger.close
+        logger.should_not be_connect
+
+        logger.post('tag', {'b' => 'c'})
+        logger.should be_connect
+        queue.last.should == ['logger-test.tag', {'b' => 'c'}]
+      }
+
+      it ('large data') {
+        data = {'a' => ('b' * 1000000)}
+        logger.post('tag', data)
+        sleep 0.01 # wait write
+        queue.last.should == ['logger-test.tag', data]
+      }
+
+      it ('msgpack unsupport data') {
+        data = {
+          'time'   => Time.utc(2008, 9, 1, 10, 5, 0),
+          'object' => Object.new,
+          'proc'   => proc { 1 },
+        }
+        logger.post('tag', data)
+        logger_data = queue.last.last
+        logger_data['time'].should == '2008-09-01 10:05:00 UTC'
+        logger_data['proc'].should be
+        logger_data['object'].should be
+      }
+
+      it ('msgpack and JSON unsupport data') {
+        data = {
+          'time'   => Time.utc(2008, 9, 1, 10, 5, 0),
+          'object' => Object.new,
+          'proc'   => proc { 1 },
+          'NaN'    => (0.0/0.0) # JSON don't convert
+        }
+        logger.post('tag', data)
+        queue.last.should be_nil
+        logger_io.rewind
+        logger_io.read =~ /FluentLogger: Can't convert to msgpack:/
+      }
+    end
+
+    context "initializer" do
+      it "backward compatible" do
+        port = fluentd_port
+        fluent_logger = Fluent::Logger::FluentLogger.new('logger-test', 'localhost', port)
+        fluent_logger.method_missing(:instance_eval) { # fluent_logger is delegetor
+          @host.should == 'localhost'
+          @port.should == port
+        }
+      end
+
+      it "hash argument" do
+        port = fluentd_port
+        fluent_logger = Fluent::Logger::FluentLogger.new('logger-test', {
+          :host => 'localhost',
+          :port => port
+        })
+        fluent_logger.method_missing(:instance_eval) { # fluent_logger is delegetor
+          @host.should == 'localhost'
+          @port.should == port
+        }
+      end
+    end
+  end
+  
+  context "not running fluentd" do
+    context('fluent logger interface') do
+      it ('post & close') { 
+        logger.post('tag', {'a' => 'b'}).should be_false
+        queue.last.should be_nil
+        logger.close
+        logger_io.rewind
+        log = logger_io.read
+        log.should =~ /Failed to connect/
+        log.should =~ /Can't send logs to/
+      }
+
+      it ('post limit over') do
+        logger.limit = 100
+        logger.post('tag', {'a' => 'b'})
+        queue.last.should be_nil
+
+        logger_io.rewind
+        logger_io.read.should_not =~ /Can't send logs to/
+
+        logger.post('tag', {'a' => ('c' * 1000)})
+        logger_io.rewind
+        logger_io.read.should =~ /Can't send logs to/
+      end
+    end
+  end
+
+end
+
+end

data/spec/logger_base_spec.rb

@@ -0,0 +1,11 @@
+
+require 'spec_helper'
+
+describe Fluent::Logger::LoggerBase do
+  context "subclass" do
+    subject { Class.new(Fluent::Logger::LoggerBase) }
+    its(:open) {
+      should be_kind_of(Fluent::Logger::LoggerBase)
+    }
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,43 @@
+
+require 'spec_helper'
+require 'stringio'
+
+describe Fluent::Logger do
+  context "default logger" do
+    let(:test_logger) {
+      Fluent::Logger::TestLogger.new
+    }
+    before(:each) do
+      Fluent::Logger.default = test_logger
+    end
+
+    it('post') {
+      time = Time.now
+      test_logger.should_receive(:post).with('tag1', {:foo => :bar}, time)
+      Fluent::Logger.post('tag1', {:foo => :bar}, time)
+    }
+
+    it('close') {
+      test_logger.should_receive(:close)
+      Fluent::Logger.close
+    }
+
+    it('open') {
+      test_logger.should_receive(:close)
+      klass = Class.new(Fluent::Logger::LoggerBase)
+      fluent_logger_logger_io = StringIO.new
+      Fluent::Logger.open('tag-prefix', {
+        :logger => ::Logger.new(fluent_logger_logger_io)
+      })
+      # Fluent::Logger::FluentLogger is delegator
+      Fluent::Logger.default.method_missing(:kind_of?, Fluent::Logger::FluentLogger).should be_true
+    }
+
+    it('open with BaseLogger class') {
+      test_logger.should_receive(:close)
+      klass = Class.new(Fluent::Logger::LoggerBase)
+      Fluent::Logger.open(klass)
+      Fluent::Logger.default.class.should == klass
+    }
+  end
+end