fluent-logger 0.3.0

data/ChangeLog

@@ -0,0 +1,17 @@
+
+Release 0.3.0 - 2011/08/21
+
+  * Added 'tag' for event logs
+
+
+Release 0.2.0 - 2011/08/05
+
+  * Redesigned Event class
+  * Added TestLogger (Fluent.open(:test))
+  * Added test programs
+
+
+Release 0.1.0 - 2011/08/04
+
+  * First release
+

data/README.rdoc

@@ -0,0 +1,117 @@
+= Fluent logger
+
+A structured event loger
+
+== Examples
+
+=== Simple
+
+    require 'fluent-logger'
+    
+    EventLogger = Fluent::Logger::ConsoleLogger.new(STDOUT)
+    
+    module Event
+      AccessEvent = EventLogger.create_event('access', :agent, :action=>'access')
+    end
+    
+    #=> access: action="access" agent="foo"
+    Event::AccessEvent.agent('foo').post!
+
+
+=== Singleton
+
+    require 'fluent-logger'
+    
+    Fluent::Logger::ConsoleLogger.open(STDOUT)
+    
+    module Event
+      AccessEvent = Fluent::Logger.create_event('access', :agent, :action=>'access')
+    end
+    
+    #=> access: action="access" agent="foo"
+    Event::AccessEvent.agent('foo').post!
+
+
+=== Combine events
+
+    require 'fluent-logger'
+    
+    EventLogger = Fluent::Logger::ConsoleLogger.new(STDOUT)
+    
+    module Event
+      User = EventLogger.create_event('user', :name, :age)
+      LoginEvent = EventLogger.create_event('login', :action=>'login')
+      BuyEvent = EventLogger.create_event('buy', :item, :action=>'login')
+    end
+    
+    e_user = Event::User.name('me').age(24)
+    
+    #=> login: action="login" name="me" age=24
+    Event::LoginEvent.with(e_user).post!
+    
+    #=> buy: action="login" name="me" age=24 item="item01"
+    Event::BuyEvent.with(e_user).item("item01").post!
+
+=== Update created events
+
+    require 'fluent-logger'
+    
+    EventLogger = Fluent::Logger::ConsoleLogger.new(STDOUT)
+    
+    module Event
+      User = EventLogger.create_event('user', :name, :age)
+      AgeChangeEvent = EventLogger.create_event('age_change', :changed_age, :action=>'age_change')
+      BuyEvent = EventLogger.create_event('buy', :item, :action=>'buy')
+    end
+    
+    e_user = User.name('me').age(24)
+    
+    #=> age_change: action="age_change" name="me" age=24 changed_age=25
+    Event::AgeChangeEvent.with(e_user).changed_age(25).post!
+    e_user.age!(25)
+    
+    #=> buy: action="buy" name="me" age=25 item="item01"
+    Event::BuyEvent.with(e_user).item("item01").post!
+
+=== Update created events by combining
+
+    require 'fluent-logger'
+    
+    EventLogger = Fluent::Logger::ConsoleLogger.new(STDOUT)
+    
+    module Event
+      User = EventLogger.create_event('user', :name, :age)
+      Browser = EventLogger.create_event('browser', :host, :agent)
+      LoginEvent = EventLogger.create_event('login', :action=>'login')
+    end
+    
+    e_user = Event::User.name('me').age(24)
+    e_browser = Event::Browser.host('remoteip').agent('firefox')
+    e_user.with!(e_browser)
+    
+    #=> login: action="login" name="me" age=24 host="remoteip" agent="firefox"
+    Event::LoginEvent.with(e_user).post!
+
+
+== Loggers
+
+=== Console
+
+    Fluent::Logger::ConsoleLogger.open(io)
+
+=== Syslog
+
+    Fluent::Logger::SyslogLogger.open(ident=$0, level=:info)
+
+=== Fluent
+
+    Fluent::Logger::FluentLogger.open('tag_prefix', 'host', port=24224)
+
+
+Web site::  http://fluent.github.com/
+Documents:: http://fluent.github.com/doc/
+Source repository:: http://github.com/fluent
+Author:: Sadayuki Furuhashi
+Copyright:: (c) 2011 FURUHASHI Sadayuki
+License:: Apache License, Version 2.0
+

