semantic_logger 0.0.2 → 0.1.0

data/FUTURE.rb

@@ -207,5 +207,3 @@
 #                option helps to create more human readable output for
 #                multithread application logs.
 
-
-

data/README.md

@@ -39,7 +39,7 @@ This can be changed over time to:
 Using this semantic example, a machine can easily find all queries for table
 'users' that took longer than 100 ms.
 
-    db.logs.find({"data.table":"users", "data.action":"query"})
+    db.logs.find({"metadata.table":"users", "metadata.action":"query"})
 
 Since SemanticLogger can call existing Loggers, it does not force end-users
 to have to adopt a Semantic aware adapter. Although, such adapters create

data/Rakefile

@@ -18,7 +18,7 @@ task :gem  do |t|
     spec.homepage    = 'https://github.com/ClarityServices/semantic_logger'
     spec.date        = Date.today.to_s
     spec.summary     = "Semantic Logger for Ruby, and Ruby on Rails"
-    spec.description = "Logging with additional machine readable and parseable log data"
+    spec.description = "Machine readable document oriented logging with support for MongoDB and text files"
     spec.files       = FileList["./**/*"].exclude('*.gem', 'nbproject').map{|f| f.sub(/^\.\//, '')}
     spec.has_rdoc    = true
     spec.add_development_dependency 'shoulda'

data/lib/semantic_logger.rb

@@ -7,9 +7,7 @@ module SemanticLogger
   module Appender
     autoload :Logger, 'semantic_logger/appender/logger'
     # Only load the MongoDB appender if the Mongo Ruby Driver is loaded
-    if defined?(Mongo)
-      autoload :MongoDB, 'semantic_logger/appender/mongodb'
-    end
+    autoload :MongoDB, 'semantic_logger/appender/mongodb'
   end
 end
 

data/lib/semantic_logger/appender/logger.rb

@@ -2,18 +2,6 @@
 #
 #   Maps the SemanticLogger API's to the Rails log, log4j, or Ruby Logger
 #
-# Installation:
-#    Rails.logger = SemanticLogger::Appender::Logger.new(Rails.logger)
-#
-# Also works with the Ruby Logger
-#    require 'logger'
-#    require 'semantic_logger'
-#    logger = Logger.new(STDOUT)
-#    Rails.log = SemanticLogger::Appender::Logger.new(logger)
-#
-# ActiveResource::BufferedLogger
-#    ...
-#
 # The log level is controlled by the Logging implementation passed into
 # this appender
 module SemanticLogger
@@ -21,80 +9,64 @@ module SemanticLogger
     class Logger
       attr_reader :logger
 
-      def initialize(logger)
+      # Create a Logger or Rails Logger appender instance
+      #
+      # Ruby Logger
+      #    require 'logger'
+      #    require 'semantic_logger'
+      #    ruby_logger = Logger.new(STDOUT)
+      #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::Logger.new(ruby_logger)
+      #    logger =  SemanticLogger::Logger.new('test')
+      #    logger.info('Hello World', :some => :payload)
+      #
+      # Enhance the Rails Logger
+      #    # Add the Rails logger to the list of appenders
+      #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::Logger.new(Rails.logger)
+      #    Rails.logger = SemanticLogger::Logger.new('Rails')
+      #
+      #    # Make ActiveRecord logging include its class name in every log entry
+      #    ActiveRecord::Base.logger = SemanticLogger::Logger.new('ActiveRecord')
+      def initialize(logger, &block)
         raise "logger cannot be null when initiailizing the SemanticLogging::Appender::Logger" unless logger
         @logger = logger
+
+        # Set the formatter to the supplied block
+        @formatter = block || self.default_formatter
       end
 
-      # The default log formatter
-      # Generates logs of the form:
+      # Default log formatter
+      #  Replace this formatter by supplying a Block to the initializer
+      #  Generates logs of the form:
       #    2011-07-19 14:36:15.660 D [1149:ScriptThreadProcess] Rails -- Hello World
-      @@formatter = Proc.new do |level, name, message, time, duration|
-        str = "#{time.strftime("%Y-%m-%d %H:%M:%S")}.#{"%03d" % (time.usec/1000)} #{level.to_s[0..0].upcase} [#{$$}:#{thread_name}] #{name} -- #{message}\n"
-        str << " (#{duration}ms)" if duration
-        str
-      end
+      def default_formatter
+        Proc.new do |log|
+          message = log.message.to_s
+          if log.payload
+            if log.payload.is_a?(Exception)
+              exception = log.payload
+              message << " -- " << "#{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
+            else
+              message << " -- " << log.payload.inspect
+            end
+          end
 
-      # For JRuby include the Thread name rather than its id
-      if defined? Java
-        def self.thread_name
-          Java::java.lang::Thread.current_thread.name
-        end
-      else
-        def self.thread_name
-          Thread.object_id
+          str = "#{log.time.strftime("%Y-%m-%d %H:%M:%S")}.#{"%03d" % (log.time.usec/1000)} #{log.level.to_s[0..0].upcase} [#{$$}:#{log.thread_name}] #{log.name} -- #{message}\n"
+          str << " (#{log.duration}ms)" if log.duration
+          str
         end
       end
 
-      # Allow the global formatter to be replaced
-      def self.formatter=(formatter)
-        @@formatter = formatter
-      end
-
       # Pass log calls to the underlying Rails, log4j or Ruby logger
       #  trace entries are mapped to debug since :trace is not supported by the
       #  Ruby or Rails Loggers
-      def log(level, name, message, hash, &block)
-        @logger.send(level == :trace ? :debug : level) { self.class.format_message(level, name, message, hash, &block) }
+      def log(log)
+        @logger.send(log.level == :trace ? :debug : log.level, @formatter.call(log))
       end
 
-      # Convert a semantic log entry into plain text
-      def self.format_message(level, name, message, hash=nil, &block)
-        # TODO need to define :try if not already defined. E.g. Outside Rails
-        msg = time = duration = nil
-        if hash
-          msg      = hash.delete(:message)
-          time     = hash.delete(:time)
-          duration = hash.delete(:duration)
-        end
-        msg  ||= message.to_s
-        time ||= Time.now
-
-        msg << " -- " << self.msg2str(hash) if hash
-        msg << " -- " << self.msg2str(block.call) if block
-        @@formatter.call(level, name, msg, time, duration)
-      end
-
-      # Convert Objects to Strings for text based logging
-      def self.msg2str(message)
-        case message
-        when ::String
-          message
-        when ::Exception
-          "#{message.class}: #{message.message}\n#{(message.backtrace || []).join("\n")}"
-        when ::Hash
-          # With a hash, the message can be an element of the hash itself
-          if msg = message[:message]
-            # Cannot change supplied hash
-            hash = message.clone
-            hash.delete(:message)
-            "#{msg} #{hash.inspect}"
-          else
-            message.inspect
-          end
-        else
-          message.inspect
-        end
+      # Flush all pending logs to disk.
+      #  Waits for all sent documents to be writted to disk
+      def flush
+        @logger.flush
       end
 
     end

data/lib/semantic_logger/appender/mongodb.rb

@@ -46,9 +46,8 @@ module SemanticLogger
       attr_accessor :formatter, :host_name, :safe, :application
 
       # Create a MongoDB Appender instance
-      # SemanticLogger::Appender::MongoDB.new(
-      #         :db => Cache::Work.db
-      #        )
+      #
+      #   SemanticLogger::Appender::MongoDB.new(:db => Mongo::Connection.new['database'])
       #
       # Parameters:
       # :db [Mongo::Database]
@@ -128,34 +127,40 @@ module SemanticLogger
         @collection ||= db[collection_name]
       end
 
-      # For JRuby include the Thread name rather than its id
-      if defined? Java
-        def self.thread_name
-          Java::java.lang::Thread.current_thread.name
-        end
-      else
-        def self.thread_name
-          Thread.object_id
-        end
+      # Flush all pending logs to disk.
+      #  Waits for all sent documents to be writted to disk
+      def flush
+        db.get_last_error
       end
 
       # Default log formatter
       #  Replace this formatter by supplying a Block to the initializer
       def default_formatter
-        Proc.new do |level, name, message, hash, block|
+        Proc.new do |log|
           document = {
-            :time      => Time.now,
-            :host_name => host_name,
-            :pid       => $PID,
-            :thread    => SemanticLogger::Appender::MongoDB.thread_name,
-            :name      => name,
-            :level     => level,
+            :time        => log.time,
+            :host_name   => host_name,
+            :pid         => $PID,
+            :thread_name => log.thread_name,
+            :name        => log.name,
+            :level       => log.level,
           }
           document[:application] = application if application
-          document[:message] = self.class.strip_colorizing(message) if message
+          document[:message]     = self.class.strip_colorizing(log.message) if log.message
+          document[:duration]    = log.duration if log.duration
 
-          SemanticLogger::Appender::MongoDB.populate(document, hash) if hash
-          SemanticLogger::Appender::MongoDB.populate(document, block.call) if block
+          if log.payload
+            if log.payload.is_a?(Exception)
+              exception = log.payload
+              document[:payload] = {
+                :exception => exception.class.name,
+                :message   => exception.message,
+                :backtrace => exception.backtrace
+              }
+            else
+              document[:payload] = log.payload
+            end
+          end
           document
         end
       end
@@ -165,55 +170,15 @@ module SemanticLogger
         message.to_s.gsub(/(\e(\[([\d;]*[mz]?))?)?/, '').strip
       end
 
-      # Log the message
-      def log(level, name, message, hash, &block)
+      # Log the message to MongoDB
+      def log(log)
         # Insert log entry into Mongo
         # Use safe=>false so that we do not wait for it to be written to disk, or
         # for the response from the MongoDB server
-        document = formatter.call(level, name, message, hash, &block)
+        document = formatter.call(log)
         collection.insert(document, :safe=>safe)
       end
 
-      # Populate Log Hash
-      def self.populate(document, message)
-        case message
-        when ::String
-          if document[:message]
-            document[:message] << " " << strip_colorizing(message)
-          else
-            document[:message] = strip_colorizing(message)
-          end
-        when ::Exception
-          document[:exception] = {
-            :class => message.class.name,
-            :message => message.message,
-            :backtrace => message.backtrace
-          }
-        when ::Hash
-          # With a hash, the message can be an element of the hash itself
-          if msg = message[:message]
-            # Cannot change supplied hash
-            hash = message.clone
-            hash.delete(:message)
-            if document[:message]
-              document[:message] << " " << strip_colorizing(msg)
-            else
-              document[:message] = strip_colorizing(msg)
-            end
-            document[:metadata] = hash
-          else
-            document[:metadata] = message
-          end
-        else
-          if document[:message]
-            document[:message] << " " << msg.inspect
-          else
-            document[:message] = msg.inspect
-          end
-        end
-        document
-      end
-
     end
   end
 end

data/lib/semantic_logger/logger.rb

@@ -26,8 +26,8 @@ module SemanticLogger
   class Logger
     include SyncAttr
 
-    # Logging levels in order of precendence
-    LEVELS = [:trace, :debug, :info, :warn, :error]
+    # Logging levels in order of precedence
+    LEVELS = [:trace, :debug, :info, :warn, :error, :fatal]
 
     # Mapping of Rails and Ruby Logger levels to SemanticLogger levels
     MAP_LEVELS = []
@@ -49,7 +49,7 @@ module SemanticLogger
       @@default_level
     end
 
-    attr_reader :application, :level
+    attr_reader :name, :level
 
     @@default_level = :info
 
@@ -59,8 +59,8 @@ module SemanticLogger
     #               to be used in the logger
     #  options:
     #    :level   The initial log level to start with for this logger instance
-    def initialize(application, options={})
-      @application = application.is_a?(String) ? application : application.name
+    def initialize(klass, options={})
+      @name = klass.is_a?(String) ? klass : klass.name
       set_level(options[:level] || self.class.default_level)
     end
 
@@ -77,7 +77,7 @@ module SemanticLogger
     #   logger.debug?
     #
     # Example:
-    #   logger = SemanticLogging::Logger.new('MyApplication')
+    #   logger = SemanticLogging::Logger.new(self)
     #   logger.debug("Only display this if log level is set to Debug or lower")
     #
     #   # Log semantic information along with a text message
@@ -88,35 +88,110 @@ module SemanticLogger
     #
     LEVELS.each_with_index do |level, index|
       class_eval <<-EOT, __FILE__, __LINE__
-        def #{level}(message = nil, data = nil, &block)                                                          # def trace(message = nil, data = nil, &block)
-          if @level_index <= #{index}                                                                            #   if @level_index <= 0
-            self.class.appenders.each {|appender| appender.log(:#{level}, application, message, data, &block) }  #     self.class.appenders.each {|appender| appender.log(:trace, application, message, data, &block) }
-            true                                                                                                 #     true
-          else                                                                                                   #   else
-            false                                                                                                #     false
-          end                                                                                                    #   end
-        end                                                                                                      # end
-
-        def #{level}?                                                                                            # def trace?
-          @level_index <= #{index}                                                                               #   @level_index <= 0
-        end                                                                                                      # end
+        def #{level}(message = nil, payload = nil)
+          if @level_index <= #{index}
+            if block_given? && (result = yield)
+              if result.is_a?(String)
+                message = message.nil? ? result : "\#{message} -- \#{result.to_s}"
+              else
+                payload = payload.nil? ? sresult : payload.merge(result)
+              end
+            end
+            self.class.queue << Log.new(:#{level}, self.class.thread_name, name, message, payload, Time.now)
+            true
+          else
+            false
+          end
+        end
+
+        def #{level}?
+          @level_index <= #{index}
+        end
+
+        def benchmark_#{level}(message, payload = nil)
+          raise "Mandatory block missing" unless block_given?
+          if @level_index <= #{index}
+            start = Time.now
+            result = yield
+            self.class.queue << Log.new(:#{level}, self.class.thread_name, name, message, payload, start, Time.now - start)
+            result
+          else
+            yield
+          end
+        end
       EOT
     end
 
-    # Semantic Logging does not support :fatal or :unknown levels since these
+    # Semantic Logging does not support :unknown level since these
     # are not understood by the majority of the logging providers
-    # Map them to :error
-    alias :fatal :error
-    alias :fatal? :error?
+    # Map it to :error
     alias :unknown :error
     alias :unknown? :error?
 
-    # forward other calls to ActiveResource::BufferedLogger
-    # #silence is not implemented since it is not thread safe prior to Rails 3.2
-    # #TODO implement a thread safe silence method
+    # #TODO implement a thread safe #silence method
+
+    # Returns [Integer] the number of log entries that have not been written
+    # to the appenders
+    #
+    # When this number grows it is because the logging appender thread is not
+    # able to write to the appenders fast enough. Either reduce the amount of
+    # logging, increase the log level, reduce the number of appenders, or
+    # look into speeding up the appenders themselves
+    def self.cache_count
+      queue.size
+    end
+
+    # Flush all pending log entry disk, database, etc.
+    #  All pending log writes are completed and each appender is flushed in turn
+    def flush
+      self.class.flush
+    end
 
+    # Flush all pending log entry disk, database, etc.
+    #  All pending log writes are completed and each appender is flushed in turn
+    def self.flush
+      return false unless @@appender_thread.alive?
+
+      reply_queue = Queue.new
+      queue << { :command => :flush, :reply_queue => reply_queue }
+      reply_queue.pop
+    end
+
+    # Internal logger for SymanticLogger
+    #   For example when an appender is not working etc..
+    #   By default logs to STDERR, replace with another Ruby logger or Rails
+    #   logger, but never to SemanticLogger itself
+    sync_cattr_accessor :logger do
+      require 'logger'
+      l = ::Logger.new(STDOUT)
+      l.level = ::Logger::INFO
+      l
+    end
+
+    ############################################################################
     protected
 
+    # Log to queue
+    #   Starts the appender thread the first time a logging call is made
+    sync_cattr_reader :queue do
+      startup
+      at_exit { shutdown }
+      Queue.new
+    end
+
+    Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration)
+
+    # For JRuby include the Thread name rather than its id
+    if defined? Java
+      def self.thread_name
+        Java::java.lang::Thread.current_thread.name
+      end
+    else
+      def self.thread_name
+        Thread.object_id
+      end
+    end
+
     # Verify and set the level
     def set_level(level)
       index = if level.is_a?(Integer)
@@ -132,5 +207,51 @@ module SemanticLogger
       @level_index = index
       @level = level
     end
+
+    # Start a separate appender thread responsible for reading log messages and
+    # calling the appenders in it's thread
+    def self.startup
+      @@appender_thread = Thread.new do
+        begin
+          # #TODO Logger needs it's own "reliable" appender ;)
+          # For example if an appender constantly fails
+          # ( bad filename or path, invalid server )
+          logger.debug "SemanticLogger::Logger Appender Thread Started"
+          while message=queue.pop
+            if message.is_a? Log
+              appenders.each {|appender| appender.log(message) }
+            else
+              case message[:command]
+              when :shutdown
+                appenders.each {|appender| appender.flush }
+                message[:reply_queue] << true
+                logger.debug "SemanticLogger::Logger appenders flushed, now shutting down"
+                break
+              when :flush
+                appenders.each {|appender| appender.flush }
+                message[:reply_queue] << true
+                logger.debug "SemanticLogger::Logger appenders flushed"
+              end
+            end
+          end
+        rescue Exception => exception
+          logger.fatal "SemanticLogger::Logger Appender Thread crashed: #{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
+          exit(-2)
+        ensure
+          logger.debug "SemanticLogger::Logger Appender Thread stopped"
+        end
+      end
+    end
+
+    # Stop the log appender thread and flush all appenders
+    def self.shutdown
+      return false unless @@appender_thread.alive?
+
+      logger.debug "SemanticLogger::Logger Shutdown. Stopping appender thread"
+      reply_queue = Queue.new
+      queue << { :command => :shutdown, :reply_queue => reply_queue }
+      reply_queue.pop
+    end
+
   end
-end
+end

data/lib/semantic_logger/railtie.rb

@@ -9,7 +9,7 @@ module SemanticLogger #:nodoc:
     #     # Add the MongoDB logger appender only once Rails is initialized
     #     config.after_initialize do
     #       config.semantic_logger.appenders << SemanticLogger::Appender::Mongo.new(
-    #         :db => Cache::Work.db
+    #         :db => Mongo::Connection.new['development_development']
     #        )
     #     end
     #   end
@@ -26,6 +26,10 @@ module SemanticLogger #:nodoc:
     initializer :initialize_semantic_logger, :after => :initialize_logger do
       config = Rails.application.config
 
+      # First set the internal logger to the one used by Rails in case something goes wrong
+      # with an appender
+      SemanticLogger::Logger.logger = Rails.logger
+
       # Add the Rails Logger to the list of appenders
       SemanticLogger::Logger.appenders << SemanticLogger::Appender::Logger.new(Rails.logger)
 

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/test/appender_logger_test.rb

@@ -5,7 +5,7 @@ require 'rubygems'
 require 'test/unit'
 require 'shoulda'
 require 'logger'
-require 'semantic_logger/appender/logger'
+require 'semantic_logger'
 require 'test/mock_logger'
 
 # Unit Test for SemanticLogger::Appender::Logger
@@ -14,64 +14,59 @@ class AppenderLoggerTest < Test::Unit::TestCase
   context SemanticLogger::Appender::Logger do
     setup do
       @time = Time.parse("2012-08-02 09:48:32.482")
+      @mock_logger = MockLogger.new
+      @appender = SemanticLogger::Appender::Logger.new(@mock_logger)
+      @hash = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
     end
 
-    context "format messages into text form" do
-      setup do
-        @hash = { :session_id=>"HSSKLEU@JDK767", :tracking_number=>12345 }
+    context "format logs into text form" do
+      should "handle nil name, message and payload" do
+        log = SemanticLogger::Logger::Log.new
+        log.time = Time.now
+        log.level = :debug
+        @appender.log(log)
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\]  -- \n/, @mock_logger.message
       end
 
-      should "handle nil level, application, message and hash" do
-        msg = SemanticLogger::Appender::Logger.format_message(nil, nil, nil, nil)
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+  \[\d+:\w+\]  -- \n/, msg
+      should "handle nil message and payload" do
+        log = SemanticLogger::Logger::Log.new
+        log.time = Time.now
+        log.level = :debug
+        log.name = 'class'
+        @appender.log(log)
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class -- \n/, @mock_logger.message
       end
 
-      should "handle nil application, message and hash" do
-        msg = SemanticLogger::Appender::Logger.format_message(:debug, nil, nil, nil)
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\]  -- \n/, msg
+      should "handle nil payload" do
+        log = SemanticLogger::Logger::Log.new
+        log.time = Time.now
+        log.level = :debug
+        log.name = 'class'
+        log.message = 'hello world'
+        @appender.log(log)
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class -- hello world\n/, @mock_logger.message
       end
 
-      should "handle nil message and hash" do
-        msg = SemanticLogger::Appender::Logger.format_message(:debug, 'application', nil, nil)
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\] application -- \n/, msg
-      end
-
-      should "handle nil hash" do
-        msg = SemanticLogger::Appender::Logger.format_message(:debug, 'application', 'hello world', nil)
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\] application -- hello world\n/, msg
-      end
-
-      should "handle hash" do
-        msg = SemanticLogger::Appender::Logger.format_message(:debug, 'application', 'hello world', @hash)
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\] application -- hello world -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\}\n/, msg
-      end
-
-      should "handle block" do
-        msg = SemanticLogger::Appender::Logger.format_message(:debug, 'application', 'hello world', @hash) { "Calculations" }
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\] application -- hello world -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\} -- Calculations\n/, msg
-      end
-
-      should "handle block with no other parameters" do
-        msg = SemanticLogger::Appender::Logger.format_message(:debug, nil, nil, nil) { "Calculations" }
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\w+\]  --  -- Calculations\n/, msg
+      should "handle payload" do
+        log = SemanticLogger::Logger::Log.new
+        log.time = Time.now
+        log.level = :debug
+        log.name = 'class'
+        log.message = 'hello world'
+        log.payload = @hash
+        @appender.log(log)
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class -- hello world -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\}\n/, @mock_logger.message
       end
     end
 
