libis-tools 0.9.20 → 0.9.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b02d1a5db6228befa73d14fb34880fc50c1c3205
-  data.tar.gz: 45cd0d340b39e2f585d0aeb25076b439132f2af7
+  metadata.gz: dc18f91c7fdaf317168eb91966d598fff6fd0252
+  data.tar.gz: 43d8f7c0f51f7e5e32b28680f53bb6f6dbb17658
 SHA512:
-  metadata.gz: 660ddb441d546e37e4170cd236853dcf5273063873dee76647a79ee9c6f0386a9fdb010c8a91f4e1ce175060278ddb6e0b3153c8ec67ef47ccc232c2beace443
-  data.tar.gz: 68d181a6f3c644f38561947f13dd138fb69973d12b3c213f0fee24b454f228e4840bdfec611ba1a8c1e9fc17b502faa31857fbd37ab4723745faec041e230436
+  metadata.gz: db2e5d1f92574eaefab41674b23aac4aa116b01206eb5eeb1304482de6dba8213a00b3c3ccfd79a83be1523b7d947d07112dd445ddadfeb781176f0fefacf65d
+  data.tar.gz: 5983fc775104c2d592fdeacdec3c86489215275ab9f138bf72211696e049e21f093e2f25e197a722d854962753652c469972e22a4dd123af58b9dd951ce8b782

data/README.md

@@ -42,181 +42,64 @@ sections below for their names.
 
 ## Content
 
-### assert
+### {Object#assert}
 