data/lib/fluent-logger.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'fluent', 'logger')

data/lib/fluent/logger.rb

@@ -0,0 +1,92 @@
+#
+# 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
+  require 'fluent/logger/event'
+  require 'fluent/logger/base'
+
+  class DefaultLogger < LoggerBase
+    INSTANCE = self.new
+
+    def self.instance
+      INSTANCE
+    end
+
+    def self.new
+      INSTANCE
+    end
+
+    def post(tag, map)
+      Fluent::Logger.default.post(tag, map)
+    end
+
+    def close
+      Fluent::Logger.default.close
+    end
+  end
+
+  @@default_logger = nil
+
+  def self.new(*args)
+    if args.first.is_a?(Class) && args.first.ancestors.include?(LoggerBase)
+      type = args.shift
+    else
+      type = FluentLogger
+    end
+    type.new(*args)
+  end
+
+  def self.open(*args)
+    close
+    @@default_logger = new(*args)
+  end
+
+  def self.close
+    if @@default_logger
+      @@default_logger.close
+      @@default_logger = nil
+    end
+  end
+
+  def self.create_event(*args)
+    DefaultLogger.instance.create_event(*args)
+  end
+
+  def self.post(tag, map)
+    DefaultLogger.instance.post(tag, map)
+  end
+
+  def self.default
+    @@default_logger ||= ConsoleLogger.new(STDOUT)
+  end
+
+  def self.default=(logger)
+    @@default_logger = logger
+  end
+
+  autoload :FluentLogger, 'fluent/logger/fluent'
+  autoload :ConsoleLogger, 'fluent/logger/console'
+  autoload :SyslogLogger, 'fluent/logger/syslog'
+  autoload :TestLogger, 'fluent/logger/test'
+end
+
+
+end
+

data/lib/fluent/logger/base.rb

@@ -0,0 +1,89 @@
+#
+# 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 create_event(tag, *args)
+    map = {}
+    keys = []
+    args.each {|a|
+      case a
+      when Hash
+        a.each_pair {|k,v|
+          keys << k.to_sym
+          map[k.to_sym] = v
+        }
+      else
+        keys << a.to_sym
+      end
+    }
+
+    m = Module.new
+    m.module_eval do
+      keys.each {|key|
+        define_method(key) do |v|
+          with(key=>v)
+        end
+        define_method(:"#{key}!") do |v|
+          with!(key=>v)
+        end
+      }
+      define_method(:MODULE) { m }
+    end
+
+    e = TerminalEvent.new(self, tag, map)
+    e.extend(m)
+    e
+  end
+
+  #def post(tag, map)
+  #end
+
+  #def close(map)
+  #end
+end
+
+
+class TextLogger < LoggerBase
+  def initialize
+    require 'json'
+    @time_format = "%b %e %H:%M:%S"
+  end
+
+  def post(tag, map)
+    a = [Time.now.strftime(@time_format), " ", tag, ":"]
+    map.each_pair {|k,v|
+      a << " #{k}="
+      a << v.to_json
+    }
+    post_text a.join
+  end
+
+  #def post_text(text)
+  #end
+end
+
+
+end
+end

data/lib/fluent/logger/console.rb

@@ -0,0 +1,56 @@
+#
+# 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 ConsoleLogger < TextLogger
+  def initialize(out)
+    super()
+    require 'time'
+
+    if out.is_a?(String)
+      @io = File.open(out, "a")
+      @on_reopen = Proc.new { @io.reopen(out, "a") }
+    elsif out.respond_to?(:write)
+      @io = out
+      @on_reopen = Proc.new { }
+    else
+      raise "Invlaid output: #{out.inspect}"
+    end
+  end
+
+  attr_accessor :time_format
+
+  def reopen!
+    @on_reopen.call
+  end
+
+  def post_text(text)
+    @io.puts text
+  end
+
+  def close
+    @io.close
+    self
+  end
+end
+
+
+end
+end

data/lib/fluent/logger/event.rb