-    context "log to Ruby logger" do
-      setup do
-        @mock_logger = MockLogger.new
-        @appender = SemanticLogger::Appender::Logger.new(@mock_logger)
-        @hash = { :tracking_number => 12345, :session_id => 'HSSKLEU@JDK767'}
-      end
-
+    context "for each log level" do
       # Ensure that any log level can be logged
       Logger::Severity.constants.each do |level|
         should "log #{level.downcase.to_sym} info" do
-          @appender.log(level.downcase.to_sym, 'application', 'hello world', @hash) { "Calculations" }
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:\w+\] application -- hello world -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\} -- Calculations\n/, @mock_logger.message
+          @appender.log SemanticLogger::Logger::Log.new(level.downcase.to_sym, 'thread', 'class', 'hello world -- Calculations', @hash, Time.now)
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:thread\] class -- hello world -- Calculations -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\}\n/, @mock_logger.message
         end
       end
-
     end
 
   end

data/test/appender_mongodb_test.rb

@@ -4,11 +4,8 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
-require 'logger'
 require 'mongo'
-require 'sync_attr'
-require 'semantic_logger/logger'
-require 'semantic_logger/appender/mongodb'
+require 'semantic_logger'
 
 # Unit Test for SemanticLogger::Appender::MongoDB
 #
