semantic_logger 2.7.0 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c16da0b153fc6641eb7fc40fdf7cb8ee2ffe74cd
-  data.tar.gz: 4907de6046cbbf1b7c5ea6f513faecc18bea3efb
+  metadata.gz: 51a1e44ec07ae96cd5dad5b3a3dc2c6377960b15
+  data.tar.gz: 820304cb8615f71b1f921869fcc70e0766ef7258
 SHA512:
-  metadata.gz: b145848428794d626f5a5d3cd276c4d4929c868346962a24a502d618274c6cf967a7e6d028017c2c02b25a801b0dba014bb52a6cd29d8ef06153d5e9a9c25df7
-  data.tar.gz: bb09287501c04bb4c6db41231f8e3245a42f8b20d645d3fe63389dc875a27ba0f0187840a02756e05db346168435e755ab7f2a6f88d25340328a77115a1d06cf
+  metadata.gz: 3faa5b434bc505b9d2045f7f00c91feae01f89bcd3a498ea7e0fe8f831d75fd276f05fd059ddd149ba2755d3ab6dfa3abeddc6d9c025191e75a4517c304c155f
+  data.tar.gz: d0691ea0ad358cf91c266e5e9005d510aed493f4adb8255423a425133c7258248d53482420e06623db1009a620adcd50ec616c56ad687757a4427eabbc16c603

data/README.md

