logsly 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  metadata.gz: 873d513fcda4a6f898be9fbea3fe557f36e25174
-  data.tar.gz: ed137cb5edb8b14102f43cdbc60bcfef30968007
+  data.tar.gz: fdb3d320ab7c960ead493dea3487d22b888ec334
+  metadata.gz: 6597d31a9454d9c6975c24133145cfc5585f3437
 SHA512: 
-  metadata.gz: 30f4de19dc9c57407713ab504f727fe309e83632e52f46b548aa1b39bfcf4b5cff8def086a8e7599d5818b04f4377756022c8a9641df6b9ae4f86a3675c8624a
-  data.tar.gz: fb1fae8744f5e4652bf8252a08e50fe15f403e5e437686c2d5e836b06e67d03cff52ccd366cb59491a46c758b1c94651a8556042d3159ed19916b4ca627ff05d
+  data.tar.gz: 3570c61158197b4135d4ace0867444427ddfdb23c068fb13462495823bc8f2e04c95e34e2d5d75080d1f75cc4714bc9c45f609a432699edc68c55e327057ae69
+  metadata.gz: b18fd5ea0718979700ff59bcb56b8a4f54488c2668e185c9963fa26c519adc92096ad29adfe18b551ef7c771e425afefc851c369c8e3a4beac2c5dcef6bac24f

data/README.md

@@ -25,7 +25,9 @@ bg_logger.debug "something"
 
 ## Implementation
 
