semantic_logger 0.5.3 → 0.6.0

data/lib/semantic_logger.rb

@@ -2,14 +2,17 @@
 require 'sync_attr'
 
 module SemanticLogger
+  autoload :Base,   'semantic_logger/base'
   autoload :Logger, 'semantic_logger/logger'
 
   module Appender
-    autoload :File, 'semantic_logger/appender/file'
-    autoload :Logger, 'semantic_logger/appender/logger'
-    # Only load the MongoDB appender if the Mongo Ruby Driver is loaded
+    autoload :File,    'semantic_logger/appender/file'
+    autoload :Wrapper, 'semantic_logger/appender/wrapper'
     autoload :MongoDB, 'semantic_logger/appender/mongodb'
   end
+
+  # Logging levels in order with most detailed logging first
+  LEVELS = [:trace, :debug, :info, :warn, :error, :fatal]
 end
 
 if defined?(Rails)

data/lib/semantic_logger/appender/file.rb

@@ -4,14 +4,16 @@
 #
 module SemanticLogger
   module Appender
-    class File
-      attr_accessor :formatter
+    class File < SemanticLogger::Base
 
       # Create a File Logger appender instance
       #
       # Example
       #    require 'semantic_logger'
       #
+      #    # Enable trace level logging
+      #    SemanticLogger::Logger.level = :info
+      #
       #    # Log to screen
       #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new(STDOUT)
       #
@@ -21,7 +23,23 @@ module SemanticLogger
       #    logger =  SemanticLogger::Logger.new('test')
       #    logger.info 'Hello World'
       #
-      def initialize(filename, &block)
+      # Example 2. To log all levels to file and only :info and above to screen:
+      #
+      #    require 'semantic_logger'
+      #
+      #    # Enable trace level logging
+      #    SemanticLogger::Logger.level = :trace
+      #
+      #    # Log to screen but only display :info and above
+      #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new(STDOUT, :info)
+      #
+      #    # And log to a file at the same time, including all :trace level data
+      #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('application.log')
+      #
+      #    logger =  SemanticLogger::Logger.new('test')
+      #    logger.info 'Hello World'
+      #
+      def initialize(filename, level=nil, &block)
         raise "logger cannot be null when initializing the SemanticLogging::Appender::Logger" unless filename
         @filename = filename
         @log = if filename.respond_to?(:write) and filename.respond_to?(:close)
@@ -29,38 +47,14 @@ module SemanticLogger
         else
           @log = open(filename, (::File::WRONLY | ::File::APPEND | ::File::CREAT))
           # Force all log entries to write immediately without buffering
+          # Allows multiple processes to write to the same log file simultaneously
           @log.sync = true
           @log.set_encoding(Encoding::BINARY) if @log.respond_to?(:set_encoding)
           @log
         end
 
-        # Set the formatter to the supplied block
-        @formatter = block || self.default_formatter
-      end
-
-      # 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\n
-      def default_formatter
-        Proc.new do |log|
-          message = log.message.to_s
-          tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
-
-          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
-
-          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}] #{tags}#{log.name} -- #{message}"
-          str << " (#{'%.1f' % log.duration}ms)" if log.duration
-          str << "\n"
-          str
-        end
+        # Set the log level and formatter if supplied
+        super(level, &block)
       end
 
       # Pass log calls to the underlying Rails, log4j or Ruby logger
@@ -69,7 +63,8 @@ module SemanticLogger
       def log(log)
         # Since only one appender thread will be writing to the file at a time
         # it is not necessary to protect access to the file with a semaphore
-        @log.write(@formatter.call(log))
+        # Allow this logger to filter out log levels lower than it's own
+        @log.write(@formatter.call(log) << "\n") if level_index <= (log.level_index || 0)
       end
 
       # Flush all pending logs to disk.

data/lib/semantic_logger/appender/mongodb.rb

@@ -1,3 +1,4 @@
+require 'socket'
 module SemanticLogger
   module Appender
     # The Mongo Appender for the SemanticLogger