@@ -16,98 +13,103 @@ class AppenderMongoDBTest < Test::Unit::TestCase
   context SemanticLogger::Appender::MongoDB do
     setup do
       @db = Mongo::Connection.new['test']
+      @appender = SemanticLogger::Appender::MongoDB.new(
+        :db               => @db,
+        :collection_size  => 10*1024**2, # 10MB
+        :host_name        => 'test',
+        :application      => 'test_application'
+      )
+      @hash = { :tracking_number => 12345, :session_id => 'HSSKLEU@JDK767'}
+      @time = Time.now
     end
 
-    context "configuration" do
-      #TODO verify configuration setting carry through
+    teardown do
+      @appender.purge_all
     end
 
-    context "formatter" do
-      setup do
-        @appender = SemanticLogger::Appender::MongoDB.new(
-          :db               => @db,
-          :collection_size  => 10*1024**2, # 10MB
-          :host_name        => 'test',
-          :application      => 'test_application'
-        )
-        @time = Time.parse("2012-08-02 09:48:32.482")
-        @hash = { :session_id=>"HSSKLEU@JDK767", :tracking_number=>12345 }
+    context "format logs into documents" do
+
+      should "handle nil name, message and hash" do
+        @appender.log SemanticLogger::Logger::Log.new(:debug)
+        document = @appender.collection.find_one
+        assert_equal :debug, document['level']
+        assert_equal nil, document['message']
+        assert_equal nil, document['thread_name']
+        assert_equal nil, document['time']
+        assert_equal nil, document['payload']
+        assert_equal $PID, document['pid']
+        assert_equal 'test', document['host_name']
+        assert_equal 'test_application', document['application']
       end
 
