lwes-logger 1.0.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2010-10-05
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,7 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/lwes_logger.rb
+test/test_lwes_logger.rb

data/README.txt

@@ -0,0 +1,156 @@
+= lwes-logger
+
+* http://github.com/yaksnrainbows/lwes-logger
+
+== DESCRIPTION:
+
+Lwes based ruby logger for real-time logging.
+
+== FEATURES:
+
+* Send logging udp events with lwes.
+
+* Optionally also log to a local file.
+
+== SYNOPSIS:
+
+  require 'lwes_logger'
+
+  logger = LwesLogger.new '127.0.0.1',
+            :log_device => "optional_backup_logfile.logs"
+
+  logger.namespace = "MyApp::Logs"
+
+  logger.meta_event.merge! :app_name => "myapp",
+                           :user     => `whoami`
+
+  logger.debug "This is a debug log event"
+  logger.error "OH NOES!"
+
+Will produce logs in the optional_backup_logfile.logs file and will
+generate the following Lwes events:
+
+  System::Startup[3]
+  {
+    SenderPort = 64885;
+    ReceiptTime = 1286495516997;
+    SenderIP = 127.0.0.1;
+  }
+  MyApp::Logs::Full[12]
+  {
+    SenderPort = 64885;
+    message = This is a debug log event;
+    progname = This is a debug log event;
+    event_id = MyApp::Logs::Debug-3bd9c9d2-d272-11df-b9a6-00254bfffeb1;
+    app_name = myapp;
+    user = system_user;
+    ReceiptTime = 1286495519612;
+    SenderIP = 127.0.0.1;
+    timestamp = Oct 07 16:51:59;
+    hostname = example.com;
+    severity = DEBUG;
+    pid = 70884;
+  }
+  MyApp::Logs::Debug[12]
+  {
+    SenderPort = 64885;
+    message = This is a debug log event;
+    progname = This is a debug log event;
+    event_id = MyApp::Logs::Debug-3bd9c9d2-d272-11df-b9a6-00254bfffeb1;
+    app_name = myapp;
+    user = system_user;
+    ReceiptTime = 1286495519612;
+    SenderIP = 127.0.0.1;
+    timestamp = Oct 07 16:51:59;
+    hostname = example.com;
+    severity = DEBUG;
+    pid = 70884;
+  }
+  MyApp::Logs::Full[12]
+  {
+    SenderPort = 64885;
+    message = OH NOES!;
+    progname = OH NOES!;
+    event_id = MyApp::Logs::Error-3a38b5f6-d273-11df-b9a6-00254bfffeb1;
+    app_name = myapp;
+    user = system_user;
+    ReceiptTime = 1286495519612;
+    SenderIP = 127.0.0.1;
+    timestamp = Oct 07 16:51:59;
+    hostname = example.com;
+    severity = ERROR;
+    pid = 70884;
+  }
+  MyApp::Logs::Error[12]
+  {
+    SenderPort = 64885;
+    message = OH NOES!;
+    progname = OH NOES!;
+    event_id = MyApp::Logs::Error-3a38b5f6-d273-11df-b9a6-00254bfffeb1;
+    app_name = myapp;
+    user = system_user;
+    ReceiptTime = 1286495519612;
+    SenderIP = 127.0.0.1;
+    timestamp = Oct 07 16:51:59;
+    hostname = example.com;
+    severity = ERROR;
+    pid = 70884;
+  }
+  System::Shutdown[7]
+  {
+    freq = 145;
+    SenderPort = 64885;
+    seq = 0;
+    ReceiptTime = 1286495661890;
+    total = 0;
+    SenderIP = 127.0.0.1;
+    count = 0;
+  }
+
+Notice that for convenience, logs events are broadcast to both the Full and
+Severity (e.g. Debug) events. You can change the name of the full logs by
+setting the full_logs_event attribute to a string, or turn full logs off
+completely by setting it to false:
+
+  logger.full_logs_event = "OtherFullLogs"
+  logger.full_logs_event = false
+
+Alternatively, if you'd rather only have full logs you can assign the
+full_logs_only attribute:
+
+  logger.full_logs_only = true
+
+== REQUIREMENTS:
+
+* lwes gem
+
+* uuidtools gem
+
+== INSTALL:
+
+* sudo gem install lwes-logger
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Jeremie Castagna
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,15 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'lwes-logger' do
+  developer('Jeremie Castagna', 'jcastagna@attinteractive.com')
+
+  self.extra_deps << ['lwes',      '~> 0.6']
+  self.extra_deps << ['uuidtools', '~> 2.1']
+
+  self.extra_dev_deps << ['flexmock', '>=0.8.7']
+end
+
+# vim: syntax=ruby