@@ -41,9 +42,9 @@ module SemanticLogger
     #   params: Hash
     #
     #   tracking_number: 'user defined tracking number'
-    class MongoDB
+    class MongoDB < SemanticLogger::Base
       attr_reader :db, :collection_name
-      attr_accessor :formatter, :host_name, :safe, :application
+      attr_accessor :host_name, :safe, :application
 
       # Create a MongoDB Appender instance
       #
@@ -84,6 +85,9 @@ module SemanticLogger
       #  :collection_max [Integer]
       #    Maximum number of log entries that the capped collection will hold
       #
+      #  :level [Symbol]
+      #    Only allow log entries of this level or higher to be written to MongoDB
+      #
       def initialize(params={}, &block)
         @db              = params[:db] || raise('Missing mandatory parameter :db')
         @collection_name = params[:collection_name] || 'semantic_logger'
@@ -95,11 +99,11 @@ module SemanticLogger
         @collection_size = params[:collection_size] || 1024**3
         @collection_max  = params[:collection_max]
 
-        # Set the formatter to the supplied block
-        @formatter       = block || self.default_formatter
-
         # Create the collection and necessary indexes
         create_indexes
+
+        # Set the log level and formatter
+        super(params[:level], &block)
       end
 
       # Create the required capped collection
@@ -189,8 +193,7 @@ module SemanticLogger
         # 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(log)
-        collection.insert(document, :safe=>safe)
+        collection.insert(formatter.call(log), :safe=>safe) if level_index <= (log.level_index || 0)
       end
 
     end

data/lib/semantic_logger/appender/{logger.rb → wrapper.rb}

@@ -1,14 +1,11 @@
-# Logger appender
+# Wrapper appender
 #
-#   Maps the SemanticLogger API's to the Rails log, log4j, or Ruby Logger
+#   Wraps the Rails log, log4r, or Ruby Logger with the SemanticLogger API's
 #
-# The log level is controlled by the Logging implementation passed into
-# this appender
 module SemanticLogger
   module Appender
-    class Logger
+    class Wrapper < SemanticLogger::Base
       attr_reader :logger
-      attr_accessor :formatter
 
       # Create a Logger or Rails Logger appender instance
       #
@@ -16,48 +13,30 @@ module SemanticLogger
       #    require 'logger'
       #    require 'semantic_logger'
       #    ruby_logger = Logger.new(STDOUT)
-      #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::Logger.new(ruby_logger)
+      #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::Wrapper.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)
+      #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::Wrapper.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')
+      #
+      # Note: Since the log level is controlled by setting the Ruby or Rails logger directly
+      #   the level is ignored for this appender
       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
+        super(:trace, &block)
       end
 
-      # 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
-      def default_formatter
-        Proc.new do |log|
-          message = log.message.to_s
-          tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
-
-          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
-
-          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}] #{tags}#{log.name} -- #{message}"
-          str << " (#{'%.1f' % log.duration}ms)" if log.duration
-          str
-        end
-      end
+      # TODO Compatible calls to #level and #level= against the underlying Rails/Ruby logger
 
       # Pass log calls to the underlying Rails, log4j or Ruby logger
       #  trace entries are mapped to debug since :trace is not supported by the

data/lib/semantic_logger/base.rb