@@ -1,26 +1,35 @@
-semantic_logger
+semantic_logger [![Build Status](https://secure.travis-ci.org/reidmorrison/semantic_logger.png?branch=master)](http://travis-ci.org/reidmorrison/semantic_logger)
 ===============
 
-Improved logging for Ruby
+Scalable, next generation logging for Ruby
 
 * http://github.com/reidmorrison/semantic_logger
 
-## Note:
-
-As of SemanticLogger V2.0 the Rails logging is no longer automatically replaced
-when including SemanticLogger. Include the [rails_semantic_logger](http://github.com/reidmorrison/rails_semantic_logger)
-gem to replace the Rails default logger with SemanticLogger
-
 ## Overview
 
-Semantic Logger takes logging in Ruby to a new level by adding several new
+Semantic Logger takes logging in Ruby to the next level by adding several new
 capabilities to the commonly used Logging API:
 
+High Performance
+
+* Logging is performed in a separate thread so as not to slow down the application
+  whilst logging to one or more destinations
+* Supports logging from hundreds of concurrent threads in the same process
+
+Drop-in Replacement
+
+* Simple drop-in replacement for the Ruby, or the Rails loggers
+* Supports current common logging interface
+* No changes to existing to code to use new logger ( other than replacing the logger )
+
 Dynamic
 
 * Increase the log level at runtime for just one class
 * For example enable debug level logging for a single class (logging instance)
   while the program is running to get more detailed logging in production for just that class
+* Change the default global logging level for all classes, unless that class has
+  specifically been overridden above
+* Use UNIX signals to change the log level for a running process
 
 Tagged Logging
 
@@ -30,17 +39,6 @@ Tagged Logging
   down log entries for a single call that is mixed in with log entries
   from hundreds of other log entries
 
-High Performance
-
-* Logging is performed in a separate thread so as not to impact performance of
-  running code
-
-Customizable
-
-* Custom formatting by destination
-* Easy to "roll your own" destination (Appender).
-  For example to log to Hadoop, Redis, etc..
-
 Payload support
 
 * Aside from the regular log message, a hash payload can also be supplied with
@@ -55,15 +53,23 @@ Exceptions
   to text destinations and writes the exception elements as a hash to NOSQL
   destinations
 
-Drop-in Replacement
+Benchmarking
 
-* Simple drop-in replacement for the Ruby, or the Rails loggers
-* Supports current common logging interface
-* No changes to existing to code to use new logger ( other than replacing the logger )
+* The performance of any block of code can be measured and logged at the same time
+  depending on the active log level
+* Supports only logging when the block of code exceeds a specified number of milli-seconds.
+  Makes it easy to find bottlenecks when the system suddenly slows down in production
+* Exceptions thrown in the block of code can also be logged so as to aid in finding
+  exceptions that may be discarded or hidden by the application
+* Benchmarked data can also be forwarded to external metric systems so that the
+  performance of these blocks can be measured and/or monitored over time
 
 Thread Safe
 
-* Semantic Logger ensures that all logging is fully thread-safe
+* Semantic Logger is completely thread safe and all methods can be called
+  concurrently from any thread
+* Tagged logging keeps any tagging data on a per-thread basis to ensure that
+  tags from different threads are not inter-mingled
 * Supports highly concurrent environments running hundreds of threads
 * Each appender writes all log entries sequentially in the appender thread so
   that log entries are written in the correct sequence
@@ -73,8 +79,9 @@ Thread Safe
 
 Thread Aware
 
-* Includes the process and thread id information in every log entry
-* If running JRuby it will also include the name of the thread for every log entry
+* Includes the process id, and thread name or thread id in every log entry so that
+  log entries from different processes and even threads are easily discernable
+* Human readable names can be assigned to every thread for logging purposes
 
 Trace Level
 
@@ -93,11 +100,6 @@ Multiple Destinations
   For example, only log :info and above to MongoDB, or :warn and above to a
   second log file
 
-Benchmarking
-
-* The performance of any block of code can be measured and logged at the same time
-  depending on the active log level
-
 Semantic Capabilities
 
 * With Semantic Logger it is simple to mix-in additional semantic information with
@@ -135,12 +137,11 @@ NOSQL Destinations
 }
 ```
 
-Thread Safe
+Customizable
 
-* Semantic Logger is completely thread safe and all methods can be called
-  concurrently from any thread
-* Tagged logging keeps any tagging data on a per-thread basis to ensure that
-  tags from different threads are not inter-mingled
+* Custom formatting by destination
+* Easy to "roll your own" destination (Appender).
+  For example to log to Hadoop, Redis, etc..
 
 ## Introduction
 
@@ -210,24 +211,30 @@ Or to query whether a specific log level is set
 logger.info?
 ```
 
-The following logging methods are available
+The following traditional logging methods are available
+
+```ruby
+logger.trace("Low level trace information such as data sent over a socket")
+logger.debug("Debugging information to aid with problem determination")
+logger.info("Informational message such as request received")
+logger.warn("Warn about something in the system")
+logger.error("An error occurred during processing")
+logger.fatal("Oh no something really bad happened")
+```
+
+Each of the above calls can take additional parameters, for example:
 
 ```ruby
-trace(message, payload=nil, exception=nil, &block)
-debug(message, payload=nil, exception=nil, &block)
-info(message, payload=nil, exception=nil, &block)
-warn(message, payload=nil, exception=nil, &block)
-error(message, payload=nil, exception=nil, &block)
-fatal(message, payload=nil, exception=nil, &block)
+log.info(message, payload=nil, exception=nil, &block)
 ```
 
 Parameters
 
-- message: The text message to log.
+- message:   The text message to log.
   Mandatory only if no block is supplied
-- payload: Optional, either a Ruby Exception object or a Hash
+- payload:   Optional, either a Ruby Exception object or a Hash
 - exception: Optional, Ruby Exception object. Allows both an exception and a payload to be logged
-- block:   The optional block is executed only if the corresponding log level
+- block:     The optional block is executed only if the corresponding log level
   is active. Can be used to prevent unnecessary calculations of debug data in
   production.
 
@@ -292,12 +299,21 @@ The exception will flow through to the caller unchanged
 The following benchmarking methods are available
 
 ```ruby
-benchmark_trace(message, params=nil, &block)
-benchmark_debug(message, params=nil, &block)
-benchmark_info(message, params=nil, &block)
-benchmark_warn(message, params=nil, &block)
-benchmark_error(message, params=nil, &block)
-benchmark_fatal(message, params=nil, &block)
+logger.benchmark_trace("Low level trace information such as data sent over a socket")
+logger.benchmark_debug("Debugging information to aid with problem determination")
+logger.benchmark_info("Informational message such as request received")
+logger.benchmark_warn("Warn about something in the system")
+logger.benchmark_error("An error occurred during processing")
+logger.benchmark_fatal("Oh no something really bad happened")
+logger.benchmark(:info, "Informational message such as request received")
+```
+
+Each of the above calls can take additional parameters, for example:
+
+```ruby
+log.benchmark_info(message, params=nil) do
+  # Measure how long it takes to run this block of code
+end
 ```
 
 Parameters
@@ -442,6 +458,59 @@ that was written during the second call to the ExternalSupplier:
 2013-11-07 16:19:26.683 I [35674:main] (0.0ms) ExternalSupplier -- Calling external interface
 ```
 
+### Change the global default logging level at runtime
+
+Log levels can be changed using signals on operating systems that support them.
+This allows log levels to be changed externally without requiring a restart
+of the running process.
+
+When the signal is raised, the global default log level rotates through the following
+log levels in the following order, starting from the current global default level:
+
+```ruby
+  :warn, :info, :debug, :trace
+```
+
+If the current level is :trace it wraps around back to :warn
+
+Example:
+
+```
+kill -SIGUSR2 1234
+```
+
+#### Enabling Log Level Signal handler
+
+On startup SemanticLogger does not register any signals so that it does not
+interfere with any existing signal handlers. In order to enable the above log level
+changes the signal handler must be registered by calling `SemanticLogger.add_signal_handler`
+
+```ruby
+require 'semantic_logger'
+
+# Enable signal handling for this process
+SemanticLogger.add_signal_handler('USR2')
+
+SemanticLogger.add_appender('development.log')
+
+logger = SemanticLogger['Example']
+logger.info "Hello World"
+```
+
+Note: The changes to the logging level will not change for any classes where the
+log_level was set explicity within the application itself. The above signal only changes
+the global default level, which is used by loggers when their log level has not been changed.
+
+#### Change the log level without using signals
+
+If the application has another means of communicating without needing signals,
+the global default log level can be modified using `SemanticLogger.default_level=`
+
+```ruby
+# Change the global default logging level for active loggers
+SemanticLogger.default_level = :debug
+```
+
 ### Tagged Logging
 
 Semantic Logger allows any Ruby or Rails program to also include tagged logging.
@@ -523,27 +592,17 @@ logger.benchmark_info "Calling external interface" do
 end
 ```
 
-Sending the performance information gathered above to something like NewRelic
-is also very useful, and we can end up with:
-
-```ruby
-logger.benchmark_info "Calling external interface" do
-  self.class.trace_execution_scoped(['Custom/slow_action/beginning_work']) do
-    # Code to call the external supplier ...
-  end
-end
-```
-
-Rather than wrapping the code everywhere with two blocks, a single subscriber can
-be setup in config/initializers/semantic_logger_metrics.rb:
+A single subscriber can be defined to collect all the metrics and forward them
+for example to NewRelic:
 
 ```ruby
+# config/initializers/semantic_logger_metrics.rb
 SemanticLogger.on_metric do |log_struct|
   ::NewRelic::Agent.record_metric(log_struct.metric, log_struct.duration)
 end
 ```
 
-Then update the log entry as follows:
+Add the :metric option to the log entry as follows:
 
 ```ruby
 logger.benchmark_info "Calling external interface", :metric => 'Custom/slow_action/beginning_work' do
@@ -709,7 +768,7 @@ to write your own custom formatter or log appender it is necessary to understand
 the fields:
 
 ```ruby
-Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index)
+Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric)
 ```
 level [Symbol]
 
@@ -748,6 +807,10 @@ level_index [Integer]
 
 * Internal use only. Index of the log level
 
+metric [Object]
+
+* Object supplied when the benchmark api was called
+
 ### Mixing Logging Levels
 
 It is sometimes useful to log a subset of the log messages to a separate file
@@ -966,29 +1029,29 @@ logger.info "Hello World"
 
 Look at the [existing appenders](https://github.com/reidmorrison/semantic_logger/tree/master/lib/semantic_logger/appender) for good examples
 
-To have your appender included in the standard list of appenders follow the fork
-instructions below.
-Very Important: New appenders will not be accepted without complete working tests.
+To have your appender included in the standard list of appenders, submit it along
+with complete working tests.
 See the [MongoDB Appender Test](https://github.com/reidmorrison/semantic_logger/blob/master/test/appender_mongodb_test.rb) for an example.
 
 ## Dependencies
 
-- Ruby MRI 1.8.7, 1.9.3 (or above) Or, JRuby 1.6.3 (or above)
-- Optional: To log to MongoDB, Mongo Ruby Driver 1.5.2 or above
+See [.travis.yml](https://github.com/reidmorrison/semantic_logger/.travis.yml) for the list of tested Ruby platforms
+
+The following gems are only required when their corresponding appenders are being used,
+and are therefore not automatically included by this gem:
+- MongoDB Appender: mongo 1.9.2 or above
+- Syslog Appender: syslog_protocol 0.9.2 or above
+- Syslog Appender to a remote syslogng server over TCP or UDP: resilient_socket 0.5.0 or above
 
 ## Install
 
     gem install semantic_logger
 
-To log to MongoDB, it also needs the Ruby Mongo Driver
-
-    gem install mongo
-
-## Future
+## Upgrade Notes:
 
-- Add support for a configuration file that can set log level by class name
-- Configuration file to support adding appenders
-- Based on end-user demand add appenders for: hadoop, redis, etc..
+As of SemanticLogger V2.0 the Rails logging is no longer automatically replaced
+when including SemanticLogger. Include the [rails_semantic_logger](http://github.com/reidmorrison/rails_semantic_logger)
+gem to replace the Rails default logger with SemanticLogger
 
 Meta
 ----
@@ -1013,7 +1076,7 @@ Marc Bellingrath :: marrrc.b@gmail.com
 License
 -------
 
-Copyright 2012, 2013 Reid Morrison
+Copyright 2012, 2013, 2014 Reid Morrison
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/Rakefile

@@ -1,15 +1,18 @@
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
-
-require 'rubygems'
-require 'rubygems/package'
 require 'rake/clean'
 require 'rake/testtask'
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require 'semantic_logger/version'
 
-desc "Build gem"
-task :gem  do |t|
-  Gem::Package.build(Gem::Specification.load('semantic_logger.gemspec'))
+task :gem do
+  system "gem build semantic_logger.gemspec"
+end
+
+task :publish => :gem do
+  system "git tag -a v#{SemanticLogger::VERSION} -m 'Tagging #{SemanticLogger::VERSION}'"
+  system "git push --tags"
+  system "gem push semantic_logger-#{SemanticLogger::VERSION}.gem"
+  system "rm semantic_logger-#{SemanticLogger::VERSION}.gem"
 end
 
 desc "Run Test Suite"
@@ -21,3 +24,5 @@ task :test do
 
   Rake::Task['functional'].invoke
 end
+
+task :default => :test

data/lib/semantic_logger/appender/base.rb

@@ -80,18 +80,25 @@ module SemanticLogger
       ############################################################################
       protected
 
-      # By default the appender should log everything that is sent to it by
-      # the loggers. That way the loggers control the log level
-      # By setting the log level to a higher value the appender can be setup
-      # to log for example only :warn or higher while other appenders
-      # are able to log lower level information
-      def initialize(level, &block)
+      # Initializer for Abstract Class SemanticLogger::Appender
+      #
+      # Parameters
+      #  level [Symbol]
+      #    Only allow log entries of this level or higher to be written to this appender
+      #    For example if set to :warn, this appender would only log :warn and :fatal
+      #    log messages when other appenders could be logging :info and lower
+      #
+      #  filter [RegExp|Proc]
+      #    Optional regular expression to filter log entries based on the class name
+      #    When filter is a proc, it is passed the entire log struct and must return
+      #    true or false indicating whether to log the message
+      def initialize(level=nil, filter=nil, &block)
         # Set the formatter to the supplied block
         @formatter = block || default_formatter
 
         # Appenders don't take a class name, so use this class name if an appender
         # is logged to directly
-        super(self.class, level || :trace)
+        super(self.class, level, filter)
       end
 
       # For JRuby include the Thread name rather than its id

data/lib/semantic_logger/appender/file.rb

@@ -39,7 +39,7 @@ module SemanticLogger
       #    logger =  SemanticLogger['test']
       #    logger.info 'Hello World'
       #
-      def initialize(filename, level=nil, &block)
+      def initialize(filename, level=nil, filter=nil, &block)
         raise "filename cannot be null when initializing the SemanticLogging::Appender::File" unless filename
         @log = if filename.respond_to?(:write) and filename.respond_to?(:close)
           filename
@@ -49,7 +49,7 @@ module SemanticLogger
         end
 
         # Set the log level and formatter if supplied
-        super(level, &block)
+        super(level, filter, &block)
       end
 
       # After forking an active process call #reopen to re-open

data/lib/semantic_logger/appender/mongodb.rb

@@ -31,7 +31,7 @@ module SemanticLogger
     #
     class MongoDB < SemanticLogger::Appender::Base
       attr_reader :db, :collection_name
-      attr_accessor :host_name, :safe, :application
+      attr_accessor :host_name, :write_concern, :application
 
       # Create a MongoDB Appender instance
       #
@@ -49,11 +49,10 @@ module SemanticLogger
       #   host_name to include in the document logged to Mongo
       #   Default: first part of host name extracted from Socket
       #
-      # :safe [Boolean]
-      #   Whether to use safe write for logging
-      #   Not recommended to change this value except to diagnose connection
-      #   issues or when log entries are not being written to Mongo
-      #   Default: false
+      # :write_concern [Integer]
+      #   Write concern to use
+      #   see: http://docs.mongodb.org/manual/reference/write-concern/
+      #   Default: 0
       #
       # :application [String]
       #   Name of the application to include in the document written to mongo
@@ -75,12 +74,18 @@ module SemanticLogger
       #  :level [Symbol]
       #    Only allow log entries of this level or higher to be written to MongoDB
       #
+      #  :filter [Regexp|Proc]
+      #    RegExp: Only include log messages where the class name matches the supplied
+      #    regular expression. All other messages will be ignored
+      #    Proc: Only include log messages where the supplied Proc returns true
+      #          The Proc must return true or false
       def initialize(params={}, &block)
         @db              = params[:db] || raise('Missing mandatory parameter :db')
         @collection_name = params[:collection_name] || 'semantic_logger'
         @host_name       = params[:host_name] || Socket.gethostname.split('.').first
-        @safe            = params[:safe] || false
+        @write_concern   = params[:write_concern] || 0
         @application     = params[:application]
+        filter           = params[:filter]
 
         # Create a collection that will hold the lesser of 1GB space or 10K documents
         @collection_size = params[:collection_size] || 1024**3
@@ -90,7 +95,7 @@ module SemanticLogger
         create_indexes
 
         # Set the log level and formatter
-        super(params[:level], &block)
+        super(params[:level], filter, &block)
       end
 
       # Create the required capped collection
@@ -103,7 +108,9 @@ module SemanticLogger
       #
       # Creates an index based on tags to support faster lookups
       def create_indexes
-        db.create_collection(collection_name, {:capped => true, :size => @collection_size, :max => @collection_max})
+        options = {:capped => true, :size => @collection_size}
+        options[:max] = @collection_max if @collection_max
+        db.create_collection(collection_name, options)
         collection.ensure_index('tags')
       end
 
@@ -172,9 +179,7 @@ module SemanticLogger
       # 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
-        collection.insert(formatter.call(log), :safe=>safe) if level_index <= (log.level_index || 0)
+        collection.insert(formatter.call(log), :w=>@write_concern) if level_index <= (log.level_index || 0)
       end
 
     end

data/lib/semantic_logger/appender/syslog.rb

@@ -143,22 +143,24 @@ module SemanticLogger
       #     For a list of options see the resilient_socket documentation:
       #       https://github.com/reidmorrison/resilient_socket/blob/master/lib/resilient_socket/tcp_client.rb
       def initialize(params = {}, &block)
-        params = params.dup
-        @ident = params.delete(:ident) || 'ruby'
-        options = params.delete(:options) || (::Syslog::LOG_PID | ::Syslog::LOG_CONS)
-        @facility = params.delete(:facility) || ::Syslog::LOG_USER
-        level = params.delete(:level)
-        level_map = params.delete(:level_map)
+        params     = params.dup
+        @ident     = params.delete(:ident) || 'ruby'
+        options    = params.delete(:options) || (::Syslog::LOG_PID | ::Syslog::LOG_CONS)
+        @facility  = params.delete(:facility) || ::Syslog::LOG_USER
+        filter     = params.delete(:filter)
+        level      = params.delete(:level)
+        level_map  = params.delete(:level_map)
         @level_map = DEFAULT_LEVEL_MAP.dup
         @level_map.update(level_map) if level_map
-        @server = params.delete(:server) || 'syslog://localhost'
-        uri = URI(@server)
-        @host = uri.host || 'localhost'
-        @protocol = (uri.scheme || :syslog).to_sym
+        @server    = params.delete(:server) || 'syslog://localhost'
+        uri        = URI(@server)
+        @host      = uri.host || 'localhost'
+        @protocol  = (uri.scheme || :syslog).to_sym
         raise "Unknown protocol #{@protocol}!" unless [:syslog, :tcp, :udp].include?(@protocol)
-        @host = 'localhost' if @protocol == :syslog
-        @port = URI(@server).port || 514
-        @local_hostname = params.delete(:local_hostname) || Socket.gethostname || `hostname`.strip
+        @host      = 'localhost' if @protocol == :syslog
+        @port      = URI(@server).port || 514
+
+        @local_hostname    = params.delete(:local_hostname) || Socket.gethostname || `hostname`.strip
         tcp_client_options = params.delete(:tcp_client)
 
         # Warn about any unknown configuration options.
@@ -194,7 +196,7 @@ module SemanticLogger
             raise "Unsupported protocol: #{protocol}"
         end
 
-        super(level, &block)
+        super(level, filter, &block)
       end
 
       # Write the log using the specified protocol and host.

data/lib/semantic_logger/appender/wrapper.rb

@@ -27,13 +27,13 @@ module SemanticLogger
       #
       # 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)
+      def initialize(logger, filter=nil, &block)
         raise "logger cannot be null when initiailizing the SemanticLogging::Appender::Wrapper" unless logger
         @logger = logger
 
         # Set the formatter to the supplied block
         @formatter = block || self.default_formatter
-        super(:trace, &block)
+        super(nil, filter, &block)
       end
 
       # Pass log calls to the underlying Rails, log4j or Ruby logger

data/lib/semantic_logger/base.rb

@@ -9,22 +9,27 @@
 module SemanticLogger
   class Base
     # Class name to be logged
-    attr_accessor :name
-
-    attr_reader :level
+    attr_accessor :name, :filter
 
     # Set the logging level for this logger
     #
-    # Note: This level is only for this particular appender. It does not override
+    # Note: This level is only for this particular instance. It does not override
     #   the log level in any logging instance or the default log level
     #   SemanticLogger.default_level
     #
-    # Must be one of the values in SemanticLogger::LEVELS
+    # Must be one of the values in SemanticLogger::LEVELS, or
+    # nil if this logger instance should use the global default log_level
     def level=(level)
-      @level_index = self.class.map_level_to_index(level)
+      @level_index = SemanticLogger.level_to_index(level)
       @level = level
     end
 
+    # Returns the current log level if set, otherwise it returns the global
+    # default log level
+    def level
+      @level || SemanticLogger.default_level
+    end
+
     # Implement the log level calls
     #   logger.debug(message, hash|exception=nil, &block)
     #
@@ -69,9 +74,9 @@ module SemanticLogger
     #    logger.info("Parsing received XML", exc)
     #
     SemanticLogger::LEVELS.each_with_index do |level, index|
-      class_eval <<-EOT, __FILE__, __LINE__
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
         def #{level}(message=nil, payload=nil, exception=nil, &block)
-          if @level_index <= #{index}
+          if level_index <= #{index}
             log_internal(:#{level}, #{index}, message, payload, exception, &block)
             true
           else
@@ -80,11 +85,11 @@ module SemanticLogger
         end
 
         def #{level}?
-          @level_index <= #{index}
+          level_index <= #{index}
         end
 
         def benchmark_#{level}(message, params = {}, &block)
-          if @level_index <= #{index}
+          if level_index <= #{index}
             benchmark_internal(:#{level}, #{index}, message, params, &block)
           else
             block.call(params) if block
@@ -93,6 +98,16 @@ module SemanticLogger
       EOT
     end
 
+    # Dynamically supply the log level with every benchmark call
+    def benchmark(level, message, params = {}, &block)
+      index = SemanticLogger.level_to_index(level)
+      if level_index <= index
+        benchmark_internal(level, index, message, params, &block)
+      else
+        block.call(params) if block
+      end
+    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
@@ -179,9 +194,31 @@ module SemanticLogger
     ############################################################################
     protected
 
-    def initialize(klass, level=nil)
-      @name = klass.is_a?(String) ? klass : klass.name
-      self.level = level || SemanticLogger.default_level
+    # Initializer for Abstract Class SemanticLogger::Base
+    #
+    # Parameters
+    #  klass [String]
+    #   Name of the class, module, or other identifier for which the log messages
+    #   are being logged
+    #
+    #  level [Symbol]
+    #    Only allow log entries of this level or higher to be written to this appender
+    #    For example if set to :warn, this appender would only log :warn and :fatal
+    #    log messages when other appenders could be logging :info and lower
+    #
+    #  filter [Regexp|Proc]
+    #    RegExp: Only include log messages where the class name matches the supplied
+    #    regular expression. All other messages will be ignored
+    #    Proc: Only include log messages where the supplied Proc returns true
+    #          The Proc must return true or false
+    def initialize(klass, level=nil, filter=nil)
+      # Support filtering all messages to this logger using a Regular Expression
+      # or Proc
+      raise ":filter must be a Regexp or Proc" unless filter.nil? || filter.is_a?(Regexp) || filter.is_a?(Proc)
+
+      @filter    = filter.is_a?(Regexp) ? filter.freeze : filter
+      @name      = klass.is_a?(String) ? klass : klass.name
+      self.level = level unless level.nil?
     end
 
     # Write log data to underlying data storage
@@ -190,7 +227,11 @@ module SemanticLogger
     end
 
     # Return the level index for fast comparisons
-    attr_reader :level_index
+    # Returns the global default level index if the level has not been explicitly
+    # set for this instance
+    def level_index
+      @level_index || SemanticLogger.default_level_index
+    end
 
     # Struct Log
     #
@@ -226,27 +267,15 @@ module SemanticLogger
     #   Object supplied when benchmark_x was called
     Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric)
 
-    # 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) && defined?(::Logger::Severity)
-        # 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
-          levels
-        end
-        @@map_levels[level]
-      elsif level.is_a?(String)
-        level = level.downcase.to_sym
-        LEVELS.index(level)
-      else
-        LEVELS.index(level)
+    # Whether to log the supplied message based on the current filter if any
+    def include_message?(struct)
+      return true if @filter.nil?
+
+      if @filter.is_a?(Regexp)
+        (@filter =~ struct.name) != nil
+      elsif @filter.is_a?(Proc)
+        @filter.call(struct) == true
       end
-      raise "Invalid level:#{level.inspect} being requested. Must be one of #{LEVELS.inspect}" unless index
-      index
     end
 
     # Log message at the specified level
@@ -270,7 +299,8 @@ module SemanticLogger
       if self.payload
         payload = payload.nil? ? self.payload : self.payload.merge(payload)
       end
-      log Log.new(level, Thread.current.name, name, message, payload, Time.now, nil, tags, index, exception)
+      struct = Log.new(level, Thread.current.name, name, message, payload, Time.now, nil, tags, index, exception)
+      log(struct) if include_message?(struct)
     end
 
     # Measure the supplied block and log the message
@@ -302,14 +332,17 @@ module SemanticLogger
         if exception
           case log_exception
           when :full
-            log Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, exception, metric)
+            struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, exception, metric)
+            log(struct) if include_message?(struct)
           when :partial
-            log Log.new(level, Thread.current.name, name, "#{message} -- Exception: #{exception.class}: #{exception.message}", payload, end_time, duration, tags, index, nil, metric)
+            struct = Log.new(level, Thread.current.name, name, "#{message} -- Exception: #{exception.class}: #{exception.message}", payload, end_time, duration, tags, index, nil, metric)
+            log(struct) if include_message?(struct)
           end
           raise exception
         elsif duration >= min_duration
           # Only log if the block took longer than 'min_duration' to complete
-          log Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric)
+          struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric)
+          log(struct) if include_message?(struct)
         end
       end
     end

data/lib/semantic_logger/logger.rb

@@ -33,9 +33,13 @@ module SemanticLogger
     #    The initial log level to start with for this logger instance
     #    Default: SemanticLogger.default_level
     #
-    def initialize(klass, level=nil)
-      @name = klass.is_a?(String) ? klass : klass.name
-      self.level = level || SemanticLogger.default_level
+    #  filter [Regexp|Proc]
+    #    RegExp: Only include log messages where the class name matches the supplied
+    #    regular expression. All other messages will be ignored
+    #    Proc: Only include log messages where the supplied Proc returns true
+    #          The Proc must return true or false
+    def initialize(klass, level=nil, filter=nil)
+      super
     end
 
     # Returns [Integer] the number of log entries that have not been written

data/lib/semantic_logger/semantic_logger.rb

@@ -13,6 +13,8 @@ module SemanticLogger
   # will not be changed in any way
   def self.default_level=(level)
     @@default_level = level
+    # For performance reasons pre-calculate the level index
+    @@default_level_index = level_to_index(level)
   end
 
   # Returns the global default log level for new Logger instances
@@ -150,6 +152,25 @@ module SemanticLogger
     SemanticLogger::Logger.on_metric(&block)
   end
 
+  # Add a signal handler so that the log level can be changed externally
+  # without restarting the process
+  #
+  # When the signal is raised on this process, the global default log level
+  # rotates through the following log levels in the following order, starting
+  # from the current global default level:
+  #   :warn, :info, :debug, :trace
+  #
+  # If the current level is :trace it wraps around back to :warn
+  def self.add_signal_handler(signal='USR2')
+    Signal.trap(signal) do
+      index = (default_level == :trace) ? LEVELS.find_index(:error) : LEVELS.find_index(default_level)
+      new_level = LEVELS[index-1]
+      self['SemanticLogger'].warn "Changed global default log level to #{new_level.inspect}"
+      self.default_level = new_level
+    end
+    signal
+  end
+
   ############################################################################
   protected
 
@@ -158,6 +179,41 @@ module SemanticLogger
   ############################################################################
   private
 
+  def self.default_level_index
+    @@default_level_index
+  end
+
+  # Returns the symbolic level for the supplied level index
+  def index_to_level(level_index)
+    LEVELS[level_index]
+  end
+
+  # Internal method to return the log level as an internal index
+  # Also supports mapping the ::Logger levels to SemanticLogger levels
+  def self.level_to_index(level)
+    return if level.nil?
+    
+    index = if level.is_a?(Symbol)
+      LEVELS.index(level)
+    elsif level.is_a?(String)
+      level = level.downcase.to_sym
+      LEVELS.index(level)
+    elsif level.is_a?(Integer) && defined?(::Logger::Severity)
+      # 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
+        levels
+      end
+      @@map_levels[level]
+    end
+    raise "Invalid level:#{level.inspect} being requested. Must be one of #{LEVELS.inspect}" unless index
+    index
+  end
+
   # Initial default Level for all new instances of SemanticLogger::Logger
   @@default_level = :info
+  @@default_level_index = level_to_index(@@default_level)
 end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "2.7.0"
+  VERSION = "2.8.0"
 end

data/test/appender_file_test.rb

@@ -13,6 +13,7 @@ require 'stringio'
 class AppenderFileTest < Test::Unit::TestCase
   context SemanticLogger::Appender::File do
     setup do
+      SemanticLogger.default_level = :trace
       @time = Time.new
       @io = StringIO.new
       @appender = SemanticLogger::Appender::File.new(@io)

data/test/appender_mongodb_test.rb

@@ -24,7 +24,7 @@ class AppenderMongoDBTest < Test::Unit::TestCase
     end
 
     teardown do
-      @appender.purge_all
+      @appender.purge_all if @appender
     end
 
     context "format logs into documents" do

data/test/logger_test.rb

@@ -10,139 +10,198 @@ require 'semantic_logger'
 # Unit Test for SemanticLogger::Logger
 class LoggerTest < Test::Unit::TestCase
   context SemanticLogger::Logger do
-    setup do
-      # Use a mock logger that just keeps the last logged entry in an instance
-      # variable
-      SemanticLogger.default_level = :trace
-      @mock_logger = MockLogger.new
-      SemanticLogger.add_appender(@mock_logger)
-
-      # Add mock metric subscriber
-      $last_metric = nil
-      SemanticLogger.on_metric do |log_struct|
-        $last_metric = log_struct.dup
-      end
-
-      # Use this test's class name as the application name in the log output
-      @logger   = SemanticLogger::Logger.new(self.class, :trace)
-      @hash     = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
-      @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-      assert_equal [], @logger.tags
-    end
-
-    teardown do
-      # Remove all appenders
-      SemanticLogger.appenders.each{|appender| SemanticLogger.remove_appender(appender)}
-    end
-
-    # Ensure that any log level can be logged
-    SemanticLogger::LEVELS.each do |level|
-      should "log #{level} info" do
-        @logger.send(level, 'hello world', @hash) { "Calculations" }
-        SemanticLogger.flush
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
-      end
-    end
-
-    context "tagged logging" do
-      should "add tags to log entries" do
-        @logger.tagged('12345', 'DJHSFK') do
-          @logger.info('Hello world')
-          SemanticLogger.flush
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[12345\] \[DJHSFK\] LoggerTest -- Hello world/, @mock_logger.message
-        end
-      end
-
-      should "add embedded tags to log entries" do
-        @logger.tagged('First Level', 'tags') do
-          @logger.tagged('Second Level') do
-            @logger.info('Hello world')
-            SemanticLogger.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[First Level\] \[tags\] \[Second Level\] LoggerTest -- Hello world/, @mock_logger.message
+    # Test each filter
+    [ nil, /\ALogger/, Proc.new{|l| (/\AExclude/ =~ l.message).nil? } ].each do |filter|
+      context "filter: #{filter.inspect}" do
+        setup do
+          # Use a mock logger that just keeps the last logged entry in an instance
+          # variable
+          SemanticLogger.default_level = :trace
+          @mock_logger = MockLogger.new
+          SemanticLogger.add_appender(@mock_logger)
+
+          # Add mock metric subscriber
+          $last_metric = nil
+          SemanticLogger.on_metric do |log_struct|
+            $last_metric = log_struct.dup
           end
-          assert_equal 2, @logger.tags.count, @logger.tags
-          assert_equal 'First Level', @logger.tags.first
-          assert_equal 'tags', @logger.tags.last
+
+          # Use this test's class name as the application name in the log output
+          @logger   = SemanticLogger::Logger.new(self.class, :trace, filter)
+          @hash     = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
+          @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
+          assert_equal [], @logger.tags
         end
-      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.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
-          end
+        teardown do
+          # Remove all appenders
+          SemanticLogger.appenders.each{|appender| SemanticLogger.remove_appender(appender)}
         end
-      end
 
-      context "Ruby Logger" do
         # Ensure that any log level can be logged
-        Logger::Severity.constants.each do |level|
-          should "log Ruby logger #{level} info" do
-            @logger.level = Logger::Severity.const_get(level)
-            if level.to_s == 'UNKNOWN'
-              assert_equal Logger::Severity.const_get('ERROR')+1, @logger.send(:level_index)
-            else
-              assert_equal Logger::Severity.const_get(level)+1, @logger.send(:level_index)
+        SemanticLogger::LEVELS.each do |level|
+          context level do
+            should "log" do
+              @logger.send(level, 'hello world', @hash) { "Calculations" }
+              SemanticLogger.flush
+              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
+            end
+
+            should "exclude log messages using Proc filter" do
+              if filter.is_a?(Proc)
+                @logger.send(level, 'Exclude this log message', @hash) { "Calculations" }
+                SemanticLogger.flush
+                assert_nil @mock_logger.message
+              end
             end
           end
         end
-      end
 
-      context "benchmark" do
-        # Ensure that any log level can be benchmarked and logged
-        SemanticLogger::LEVELS.each do |level|
-          should "log #{level} info" do
-            assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world') { "result" } # Measure duration of the supplied block
-            SemanticLogger.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+        context "tagged logging" do
+          should "add tags to log entries" do
+            @logger.tagged('12345', 'DJHSFK') do
+              @logger.info('Hello world')
+              SemanticLogger.flush
+              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[12345\] \[DJHSFK\] LoggerTest -- Hello world/, @mock_logger.message
+            end
           end
 
-          should "log #{level} info with payload" do
-            assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :payload => @hash) { "result" } # Measure duration of the supplied block
-            SemanticLogger.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+          should "add embedded tags to log entries" do
+            @logger.tagged('First Level', 'tags') do
+              @logger.tagged('Second Level') do
+                @logger.info('Hello world')
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[First Level\] \[tags\] \[Second Level\] LoggerTest -- Hello world/, @mock_logger.message
+              end
+              assert_equal 2, @logger.tags.count, @logger.tags
+              assert_equal 'First Level', @logger.tags.first
+              assert_equal 'tags', @logger.tags.last
+            end
           end
 
-          should "not log #{level} info when block is faster than :min_duration" do
-            assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 0.5) { "result" } # Measure duration of the supplied block
-            SemanticLogger.flush
-            assert_nil @mock_logger.message
+          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.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
+              end
+            end
           end
 
-          should "log #{level} info when block duration exceeds :min_duration" do
-            assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 0.2, :payload => @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
-            SemanticLogger.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+          context "Ruby Logger" do
+            # Ensure that any log level can be logged
+            Logger::Severity.constants.each do |level|
+              should "log Ruby logger #{level} info" do
+                @logger.level = Logger::Severity.const_get(level)
+                if level.to_s == 'UNKNOWN'
+                  assert_equal Logger::Severity.const_get('ERROR')+1, @logger.send(:level_index)
+                else
+                  assert_equal Logger::Severity.const_get(level)+1, @logger.send(:level_index)
+                end
+              end
+            end
           end
 
-          should "log #{level} info with an exception" do
-            assert_raise RuntimeError do
-              @logger.send("benchmark_#{level}", 'hello world', :payload => @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
+          context "benchmark" do
+            # Ensure that any log level can be benchmarked and logged
+            SemanticLogger::LEVELS.each do |level|
+
+              context 'direct method' do
+                should "log #{level} info" do
+                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world') { "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                end
+
+                should "log #{level} info with payload" do
+                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :payload => @hash) { "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                end
+
+                should "not log #{level} info when block is faster than :min_duration" do
+                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 500) { "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_nil @mock_logger.message
+                end
+
+                should "log #{level} info when block duration exceeds :min_duration" do
+                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 200, :payload => @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                end
+
+                should "log #{level} info with an exception" do
+                  assert_raise RuntimeError do
+                    @logger.send("benchmark_#{level}", 'hello world', :payload => @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
+                  end
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+                end
+
+                should "log #{level} info with metric" do
+                  metric_name = '/my/custom/metric'
+                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                  assert metric_name, $last_metric.metric
+                end
+              end
+
+              context 'generic method' do
+                should "log #{level} info" do
+                  assert_equal "result", @logger.benchmark(level, 'hello world') { "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                end
+
+                should "log #{level} info with payload" do
+                  assert_equal "result", @logger.benchmark(level, 'hello world', :payload => @hash) { "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                end
+
+                should "not log #{level} info when block is faster than :min_duration" do
+                  assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 500) { "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_nil @mock_logger.message
+                end
+
+                should "log #{level} info when block duration exceeds :min_duration" do
+                  assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 200, :payload => @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                end
+
+                should "log #{level} info with an exception" do
+                  assert_raise RuntimeError do
+                    @logger.benchmark(level, 'hello world', :payload => @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
+                  end
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+                end
+
+                should "log #{level} info with metric" do
+                  metric_name = '/my/custom/metric'
+                  assert_equal "result", @logger.benchmark(level, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                  assert metric_name, $last_metric.metric
+                end
+              end
             end
-            SemanticLogger.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
-          end
 
-          should "log #{level} info with metric" do
-            metric_name = '/my/custom/metric'
-            assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', metric: metric_name) { "result" } # Measure duration of the supplied block
-            SemanticLogger.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
-            assert metric_name, $last_metric.metric
+            should "log when the block performs a return" do
+              assert_equal "Good", function_with_return(@logger)
+              SemanticLogger.flush
+              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+            end
           end
         end
-
-        should "log when the block performs a return" do
-          assert_equal "Good", function_with_return(@logger)
-          SemanticLogger.flush
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
-        end
       end
-
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.8.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-07 00:00:00.000000000 Z
+date: 2014-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
@@ -38,7 +38,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.0
-description: Semantic Logger takes logging in Ruby to a new level by adding several
+description: Semantic Logger takes logging in Ruby to the next level by adding several
   new capabilities to the commonly used Logging API
 email:
 - reidmo@gmail.com
@@ -88,10 +88,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Improved logging for Ruby
+summary: Scalable, next generation logging for Ruby
 test_files:
 - test/appender_file_test.rb
 - test/appender_mongodb_test.rb