semantic_logger 2.4.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24d556e477347252ddf0b9ec58747b066a72d3de
-  data.tar.gz: 4a3ed8b3b1fb893903194cf3ed672a039a974b48
+  metadata.gz: 758d812e95b3b1643fa451574e705b85d2fd5870
+  data.tar.gz: 4a4c5722a4222a1c8dc4d03b5a14318d2677fc3c
 SHA512:
-  metadata.gz: 9ca1d356e5b4d8d3bcb7d5f71616c0189d0cde904bbea832e0e9ec08d1dc8faad5e367eebe456668fa3c4e1ab5515a9eea8542520acbaad1f4f22bc7e2c520fb
-  data.tar.gz: c0a06161e582b5b979f96c65ac32f7329fe5aa56f714bc6e3da81e19cfb73027ebb0a114d8e8bfd919d0a718308dc45edb98adb28efb3ad80c5b468685d1393b
+  metadata.gz: 62b30c9df3a64a577c12791dc4ee61d5cbcba35371ee874ea3379c7020c9eb36c915a5385fec6c798724269484e78d7a7471f119ff91e0435ae6fbe1585e1173
+  data.tar.gz: 1daa2ae91c65e34cdb0d90747d7a80da362af7e7c80c96de270338c0653aa9bee63f878ecc6cba3fda7ee15f863ea1a00a1aec8be5861df8c4baed988c318cd9

data/README.md

@@ -3,12 +3,12 @@ semantic_logger
 
 Improved logging for Ruby
 
-* http://github.com/ClarityServices/semantic_logger
+* 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/ClarityServices/rails_semantic_logger)
+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
@@ -61,6 +61,16 @@ Drop-in Replacement
 * Supports current common logging interface
 * No changes to existing to code to use new logger ( other than replacing the logger )
 
+Thread Safe
+
+* Semantic Logger ensures that all logging is fully thread-safe
+* 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
+* Avoids issues that other loggers experience when multiple threads try to write
+  to the same log file at the same time creating partial and overwritten log
+  entries in the log file
+
 Thread Aware
 
 * Includes the process and thread id information in every log entry
@@ -354,8 +364,6 @@ It is recommended to include a class specific logger for all major classes that
 be logging using the SemanticLogger::Loggable mix-in. For Example:
 
 ```ruby
-require 'semantic_logger'
-
 class ExternalSupplier
   # Lazy load logger class variable on first use
   include SemanticLogger::Loggable
@@ -375,6 +383,55 @@ This will result in the log output identifying the log entry as from the Externa
 
     2012-08-30 15:37:29.474 I [48308:ScriptThreadProcess: script/rails] (5.2ms) ExternalSupplier -- Calling external interface
 
+### Changing the log level for a single class at runtime
+
+Since the logger is class specific, its log level can be changed dynamically at runtime.
+For example, to temporarily set the log level to :trace to diagnose an issue:
+
+```ruby
+require 'semantic_logger'
+
+SemanticLogger.default_level = :info
+SemanticLogger.add_appender('example.log')
+
+class ExternalSupplier
+  # Lazy load logger class variable on first use
+  include SemanticLogger::Loggable
+
+  def call_supplier(amount, name)
+    logger.trace "Calculating with amount", { :amount => amount, :name => name }
+
+    # Measure and log on completion how long the call took to the external supplier
+    logger.benchmark_info "Calling external interface" do
+      # Code to call the external supplier ...
+    end
+  end
+end
+
+# Create and use the class
+supplier = ExternalSupplier.new
+supplier.call_supplier(100, 'Jack')
+
+# Now change the log level to :trace
+ExternalSupplier.logger.level = :trace
+
+# Call the supplier, this time including trace level messages
+supplier.call_supplier(100, 'Jack')
+
+# Change the log level back to the default level
+ExternalSupplier.logger.level = SemanticLogger.default_level
+```
+
+Below is the output from the above example showing the :trace log level message
+that was written during the second call to the ExternalSupplier:
+
+```
+2013-11-07 16:19:26.496 I [35674:main] (0.0ms) ExternalSupplier -- Calling external interface
+
+2013-11-07 16:19:26.683 T [35674:main] ExternalSupplier -- Calculating with amount -- {:amount=>100, :name=>"Jack"}
+2013-11-07 16:19:26.683 I [35674:main] (0.0ms) ExternalSupplier -- Calling external interface
+```
+
 ### Tagged Logging
 
 Semantic Logger allows any Ruby or Rails program to also include tagged logging.
@@ -409,6 +466,39 @@ logger.with_payload(:user => 'Jack', :zip_code => 12345) do
 end
 ```
 