@@ -0,0 +1,280 @@
+# Base appender
+#
+#   Abstract base class for appenders
+#
+#   Implements common behavior such as log level, default text formatter etc
+#
+#   Note: Do not create instances of this class directly
+#
+module SemanticLogger
+  class Base
+    attr_accessor :formatter
+    attr_reader   :level
+
+    def initialize(level, &block)
+      # Set the formatter to the supplied block
+      @formatter = block || default_formatter
+
+      # Log everything that comes to the appender by default
+      self.level = level || :trace
+    end
+
+    # 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
+    def default_formatter
+      Proc.new do |log|
+        message = log.message.to_s
+        tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
+
+        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
+
+        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}] #{tags}#{log.name} -- #{message}"
+        str << " (#{'%.1f' % log.duration}ms)" if log.duration
+        str
+      end
+    end
+
+    # Write log data to underlying data storage
+    def log(log_)
+      raise "Logging Appender must implement #log(log)"
+    end
+
+    # Set the logging level for this appender
+    #
+    # Note: This level is only for this particular appender. It does not override
+    #   the log level in any logging instance or the default log level
+    #   SemanticLogger::Logger.level
+    #
+    # Must be one of the values in SemanticLogger::Logger::LEVELS
+    def level=(level)
+      @level_index = self.class.map_level_to_index(level)
+      @level = level
+    end
+
+    # Implement the log level calls
+    #   logger.debug(message, hash|exception=nil, &block)
+    #
+    # Implement the log level query
+    #   logger.debug?
+    #
+    # Example:
+    #    require 'semantic_logger'
+    #
+    #    # Enable trace level logging
+    #    SemanticLogger::Logger.level = :info
+    #
+    #    # Log to screen
+    #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new(STDOUT)
+    #
+    #    # And log to a file at the same time
+    #    SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('application.log')
+    #
+    #    logger = SemanticLogger::Logger.new('MyApplication')
+    #    logger.debug("Only display this if log level is set to Debug or lower")
+    #
+    #    # Log semantic information along with a text message
+    #    logger.info("Request received", :user => "joe", :duration => 100)
+    #
+    #    # Log an exception in a semantic way
+    #    logger.info("Parsing received XML", exc)
+    #
+    SemanticLogger::LEVELS.each_with_index do |level, index|
+      class_eval <<-EOT, __FILE__, __LINE__
+        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? ? result : payload.merge(result)
+              end
+            end
+            # Add scoped payload
+            if self.payload
+              payload = payload.nil? ? self.payload : self.payload.merge(payload)
+            end
+            log Log.new(:#{level}, self.class.thread_name, name, message, payload, Time.now, nil, tags, #{index})
+            true
+          else
+            false
+          end
+        end
+
+        def #{level}?
+          @level_index <= #{index}
+        end
+
+        # Log the duration of the supplied block
+        #   If an exception occurs in the block the exception is logged using the
+        #   same log level. The exception will flow through to the caller unchanged
+        def benchmark_#{level}(message, payload = nil)
+          raise "Mandatory block missing" unless block_given?
+          if @level_index <= #{index}
+            start = Time.now
+            begin
+              result = yield
+              end_time = Time.now
+              # Add scoped payload
+              if self.payload
+                payload = payload.nil? ? self.payload : self.payload.merge(payload)
+              end
+              log Log.new(:#{level}, self.class.thread_name, name, message, payload, end_time, 1000.0 * (end_time - start), tags, #{index})
+              result
+            rescue Exception => exc
+              # TODO Need to be able to have both an exception and a Payload
+              log Log.new(:#{level}, self.class.thread_name, name, message, exc, Time.now, 1000.0 * (Time.now - start), tags, #{index})
+              raise exc
+            end
+          else
+            yield
+          end
+        end
+      EOT
+    end
+
+    # Add the supplied tags to the list of tags to log for this thread whilst
+    # the supplied block is active
+    # Returns nil if no tags are currently set
+    def with_tags(*tags)
+      current_tags = self.tags
+      # Check for nil tags
+      if tags
+        Thread.current[:semantic_logger_tags] = current_tags ? current_tags + tags : tags
+      end
+      yield
+    ensure
+      Thread.current[:semantic_logger_tags] = current_tags
+    end
+
+    # Add support for the ActiveSupport::TaggedLogging
+    alias_method :tagged, :with_tags
+
+    # Returns [Array] of [String] tags currently active for this thread
+    # Returns nil if no tags are set
+    def tags
+      Thread.current[:semantic_logger_tags]
+    end
+
+    # Thread specific context information to be logged with every log entry
+    #
+    # Add a payload to all log calls on This Thread within the supplied block
+    #
+    #   logger.with_payload(:tracking_number=>12345) do
+    #     logger.debug('Hello World')
+    #   end
+    #
+    # If a log call already includes a pyload, this payload will be merged with
+    # the supplied payload, with the supplied payload taking precedence
+    #
+    #   logger.with_payload(:tracking_number=>12345) do
+    #     logger.debug('Hello World', :result => 'blah')
+    #   end
+    def with_payload(payload)
+      current_payload = self.payload
+      Thread.current[:semantic_logger_payload] = current_payload ? current_payload.merge(payload) : payload
+      yield
+    ensure
+      Thread.current[:semantic_logger_payload] = current_payload
+    end
+
+    # Returns [Hash] payload to be added to every log entry in the current scope
+    # on this thread.
+    # Returns nil if no payload is currently set
+    def payload
+      Thread.current[:semantic_logger_payload]
+    end
+
+    # Semantic Logging does not support :unknown level since these
+    # are not understood by the majority of the logging providers
+    # Map it to :error
+    alias :unknown :error
+    alias :unknown? :error?
+
+    # #TODO implement a thread safe #silence method
+
+    ############################################################################
+    protected
+
+    # Return the level index for fast comparisons
+    attr_reader :level_index
+
+    # Struct Log
+    #
+    # level
+    #   Log level of the supplied log call
+    #   :trace, :debug, :info, :warn, :error, :fatal
+    #
+    # thread_name
+    #   Name of the thread in which the logging call was called
+    #
+    # name
+    #   Class name supplied to the logging instance
+    #
+    # message
+    #   Text message to be logged
+    #
+    # payload
+    #   Optional Hash or Ruby Exception object to be logged
+    #
+    # time
+    #   The time at which the log entry was created
+    #
+    # duration
+    #   The time taken to complete a benchmark call
+    #
+    # tags
+    #   Any tags active on the thread when the log call was made
+    #
+    # level_index
+    #   Internal index of the log level
+    Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index)
+
+    # 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.current.object_id
+      end
+    end
+
+    # Internal method to return the log level as an internal index
+    # Also supports mapping the ::Logger levels to SemanticLogger levels
+    def self.map_level_to_index(level)
+      index = if level.is_a?(Integer)
+        # Mapping of Rails and Ruby Logger levels to SemanticLogger levels
+        @@map_levels ||= begin
+          levels = []
+          ::Logger::Severity.constants.each do |constant|
+            levels[::Logger::Severity.const_get(constant)] = LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error)
+          end
+        end [level] if defined?(::Logger::Severity)
+      elsif level.is_a?(String)
+        level = level.downcase.to_sym
+        LEVELS.index(level)
+      else
+        LEVELS.index(level)
+      end
+      raise "Invalid level:#{level.inspect} being requested. Must be one of #{LEVELS.inspect}" unless index
+      index
+    end
+
+    # Appenders don't take a class name, so use this class name if an appender
+    # is logged to directly
+    def name
+      self.class.name
+    end
+
+  end
+end

data/lib/semantic_logger/logger.rb

@@ -19,7 +19,7 @@
 #
 #   # Now log to the Logger above as well as MongoDB at the same time
 #
-#   db = Mongo::Connection.new['production_logging']
+#   db = Mongodb::Connection.new['production_logging']
 #
 #   SemanticLogger::Logger.appenders << SemanticLogger::Appender::MongoDB.new(
 #     :db              => db,
@@ -29,40 +29,31 @@
 #   # This will be logged to both the Ruby Logger and MongoDB
 #   logger.debug("Login time", :user => 'Mary', :duration => 230, :ip_address=>'192.168.0.1')
 #
-require 'logger'
 module SemanticLogger
-  class Logger
+  class Logger < Base
     include SyncAttr
 
-    # 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 = []
-    ::Logger::Severity.constants.each do |constant|
-      MAP_LEVELS[::Logger::Severity.const_get(constant)] = LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error)
-    end
-
     # Thread safe Class Attribute accessor for appenders array
     sync_cattr_accessor :appenders do
       []
     end
 