@@ -0,0 +1,118 @@
+#
+# 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 Event
+  def initialize(link, map)
+    @link = link
+    @map = map
+  end
+
+  def to_hash(o={})
+    @link.to_hash(o)
+    o.merge!(@map)
+    o
+  end
+
+  def tag
+    @link.tag
+  end
+
+  def logger
+    @link.logger
+  end
+
+  def logger=(logger)
+    @link.logger = logger
+  end
+
+  def post!(with_tag=tag)
+    logger.post(with_tag, to_hash)
+    self
+  end
+
+  alias post post!
+
+  def with(a)
+    if a.is_a?(Event)
+      ma = MODULE()
+      mb = a.MODULE()
+      m = Module.new
+      m.module_eval do
+        include ma
+        include mb
+        define_method(:MODULE) { m }
+      end
+      map = a.to_hash(to_hash)
+      e = TerminalEvent.new(LOGGER(), tag, map)
+      e.extend(m)
+    else
+      map = a.to_hash
+      e = Event.new(self, map)
+      e.extend(MODULE())
+    end
+    e
+  end
+
+  alias + with
+
+  def with!(a)
+    if a.is_a?(Event)
+      self.extend a.MODULE()
+      a.to_hash(@map)
+    else
+      @map.merge!(a.to_hash)
+    end
+    self
+  end
+
+  def create_event(*args)
+    self.with(LOGGER().create_event(*args))
+  end
+
+  def LOGGER
+    @link.LOGGER()
+  end
+end
+
+
+class TerminalEvent < Event
+  def initialize(logger, tag, map)
+    @logger = logger
+    @tag = tag
+    @map = map
+  end
+
+  def to_hash(o={})
+    o.merge!(@map)
+    o
+  end
+
+  attr_accessor :tag
+  attr_accessor :logger
+
+  def LOGGER
+    @logger
+  end
+end
+
+
+end
+end

data/lib/fluent/logger/fluent.rb

@@ -0,0 +1,115 @@
+#
+# 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 FluentLogger < LoggerBase
+  BUFFER_LIMIT = 8*1024*1024
+
+  def initialize(tag, host, port=24224)
+    super()
+    require 'msgpack'
+    require 'socket'
+    require 'monitor'
+    require 'logger'
+    @mon = Monitor.new
+
+    @tag = tag
+
+    @pending = nil
+    @host = host
+    @port = port
+    connect!
+
+    @limit = BUFFER_LIMIT
+    @logger = ::Logger.new(STDERR)
+
+    FluentLogger.close_on_exit(self)
+  end
+
+  attr_accessor :limit, :logger
+
+  def post(tag, map)
+    time = Time.now.to_i
+    write ["#{@tag}.#{tag}", time, map]
+  end
+
+  def close
+    if @pending
+      @logger.error("FluentLogger: Can't send logs to #{@host}:#{@port}")
+    end
+    @con.close if @con
+    @con = nil
+    @pending = nil
+    self
+  end
+
+  private
+  def write(msg)
+    data = msg.to_msgpack
+    @mon.synchronize {
+      if @pending
+        @pending << data
+        data = @pending
+      end
+      begin
+        unless @con
+          connect!
+        end
+        while true
+          n = @con.syswrite(data)
+          if n >= data.bytesize
+            break
+          end
+          data = data[n..-1]
+        end
+        @pending = nil
+      rescue
+        if @pending
+          if @pending.bytesize > @limit
+            @logger.error("FluentLogger: Can't send logs to #{@host}:#{@port}")
+            @pending = nil
+          end
+        else
+          @pending = data
+        end
+        @con.close if @con
+        @con = nil
+      end
+    }
+  end
+
+  def connect!
+    @con = TCPSocket.new(@host, @port)
+  end
+
+  def self.close_on_exit(logger)
+    ObjectSpace.define_finalizer(logger, self.finalizer(logger))
+  end
+
+  def self.finalizer(logger)
+    proc {
+      logger.close
+    }
+  end
+end
+
+
+end
+end

data/lib/fluent/logger/syslog.rb