data/lib/lwes_logger.rb

@@ -0,0 +1,181 @@
+require 'socket'
+require 'logger'
+
+require 'rubygems'
+require 'lwes'
+require 'uuidtools'
+
+##
+# Lwes based ruby logger for real-time logging.
+
+class LwesLogger < Logger
+
+  VERSION = '1.0.0'
+
+  HOSTNAME = Socket.gethostname
+  FORMAT   = "%s [%s#%d] %5s -- %s: %s\n"
+  DATETIME_FORMAT = "%b %d %H:%M:%S"
+
+
+  # The default event data to pass along with the lwes event.
+  attr_reader :meta_event
+
+  # The name of the event to emit all severity types to.
+  # Will not emit to the full logs event if set to nil or false.
+  # Defaults to "Full"
+  attr_accessor :full_logs_event
+
+  # Don't segregate by severity and only emit events to Namespace::Full.
+  # Defaults to false.
+  attr_accessor :full_logs_only
+
+  # Base lwes namespace for events.
+  attr_reader :namespace
+
+  # The lwes event emitter.
+  attr_reader :emitter
+
+  # Format of the timestamp in the lwes events.
+  # Note: If using a custom formatter, this property will only
+  # apply to lwes events. Defaults to DATETIME_FORMAT.
+  attr_accessor :datetime_format
+
+
+  ##
+  # Creates a new LwesLogger. Supports the following options:
+  # :log_device:: Supports the same arguments as Logger.new - default: nil
+  # :namespace::        Lwes root event namespace - default: "LwesLogger"
+  # :datetime_format::  Timestamp format in lwes logs - default: DATETIME_FORMAT
+  # :iface::            Forwarded to LWES::Event.new - default: "0.0.0.0"
+  # :port::             Forwarded to LWES::Event.new - default: 12345
+  # :heartbeat::        Forwarded to LWES::Event.new - default: 1
+  # :ttl::              Forwarded to LWES::Event.new - default: 1
+
+
+  def initialize ip_address, options={}
+    args = [options[:log_device]].flatten
+    super(*args)
+
+    @meta_event = {
+      :hostname => HOSTNAME,
+      :pid      => $$.to_s
+    }
+
+    @datetime_format = options[:datetime_format] || DATETIME_FORMAT
+
+    @full_logs_event = "Full"
+    @full_logs_only  = false
+
+    @formatter  = method(:call_format)
+    @namespace  = camelize options[:namespace] || "LwesLogger"
+    @emitter    = lwes_emitter ip_address, options
+  end
+
+
+  ##
+  # Dump given message to the log device without any formatting.
+  # Creates an LwesLogger::Any event.
+
+  def << msg
+    emit_log nil, msg
+    super
+  end
+
+
+  ##
+  # Log to both lwes and the log device, if given.
+
+  def add severity, message=nil, progname=nil, &block
+    return true if severity < @level
+
+    emit_log severity, message, progname, &block
+    super
+  end
+
+  alias log add
+
+
+  ##
+  # Emits an lwes logging event. Setting the data argument will
+  # pass additional data to the emitted event.
+
+  def emit_log severity, message=nil, progname=nil, data={}, &block
+    event_hash = build_log_event severity, message, progname, data, &block
+
+    dump_event = [@namespace, @full_logs_event].join("::")
+    @emitter.emit dump_event, event_hash if @full_logs_event
+
+    event_name = [@namespace, event_hash[:severity].capitalize].join("::")
+    @emitter.emit event_name, event_hash unless @full_logs_only
+  end
+
+
+  ##
+  # Creates an lwes event hash with log data.
+
+  def build_log_event severity, message=nil, progname=nil, data={}, &block
+    severity ||= UNKNOWN
+    severity = format_severity(severity)
+
+    progname ||= @progname
+    message  ||= block.call if block_given?
+    message  ||= progname
+
+    event_id =
+      "#{@namespace}::#{severity.capitalize}-" +
+      UUIDTools::UUID.timestamp_create.to_s
+
+    event_hash = @meta_event.merge \
+      :message   => message.to_s.gsub(/\e\[.*?m/, ''),
+      :progname  => progname.to_s,
+      :severity  => severity,
+      :timestamp => Time.now.strftime(@datetime_format),
+      :event_id  => event_id
+
+    data = data.dup
+    data.each{|k, v| event_hash[k] = v.to_s}
+
+    event_hash
+  end
+
+
+  ##
+  # Set the emitter namespace.
+
+  def namespace= str
+    @namespace = camelize str
+  end
+
+
+  private
+
+
+  def call_format severity, time, progname, message
+    FORMAT % [
+      HOSTNAME,
+      time.strftime(@datetime_format),
+      $$,
+      severity,
+      progname,
+      message
+    ]
+  end
+
+
+  def lwes_emitter ip_address, options={}
+    options = {
+      :address    => ip_address,
+      :iface      => '0.0.0.0',
+      :port       => 12345,
+      :heartbeat  => 1,
+      :ttl        => 1
+    }.merge options
+
+    LWES::Emitter.new options
+  end
+
+
+  def camelize string
+    string.gsub(/(_|^)./i){|s| s[-1..-1].upcase}
+  end
+end

data/test/test_lwes_logger.rb

@@ -0,0 +1,305 @@
+require "rubygems"
+require "test/unit"
+require "tmpdir"
+require "lwes_logger"
+require "flexmock/test_unit"
+
+class TestLwesLogger < Test::Unit::TestCase
+
+  def setup
+    @tmpdir = File.join Dir.tmpdir, "lwes_logger_tests_#{$$}"
+    FileUtils.mkdir_p @tmpdir
+
+    @emitter_hash = {
+      :address    => "127.0.0.1",
+      :iface      => '0.0.0.0',
+      :port       => 12345,
+      :heartbeat  => 1,
+      :ttl        => 1
+    }
+
+    @mock_emitter = flexmock LWES::Emitter.new(@emitter_hash)
+
+    @lwes_emitter_class = flexmock LWES::Emitter
+    @lwes_emitter_class.should_receive(:new).
+      with(@emitter_hash).and_return(@mock_emitter)
+
+    @logger = LwesLogger.new "127.0.0.1"
+
+    @time = Time.now
+    flexmock(Time).should_receive(:now).and_return(@time)
+
+    flexmock(UUIDTools::UUID).should_receive(:timestamp_create).
+      and_return("uuid_timestamp")
+  end
+
+
+  def teardown
+    @mock_emitter.reset_emitted if @mock_emitter.respond_to? :reset_emitted
+    FileUtils.rm_rf @tmpdir
+  end
+
+
+  def test_init
+    logger = LwesLogger.new "127.0.0.1"
+
+    assert LWES::Emitter === logger.emitter
+    assert_equal "Full", logger.full_logs_event
+    assert_equal false, logger.full_logs_only
+    assert_equal "LwesLogger", logger.namespace
+    assert_nil logger.instance_variable_get("@logdev")
+  end
+
+
+  def test_init_log_device
+    log_device = ["#{@tmpdir}/test.log", 10, 10241024]
+
+    @lwes_emitter_class.should_receive(:new).
+      with(@emitter_hash.merge(:log_device => log_device)
+      ).and_return(@mock_emitter)
+
+    logger = LwesLogger.new "127.0.0.1", :log_device => log_device
+
+    logdev = logger.instance_variable_get("@logdev")
+
+    assert Logger::LogDevice === logdev
+    assert_equal "#{@tmpdir}/test.log", logdev.filename
+    assert_equal 10, logdev.instance_variable_get("@shift_age")
+    assert_equal 10241024, logdev.instance_variable_get("@shift_size")
+  end
+
+
+  def test_init_log_device_io
+    logfile = File.open("#{@tmpdir}/test.log", "w+")
+
+    @lwes_emitter_class.should_receive(:new).
+      with(@emitter_hash.merge(:log_device => logfile)
+      ).and_return(@mock_emitter)
+
+    logger = LwesLogger.new "127.0.0.1", :log_device => logfile
+    logdev = logger.instance_variable_get("@logdev")
+
+    assert_equal logfile, logdev.instance_variable_get("@dev")
+    logfile.close
+  end
+
+
+  def test_init_emitter_options
+    @lwes_emitter_class.should_receive(:new).with({
+      :address    => "0.0.0.0",
+      :iface      => "244.0.0.1",
+      :port       => 54321,
+      :heartbeat  => 5,
+      :ttl        => 30
+    }).at_least.once
+
+    LwesLogger.new "0.0.0.0",
+      :iface      => "244.0.0.1",
+      :port       => 54321,
+      :heartbeat  => 5,
+      :ttl        => 30
+  end
+
+
+  def test_init_namespace
+    @lwes_emitter_class.should_receive(:new).and_return @mock_emitter
+
+    logger = LwesLogger.new "127.0.0.1", :namespace => "test_namespace"
+    assert_equal "TestNamespace", logger.namespace
+  end
+
+
+  def test_append
+    event_hash = @logger.build_log_event nil, "test log"
+
+    log_device = StringIO.new("")
+
+    @lwes_emitter_class.should_receive(:new).
+      with(@emitter_hash.merge(:log_device => log_device)).
+      and_return(@mock_emitter)
+
+    add_emit_hooks @mock_emitter
+    logger = LwesLogger.new "127.0.0.1", :log_device => log_device
+
+    logger << "test log"
+
+    assert_equal 2, @mock_emitter.emitted.length
+    assert_equal ["LwesLogger::Full", event_hash], @mock_emitter.emitted[0]
+    assert_equal ["LwesLogger::Any", event_hash], @mock_emitter.emitted[1]
+
+    log_device.rewind
+    assert_equal "test log", log_device.read
+  end
+
+
+  def test_add
+    event_hash = @logger.build_log_event Logger::DEBUG, "test log"
+
+    log_device = StringIO.new("")
+
+    @lwes_emitter_class.should_receive(:new).
+      with(@emitter_hash.merge(:log_device => log_device)).
+      and_return(@mock_emitter)
+
+    add_emit_hooks @mock_emitter
+    logger = LwesLogger.new "127.0.0.1", :log_device => log_device
+
+    logger.add Logger::DEBUG, "test log"
+    args = [logger.send(:format_severity, Logger::DEBUG),
+            @time, nil, "test log"]
+
+    log_line = logger.send :format_message, *args
+
+    assert_equal 2, @mock_emitter.emitted.length
+    assert_equal ["LwesLogger::Full", event_hash], @mock_emitter.emitted[0]
+    assert_equal ["LwesLogger::Debug", event_hash], @mock_emitter.emitted[1]
+
+    log_device.rewind
+    assert_equal log_line, log_device.read
+  end
+
+
+  def test_namespace=
+    @logger.namespace = "test_namespace"
+    assert_equal "TestNamespace", @logger.namespace
+  end
+
+
+  def test_build_log_event
+    hash = @logger.build_log_event Logger::DEBUG,
+                                   "log message",
+                                   "log prog",
+                                   :extra_data => "data"
+
+    assert_equal({
+      :extra_data => "data",
+      :message    => "log message",
+      :progname   => "log prog",
+      :timestamp  => @time.strftime("%b %d %H:%M:%S"),
+      :severity   => "DEBUG",
+      :event_id   => "LwesLogger::Debug-uuid_timestamp",
+      :hostname   => Socket.gethostname,
+      :pid        => $$.to_s
+    }, hash)
+  end
+
+
+  def test_build_log_event_overrides
+    hash = @logger.build_log_event Logger::DEBUG,
+                                   "log message",
+                                   "log prog",
+                                   :message => "overriden",
+                                   :pid     => 0
+
+    assert_equal "0", hash[:pid]
+    assert_equal "overriden", hash[:message]
+  end
+
+
+  def test_build_log_event_message
+    hash = @logger.build_log_event Logger::DEBUG, "log message", "log prog" do
+             "msg from block"
+           end
+    assert_equal "log message", hash[:message]
+
+    hash = @logger.build_log_event Logger::DEBUG, nil, "log prog" do
+             "msg from block"
+           end
+    assert_equal "msg from block", hash[:message]
+
+    hash = @logger.build_log_event Logger::DEBUG, nil, "log prog"
+    assert_equal "log prog", hash[:message]
+  end
+
+
+  def test_build_log_event_severity
+    hash = @logger.build_log_event nil
+    assert_equal "ANY", hash[:severity]
+  end
+
+
+  def test_build_log_event_progname
+    @logger.instance_variable_set("@progname", "inst progname")
+    hash = @logger.build_log_event Logger::DEBUG
+    assert_equal "inst progname", hash[:progname]
+  end
+
+
+  def test_emit_log
+    event_hash = @logger.build_log_event Logger::DEBUG, "log msg"
+
+    @mock_emitter.should_receive(:emit).with "LwesLogger::Full", event_hash
+    @mock_emitter.should_receive(:emit).with "LwesLogger::Debug", event_hash
+
+    @logger.emit_log Logger::DEBUG, "log msg"
+  end
+
+
+  def test_emit_log_full_only
+    @logger.full_logs_only = true
+    event_hash = @logger.build_log_event Logger::DEBUG, "log msg"
+
+    add_emit_hooks @mock_emitter
+    @logger.emit_log Logger::DEBUG, "log msg"
+
+    assert_equal 1, @mock_emitter.emitted.length
+    assert_equal ["LwesLogger::Full", event_hash], @mock_emitter.emitted.first
+  end
+
+
+  def test_emit_log_severity_only
+    @logger.full_logs_event = false
+    event_hash = @logger.build_log_event Logger::DEBUG, "log msg"
+
+    add_emit_hooks @mock_emitter
+    @logger.emit_log Logger::DEBUG, "log msg"
+
+    assert_equal 1, @mock_emitter.emitted.length
+    assert_equal ["LwesLogger::Debug", event_hash], @mock_emitter.emitted.first
+  end
+
+
+  def test_call_format
+    time = Time.now
+    timestamp = time.strftime("%b %d %H:%M:%S")
+
+    host = Socket.gethostname
+    sev  = "ERROR"
+    prog = "prog"
+    msg  = "message"
+
+    results = @logger.send(:call_format, sev, time, prog, msg)
+    expected = "#{host} [#{timestamp}##{$$}] #{sev} -- #{prog}: #{msg}\n"
+
+    assert_equal expected, results
+  end
+
+
+  def test_camelize
+    assert_equal "TestThing",  @logger.send(:camelize, "test_thing")
+    assert_equal "Test-thing", @logger.send(:camelize, "test-thing")
+    assert_equal "Test-Thing", @logger.send(:camelize, "Test-_thing")
+    assert_equal "Test_thing", @logger.send(:camelize, "test__thing")
+    assert_equal "TESTTHING",  @logger.send(:camelize, "TEST_THING")
+    assert_equal "TestThing",  @logger.send(:camelize, "TestThing")
+  end
+
+
+  private
+
+  def add_emit_hooks emitter
+    emitter.instance_eval do
+      def emit *args
+        @emitted ||= []
+        @emitted << args
+      end
+      def emitted
+        @emitted
+      end
+      def reset_emitted
+        @emitted = []
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification 
+name: lwes-logger
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jeremie Castagna
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: lwes
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 6
+        version: "0.6"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 2
+        - 1
+        version: "2.1"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: flexmock
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 6
+        - 2
+        version: 2.6.2
+  type: :development
+  version_requirements: *id005
+description: Lwes based ruby logger for real-time logging.
+email: 
+- jcastagna@attinteractive.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/lwes_logger.rb
+- test/test_lwes_logger.rb
+has_rdoc: true
+homepage: http://github.com/yaksnrainbows/lwes-logger
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: lwes-logger
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Lwes based ruby logger for real-time logging.
+test_files: 
+- test/test_lwes_logger.rb