+    # Initial default Level for all new instances of SemanticLogger::Logger
+    @@default_level = :info
+
     # Allow for setting the global default log level
     # This change only applies to _new_ loggers, existing logger levels
     # will not be changed in any way
-    def self.level=(level)
-      @@level = level
+    def self.default_level=(level)
+      @@default_level = level
     end
 
     # Returns the global default log level for new Logger instances
-    def self.level
-      @@level
+    def self.default_level
+      @@default_level
     end
 
-    attr_reader :name, :level
-
-    @@level = :info
+    attr_reader :name
 
     # Returns a Logger instance
     #
@@ -76,144 +67,11 @@ module SemanticLogger
     #               to be used in the logger
     #  options:
     #    :level   The initial log level to start with for this logger instance
-    def initialize(klass, options={})
+    def initialize(klass, level=self.class.default_level)
       @name = klass.is_a?(String) ? klass : klass.name
-      set_level(options[:level] || self.class.level)
+      self.level = level
     end
 
-    # Set the logging level
-    # Must be one of the values in #LEVELS
-    def level=(level)
-      set_level(level)
-    end
-
-    # Implement the log level calls
-    #   logger.debug(message|hash|exception, hash|exception=nil, &block)
-    #
-    # Implement the log level query
-    #   logger.debug?
-    #
-    # Example:
-    #   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
-    #   logger.info("Request received", :user => "joe", :duration => 100)
-    #
-    #   # Log an exception in a semantic way
-    #   logger.info("Parsing received XML", exc)
-    #
-    LEVELS.each_with_index do |level, index|
-      class_eval <<-EOT, __FILE__, __LINE__
-        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? ? result : payload.merge(result)
-              end
-            end
-            # Add scoped payload
-            if self.payload
-              payload = payload.nil? ? self.payload : self.payload.merge(payload)
-            end
-            self.class.queue << Log.new(:#{level}, self.class.thread_name, name, message, payload, Time.now, nil, tags)
-            true
-          else
-            false
-          end
-        end
-
-        def #{level}?
-          @level_index <= #{index}
-        end
-
-        # Log the duration of the supplied block
-        #   If an exception occurs in the block the exception is logged using the
-        #   same log level. The exception will flow through to the caller unchanged
-        def benchmark_#{level}(message, payload = nil)
-          raise "Mandatory block missing" unless block_given?
-          if @level_index <= #{index}
-            start = Time.now
-            begin
-              result = yield
-              end_time = Time.now
-              # Add scoped payload
-              if self.payload
-                payload = payload.nil? ? self.payload : self.payload.merge(payload)
-              end
-              self.class.queue << Log.new(:#{level}, self.class.thread_name, name, message, payload, end_time, 1000.0 * (end_time - start), tags)
-              result
-            rescue Exception => exc
-              # TODO Need to be able to have both an exception and a Payload
-              self.class.queue << Log.new(:#{level}, self.class.thread_name, name, message, exc, Time.now, 1000.0 * (Time.now - start), tags)
-              raise exc
-            end
-          else
-            yield
-          end
-        end
-      EOT
-    end
-
-    # Add the supplied tags to the list of tags to log for this thread whilst
-    # the supplied block is active
-    # Returns nil if no tags are currently set
-    def with_tags(*tags)
-      current_tags = self.tags
-      # Check for nil tags
-      if tags
-        Thread.current[:semantic_logger_tags] = current_tags ? current_tags + tags : tags
-      end
-      yield
-    ensure
-      Thread.current[:semantic_logger_tags] = current_tags
-    end
-
-    # Returns [Array] of [String] tags currently active for this thread
-    # Returns nil if no tags are set
-    def tags
-      Thread.current[:semantic_logger_tags]
-    end
-
-    # Thread specific context information to be logged with every log entry
-    #
-    # Add a payload to all log calls on This Thread within the supplied block
-    #
-    #   logger.with_payload(:tracking_number=>12345) do
-    #     logger.debug('Hello World')
-    #   end
-    #
-    # If a log call already includes a pyload, this payload will be merged with
-    # the supplied payload, with the supplied payload taking precedence
-    #
-    #   logger.with_payload(:tracking_number=>12345) do
-    #     logger.debug('Hello World', :result => 'blah')
-    #   end
-    def with_payload(payload)
-      current_payload = self.payload
-      Thread.current[:semantic_logger_payload] = current_payload ? current_payload.merge(payload) : payload
-      yield
-    ensure
-      Thread.current[:semantic_logger_payload] = current_payload
-    end
-
-    # Returns [Hash] payload to be added to every log entry in the current scope
-    # on this thread.
-    # Returns nil if no payload is currently set
-    def payload
-      Thread.current[:semantic_logger_payload]
-    end
-
-    # Semantic Logging does not support :unknown level since these
-    # are not understood by the majority of the logging providers
-    # Map it to :error
-    alias :unknown :error
-    alias :unknown? :error?
-
-    # #TODO implement a thread safe #silence method
-
     # Returns [Integer] the number of log entries that have not been written
     # to the appenders
     #
@@ -235,22 +93,27 @@ module SemanticLogger
       reply_queue.pop
     end
 
+    ############################################################################
+    protected
+
+    # Place log request on the queue for the Appender thread to write to each
+    # appender in the order that they were registered
+    def log(log)
+      self.class.queue << log
+    end
+
     # Internal logger for SemanticLogger
     #   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
+    #   By default logs to STDERR
+    #   Can be replaced with another Ruby logger or Rails logger, but never to
+    #   SemanticLogger::Logger itself
     #
     # Warning: Do not use this logger directly it is intended for internal logging
     #          within Semantic Logger itself
     sync_cattr_accessor :logger do
-      l = ::Logger.new(STDERR)
-      l.level = ::Logger::INFO
-      l
+      SemanticLogger::Appender::File.new(STDERR, :warn)
     end
 
-    ############################################################################
-    protected
-
     # Log to queue
     #   Starts the appender thread the first time a logging call is made
     sync_cattr_reader :queue do
@@ -259,70 +122,11 @@ module SemanticLogger
       Queue.new
     end
 
-    # Struct Log
-    #
-    # level
-    #   Log level of the supplied log call
-    #   :trace, :debug, :info, :warn, :error, :fatal
-    #
-    # thread_name
-    #   Name of the thread in which the logging call was called
-    #
-    # name
-    #   Class name supplied to the logging instance
-    #
-    # message
-    #   Text message to be logged
-    #
-    # payload
-    #   Optional Hash or Ruby Exception object to be logged
-    #
-    # time
-    #   The time at which the log entry was created
-    #
-    # duration
-    #   The time taken to complete a benchmark call
-    #
-    # tags
-    #   Any tags active on the thread when the log call was made
-    #
-    Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags)
-
-    # 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.current.object_id
-      end
-    end
-
-    # Verify and set the level
-    def set_level(level)
-      index = if level.is_a?(Integer)
-        MAP_LEVELS[level]
-      elsif level.is_a?(String)
-        level = level.downcase.to_sym
-        LEVELS.index(level)
-      else
-        LEVELS.index(level)
-      end
-
-      raise "Invalid level:#{level.inspect} being requested. Must be one of #{LEVELS.inspect}" unless index
-      @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
@@ -365,5 +169,11 @@ module SemanticLogger
       result
     end
 
+    # Formatting does not occur within this thread, it is done by each appender
+    # in the appender thread
+    def default_formatter
+      nil
+    end
+
   end
 end

data/lib/semantic_logger/railtie.rb

@@ -27,7 +27,7 @@ module SemanticLogger #:nodoc:
       config = Rails.application.config
 
       # Set the default log level based on the Rails config
-      SemanticLogger::Logger.level = config.log_level
+      SemanticLogger::Logger.default_level = config.log_level
 
       # Existing loggers are ignored because servers like trinidad supply their
       # own file loggers which would result in duplicate logging to the same log file
@@ -38,26 +38,24 @@ module SemanticLogger #:nodoc:
           FileUtils.mkdir_p File.dirname path
         end
 
-        # First set the internal logger in case something goes wrong
-        # with an appender
-        SemanticLogger::Logger.logger = begin
-          l = ::Logger.new(path)
-          l.level = ::Logger.const_get(config.log_level.to_s.upcase)
-          l
-        end
-
         # Add the log file to the list of appenders
-        SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new(path)
-
-        #logger = ActiveSupport::TaggedLogging.new(logger) if defined?(ActiveSupport::TaggedLogging)
+        file_appender = SemanticLogger::Appender::File.new(path)
 
+        # Set internal logger to log to file only, in case another appender
+        # experiences logging problems
+        SemanticLogger::Logger.logger = file_appender
+        SemanticLogger::Logger.appenders << file_appender
+        
         SemanticLogger::Logger.new(Rails)
       rescue StandardError
-        SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new(STDERR)
+        # If not able to log to file, log to standard error with warning level only
+        SemanticLogger::Logger.default_level = :warn
+
+        file_appender = SemanticLogger::Appender::File.new(STDERR)
+        SemanticLogger::Logger.logger = file_appender
+        SemanticLogger::Logger.appenders << file_appender
 
         logger = SemanticLogger::Logger.new(Rails)
-        logger.level = :warn
-        #logger = ActiveSupport::TaggedLogging.new(logger) if defined?(ActiveSupport::TaggedLogging)
         logger.warn(
           "Rails Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666. " +
             "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "0.5.3"
+  VERSION = "0.6.0"
 end

data/test/appender_file_test.rb

@@ -0,0 +1,52 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'logger'
+require 'semantic_logger'
+require 'test/mock_logger'
+
+# Unit Test for SemanticLogger::Appender::File
+#
+class AppenderFileTest < Test::Unit::TestCase
+  context SemanticLogger::Appender::File do
+    setup do
+      @time = Time.parse("2012-08-02 09:48:32.482")
+      @io = StringIO.new
+      @appender = SemanticLogger::Appender::File.new(@io)
+      @hash = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
+      @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
+      @thread_name = SemanticLogger::Base.thread_name
+    end
+
+    context "format logs into text form" do
+      should "handle no message or payload" do
+        @appender.debug
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- \n/, @io.string
+      end
+
+      should "handle message" do
+        @appender.debug 'hello world'
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world\n/, @io.string
+      end
+
+      should "handle message and payload" do
+        @appender.debug 'hello world', @hash
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string
+      end
+    end
+
+    context "for each log level" do
+      # Ensure that any log level can be logged
+      SemanticLogger::LEVELS.each do |level|
+        should "log #{level} information" do
+          @appender.send(level, 'hello world', @hash)
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string
+        end
+      end
+    end
+
+  end
+end

data/test/appender_mongodb_test.rb

@@ -98,7 +98,7 @@ class AppenderMongoDBTest < Test::Unit::TestCase
 
     context "for each log level" do
       # Ensure that any log level can be logged
-      SemanticLogger::Logger::LEVELS.each do |level|
+      SemanticLogger::LEVELS.each do |level|
         should "log #{level} information" do
           @appender.log SemanticLogger::Logger::Log.new(level, 'thread', 'my_class', 'hello world -- Calculations', @hash, @time)
           document = @appender.collection.find_one

data/test/{appender_logger_test.rb → appender_wrapper_test.rb}

@@ -8,15 +8,16 @@ require 'logger'
 require 'semantic_logger'
 require 'test/mock_logger'
 
-# Unit Test for SemanticLogger::Appender::Logger
+# Unit Test for SemanticLogger::Appender::Wrapper
 #
-class AppenderLoggerTest < Test::Unit::TestCase
-  context SemanticLogger::Appender::Logger do
+class AppenderWrapperTest < Test::Unit::TestCase
+  context SemanticLogger::Appender::Wrapper do
     setup do
       @time = Time.parse("2012-08-02 09:48:32.482")
       @mock_logger = MockLogger.new
-      @appender = SemanticLogger::Appender::Logger.new(@mock_logger)
+      @appender = SemanticLogger::Appender::Wrapper.new(@mock_logger)
       @hash = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
+      @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
     end
 
     context "format logs into text form" do
@@ -55,7 +56,7 @@ class AppenderLoggerTest < Test::Unit::TestCase
         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\}/, @mock_logger.message
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:\] class -- hello world -- #{@hash_str}/, @mock_logger.message
       end
     end
 
@@ -63,8 +64,8 @@ class AppenderLoggerTest < Test::Unit::TestCase
       # Ensure that any log level can be logged
       Logger::Severity.constants.each do |level|
         should "log #{level.downcase.to_sym} info" do
-          @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\}/, @mock_logger.message
+          @appender.log SemanticLogger::Logger::Log.new(level.downcase.to_sym, 'thread', 'class', 'hello world', @hash, Time.now)
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:thread\] class -- hello world -- #{@hash_str}/, @mock_logger.message
         end
       end
     end