-      context "format messages into text form" do
-        should "handle nil level, application, message and hash" do
-          document = @appender.formatter.call(nil, nil, nil, nil)
-          assert_equal({ :level=>nil, :time=>document[:time], :name=>nil, :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application'}, document)
-        end
-
-        should "handle nil application, message and hash" do
-          document = @appender.formatter.call(:debug, nil, nil, nil)
-          assert_equal({ :level=>:debug, :time=>document[:time], :name=>nil, :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application'}, document)
-        end
-
-        should "handle nil message and hash" do
-          document = @appender.formatter.call(:debug, nil, nil, @hash)
-          assert_equal({ :level=>:debug, :time=>document[:time], :name=>nil, :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
-        end
-
-        should "handle nil hash" do
-          document = @appender.formatter.call(:debug, 'myclass', 'hello world', nil)
-          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world'}, document)
-        end
-
-        should "handle hash" do
-          document = @appender.formatter.call(:debug, 'myclass', 'hello world', @hash)
-          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
-        end
-
-        should "handle string block with no message" do
-          document = @appender.formatter.call(:debug, 'myclass', nil, @hash, Proc.new { "Calculations" })
-          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'Calculations', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
-        end
-
-        should "handle string block" do
-          document = @appender.formatter.call(:debug, 'myclass', 'hello world', @hash, Proc.new { "Calculations" })
-          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world Calculations', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
-        end
-
-        should "handle hash block" do
-          document = @appender.formatter.call(:debug, 'myclass', 'hello world', nil, Proc.new { @hash })
-          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
-        end
-
-        should "handle string block with no other parameters" do
-          document = @appender.formatter.call(:debug, 'myclass', 'hello world', @hash, Proc.new { "Calculations" })
-          assert_equal({ :level=>:debug, :time=>document[:time], :name=>'myclass', :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world Calculations', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
-        end
-
-        should "handle hash block with no other parameters" do
-          document = @appender.formatter.call(:debug, nil, nil, nil, Proc.new { @hash.merge(:message => 'hello world') })
-          assert_equal({ :level=>:debug, :time=>document[:time], :name=>nil, :pid=>$PID, :host_name=>"test", :thread=>document[:thread], :application=>'test_application', :message=>'hello world', :metadata=>{:session_id=>"HSSKLEU@JDK767", :tracking_number=>12345}}, document)
-        end
+      should "handle nil message and payload" do
+        log = SemanticLogger::Logger::Log.new(:debug)
+        log.payload = @hash
+        @appender.log(log)
+
+        document = @appender.collection.find_one
+        assert_equal :debug, document['level']
+        assert_equal nil, document['message']
+        assert_equal nil, document['thread_name']
+        assert_equal nil, document['time']
+        assert_equal({ "tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
+        assert_equal $PID, document['pid']
+        assert_equal 'test', document['host_name']
+        assert_equal 'test_application', document['application']
       end
-    end
 
-    context "log to Mongo logger" do
-      setup do
-        @appender = SemanticLogger::Appender::MongoDB.new(
-          :db               => @db,
-          :collection_size  => 10*1024**2, # 10MB
-          :host_name        => 'test',
-          :application      => 'test_application'
-        )
-        @hash = { :tracking_number => 12345, :session_id => 'HSSKLEU@JDK767'}
+      should "handle message and payload" do
+        log = SemanticLogger::Logger::Log.new(:debug)
+        log.message = 'hello world'
+        log.payload = @hash
+        log.thread_name = 'thread'
+        log.time = @time
+        @appender.log(log)
+
+        document = @appender.collection.find_one
+        assert_equal :debug, document['level']
+        assert_equal 'hello world', document['message']
+        assert_equal 'thread', document['thread_name']
+        assert_equal @time.to_i, document['time'].to_i
+        assert_equal({ "tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
+        assert_equal $PID, document['pid']
+        assert_equal 'test', document['host_name']
+        assert_equal 'test_application', document['application']
       end
 
-      teardown do
-        @appender.purge_all
+      should "handle message without payload" do
+        log = SemanticLogger::Logger::Log.new(:debug)
+        log.message = 'hello world'
+        log.thread_name = 'thread'
+        log.time = @time
+        @appender.log(log)
+
+        document = @appender.collection.find_one
+        assert_equal :debug, document['level']
+        assert_equal 'hello world', document['message']
+        assert_equal 'thread', document['thread_name']
+        assert_equal @time.to_i, document['time'].to_i
+        assert_equal nil, document['payload']
+        assert_equal $PID, document['pid']
+        assert_equal 'test', document['host_name']
+        assert_equal 'test_application', document['application']
       end
+    end
 
+    context "for each log level" do
       # Ensure that any log level can be logged
       SemanticLogger::Logger::LEVELS.each do |level|
         should "log #{level} information" do
-          @appender.log(level, 'my_class', 'hello world', @hash) { "Calculations" }
+          @appender.log SemanticLogger::Logger::Log.new(level, 'thread', 'my_class', 'hello world -- Calculations', @hash, @time)
           document = @appender.collection.find_one
-          assert_equal({"_id"=>document['_id'], "level"=>level, "message"=>"hello world", "thread"=>document['thread'], "time"=>document['time'], 'metadata'=>{'session_id'=>"HSSKLEU@JDK767", 'tracking_number'=>12345}, "name"=>"my_class", "pid"=>document['pid'], "host_name"=>"test", "application"=>"test_application"}, document)
+          assert_equal level, document['level']
+          assert_equal 'hello world -- Calculations', document['message']
+          assert_equal 'thread', document['thread_name']
+          assert_equal @time.to_i, document['time'].to_i
+          assert_equal({ "tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
+          assert_equal $PID, document['pid']
+          assert_equal 'test', document['host_name']
+          assert_equal 'test_application', document['application']
         end
       end
 

data/test/logger_test.rb

@@ -23,7 +23,7 @@ class LoggerTest < Test::Unit::TestCase
         # Use this test's class name as the application name in the log output
         @logger = SemanticLogger::Logger.new('LoggerTest', :level => :trace)
 
-        @hash = { :tracking_number => 12345, :session_id => 'HSSKLEU@JDK767'}
+        @hash = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
       end
 
       teardown do
@@ -34,7 +34,8 @@ class LoggerTest < Test::Unit::TestCase
       SemanticLogger::Logger::LEVELS.each do |level|
         should "log #{level} info" do
           @logger.send(level, 'hello world', @hash) { "Calculations" }
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:\w+\] LoggerTest -- hello world -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\} -- Calculations\n/, @mock_logger.message
+          @logger.flush
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- hello world -- Calculations -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\}\n/, @mock_logger.message
         end
       end
 

data/test/mock_logger.rb

@@ -21,5 +21,9 @@ class MockLogger
         end
     EOT
   end
+
+  def flush
+    true
+  end
 end
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 2
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - Reid Morrison
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-08 00:00:00 -04:00
+date: 2012-08-17 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,7 +29,7 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id001
-description: Logging with additional machine readable and parseable log data
+description: Machine readable document oriented logging with support for MongoDB and text files
 email: 
 - reidmo@gmail.com
 executables: []