-Logsly creates and delegates to a [Logging logger](https://github.com/TwP/logging).  When you create an instance of your logger class, Logsly sets up and configures Logging for you.
+Logsly creates and delegates to a [Logging logger](https://github.com/TwP/logging/tree/logging-1.8.2).  When you create an instance of your logger class, Logsly sets up and configures Logging for you.
+
+**Note**: [Logging v1.8.2](https://github.com/TwP/logging/tree/logging-1.8.2) is the last version that is Ruby 1.8.7 compatible.  However, that version doesn't work in modern Ruby versions.  Therefore I've taken the source from Logging v1.8.2 and brought it in manually as a submodule under the `Logsly::Logging182` namespace.  I've tweaked the original source to allow properly requiring/referencing it as a submodule and to also make it work in modern Ruby.  All source in the `Logsly::Logging182` namespace is [MIT License Copyright (c) 2012 Tim Pease](https://github.com/TwP/logging/tree/logging-1.8.2#license) and all credit is his.
 
 ## Settings
 
@@ -76,7 +78,7 @@ Define a named syslog output to use with your loggers.  Takes the same parameter
 
 ### Patterns
 
-Each output can define what pattern to format its messages with using the `pattern' method.  See [Logging's patterns](https://github.com/TwP/logging/blob/master/lib/logging/layouts/pattern.rb) for details.
+Each output can define what pattern to format its messages with using the `pattern' method.  See [Logging's patterns](https://github.com/TwP/logging/blob/logging-1.8.2/lib/logging/layouts/pattern.rb) for details.
 
 ### Colors
 
@@ -93,7 +95,7 @@ Logsly.colors('my_colors') do
 end
 ```
 
-Define a named color scheme to use on your outputs.  Essentially creates a [Logging::ColorScheme](https://github.com/TwP/logging/blob/master/lib/logging/color_scheme.rb) object.  See that file for configuration and details.
+Define a named color scheme to use on your outputs.  Essentially creates a [Logging::ColorScheme](https://github.com/TwP/logging/blob/logging-1.8.2/lib/logging/color_scheme.rb) object.  See that file for configuration and details.
 
 ## Installation
 

data/lib/logsly/colors.rb

@@ -1,6 +1,6 @@
 # This class provides a DSL for setting color scheme values and lazy eval's
 # the DSL to generate a Logging color scheme object.
-# See https://github.com/TwP/logging/blob/master/lib/logging/color_scheme.rb
+# See https://github.com/TwP/logging/blob/logging-1.8.2/lib/logging/color_scheme.rb
 # for details on Logging color schemes.
 
 module Logsly
@@ -19,7 +19,7 @@ module Logsly
 
     def to_scheme(*args)
       "#{@name}-#{args.map{|a| a.object_id}.join('-')}".tap do |scheme_name|
-        Logging.color_scheme(scheme_name, ColorsData.new(*args, &@build).to_scheme_opts)
+        Logsly::Logging182.color_scheme(scheme_name, ColorsData.new(*args, &@build).to_scheme_opts)
       end
     end
 

data/lib/logsly/logging182/appender.rb

@@ -0,0 +1,290 @@
+
+module Logsly::Logging182
+
+# The +Appender+ class is provides methods for appending log events to a
+# logging destination. The log events are formatted into strings using a
+# Layout.
+#
+# All other Appenders inherit from this class which provides stub methods.
+# Each subclass should provide a +write+ method that will write log
+# messages to the logging destination.
+#
+# A private +sync+ method is provided for use by subclasses. It is used to
+# synchronize writes to the logging destination, and can be used by
+# subclasses to synchronize the closing or flushing of the logging
+# destination.
+#
+class Appender
+
+  attr_reader :name, :layout, :level
+
+  # call-seq:
+  #    Appender.new( name )
+  #    Appender.new( name, :layout => layout )
+  #
+  # Creates a new appender using the given name. If no Layout is specified,
+  # then a Basic layout will be used. Any logging header supplied by the
+  # layout will be written to the logging destination when the Appender is
+  # created.
+  #
+  # Options:
+  #
+  #    :layout   => the layout to use when formatting log events
+  #    :level    => the level at which to log
+  #    :encoding => encoding to use when writing messages (defaults to UTF-8)
+  #
+  def initialize( name, opts = {} )
+    ::Logsly::Logging182.init unless ::Logsly::Logging182.initialized?
+
+    @name = name.to_s
+    @closed = false
+
+    self.layout = opts.getopt(:layout, ::Logsly::Logging182::Layouts::Basic.new)
+    self.level = opts.getopt(:level)
+    self.encoding = opts.fetch(:encoding, self.encoding)
+
+    @mutex = ReentrantMutex.new
+
+    if opts.getopt(:header, true)
+      header = @layout.header
+
+      unless header.nil? || header.empty?
+        begin
+          write(header)
+        rescue StandardError => err
+          ::Logsly::Logging182.log_internal(-2) {err}
+        end
+      end
+    end
+
+    ::Logsly::Logging182::Appenders[@name] = self
+  end
+
+  # call-seq:
+  #    append( event )
+  #
+  # Write the given _event_ to the logging destination. The log event will
+  # be processed through the Layout associated with the Appender.
+  #
+  def append( event )
+    if @closed
+      raise RuntimeError,
+            "appender '<#{self.class.name}: #{@name}>' is closed"
+    end
+
+    # only append if the event level is less than or equal to the configured
+    # appender level
+    unless @level > event.level
+      begin
+        write(event)
+      rescue StandardError => err
+        ::Logsly::Logging182.log_internal(-2) {err}
+      end
+    end
+
+    self
+  end
+
+  # call-seq:
+  #    appender << string
+  #
+  # Write the given _string_ to the logging destination "as is" -- no
+  # layout formatting will be performed.
+  #
+  def <<( str )
+    if @closed
+      raise RuntimeError,
+            "appender '<#{self.class.name}: #{@name}>' is closed"
+    end
+
+    unless @level >= ::Logsly::Logging182::LEVELS.length
+      begin
+        write(str)
+      rescue StandardError => err
+        ::Logsly::Logging182.log_internal(-2) {err}
+      end
+    end
+    self
+  end
+
+  # call-seq:
+  #    level = :all
+  #
+  # Set the level for this appender; log events below this level will be
+  # ignored by this appender. The level can be either a +String+, a
+  # +Symbol+, or a +Fixnum+. An +ArgumentError+ is raised if this is not
+  # the case.
+  #
+  # There are two special levels -- "all" and "off". The former will
+  # enable recording of all log events. The latter will disable the
+  # recording of all events.
+  #
+  # Example:
+  #
+  #    appender.level = :debug
+  #    appender.level = "INFO"
+  #    appender.level = 4
+  #    appender.level = 'off'
+  #    appender.level = :all
+  #
+  # These produce an +ArgumentError+
+  #
+  #    appender.level = Object
+  #    appender.level = -1
+  #    appender.level = 1_000_000_000_000
+  #
+  def level=( level )
+    lvl = case level
+          when String, Symbol; ::Logsly::Logging182::level_num(level)
+          when Fixnum; level
+          when nil; 0
+          else
+            raise ArgumentError,
+                  "level must be a String, Symbol, or Integer"
+          end
+    if lvl.nil? or lvl < 0 or lvl > ::Logsly::Logging182::LEVELS.length
+      raise ArgumentError, "unknown level was given '#{level}'"
+    end
+
+    @level = lvl
+  end
+
+  # call-seq
+  #    appender.layout = Logsly::Logging182::Layouts::Basic.new
+  #
+  # Sets the layout to be used by this appender.
+  #
+  def layout=( layout )
+    unless layout.kind_of? ::Logsly::Logging182::Layout
+      raise TypeError,
+            "#{layout.inspect} is not a kind of 'Logsly::Logging182::Layout'"
+    end
+    @layout = layout
+  end
+
+  # call-seq:
+  #    close( footer = true )
+  #
+  # Close the appender and writes the layout footer to the logging
+  # destination if the _footer_ flag is set to +true+. Log events will
+  # no longer be written to the logging destination after the appender
+  # is closed.
+  #
+  def close( footer = true )
+    return self if @closed
+    ::Logsly::Logging182::Appenders.remove(@name)
+    @closed = true
+
+    flush
+
+    if footer
+      footer = @layout.footer
+      unless footer.nil? || footer.empty?
+        begin
+          write(footer)
+        rescue StandardError => err
+          ::Logsly::Logging182.log_internal(-2) {err}
+        end
+      end
+    end
+    self
+  end
+
+  # call-seq:
+  #    closed?
+  #
+  # Returns +true+ if the appender has been closed; returns +false+
+  # otherwise. When an appender is closed, no more log events can be
+  # written to the logging destination.
+  #
+  def closed?
+    @closed
+  end
+
+  # Reopen the connection to the underlying logging destination. If the
+  # connection is currently closed then it will be opened. If the connection
+  # is currently open then it will be closed and immediately opened.
+  #
+  def reopen
+    @closed = false
+    self
+  end
+
+  # call-seq:
+  #    flush
+  #
+  # Call +flush+ to force an appender to write out any buffered log events.
+  # Similar to IO#flush, so use in a similar fashion.
+  #
+  def flush
+    self
+  end
+
+  # call-seq:
+  #     inspect    => string
+  #
+  # Returns a string representation of the appender.
+  #
+  def inspect
+    "<%s:0x%x name=\"%s\">" % [
+        self.class.name.sub(%r/^Logsly::Logging182::/, ''),
+        self.object_id,
+        self.name
+    ]
+  end
+
+  # Returns the current Encoding for the appender or nil if an encoding has
+  # not been set.
+  #
+  def encoding
+    return @encoding if defined? @encoding
+    @encoding = Object.const_defined?(:Encoding) ? Encoding.default_external : nil
+  end
+
+  # Set the appender encoding to the given value. The value can either be an
+  # Encoding instance or a String or Symbol referring to a valid encoding.
+  #
+  # This method only applies to Ruby 1.9 or later. The encoding will always be
+  # nil for older Rubies.
+  #
+  # value - The encoding as a String, Symbol, or Encoding instance.
+  #
+  # Raises ArgumentError if the value is not a valid encoding.
+  #
+  def encoding=( value )
+    if value.nil?
+      @encoding = nil
+    else
+      @encoding = Object.const_defined?(:Encoding) ? Encoding.find(value.to_s) : nil
+    end
+  end
+
+
+private
+
+  # call-seq:
+  #    write( event )
+  #
+  # Writes the given _event_ to the logging destination. Subclasses should
+  # provide an implementation of this method. The _event_ can be either a
+  # LogEvent or a String. If a LogEvent, then it will be formatted using
+  # the layout given to the appender when it was created.
+  #
+  def write( event )
+    nil
+  end
+
+  # call-seq:
+  #    sync { block }
+  #
+  # Obtains an exclusive lock, runs the block, and releases the lock when
+  # the block completes. This method is re-entrant so that a single thread
+  # can call +sync+ multiple times without hanging the thread.
+  #
+  def sync( &block )
+    @mutex.synchronize(&block)
+  end
+
+end  # class Appender
+end  # module Logsly::Logging182
+