@@ -0,0 +1,127 @@
+#
+# 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 SyslogLogger < TextLogger
+  def initialize(ident=$0, level=:info)
+    super()
+    require 'syslog'
+
+    @ident = ident
+    self.level = level
+    #self.facility = facility
+    Syslog.open(@ident)
+  end
+
+  attr_reader :level
+
+  def level=(level)
+    level = level.to_sym if level.is_a?(String)
+    @level = case level
+      when :emerg, Syslog::LOG_EMERG
+        Syslog::LOG_EMERG
+      when :alert, Syslog::LOG_ALERT
+        Syslog::LOG_ALERT
+      when :crit, Syslog::LOG_CRIT
+        Syslog::LOG_CRIT
+      when :err, :error, Syslog::LOG_ERR
+        Syslog::LOG_ERR
+      when :warning, :warn, Syslog::LOG_WARNING
+        Syslog::LOG_WARNING
+      when :notice, Syslog::LOG_NOTICE
+        Syslog::LOG_NOTICE
+      when :info, Syslog::LOG_INFO
+        Syslog::LOG_INFO
+      when :debug, Syslog::LOG_DEBUG
+        Syslog::LOG_DEBUG
+      else
+        raise "Unknown level description #{level.inspect}"
+      end
+  end
+
+  #def facility=(facility)
+  #  facility = facility.to_sym if facility.is_a?(String)
+  #  @facility = case facility
+  #    when :auth, Syslog::LOG_AUTH
+  #      Syslog::LOG_AUTH
+  #    when :authpriv, Syslog::LOG_AUTHPRIV
+  #      Syslog::LOG_AUTHPRIV
+  #    when :console, Syslog::LOG_CONSOLE
+  #      Syslog::LOG_CONSOLE
+  #    when :cron, Syslog::LOG_CRON
+  #      Syslog::LOG_CRON
+  #    when :daemon, Syslog::LOG_DAEMON
+  #      Syslog::LOG_DAEMON
+  #    when :ftp, Syslog::LOG_FTP
+  #      Syslog::LOG_FTP
+  #    when :kern, Syslog::LOG_KERN
+  #      Syslog::LOG_KERN
+  #    when :lpr, Syslog::LOG_LPR
+  #      Syslog::LOG_LPR
+  #    when :mail, Syslog::LOG_MAIL
+  #      Syslog::LOG_MAIL
+  #    when :news, Syslog::LOG_NEWS
+  #      Syslog::LOG_NEWS
+  #    when :ntp, Syslog::LOG_NTP
+  #      Syslog::LOG_NTP
+  #    when :security, Syslog::LOG_SECURITY
+  #      Syslog::LOG_SECURITY
+  #    when :syslog, Syslog::LOG_SYSLOG
+  #      Syslog::LOG_SYSLOG
+  #    when :user, Syslog::LOG_USER
+  #      Syslog::LOG_USER
+  #    when :uucp, Syslog::LOG_UUCP
+  #      Syslog::LOG_UUCP
+  #    when :local0, Syslog::LOG_LOCAL0
+  #      Syslog::LOG_LOCAL0
+  #    when :local1, Syslog::LOG_LOCAL1
+  #      Syslog::LOG_LOCAL1
+  #    when :local2, Syslog::LOG_LOCAL2
+  #      Syslog::LOG_LOCAL2
+  #    when :local3, Syslog::LOG_LOCAL3
+  #      Syslog::LOG_LOCAL3
+  #    when :local4, Syslog::LOG_LOCAL4
+  #      Syslog::LOG_LOCAL4
+  #    when :local5, Syslog::LOG_LOCAL5
+  #      Syslog::LOG_LOCAL5
+  #    when :local6, Syslog::LOG_LOCAL6
+  #      Syslog::LOG_LOCAL6
+  #    when :local7, Syslog::LOG_LOCAL7
+  #      Syslog::LOG_LOCAL7
+  #    else
+  #      raise "Unknown facility description #{facility.inspect}"
+  #    end
+  #  Syslog.reopen(@ident, Syslog::LOG_PID|Syslog::LOG_CONS, @facility)
+  #  facility
+  #end
+
+  def post_text(text)
+    Syslog.log(@level, "%s", text)
+  end
+
+  def close
+    Syslog.close
+    self
+  end
+end
+
+
+end
+end

data/lib/fluent/logger/test.rb