+### Named threads
+
+SemanticLogger logs the name or id of the thread in every log message.
+
+On Ruby MRI the thread name is by default the thread's object_id, For example: 70184354571980
+
+```
+2013-11-07 16:25:14.279627 I [35841:70184354571980] (0.0ms) ExternalSupplier -- Calling external interface
+```
+
+To set a custom name for any thread so that it shows up in the logger:
+
+```ruby
+Thread.current.name = "User calculation thread 32"
+```
+
+Sample output:
+
+```
+2013-11-07 16:26:02.744139 I [35841:User calculation thread 32] (0.0ms) ExternalSupplier -- Calling external interface
+```
+
+#### NOTE:
+
+Make sure that the assigned thread name is unique otherwise it will be difficult
+to distinguish between concurrently running threads if they have the same name.
+
+For example, use the current thread object_id to ensure uniqueness:
+
+```ruby
+Thread.current.name = "Worker Thread:#{Thread.current.object_id}"
+```
+
 ## Standalone SemanticLogger
 
 When using SemanticLogger inside of Rails all we need to do is include the
@@ -558,7 +648,7 @@ log file at the same time.
 
 ### Rails Configuration
 
-To automatically replace the Rails logger with Semantic Logger use the gem [rails_semantic_logger](http://github.com/ClarityServices/rails_semantic_logger)
+To automatically replace the Rails logger with Semantic Logger use the gem [rails_semantic_logger](http://github.com/reidmorrison/rails_semantic_logger)
 
 ## Log Struct
 
@@ -676,15 +766,15 @@ require 'semantic_logger'
 SemanticLogger.default_level = :trace
 
 SemanticLogger.add_appender('development.log') do |log|
-tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
+  tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
 
-message = log.message.to_s
-message << " -- " << log.payload.inspect if log.payload
-message << " -- " << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
+  message = log.message.to_s
+  message << " -- " << log.payload.inspect if log.payload
+  message << " -- " << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
 
-duration_str = log.duration ? "(#{'%.1f' % log.duration}ms) " : ''
+  duration_str = log.duration ? "(#{'%.1f' % log.duration}ms) " : ''
 
-"#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{log.level.to_s[0..0].upcase} [#{$$}:#{log.thread_name}] #{tags}#{duration_str}#{log.name} -- #{message}"
+  "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{log.level.to_s[0..0].upcase} [#{$$}:#{log.thread_name}] #{tags}#{duration_str}#{log.name} -- #{message}"
 end
 ```
 
@@ -817,12 +907,12 @@ logger = SemanticLogger['Hello']
 logger.info "Hello World"
 ```
 
-Look at the [existing appenders](https://github.com/ClarityServices/semantic_logger/tree/master/lib/semantic_logger/appender) for good examples
+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.
-See the [MongoDB Appender Test](https://github.com/ClarityServices/semantic_logger/blob/master/test/appender_mongodb_test.rb) for an example.
+See the [MongoDB Appender Test](https://github.com/reidmorrison/semantic_logger/blob/master/test/appender_mongodb_test.rb) for an example.
 
 ## Dependencies
 
@@ -846,9 +936,9 @@ To log to MongoDB, it also needs the Ruby Mongo Driver
 Meta
 ----
 
-* Code: `git clone git://github.com/ClarityServices/semantic_logger.git`
-* Home: <https://github.com/ClarityServices/semantic_logger>
-* Bugs: <http://github.com/ClarityServices/semantic_logger/issues>
+* Code: `git clone git://github.com/reidmorrison/semantic_logger.git`
+* Home: <https://github.com/reidmorrison/semantic_logger>
+* Bugs: <http://github.com/reidmorrison/semantic_logger/issues>
 * Gems: <http://rubygems.org/gems/semantic_logger>
 
 This project uses [Semantic Versioning](http://semver.org/).

data/lib/semantic_logger.rb

@@ -1,5 +1,4 @@
-# Place requires here to prevent issues on JRuby with global.require.lock=true
-require 'thread'
+require 'semantic_logger/core_ext/thread'
 require 'semantic_logger/version'
 require 'semantic_logger/semantic_logger'
 

data/lib/semantic_logger/appender/base.rb

@@ -40,7 +40,7 @@ module SemanticLogger
 
           duration_str = log.duration ? "(#{'%.1f' % log.duration}ms) " : ''
 
-          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{log.level.to_s[0..0].upcase} [#{$$}:#{log.thread_name}] #{tags}#{duration_str}#{log.name} -- #{message}"
+          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{log.level.to_s[0..0].upcase} [#{$$}:#{'%.30s' % log.thread_name}] #{tags}#{duration_str}#{log.name} -- #{message}"
         end
       end
 
@@ -73,7 +73,7 @@ module SemanticLogger
             colors::RED
           end
 
-          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{level_color}#{colors::BOLD}#{log.level.to_s[0..0].upcase}#{colors::CLEAR} [#{$$}:#{log.thread_name}] #{tags}#{duration_str}#{level_color}#{log.name}#{colors::CLEAR} -- #{message}"
+          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{level_color}#{colors::BOLD}#{log.level.to_s[0..0].upcase}#{colors::CLEAR} [#{$$}:#{'%.30s' % log.thread_name}] #{tags}#{duration_str}#{level_color}#{log.name}#{colors::CLEAR} -- #{message}"
         end
       end
 

data/lib/semantic_logger/base.rb

@@ -91,7 +91,7 @@ module SemanticLogger
             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}, exception)
+            log Log.new(:#{level}, Thread.current.name, name, message, payload, Time.now, nil, tags, #{index}, exception)
             true
           else
             false
@@ -125,14 +125,14 @@ module SemanticLogger
               if exception
                 case log_exception
                 when :full
-                  log Log.new(:#{level}, self.class.thread_name, name, message, payload, end_time, duration, tags, #{index}, exception)
+                  log Log.new(:#{level}, Thread.current.name, name, message, payload, end_time, duration, tags, #{index}, exception)
                 when :partial
-                  log Log.new(:#{level}, self.class.thread_name, name, "\#{message} -- Exception: \#{exception.class}: \#{exception.message}", payload, end_time, duration, tags, #{index}, nil)
+                  log Log.new(:#{level}, Thread.current.name, name, "\#{message} -- Exception: \#{exception.class}: \#{exception.message}", payload, end_time, duration, tags, #{index}, nil)
                 end
                 raise exception
               elsif duration >= min_duration
                 # Only log if the block took longer than 'min_duration' to complete
-                log Log.new(:#{level}, self.class.thread_name, name, message, payload, end_time, duration, tags, #{index}, nil)
+                log Log.new(:#{level}, Thread.current.name, name, message, payload, end_time, duration, tags, #{index}, nil)
               end
             end
           else
@@ -165,8 +165,7 @@ module SemanticLogger
     # Add tags to the current scope
     #   To support: ActiveSupport::TaggedLogging V4 and above
     def push_tags *tags
-      # Check for nil tags
-      Thread.current[:semantic_logger_tags] = self.tags.concat(tags)
+      Thread.current[:semantic_logger_tags] = self.tags.concat(tags.flatten.collect(&:to_s).reject(&:empty?))
     end
 
     # Remove specified number of tags from the current tag list
@@ -271,18 +270,6 @@ module SemanticLogger
     #   Internal index of the log level
     Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception)
 
-    # For JRuby include the Thread name rather than its id
-    if defined? Java
-      # Name of the current Thread
-      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)

data/lib/semantic_logger/core_ext/thread.rb

@@ -0,0 +1,24 @@
+require 'thread'
+class Thread
+  # Returns the name of the current thread
+  # Default:
+  #    JRuby: The Java thread name
+  #    Other: String representation of this thread's object_id
+  if defined? JRuby
+    # Design Note:
+    #   In JRuby with "thread.pool.enabled=true" each Ruby Thread instance is
+    #   new, even though the Java threads are being re-used from the pool
+    def name
+      @name ||= JRuby.reference(self).native_thread.name
+    end
+  else
+    def name
+      @name ||= object_id.to_s
+    end
+  end
+
+  # Set the name of this thread for logging and debugging purposes
+  def name=(name)
+    @name = name.to_s
+  end
+end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "2.4.1"
+  VERSION = "2.5.0"
 end

data/test/appender_file_test.rb

@@ -18,7 +18,7 @@ class AppenderFileTest < Test::Unit::TestCase
       @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
+      @thread_name = Thread.current.name
     end
 
     context "format logs into text form" do

data/test/loggable_test.rb

@@ -25,7 +25,7 @@ class AppenderFileTest < Test::Unit::TestCase
       SemanticLogger.add_appender(@appender)
       @hash = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
       @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-      @thread_name = SemanticLogger::Base.thread_name
+      @thread_name = Thread.current.name
     end
 
     teardown do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.4.1
+  version: 2.5.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-29 00:00:00.000000000 Z
+date: 2013-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
@@ -52,6 +52,7 @@ files:
 - lib/semantic_logger/appender/syslog.rb
 - lib/semantic_logger/appender/wrapper.rb
 - lib/semantic_logger/base.rb
+- lib/semantic_logger/core_ext/thread.rb
 - lib/semantic_logger/loggable.rb
 - lib/semantic_logger/logger.rb
 - lib/semantic_logger/semantic_logger.rb