data/test/logger_test.rb

@@ -16,13 +16,14 @@ class LoggerTest < Test::Unit::TestCase
       setup do
         # Use a mock logger that just keeps the last logged entry in an instance variable
         @mock_logger = MockLogger.new
-        @appender = SemanticLogger::Appender::Logger.new(@mock_logger)
+        @appender = SemanticLogger::Appender::Wrapper.new(@mock_logger)
         SemanticLogger::Logger.appenders << @appender
 
         # Use this test's class name as the application name in the log output
-        @logger = SemanticLogger::Logger.new('LoggerTest', :level => :trace)
+        @logger = SemanticLogger::Logger.new('LoggerTest', :trace)
 
         @hash = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
+        @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
       end
 
       teardown do
@@ -30,11 +31,11 @@ class LoggerTest < Test::Unit::TestCase
       end
 
       # Ensure that any log level can be logged
-      SemanticLogger::Logger::LEVELS.each do |level|
+      SemanticLogger::LEVELS.each do |level|
         should "log #{level} info" do
           @logger.send(level, 'hello world', @hash) { "Calculations" }
           SemanticLogger::Logger.flush
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- hello world -- Calculations -- \{:session_id=>\"HSSKLEU@JDK767\", :tracking_number=>12345\}/, @mock_logger.message
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
         end
       end
 
@@ -58,12 +59,13 @@ class LoggerTest < Test::Unit::TestCase
         end
 
         should "add payload to log entries" do
+          hash = {:tracking_number=>"123456", :even=>2, :more=>"data"}
+          hash_str = hash.inspect.sub("{", "\\{").sub("}", "\\}")
           @logger.with_payload(:tracking_number => '123456') do
             @logger.with_payload(:even => 2, :more => 'data') do
               @logger.info('Hello world')
               SemanticLogger::Logger.flush
-              # TODO make test ignore order of Hash elements
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- Hello world -- \{:even=>2, :more=>\"data\", :tracking_number=>\"123456\"\}/, @mock_logger.message
+              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
             end
           end
         end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 3
-  version: 0.5.3
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Reid Morrison
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-09-14 00:00:00 -04:00
+date: 2012-09-18 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -54,8 +54,9 @@ files:
 - FUTURE.rb
 - init.txt
 - lib/semantic_logger/appender/file.rb
-- lib/semantic_logger/appender/logger.rb
 - lib/semantic_logger/appender/mongodb.rb
+- lib/semantic_logger/appender/wrapper.rb
+- lib/semantic_logger/base.rb
 - lib/semantic_logger/logger.rb
 - lib/semantic_logger/railtie.rb
 - lib/semantic_logger/version.rb
@@ -63,8 +64,9 @@ files:
 - LICENSE.txt
 - Rakefile
 - README.md
-- test/appender_logger_test.rb
+- test/appender_file_test.rb
 - test/appender_mongodb_test.rb
+- test/appender_wrapper_test.rb
 - test/logger_test.rb
 - test/mock_logger.rb
 has_rdoc: true