@@ -0,0 +1,55 @@
+#
+# 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 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
+      @queue.shift
+    end
+    (class<<map;self;end).module_eval do
+      define_method(:tag) { tag }
+    end
+    @queue << map
+  end
+
+  def close
+    @close_called += 1
+  end
+
+  def closed?
+    @close_called > 0
+  end
+end
+
+
+end
+end
+

data/lib/fluent/logger/version.rb

@@ -0,0 +1,7 @@
+module Fluent
+module Logger
+
+VERSION = '0.3.0'
+
+end
+end

data/test/event_test.rb

@@ -0,0 +1,183 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+class EventTest < Test::Unit::TestCase
+  it 'keys' do
+    g = Fluent::Logger::TestLogger.new
+
+    assert_nothing_raised do
+      e1 = g.create_event('e1', :k1)
+      e1.k1('v1')
+    end
+
+    assert_raise(NoMethodError) do
+      e2 = g.create_event('e2')
+      e2.k1('v1')
+    end
+
+    assert_raise(NoMethodError) do
+      e3 = g.create_event('e3', :k1)
+      e3.k2('v2')
+    end
+  end
+
+  it 'set_value' do
+    g = Fluent::Logger::TestLogger.new
+
+    e1 = g.create_event('e1', :k1)
+    e1.k1('v1').post!
+    assert_equal g.queue.last, {:k1=>'v1'}
+
+    e2 = g.create_event('e2', :k1, :k2)
+    e2.k1('v1').k2('v2').post!
+    assert_equal g.queue.last, {:k1=>'v1', :k2=>'v2'}
+
+    e3 = g.create_event('e3', :k1, :k2)
+    e3.k1('v1').post!
+    assert_equal g.queue.last, {:k1=>'v1'}
+  end
+
+  it 'default_value' do
+    g = Fluent::Logger::TestLogger.new
+
+    e1 = g.create_event('e1', :k1)
+    e1.post!
+    assert_equal g.queue.last, {}
+
+    e2 = g.create_event('e2', :k1=>'v1')
+    e2.post!
+    assert_equal g.queue.last, {:k1=>'v1'}
+
+    e3 = g.create_event('e3', :k1=>'v1', :k2=>'v2')
+    e3.post!
+    assert_equal g.queue.last, {:k1=>'v1', :k2=>'v2'}
+
+    e4 = g.create_event('e4', :k1=>'v1', :k2=>'v2')
+    e4.k2('v3').post!
+    assert_equal g.queue.last, {:k1=>'v1', :k2=>'v3'}
+  end
+
+  it 'modify' do
+    g = Fluent::Logger::TestLogger.new
+
+    e1 = g.create_event('e1', :k1)
+    e1.k1!('v1')
+    e1.post!
+    assert_equal g.queue.last, {:k1=>'v1'}
+
+    e1.k1!('v2')
+    e1.post!
+    assert_equal g.queue.last, {:k1=>'v2'}
+
+    e2 = g.create_event('e2', :k1=>'v1')
+    e2.k1!('v2')
+    e2.post!
+    assert_equal g.queue.last, {:k1=>'v2'}
+  end
+
+  it 'no_modify' do
+    g = Fluent::Logger::TestLogger.new
+
+    e1 = g.create_event('e1', :k1)
+    e1.k1('v1')
+    e1.post!
+    assert_equal g.queue.last, {}
+
+    e1.k1('v2')
+    e1.post!
+    assert_equal g.queue.last, {}
+
+    e2 = g.create_event('e1', :k1=>'v1')
+    e2.k1('v2')
+    e2.post!
+    assert_equal g.queue.last, {:k1=>'v1'}
+  end
+
+  it 'with_map' do
+    g = Fluent::Logger::TestLogger.new
+
+    e1 = g.create_event('e1')
+    e1.with(:k1=>'v1').post!
+    assert_equal g.queue.last, {:k1=>'v1'}
+
+    e2 = g.create_event('e2', :k1=>'v1')
+    e2.with(:k1=>'v2').post!
+    assert_equal g.queue.last, {:k1=>'v2'}
+
+    e3 = g.create_event('e3', :k1=>'v1')
+    e3.with(:k1=>'v2', :k2=>'v3').post!
+    assert_equal g.queue.last, {:k1=>'v2', :k2=>'v3'}
+  end
+
+  it 'with_map_modify' do
+    g = Fluent::Logger::TestLogger.new
+
+    e1 = g.create_event('e2', :k1)
+    e1.with!(:k1=>'v1')
+    e1.post!
+    assert_equal g.queue.last, {:k1=>'v1'}
+
+    e1.with!(:k1=>'v2')
+    e1.post!
+    assert_equal g.queue.last, {:k1=>'v2'}
+
+    e2 = g.create_event('e2')
+    e2.with!(:k1=>'v1', :k2=>'v2')
+    e2.post!
+    assert_equal g.queue.last, {:k1=>'v1', :k2=>'v2'}
+
+    e2.with!(:k1=>'v3')
+    e2.post!
+    assert_equal g.queue.last, {:k1=>'v3', :k2=>'v2'}
+  end
+
+  it 'with_event_keys' do
+    g = Fluent::Logger::TestLogger.new
+
+    assert_nothing_raised do
+      e1 = g.create_event('e1', :k1)
+      e2 = g.create_event('e2', :k2)
+      e3 = e1.with(e2)
+      e3.k1('v1').k2('v2')
+    end
+
+    assert_nothing_raised do
+      e1 = g.create_event('e1', :k1)
+      e2 = g.create_event('e2', :k1, :k2)
+      e3 = e1.with(e2)
+      e3.k1('v1').k2('v2')
+    end
+
+    assert_nothing_raised do
+      e1 = g.create_event('e1', :k1)
+      e2 = g.create_event('e2', :k2)
+      e1.with!(e2)
+      e1.k1('v1').k2('v2')
+    end
+
+    assert_raise(NoMethodError) do
+      e1 = g.create_event('e1', :k1)
+      e2 = g.create_event('e2', :k2)
+      e3 = e1.with(e2)
+      e1.k2('v1')
+    end
+
+    assert_raise(NoMethodError) do
+      e1 = g.create_event('e1', :k1)
+      e2 = g.create_event('e2', :k2)
+      e1.with!(e2)
+      e2.k1('v1')
+    end
+  end
+
+  it 'tag' do
+    g = Fluent::Logger::TestLogger.new
+
+    e1 = g.create_event('e1')
+    e1.post!
+    assert_equal g.queue.last.tag, 'e1'
+
+    e1.post!('e2')
+    assert_equal g.queue.last.tag, 'e2'
+  end
+end
+