-The Object#assert method enables the assert functionality found in other languages.
-The method takes an argument that will be interpreted as a boolean expression and an optional message.
-If the boolean expression evaluates to false an AssertionFailure exception will be raised.
+The {Object#assert} method enables the assert functionality found in other languages. Since it is defined on the
+Object class, it is available on almost any class.
 
-Alternatively, if a block is passed to the method, the given block will be evaluated and the result will decide if the
-exception will be raised. In that case the first argument passed to the assert method is used as message and the second
-argument is ignored.
+### {::Libis::Tools::Checksum}
 
-The method will not evaluate the first parameter or block unless the general parameter $DEBUG evaluates to true. That
-means that special care should be taken that the expression does not generate any side effects that the program may rely
-on.
+The {::Libis::Tools::Checksum} class offers a standardized interface for calculating checksums of file 
+contents in different formats.
 
-Examples:
+### {::Libis::Tools::Command}
 
-```ruby
-    require 'libis/tools/assert'
-    assert(value > 0, 'value should be positive number')
-```
-and using a code block:
-
-```ruby
-    require 'libis/tools/assert'
-    assert 'database is not idle' do
-        db = get_database
-        db.status == :IDLE
-    end
-```
-
-### Checksum
+The {::Libis::Tools::Command} module offers a safe way to execute external commands and gives you access to the 
+exit status as well as standard output and standard error information. May have issues on older JRuby versions. 
 
-The ::Libis::Tools::Checksum class offers a standardized interface for calculating checksums of file contents in
-different formats. The actual list of supported checksum formats is in ::Libis::Tools::Checksum.CHECKSUM_TYPES. It
-contains MD5, SHA-1 and SHA-2 (in 256-bit, 384-bit and 512-bit variants).
-
-There are two ways this can be used: using a class instance or using class methods. When a class instance is used, the
-desired checksum type has to be supplied when the instance is created. Each call to a checksum method will calculate the
-checksum and reset the digest to prevent future calls to be affected by the current result. When a class method is used
-besides the file name, the checksum type has to be supplied.
-
-The available methods on both instance and class level are:
-
-* digest: return the checksum as (binary) string.
-* hexdigest: return the checksum as hexadecimal encoded string.
-* base64digest: return the checksum as base64 encoded string.
-
-Examples:
-
-```ruby
-    require 'libis/tools/checksum'
-    checksum = ::Libis::Tools::Checksum.new(:MD5)
-    puts "Checksum: #{checksum.hexdigest(file_name)} (MD5, hex)"
-```
-
-```ruby
-    require 'libis/tools/checksum'
-    puts "Checksum: #{::Libis::Tools::Checksum.base64digest(file_name, :SHA384)} (SHA-2, 384 bit, base64)"
-```
-
-### Command
-
-This module allows to run an external command safely and returns it's output, error messages and status. The run method
-takes any number of arguments that will be used as command-line arguments. The method returns a Hash with:
-
-* :out => an array with lines that were printed on the external program's standard out.
-* :err => an array with lines that were printed on the external program's standard error.
-* :status => exit code returned by the external program.
-
-```ruby
-    require 'libis/tools/command'
-    result = ::Libis::Tools::Command.run('ls', '-l', File.absolute_path(__FILE__))
-    p result # => {out: [...], err: [...], status: 0}
-```
-
-or:
-
-```ruby
-    require 'libis/tools/command'
-    include ::Libis::Tools::Command
-    result = run('ls', '-l', File.absolute_path(__FILE__))
-    p result # => {out: [...], err: [...], status: 0}
-```
+### {::Libis::Tools::DeepStruct}
 
-Note that the Command class uses Open3#popen3 internally. All arguments supplied to Command#run are passed to the popen3
-call. Unfortunately JRuby has some known issues with popen3. Please use and test carefully in JRuby environments.
+A class that derives from OpenStruct through the RecursiveOpenStruct.
+By wrapping a Hash recursively, it allows for easy access to the content by method names.
 
-### DeepStruct
+### {::Libis::Tools::ConfigFile}
 
-A class that derives from OpenStruct through the RecursiveOpenStruct. A RecursiveOpenStruct is derived from stdlib's
-OpenStruct, but can be made recursive. DeepStruct enforces this behaviour and adds a clear! method.
+A base class for {::Libis::Tools::Config}, but useable on it's own.
+It extends the DeepStruct with loading from and saving to YAML files.
 
-### ConfigFile
+### {::Libis::Tools::Config}
 
-A base class for Config, but useable on it's own. It extends the DeepStruct with << and >> methods that supports
-loading and saving of configuration values from and to files. Note that ERB commands will get lost during a round-trip.
- 
-```ruby
-    require 'libis/tools/config_file'
-    cfg_file = ::Libis::Tools::ConfigFile.new
-    cfg_file << {foo: 'bar'}
-    cfg_file.my_value = 10
-    p cfg_file[:my_value] # => 10
-    cfg_file{:my_text] = 'abc'
-    p cfg_file['my_text'] # => 'abc'
-    p cfg_file.to_hash # => { :foo => 'bar', 'my_value' => 10, :my_text => 'abc' }
-    cfg >> 'my_config.yml'
-```
-### Config
+This Singleton class is a convenience class for easy configuration maintenance and loading.
+It also initializes a default logger.
 
-The Config class is a convenience class for easy configuration maintenance and loading. Based on ConfigFile and 
-DeepStruc, it supports code defaults and loading configurations from multiple YAML files containing ERB statements.
-The Config class follows the Singleton pattern and behaves like a Hash/OpenStruct/HashWithIndifferentAccess with 
-recursion over hashes and arrays. It also initializes a default Logger instance.
+### {::Libis::Tools::Logger}
 
-For each configuration parameter, the value can be accessed via the class or the Singleton instance through a method
-call or via the Hash operator using the parameter name either as a string or a symbol.
+The ::Libis::Tools::Logger module adds support for logging functionality to any class.
 
-Examples:
+## {::Libis::Tools::Metadata}
 
-```ruby
-    require 'libis/tools/config'
-    cfg = ::Libis::Tools::Config
-    cfg << 'my_config.yml'
-    cfg['my_value'] = 10
-    p cfg.instance.my_value # => 10
-    cfg.instance.my_text = 'abc'
-    p cfg[:my_text] # => 'abc'
-    p cfg.logger.warn('message') # => W, [2015-03-16T12:51:01.180548 #28935]  WARN -- : message
-```
+This gem also provides some modules and classes that assist in working with metadata. There are classes that allow to 
+create and/or read metadata for MARC(21), Dublin Core and SharePoint. These classes all live in the 
+Libis::Tools::Metadata namespace.
 
-### Logger
+### MARC
 
-The Logger module adds logging functionality to any class. Just include the ::Libis::Tools::Logger module and the
-methods debug, info, warn, error and fatal will be available to the class instance. Each method takes a message argument
-and optional extra parameters. The methods all call the message method with the logging level as first argument and the
-supplied arguments appended.
+The classes {::Libis::Tools::Metadata::MarcRecord} and it's child class {::Libis::Tools::Metadata::Marc21Record} are 
+mainly built for reading MARC(21) records. Most of the class logic is in the base class 
+{::Libis::Tools::Metadata::MarcRecord MarcRecord}, which is incomplete and should be considered an abstract class. 
 
-The default message method implementation uses the logger of ::Libis::Tools::Config. If extra parameters are supplied,
-the message will be used as a format specification with the extra parameters applied to it. If an 'appname' parameter is
-defined in the Config object, it will be used as program name by the logger, otherwise the class name is taken.
+{::Libis::Tools::Metadata::Marc21Record Marc21Record} on the other hand only contains the logic to parse the XML data 
+into the internal structure. A {::Libis::Tools::Metadata::MarcRecord MarcRecord} is created by supplying it an XML node
+(from Nokogiri or {::Libis::Tools::XmlDocument}) that contains child nodes with the MARC data of a single record. 
 
-If the class defines a #options method that returns a Hash containing a :quiet key, the value for that key will be
-evaluated and if true debug, info and warning messages will not be printed.
+The code will strip namespaces from the input in order to greatly simplify working with the XML.
 
-Example:
+## {::Libis::Tools::Parameter} and {::Libis::Tools::ParameterContainer} 
 
-```ruby
-    require 'libis/tools/logger'
-    class TestLogger
-      include ::Libis::Tools::Logger
-      attr_accessor :options, name
-      def initialize
-        @options = {}
-        @name = nil
-      end
-    end
-    tl = TestLogger.new
-    tl.debug 'message'
-    tl.options[:quiet] = true
-    tl.warn 'message'
-    ::Libis::Tools::Config.appname = 'TestApplication'
-    tl.error 'huge error: [%d] %s', 1000, 'Exit'
-    tl.name = 'TestClass'
-    tl.options[:quiet] = false
-    tl.info 'Running application: %s', ::Libis::Tools::Config.appname
-```
-produces:
-    <pre>
-    D, [...] DEBUG -- TestLogger: message
-    E, [...] ERROR -- TestApplication: huge error: [1000] Exit
-    I, [...]  INFO -- TestClass: Running application TestApplication
-    </pre>
+The class {::Libis::Tools::Parameter} and the {::Libis::Tools::ParameterContainer} module provide a simple framework for
+instance variables that are type-safe and can easily be documented and provide defaults.
 
-### XmlDocument
+### {::Libis::Tools::XmlDocument}
 
 Class that embodies most used features of Nokogiri, Nori and Gyoku in one convenience class. The Nokogiri document is
 stored in the class variable 'document' and can be accessed and manipulated directly - if required. The class supports
@@ -300,87 +183,7 @@ produces:
       <email>harry.potter@hogwarts.edu</email>
       <email>hpotter@JKRowling.com</email>
     </patron>
-    
-## Metadata
-
-This gem also provides some modules and classes that assist in working with metadata. There are classes that allow to 
-create and/or read metadata for MARC(21), Dublin Core and SharePoint. These classes all live in the 
-Libis::Tools::Metadata namespace.
-
-### MARC
-
-The classes Libis::Tools::Metadata::MarcRecord and it's child class Libis::Tools::Metadata::Marc21Record are mainly
-built for reading MARC(21) records. Most of the class logic is in the base class MarcRecord, which is incomplete and
-should be considered an abstract class. Marc21Record on the other hand only contains the logic to parse the XML data 
-into the internal structure. A MarcRecord is created by supplying it an XML node (from Nokogiri or 
-Libis::Tools::XmlDocument) that contains child nodes with the MARC data of a single record. The code will strip
-namespaces from the input in order to greatly simplify working with the XML.
- 
-## Parameter
-
-The class ::Libis::Tools::Parameter and the ::Libis::Tools::ParameterContainer module provide a simple framework for
-instance variables that are type-safe and can easily be documented and provide defaults.
  
-To use these parameters a class should include the ::Libis::Tools::ParameterContainer module and add 'parameter' 
-statements to the body of the class definition. It takes only one mandatory argument which is a Hash. The first entry is
-interpreted as '<name> => <default>'. The name for the parameter should be unique and the default value can be any value
-of type TrueClass, FalseClass, String, Integer, Float, Date, Time, DateTime, Array, Hash or NilClass.
-
-The second up to last Hash entries are optional properties for the parameter. These are:
-
-* datatype: the type of values the parameter will accept. Valid values are:
-
-    * 'bool' or 'boolean'
-    * 'string'
-    * 'int'
-    * 'float'
-    * 'datetime'
-    * 'array'
-    * 'hash'
-
-    Any other value will raise a RuntimeError when the parameter is used. The value is case-insensitive and if not present, 
-    the datatype will be derived from the default value with 'string' being the default for NilClass. In any case the 
-    parameter will try its best to convert supplied values to the proper data type. For instance, an Integer parameter will 
-    accept 3, 3.1415, '3' and Rational(10/3) as valid values and store them as the integer value 3. Likewise DateTime 
-    parameters will try to interprete date and time strings.
-
-* description: any descriptive text you want to add to clarify what this parameter is used for. Any tool can ask the
-class for its parameters and - for instance - can use this property to provide help in a GUI when asking the user for
-input.
-
-* constraint: adds a validation condition to the parameter. The condition value can be: 
-
-    * an array: only values that convert to a value in the list are considered valid.
-    * a range: only values that convert to a value in the given range are considered valid.
-    * a regular expression: only values that match the regular expression are considered valid.
-    * a string: only values that are '==' to the constraint are considered valid.
-    
-* frozen: if set to true, prevents the class instance to set the parameter to any value other than the default. Mostly
-useful when a derived class needs a parameter in the parent class to be set to a specific value. Setting a value on 
-a frozen parameter with the 'parameter(name,value)' method throws a ::Libis::Tools::ParameterFrozenError. The '[]=' 
-method silently ignores the exception. In any case the default value will not be changed.
-
-* options: a hash with any additional properties that you want to associate to the parameter. Any key-value pair in this
-hash is added to the retrievable properties of the parameter. Likewise any property defined, that is not in the list of 
-known properties is added to the options hash. In this aspect the ::Libis::Tools::Parameter class behaves much like an
-OpenStruct even though it is implemented as a Struct.
-
-Besides enabling the 'parameter' class method to define parameters, the ::Libis::Tools::ParameterContainer add the class
-method 'parameters' that will return a Hash with parameter names as keys and their respective parameter definitions as
-values. On each class instance the 'parameter' method is added and serves as both getter and setter for parameter values:
-With only one argument (the parameter name) it returns the current value for the parameter, but the optional second 
-argument will cause the method to set the parameter value. If the parameter is not available or the given value is not 
-a valid value for the parameter, the method will return the special constant ::Libis::ParameterContainer::NO_VALUE. The 
-methods '[]' and '[]=' serve as aliases for the getter and setter calls.
-
-Additionally two protected methods are available on the instance:
-* 'parameters': returns the Hash that keeps track of the current parameter values for the instance.
-* 'get_parameter_defintion': retrieves the parameter definition from the instance's class for the given parameter name.
-
-Any class that derives from a class that included the ::Libis::Tools::ParameterContainer module will automatically 
-inherit all parameter definitions from all of it's base classes and can override any of these parameter definitions e.g. 
-to change the default values for the parameter.
-
 ## Contributing
 
 1. Fork it ( https://github.com/Kris-LIBIS/LIBIS_Tools/fork )

data/Rakefile

@@ -1,6 +1,11 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'yard'
 
 RSpec::Core::RakeTask.new
 
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']
+end
+
 task :default => :spec

data/lib/libis/tools.rb

@@ -12,6 +12,7 @@ module Libis
     autoload :Logger, 'libis/tools/logger'
     autoload :MetsFile, 'libis/tools/mets_file'
     autoload :Parameter, 'libis/tools/parameter'
+    autoload :ThreadSafe, 'libis/tools/thread_safe'
     autoload :XmlDocument, 'libis/tools/xml_document'
 
   end

data/lib/libis/tools/assert.rb

@@ -19,6 +19,17 @@ class Object
   #
   # Examples:
   #
+  #     require 'libis/tools/assert'
+  #     assert(value > 0, 'value should be positive number')
+  #
+  #     # using a code block:
+  #     require 'libis/tools/assert'
+  #     assert 'database is not idle' do
+  #       db = get_database
+  #       db.status == :IDLE
+  #     end
+  #
+  #     # using $DEBUG:
   #     $DEBUG = nil
   #     assert false, 'assert 1'        # nothing happens
   #     $DEBUG = true

data/lib/libis/tools/checksum.rb

@@ -11,16 +11,33 @@ module Libis
     # All methods are available on the class and on the instance. The instance has to be initialized with a checksum
     # algorithm and therefore the instance methods do not have to specify the checksum type.
     #
+    # There are two ways this can be used: using a class instance or using class methods. When a class instance is used,
+    # the desired checksum type has to be supplied when the instance is created. Each call to a checksum method will
+    # calculate the checksum and reset the digest to prevent future calls to be affected by the current result. When a
+    # class method is used besides the file name, the checksum type has to be supplied.
+    #
+    # Examples:
+    #
+    #     require 'libis/tools/checksum'
+    #     checksum = ::Libis::Tools::Checksum.new(:MD5)
+    #     puts "Checksum: #{checksum.hexdigest(file_name)} (MD5, hex)"
+    #
+    #     require 'libis/tools/checksum'
+    #     puts "Checksum: #{::Libis::Tools::Checksum.base64digest(file_name, :SHA384)} (SHA-2, 384 bit, base64)"
     class Checksum
-      if defined? JRUBY_VERSION
-        CHECKSUM_TYPES = [:MD5, :SHA1, :SHA256, :SHA384, :SHA512]
-      else
-        CHECKSUM_TYPES = [:MD5, :RMD160, :SHA1, :SHA256, :SHA384, :SHA512]
+      # All supported checksum types
+      CHECKSUM_TYPES = [:MD5, :SHA1, :SHA256, :SHA384, :SHA512]
+
+      # @!visibility private
+      # noinspection RubyResolve
+      unless defined? JRUBY_VERSION
+        checksum_types = CHECKSUM_TYPES
+        checksum_types << :RMD160
       end
 
       # Create instance for a given checksum algorithm.
       #
-      # @param [Symbol] type checksum algorithm; one of {#CHECKSUM_TYPES}
+      # @param [Symbol] type checksum algorithm; one of {CHECKSUM_TYPES}
       def initialize(type)
         @hasher = self.class.get_hasher(type)
       end

data/lib/libis/tools/command.rb

@@ -4,6 +4,27 @@ require 'open3'
 module Libis
   module Tools
 
+    # This module allows to run an external command safely and returns it's output, error messages and status.
+    # The run method takes any number of arguments that will be used as command-line arguments. The method returns
+    # a Hash with:
+    # * :out => an array with lines that were printed on the external program's standard out.
+    # * :err => an array with lines that were printed on the external program's standard error.
+    # * :status => exit code returned by the external program.
+    #
+    # Examples:
+    #
+    #     require 'libis/tools/command'
+    #     result = ::Libis::Tools::Command.run('ls', '-l', File.absolute_path(__FILE__))
+    #     p result # => {out: [...], err: [...], status: 0}
+    #
+    #     require 'libis/tools/command'
+    #     include ::Libis::Tools::Command
+    #     result = run('ls', '-l', File.absolute_path(__FILE__))
+    #     p result # => {out: [...], err: [...], status: 0}
+    #
+    # Note that the Command class uses Open3#popen3 internally. All arguments supplied to Command#run are passed to
+    # the popen3 call. Unfortunately some older JRuby versions have some known issues with popen3. Please use and
+    # test carefully in JRuby environments.
     module Command
 
       # Run an external program and return status, stdout and stderr.
@@ -12,9 +33,9 @@ module Libis
       # @param [String] cmd program name
       # @param [Array<String>] opts optional list of command line arguments
       # @return [Hash] a Hash with:
-      #         * +:status+ : the exit status of the command
-      #         * +:out+ : the stdout output of the command
-      #         * +:err+ : the stderr output of the command
+      #         * :status (Integer) - the exit status of the command
+      #         * :out (Array<String>) - the stdout output of the command
+      #         * :err (Array<String>)- the stderr output of the command
       def self.run(cmd, *opts)
         result = {
             status: 999,

data/lib/libis/tools/config.rb

@@ -2,18 +2,19 @@
 require 'singleton'
 require 'yaml'
 require 'erb'
-require 'logger'
+require 'logging'
 
-require 'libis/tools/config_file'
+require_relative 'config_file'
 
 module Libis
   module Tools
 
-    # The Config class is a convenience class for easy configuration maintenance, loading and saving.
-    # It supports code defaults, loading configurations from multiple YAML files containing ERB statements.
-    # The Config class follows the Singleton pattern and behaves like a Hash/OpenStruct/HashWithIndifferentAccess.
-    # It also initializes a default Logger instance.
-    # The class also stores a system-wide {::Logger} instance that will be used by {::Libis::Tools::Logger}.
+    # The Singleton Config class is a convenience class for easy configuration maintenance, loading and saving.
+    # It also initializes a default logger and supports creating extra loggers. The logging infrastructure is based on
+    # the {http://www.rubydoc.info/gems/logging/Logging ::Logging} gem and supports the {::Libis::Tools::Logger} class.
+    #
+    # For the configuration parameters, it supports code defaults, loading configurations from multiple YAML files
+    # containing ERB statements. The Config class behaves like a Hash/OpenStruct/HashWithIndifferentAccess.
     #
     # The parameters can be accessed by getter/setter method or using the Hash syntax:
     #
@@ -23,7 +24,7 @@ module Libis
     #         p cfg.instance.my_value # => 10
     #         cfg.instance.my_text = 'abc'
     #         p cfg[:my_text] # => 'abc'
-    #         p cfg.logger.warn('message') # => W, [2015-03-16T12:51:01.180548 #28935]  WARN -- : message
+    #         p cfg.logger.warn('message') # => W, [2015-03-16T12:51:01.180548 #123.456]  WARN : message
     #
     class Config
       include Singleton
@@ -33,6 +34,7 @@ module Libis
         private
 
         # For each configuration parameter, the value can be accessed via the class or the Singleton instance.
+        # The class diverts to the instance automatically.
         def method_missing(name, *args, &block)
           result = instance.send(name, *args, &block)
           self === result ? self : result
@@ -40,6 +42,7 @@ module Libis
 
       end
 
+      # Instance method that allows to access the configuration parameters by method.
       def method_missing(name, *args, &block)
         result = config.send(name, *args, &block)
         self === config ? self : result
@@ -50,8 +53,10 @@ module Libis
       # The file paths and Hashes are memorised and loaded again by the {#reload} methods.
       # @param [String,Hash] file_or_hash
       def <<(file_or_hash)
-        @config.send('<<', (file_or_hash)) { |data| @sources << data }
-        self
+        sync do
+          @config.send('<<', (file_or_hash)) { |data| @sources << data }
+          self
+        end
       end
 
       # Load all files and Hashes again.
@@ -59,10 +64,12 @@ module Libis
       # Will not reset the configuration parameters. Parameters set directly on the
       # configuration are kept intact unless they also exist in the files or hashes in which case they will be overwritten.
       def reload
-        sources = @sources.dup
-        @sources.clear
-        sources.each { |f| self << f }
-        self
+        sync do
+          sources = @sources.dup
+          @sources.clear
+          sources.each { |f| self << f }
+          self
+        end
       end
 
       # Clear data and load all files and Hashes again.
@@ -71,8 +78,10 @@ module Libis
       # added directly (not via file or hash) will no longer be available. Parameters set explicitly that also exist in
       # the files or hashes will be reset to the values in those files and hashes.
       def reload!
-        @config.clear!
-        reload
+        sync do
+          @config.clear!
+          reload
+        end
       end
 
       # Clear all data.
@@ -80,38 +89,57 @@ module Libis
       # Not only all configuration parameters are deleted, but also the memorized list of loaded files
       # and hashes are cleared and the logger configuration is reset to it's default status.
       def clear!
-        @config.clear!
-        @sources = Array.new
-        @logger = ::Logger.new(STDOUT)
-        set_log_formatter
-        self
+        sync do
+          @config.clear!
+          @sources = Array.new
+          self.logger
+          self
+        end
       end
 
-      # Set the ::Logger instance's formatter.
-      # If the supplied formatter is missing or nil, a default formatter will be applied. The default formatter prints
-      # log lines like this:
+      # Gets the default ::Logging formatter.
+      #
+      # This in an instance of a layout that prints in the default message format.
+      #
+      # The default layout prints log lines like this:
       #
-      #     <first char of severity>, [<timestamp>#<process-id>] <severity> -- <program_name> : <message>
+      #     <first char of severity>, [<timestamp> #<process-id>.<thread-id] <severity> : <message>
       #
-      # @param [Proc] formatter the formatter procedure or nil for default formatter
-      def set_log_formatter(formatter = nil)
-        self.logger.formatter = formatter || proc do |severity, time, progname, msg|
-          "%s, [%s#%d] %5s -- %s: %s\n" % [severity[0..0],
-                                           (time.strftime('%Y-%m-%dT%H:%M:%S.') << '%06d ' % time.usec),
-                                           $$, severity, progname, msg]
+      def get_log_formatter
+        # noinspection RubyResolve
+        ::Logging::Layouts::Pattern.new(DEFAULT_LOG_LAYOUT_PARAMETERS)
+      end
+
+      def logger(name = nil)
+        sync do
+          name ||= :root
+          logger = ::Logging.logger[name]
+          logger.appenders = ::Logging.appenders.stdout(DEFAULT_LOG_LAYOUT_PARAMETERS) if logger.appenders.empty?
+          logger
         end
       end
 
-      attr_accessor :logger, :config, :sources
+      attr_accessor :config, :sources
 
       protected
 
       def initialize(hash = nil, opts = {})
+        @mutex = ReentrantMutex.new
         @config = ConfigFile.new(hash, opts)
         self.clear!
       end
 
+      def sync(&block)
+        @mutex.synchronize(&block)
+      end
+
+      ::Logging::init
+      # noinspection RubyResolve
+      DEFAULT_LOG_LAYOUT_PARAMETERS = {
+          pattern: "%.1l, [%d #%p.%t] %#{::Logging::MAX_LEVEL_LENGTH}l : %m\n",
+          date_pattern: '%Y-%m-%dT%H:%M:%S.%L'
+      }
+
     end
   end
 end
-