data/test/instance_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+class InstanceTest < Test::Unit::TestCase
+  it 'default' do
+    g1 = Fluent::Logger::TestLogger.open
+    assert_equal g1.object_id, Fluent::Logger.default.object_id
+
+    assert_equal false, g1.closed?
+
+    g2 = Fluent::Logger::TestLogger.open
+    assert_equal g2.object_id, Fluent::Logger.default.object_id
+
+    assert_equal true, g1.closed?
+
+    g3 = Fluent::Logger::TestLogger.new
+    assert_equal g2.object_id, Fluent::Logger.default.object_id
+
+    assert_equal false, g2.closed?
+    Fluent::Logger.close
+    assert_equal true, g2.closed?
+  end
+
+  it 'post' do
+    g1 = Fluent::Logger::TestLogger.new
+
+    g1.post :k1=>'v1'
+    assert_equal g1.queue.last, {:k1=>'v1'}
+
+    g2 = Fluent::Logger::TestLogger.open
+
+    Fluent::Logger.post :k2=>'v2'
+    assert_equal g2.queue.last, {:k2=>'v2'}
+  end
+end

data/test/simple_test.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+class SimpleTest < Test::Unit::TestCase
+  it 'singleton' do
+    Fluent::Logger::ConsoleLogger.open(STDOUT)
+
+    AccessEvent = Fluent::Logger.create_event('e1', :agent, :action=>'access')
+    LoginEvent = Fluent::Logger.create_event('e2', :user, :action=>'login')
+
+    #=> action="access" agent="foo"
+    AccessEvent.agent('foo').post!
+
+    #=> action="login" user="bar"
+    LoginEvent.user('bar').post!
+  end
+
+  it 'local' do
+    E2_LOG = Fluent::Logger::ConsoleLogger.new(STDOUT)
+
+    E2_AccessEvent = E2_LOG.create_event('e1', :agent, :action=>'access')
+    E2_LoginEvent = E2_LOG.create_event('e2', :user, :action=>'login')
+
+    #=> action="access" agent="foo"
+    E2_AccessEvent.agent('foo').post!
+
+    #=> action="login" user="bar"
+    E2_LoginEvent.user('bar').post!
+  end
+
+  it 'combine' do
+    E3_LOG = Fluent::Logger::ConsoleLogger.new(STDOUT)
+
+    E3_User = E3_LOG.create_event('e1', :name, :age)
+    E3_LoginEvent = E3_LOG.create_event('e2', :action=>'login')
+    E3_BuyEvent = E3_LOG.create_event('e3', :item, :action=>'login')
+
+    e_user = E3_User.name('me').age(24)
+
+    #=> action="login" name="me" age=24
+    E3_LoginEvent.with(e_user).post!
+
+    #=> action="login" name="me" age=24 item="item01"
+    E3_BuyEvent.with(e_user).item("item01").post!
+  end
+
+  it 'update' do
+    E4_LOG = Fluent::Logger::ConsoleLogger.new(STDOUT)
+
+    E4_User = E4_LOG.create_event('e1', :name, :age)
+    E4_AgeChangeEvent = E4_LOG.create_event('e2', :changed_age, :action=>'age_change')
+    E4_BuyEvent = E4_LOG.create_event('e3', :item, :action=>'buy')
+
+    e_user = E4_User.name('me').age(24)
+
+    #=> action="age_change" name="me" age=24 changed_age=25
+    E4_AgeChangeEvent.with(e_user).changed_age(25).post!
+    e_user.age!(25)
+
+    #=> action="buy" name="me" age=25 item="item01"
+    E4_BuyEvent.with(e_user).item("item01").post!
+  end
+
+  it 'combine_update' do
+    E5_LOG = Fluent::Logger::ConsoleLogger.new(STDOUT)
+
+    E5_User = E5_LOG.create_event('e1', :name, :age)
+    E5_Browser = E5_LOG.create_event('e2', :host, :agent)
+    E5_LoginEvent = E5_LOG.create_event('e3', :action=>'login')
+
+    e_user = E5_User.name('me').age(24)
+    e_browser = E5_Browser.host('remoteip').agent('firefox')
+    e_user.with!(e_browser)
+
+    #=> action="login" name="me" age=24 host="remoteip" agent="firefox"
+    E5_LoginEvent.with(e_user).post!
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+$LOAD_PATH << File.dirname(__FILE__)+"/../lib"
+require 'fluent/logger'
+require 'fileutils'
+
+class Test::Unit::TestCase
+  #class << self
+  #  alias_method :it, :test
+  #end
+	def self.it(name, &block)
+		define_method("test_#{name}", &block)
+	end
+end
+

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: fluent-logger
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Sadayuki Furuhashi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-21 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: msgpack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 4
+        - 4
+        version: 0.4.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 4
+        - 3
+        version: 1.4.3
+  type: :runtime
+  version_requirements: *id002
+description: 
+email: frsyuki@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- ChangeLog
+- README.rdoc
+files: 
+- lib/fluent-logger.rb
+- lib/fluent/logger.rb
+- lib/fluent/logger/base.rb
+- lib/fluent/logger/console.rb
+- lib/fluent/logger/event.rb
+- lib/fluent/logger/fluent.rb
+- lib/fluent/logger/syslog.rb
+- lib/fluent/logger/test.rb
+- lib/fluent/logger/version.rb
+- test/event_test.rb
+- test/instance_test.rb
+- test/simple_test.rb
+- test/test_helper.rb
+- ChangeLog
+- README.rdoc
+has_rdoc: true
+homepage: http://fluent.github.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Structured event logger
+test_files: 
+- test/event_test.rb
+- test/instance_test.rb
+- test/simple_test.rb
+- test/test_helper.rb