lumberjack 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6869d51bf38cc7ee1aad46005d947c5313bf58064da86cbd44ab5ca69dd04a71
-  data.tar.gz: 2817b2ace992f96770a16f1f5d6133a06f1e7277dfe236deb31d8fcad9934d39
+  metadata.gz: 10f2db93994b2941a8684c4fd933f07fc2d0067afdcfa3798f4ba3b5cc34b354
+  data.tar.gz: e6413b5b475b1c05ffcc17662e4f553af8e6d47d79e961a5802d0d875a413f9e
 SHA512:
-  metadata.gz: 6419348e19de6901892b35118ebc4405a773706b817d5c3c443f733973a977ad3be171b1f736b81334d9173cae5271799e267917284d3a28459349bc0cfc76f7
-  data.tar.gz: 5dca009d8cc55ea4044e9eba50df1ebba04351d019c3322b733ae01fc0d250f29d3a9f625c67da3549a0a7ebf8487a465f1ff4cca1ccfccf662f1cbccc4629cd
+  metadata.gz: 809fc20f5cb8cc7d704f5a5e6878f321285953c8c79139fbd9892fa6c954b645b6bdcc0ce0e0265e18b29974fd864a96fdd735a424f57bd1224653759b139fd8
+  data.tar.gz: c7cf6e570fe6a1cbba068905ad860c26ad375b5f413d449c8f77f84c4ad81b139585ef2917aa2328dac2b80e0a3f962895a5efb8c5b988a14605e59ccf6eafbc

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 1.2.0
+
+* Enable compatibility with ActiveSupport::TaggedLogger by calling `tagged_logger!` on a logger.
+* Add `tag_formatter` to logger to specify formatting of tags for output.
+* Allow adding and removing classes by name to formatters.
+* Allow adding and removing multiple classes in a single call to a formatter.
+* Allow using symbols and strings as log level for silencing a logger.
+* Ensure flusher thread gets stopped when logger is closed.
+* Add writer for logger device attribute.
+* Handle passing an array of devices to a multi device.
+* Helper method to get a tag with a specified name.
+* Add strip formatter to strip whitespace from strings.
+* Support non-alpha numeric characters in template variables.
+* Add backtrace cleaner to ExceptionFormatter.
+
 ## 1.1.1
 
 * Replace Procs in tag values with the value of calling the Proc in log entries.
@@ -15,6 +30,7 @@
 * Add DateTimeFormatter, IdFormatter, ObjectFormatter, and StructuredFormatter
 * Add rack Context middleware for setting thread global context
 * End support for ruby versions < 2.3
+* Add support for modules in formatters
 
 ## 1.0.13
 

data/README.md

@@ -85,6 +85,16 @@ logger.info("no requests") # Will not include the `request_id` tag
 
 Tag keys are always converted to strings. Tags are inherited so that message tags take precedence over block tags which take precedence over global tags.
 
+#### Compatibility with ActiveSupport::TaggedLogger
+
+`Lumberjack::Logger` version 1.1.2 or greater is compatible with `ActiveSupport::TaggedLogger`. This is so that other code that expect to have a logger that responds to the `tagged` method will work. Any tags added with the `tagged` method will be appended to an array in the the "tagged" tag. However, if a tagged value has a colon or equals sign in it, it will be parsed to a name value pair.
+
+```ruby
+logger.tagged("foo", "bar=1", "baz:2", "other") do
+  logger.info("here") # will include tags: {"tagged" => ["foo", "other"], "bar" => "1", "baz" => "2"}
+end
+```
+
 #### Templates
 
 The built in `Lumberjack::Device::Writer` class has built in support for including tags in the output using the `Lumberjack::Template` class.
@@ -117,33 +127,57 @@ If you'd like to send you log to a different kind of output, you just need to ex
 
 #### Formatters
 
-When a message is logged, it is first converted into a string. You can customize how it is converted by adding mappings to a Formatter.
+The message you send to the logger can be any object type and does not need to be a string. You can specify a `Lumberjack::Formatter` to instruct the logger how to format objects before outputting them to the device. You do this by mapping classes or modules to formatter code. This code can be either a block or an object that responds to the `call` method. The formatter will be called with the object logged as the message and the returned value will be what is sent to the device.
+
+```ruby
+  # Format all floating point number with three significant digits.
+  logger.formatter.add(Float) { |value| value.round(3) }
+
+  # Format all enumerable objects as a comma delimited string.
+  logger.formatter.add(Enumerable) { |value| value.join(", ") }
+```
 
-There are several built in classes you can add as formatters
+There are several built in classes you can add as formatters. You can use a symbol to reference built in formatters.
 
 ```ruby
   logger.formatter.add(Hash, :pretty_print)  # use the Formatter::PrettyPrintFormatter for all Hashes
   logger.formatter.add(Hash, Lumberjack::Formatter::PrettyPrintFormatter.new)  # alternative using a formatter instance
 ```
 
-* `Lumberjack::Formatter::ObjectFormatter` - no op conversion that returns the object itself.
-* `Lumberjack::Formatter::StringFormatter` - calls `to_s` on the object.
-* `Lumberjack::Formatter::InspectFormatter` - calls `inspect` on the object.
-* `Lumberjack::Formatter::ExceptionFormatter` - special formatter for exceptions which logs them as multi line statements with the message and backtrace.
-* `Lumberjack::Formatter::DateTimeFormatter` - special formatter for dates and times to format them using `strftime`.
-* `Lumberjack::Formatter::PrettyPrintFormatter` - returns the pretty print format of the object.
-* `Lumberjack::Formatter::IdFormatter` - returns a hash of the object with keys for the id attribute and class.
-* `Lumberjack::Formatter::StructuredFormatter` - crawls the object and applies the formatter recursively to Enumerable objects found in it (arrays, hashes, etc.).
+* `:object` - `Lumberjack::Formatter::ObjectFormatter` - no op conversion that returns the object itself.
+* `:string` - `Lumberjack::Formatter::StringFormatter` - calls `to_s` on the object.
+* `:strip` - `Lumberjack::Formatter::StripFormatter` - calls `to_s.strip` on the object.
+* `:inspect` - `Lumberjack::Formatter::InspectFormatter` - calls `inspect` on the object.
+* `:exception` - `Lumberjack::Formatter::ExceptionFormatter` - special formatter for exceptions which logs them as multi line statements with the message and backtrace.
+* `:date_time` - `Lumberjack::Formatter::DateTimeFormatter` - special formatter for dates and times to format them using `strftime`.
+* `:pretty_print` - `Lumberjack::Formatter::PrettyPrintFormatter` - returns the pretty print format of the object.
+* `:id` - `Lumberjack::Formatter::IdFormatter` - returns a hash of the object with keys for the id attribute and class.
+* `:structured` - `Lumberjack::Formatter::StructuredFormatter` - crawls the object and applies the formatter recursively to Enumerable objects found in it (arrays, hashes, etc.).
+
+To define your own formatter, either provide a block or an object that responds to `call` with a single argument.
+
+The default formatter will pass through values for strings, numbers, and booleans, and use the `:inspect` formatter for all objects except for exceptions which will be formatted with the `:exception` formatter.
+
+#### Tag Formatters
+
+The `logger.formatter` will only apply to log messages. You can use `logger.tag_formatter` to register formatters for tags. You can register both default formatters that will apply to all tag values, as well as tag specifice formatters that will apply only to objects with a specific tag name.
 
-You can also specify a block to use as a formatter:
+The fomatter values can be either a `Lumberjack::Formatter` or a block or an object that responds to `call`. If you supply a `Lumberjack::Formatter`, the tag value will be passed through the rules for that formatter. If you supply a block or other object, it will be called with the tag value.
 
 ```ruby
-  logger.formatter.add(MyClass){|obj| "#{obj.class}@#{obj.id}"}  # use a block to provide a custom format
+# These will all do the same thing formatting all tag values with `inspect`
+logger.tag_formatter.default(Lumberjack::Formatter.new.clear.add(Object, :inspect))
+logger.tag_formatter.default(Lumberjack::Formatter::InspectFormatter.new)
+logger.tag_formatter.default { |value| value.inspect }
+
+# This will register formatters only on specific tag names
+logger.tag_formatter.add(:thread) { |thread| "Thread(#{thread.name})" }
+logger.tag_formatter.add(:current_user, Lumberjack::Formatter::IdFormatter.new)
 ```
 
 #### Templates
 
-If you use the built in devices, you can also customize the Template used to format the LogEntry.
+If you use the built in `Lumberjack::Writer` derived devices, you can also customize the Template used to format the LogEntry.
 
 See `Lumberjack::Template` for a complete list of macros you can use in the template. You can also use a block that receives a `Lumberjack::LogEntry` as a template.
 

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.2.0

data/lib/lumberjack.rb

@@ -10,12 +10,15 @@ module Lumberjack
   LINE_SEPARATOR = (RbConfig::CONFIG['host_os'].match(/mswin/i) ? "\r\n" : "\n")
 
   require_relative "lumberjack/severity.rb"
+  require_relative "lumberjack/formatter.rb"
+
   require_relative "lumberjack/context.rb"
   require_relative "lumberjack/log_entry.rb"
-  require_relative "lumberjack/formatter.rb"
   require_relative "lumberjack/device.rb"
   require_relative "lumberjack/logger.rb"
   require_relative "lumberjack/tags.rb"
+  require_relative "lumberjack/tag_formatter.rb"
+  require_relative "lumberjack/tagged_logger_support.rb"
   require_relative "lumberjack/template.rb"
   require_relative "lumberjack/rack.rb"
 

data/lib/lumberjack/device/multi.rb

@@ -5,7 +5,7 @@ module Lumberjack
     # This is a logging device that forward log entries to multiple other devices.
     class Multi < Device
       def initialize(*devices)
-        @devices = devices
+        @devices = devices.flatten
       end
       
       def write(entry)

data/lib/lumberjack/formatter.rb

@@ -19,18 +19,24 @@ module Lumberjack
     require_relative "formatter/object_formatter.rb"
     require_relative "formatter/pretty_print_formatter.rb"
     require_relative "formatter/string_formatter.rb"
+    require_relative "formatter/strip_formatter.rb"
     require_relative "formatter/structured_formatter.rb"
 
+    class << self
+      # Returns a new empty formatter with no mapping. For historical reasons, a formatter
+      # is initialized with mappings to help output objects as strings. This will return one
+      # without the default mappings.
+      def empty
+        new.clear
+      end
+    end
+    
     def initialize
       @class_formatters = {}
       @module_formatters = {}
-      @_default_formatter = InspectFormatter.new
       structured_formatter = StructuredFormatter.new(self)
-      add(String, :object)
-      add(Numeric, :object)
-      add(TrueClass, :object)
-      add(FalseClass, :object)
-      add(Object, @_default_formatter)
+      add([String, Numeric, TrueClass, FalseClass], :object)
+      add(Object, InspectFormatter.new)
       add(Exception, :exception)
       add(Enumerable, structured_formatter)
     end
@@ -41,6 +47,12 @@ module Lumberjack
     #
     # The predefined formatters are: :inspect, :string, :exception, and :pretty_print.
     #
+    # You can add multiple classes at once by passing an array of classes.
+    #
+    # You can also pass class names as strings instead of the classes themselves. This can
+    # help avoid loading dependency issues. This applies only to classes; modules cannot be
+    # passed in as strings.
+    #
     # === Examples
     #
     #   # Use a predefined formatter
@@ -56,24 +68,41 @@ module Lumberjack
     #   formatter.add(MyClass, :pretty_print).add(YourClass){|obj| obj.humanize}
     def add(klass, formatter = nil, &block)
       formatter ||= block
-      if formatter.is_a?(Symbol)
-        formatter_class_name = "#{formatter.to_s.gsub(/(^|_)([a-z])/){|m| $~[2].upcase}}Formatter"
-        formatter = Formatter.const_get(formatter_class_name).new
-      end
-      if klass.is_a?(Class)
-        @class_formatters[klass] = formatter
+      if formatter.nil?
+        remove(klass)
       else
-        @module_formatters[klass] = formatter
+        if formatter.is_a?(Symbol)
+          formatter_class_name = "#{formatter.to_s.gsub(/(^|_)([a-z])/){|m| $~[2].upcase}}Formatter"
+          formatter = Formatter.const_get(formatter_class_name).new
+        end
+        
+        Array(klass).each do |k|
+          if k.class == Module
+            @module_formatters[k] = formatter
+          else
+            k = k.name if k.is_a?(Class)
+            @class_formatters[k] = formatter
+          end
+        end
       end
       self
     end
 
     # Remove the formatter associated with a class. Remove statements can be chained together.
+    #
+    # You can remove multiple classes at once by passing an array of classes.
+    #
+    # You can also pass class names as strings instead of the classes themselves. This can
+    # help avoid loading dependency issues. This applies only to classes; modules cannot be
+    # passed in as strings.
     def remove(klass)
-      if klass.is_a?(Class)
-        @class_formatters.delete(klass)
-      else
-        @module_formatters.delete(klass)
+      Array(klass).each do |k|
+        if k.class == Module
+          @module_formatters.delete(k)
+        else
+          k = k.name if k.is_a?(Class)
+          @class_formatters.delete(k)
+        end
       end
       self
     end
@@ -87,7 +116,12 @@ module Lumberjack
 
     # Format a message object as a string.
     def format(message)
-      formatter_for(message.class).call(message)
+      formatter = formatter_for(message.class)
+      if formatter && formatter.respond_to?(:call)
+        formatter.call(message)
+      else
+        message
+      end
     end
 
     # Compatibility with the Logger::Formatter signature. This method will just convert the message
@@ -102,7 +136,7 @@ module Lumberjack
     def formatter_for(klass) #:nodoc:
       check_modules = true
       while klass != nil do
-        formatter = @class_formatters[klass]
+        formatter = @class_formatters[klass.name]
         return formatter if formatter
 
         if check_modules
@@ -113,7 +147,6 @@ module Lumberjack
 
         klass = klass.superclass
       end
-      @_default_formatter
     end
   end
 end

data/lib/lumberjack/formatter/exception_formatter.rb

@@ -2,13 +2,38 @@
 
 module Lumberjack
   class Formatter
-    # Format an exception including the backtrace.
+    # Format an exception including the backtrace. You can specify an object that
+    # responds to `call` as a backtrace cleaner. The exception backtrace will be
+    # passed to this object and the returned array is what will be logged. You can
+    # use this to clean out superfluous lines.
     class ExceptionFormatter
+
+      attr_accessor :backtrace_cleaner
+
+      def initialize(backtrace_cleaner = nil)
+        self.backtrace_cleaner = backtrace_cleaner
+      end
+
       def call(exception)
         message = "#{exception.class.name}: #{exception.message}"
-        message << "#{Lumberjack::LINE_SEPARATOR}  #{exception.backtrace.join("#{Lumberjack::LINE_SEPARATOR}  ")}" if exception.backtrace
+        trace = exception.backtrace
+        if trace
+          trace = clean_backtrace(trace)
+          message << "#{Lumberjack::LINE_SEPARATOR}  #{trace.join("#{Lumberjack::LINE_SEPARATOR}  ")}"
+        end
         message
       end
+
+      private
+
+      def clean_backtrace(trace)
+        if trace && backtrace_cleaner
+          backtrace_cleaner.call(trace)
+        else
+          trace
+        end
+      end
+
     end
   end
 end

data/lib/lumberjack/formatter/string_formatter.rb

@@ -2,7 +2,7 @@
 
 module Lumberjack
   class Formatter
-    # Format an object by calling +to_s+ on it.
+    # Format an object by calling `to_s` on it.
     class StringFormatter
       def call(obj)
         obj.to_s

data/lib/lumberjack/formatter/strip_formatter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literals: true
+
+module Lumberjack
+  class Formatter
+    # Format an object by calling `to_s` on it and stripping leading and trailing whitespace.
+    class StripFormatter
+      def call(obj)
+        obj.to_s.strip
+      end
+    end
+  end
+end

data/lib/lumberjack/formatter/structured_formatter.rb

@@ -10,7 +10,7 @@ module Lumberjack
         @formatter = formatter
       end
 
-      def call(obj)        
+      def call(obj)
         if obj.is_a?(Hash)
           hash = {}
           references ||= Set.new
@@ -18,7 +18,7 @@ module Lumberjack
             hash[name.to_s] = call(value)
           end
           hash
-        elsif obj.is_a?(Enumerable)
+        elsif obj.is_a?(Enumerable) && obj.respond_to?(:size) && obj.size != Float::INFINITY
           obj.collect { |element| call(element) }
         elsif @formatter
           @formatter.format(obj)

data/lib/lumberjack/log_entry.rb

@@ -49,6 +49,11 @@ module Lumberjack
         @tags = { UNIT_OF_WORK_ID => value }
       end
     end
+    
+    # Return the tag with the specified name.
+    def tag(name)
+      tags[name.to_s] if tags
+    end
 
     private
 

data/lib/lumberjack/logger.rb

@@ -37,7 +37,10 @@ module Lumberjack
     attr_writer :progname
 
     # The device being written to
-    attr_reader :device
+    attr_accessor :device
+
+    # The TagFormatter used for formatting tags for output
+    attr_accessor :tag_formatter
 
     # Create a new logger to log to a Device.
     #
@@ -53,6 +56,7 @@ module Lumberjack
     # * :level - The logging level below which messages will be ignored.
     # * :formatter - The formatter to use for outputting messages to the log.
     # * :datetime_format - The format to use for log timestamps.
+    # * :tag_formatter - The TagFormatter to use for formatting tags.
     # * :progname - The name of the program that will be recorded with each log entry.
     # * :flush_seconds - The maximum number of seconds between flush calls.
     # * :roll - If the log device is a file path, it will be a Device::DateRollingLogFile if this is set.
@@ -66,25 +70,27 @@ module Lumberjack
       max_flush_seconds = options.delete(:flush_seconds).to_f
 
       @device = open_device(device, options) if device
-      @_formatter = (options[:formatter] || Formatter.new)
+      self.formatter = (options[:formatter] || Formatter.new)
+      @tag_formatter = (options[:tag_formatter] || TagFormatter.new)
       time_format = (options[:datetime_format] || options[:time_format])
       self.datetime_format = time_format if time_format
       @last_flushed_at = Time.now
       @silencer = true
       @tags = {}
+      @closed = false
 
       create_flusher_thread(max_flush_seconds) if max_flush_seconds > 0
     end
 
     # Get the timestamp format on the device if it has one.
     def datetime_format
-      @device.datetime_format if @device.respond_to?(:datetime_format)
+      device.datetime_format if device.respond_to?(:datetime_format)
     end
 
     # Set the timestamp format on the device if it is supported.
     def datetime_format=(format)
-      if @device.respond_to?(:datetime_format=)
-        @device.datetime_format = format
+      if device.respond_to?(:datetime_format=)
+        device.datetime_format = format
       end
     end
 
@@ -110,12 +116,29 @@ module Lumberjack
 
     # Set the Lumberjack::Formatter used to format objects for logging as messages.
     def formatter=(value)
-      @_formatter = value
+      @_formatter = (value.is_a?(TaggedLoggerSupport::Formatter) ? value.__formatter : value)
     end
 
     # Get the Lumberjack::Formatter used to format objects for logging as messages.
     def formatter
-      @_formatter
+      if respond_to?(:tagged)
+        # Wrap in an object that supports ActiveSupport::TaggedLogger API
+        TaggedLoggerSupport::Formatter.new(logger: self, formatter: @_formatter)
+      else
+        @_formatter
+      end
+    end
+
+    # Enable this logger to function like an ActiveSupport::TaggedLogger. This will make the logger
+    # API compatible with ActiveSupport::TaggedLogger and is provided as a means of compatibility
+    # with other libraries that assume they can call the `tagged` method on a logger to add tags.
+    #
+    # The tags added with this method are just strings so they are stored in the logger tags
+    # in an array under the "tagged" tag. So calling `logger.tagged("foo", "bar")` will result
+    # in tags `{"tagged" => ["foo", "bar"]}`.
+    def tagged_logger!
+      self.extend(TaggedLoggerSupport)
+      self
     end
 
     # Add a message to the log with a given severity. The message can be either
@@ -135,7 +158,7 @@ module Lumberjack
     def add_entry(severity, message, progname = nil, tags = nil)
       severity = Severity.label_to_level(severity) unless severity.is_a?(Integer)
 
-      return true unless @device && severity && severity >= level
+      return true unless device && severity && severity >= level
 
       time = Time.now
       message = message.call if message.is_a?(Proc)
@@ -154,6 +177,7 @@ module Lumberjack
         end
       end
       tags = Tags.expand_runtime_values(tags)
+      tags = tag_formatter.format(tags) if tag_formatter
 
       entry = LogEntry.new(time, severity, message, progname, $$, tags)
       write_to_device(entry)
@@ -186,10 +210,16 @@ module Lumberjack
     # Close the logging device.
     def close
       flush
-      @device.close if @device.respond_to?(:close)
+      device.close if device.respond_to?(:close)
+      @closed = true
+    end
+
+    def closed?
+      @closed
     end
 
     def reopen(logdev = nil)
+      @closed = false
       device.reopen(logdev) if device.respond_to?(:reopen)
     end
 
@@ -264,6 +294,9 @@ module Lumberjack
     #   end
     def silence(temporary_level = ERROR, &block)
       if silencer
+        unless temporary_level.is_a?(Integer)
+          temporary_level = Severity::label_to_level(temporary_level)
+        end
         push_thread_local_value(:lumberjack_logger_level, temporary_level, &block)
       else
         yield
@@ -393,7 +426,7 @@ module Lumberjack
 
     def write_to_device(entry) #:nodoc:
       begin
-        @device.write(entry)
+        device.write(entry)
       rescue => e
         $stderr.puts("#{e.class.name}: #{e.message}#{' at ' + e.backtrace.first if e.backtrace}")
         $stderr.puts(entry.to_s)
@@ -406,7 +439,7 @@ module Lumberjack
         begin
           logger = self
           Thread.new do
-            loop do
+            while !closed?
               begin
                 sleep(flush_seconds)
                 logger.flush if Time.now - logger.last_flushed_at >= flush_seconds

data/lib/lumberjack/tag_formatter.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  # Class for formatting tags. You can register a default formatter and tag
+  # name specific formatters. Formatters can be either `Lumberjack::Formatter`
+  # objects or any object that responds to `call`.
+  #
+  # tag_formatter = Lumberjack::TagFormatter.new.default(Lumberjack::Formatter.new)
+  # tag_formatter.add(["password", "email"]) { |value| "***" }
+  # tag_formatter.add("finished_at", Lumberjack::Formatter::DateTimeFormatter.new("%Y-%m-%dT%H:%m:%S%z"))
+  class TagFormatter
+
+    def initialize
+      @formatters = {}
+      @default_formatter = nil
+    end
+
+    # Add a default formatter applied to all tag values. This can either be a Lumberjack::Formatter
+    # or an object that responds to `call` or a block.
+    def default(formatter = nil, &block)
+      formatter ||= block
+      formatter = dereference_formatter(formatter)
+      @default_formatter = formatter
+      self
+    end
+
+    # Remove the default formatter.
+    def remove_default
+      @default_formatter = nil
+      self
+    end
+
+    # Add a formatter for specific tag names. This can either be a Lumberjack::Formatter
+    # or an object that responds to `call` or a block. The default formatter will not be
+    # applied.
+    def add(names, formatter = nil, &block)
+      formatter ||= block
+      formatter = dereference_formatter(formatter)
+      if formatter.nil?
+        remove(key)
+      else
+        Array(names).each do |name|
+          @formatters[name.to_s] = formatter
+        end
+      end
+      self
+    end
+
+    # Remove formatters for specific tag names. The default formatter will still be applied.
+    def remove(names)
+      Array(names).each do |name|
+        @formatters.delete(name.to_s)
+      end
+      self
+    end
+
+    # Remove all formatters.
+    def clear
+      @default_formatter = nil
+      @formatters.clear
+      self
+    end
+
+    # Format a hash of tags using the formatters
+    def format(tags)
+      return nil if tags.nil?
+      if @default_formatter.nil? && (@formatters.empty? || (@formatters.keys & tags.keys).empty?)
+        tags
+      else
+        formatted = {}
+        tags.each do |name, value|
+          formatter = (@formatters[name.to_s] || @default_formatter)
+          if formatter.is_a?(Lumberjack::Formatter)
+            value = formatter.format(value)
+          elsif formatter.respond_to?(:call)
+            value = formatter.call(value)
+          end
+          formatted[name.to_s] = value
+        end
+        formatted
+      end
+    end
+
+    private
+
+    def dereference_formatter(formatter)
+      if formatter.is_a?(TaggedLoggerSupport::Formatter)
+        formatter.__formatter
+      elsif formatter.is_a?(Symbol)
+        formatter_class_name = "#{formatter.to_s.gsub(/(^|_)([a-z])/){|m| $~[2].upcase}}Formatter"
+        Formatter.const_get(formatter_class_name).new
+      else
+        formatter
+      end
+    end
+
+  end
+end

data/lib/lumberjack/tagged_logger_support.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "forwardable"
+
+module Lumberjack
+  # Methods to make Lumberjack::Logger API compatible with ActiveSupport::TaggedLogger.
+  module TaggedLoggerSupport
+
+    class Formatter < DelegateClass(Lumberjack::Formatter)
+      extend Forwardable
+      def_delegators :@logger, :tagged, :push_tags, :pop_tags, :clear_tags!
+
+      def initialize(formatter:, logger:)
+        @logger = logger
+        @formatter = formatter
+        super(formatter)
+      end
+
+      def current_tags
+        tags = @logger.instance_variable_get(:@tags)
+        if tags.is_a?(Hash)
+          Array(tags["tagged"])
+        else
+          []
+        end
+      end
+
+      def tags_text
+        tags = current_tags
+        if tags.any?
+          tags.collect { |tag| "[#{tag}] " }.join
+        end
+      end
+
+      def __formatter
+        @formatter
+      end
+    end
+
+    # Compatibility with ActiveSupport::TaggedLogging which only supports adding tags as strings.
+    # If a tag looks like "key:value"  or "key=value", it will be added as a key value pair.
+    # Otherwise it will be appended to a list named "tagged".
+    def tagged(*tags, &block)
+      tag_hash = {}
+      tags.flatten.each do |tag|
+        tagged_values = Array(tag_hash["tagged"] || self.tags["tagged"])
+        tag_hash["tagged"] = tagged_values + [tag]
+      end
+      tag(tag_hash, &block)
+    end
+
+    def push_tags(*tags)
+      tagged(*tags)
+    end
+
+    def pop_tags(size = 1)
+      tagged_values = Array(@tags["tagged"])
+      tagged_values = (tagged_values.size > size ? tagged_values[0, tagged_values.size - size] : nil)
+      tag("tagged" => tagged_values)
+    end
+
+    def clear_tags!
+      tag("tagged" => nil)
+    end
+  end
+end

data/lib/lumberjack/template.rb

@@ -11,10 +11,13 @@ module Lumberjack
   # * :message
   #
   # Any other words prefixed with a colon will be substituted with the value of the tag with that name.
+  # If your tag name contains characters other than alpha numerics and the underscore, you must surround it
+  # with curly brackets: `:{http.request-id}`.
   class Template
     TEMPLATE_ARGUMENT_ORDER = %w(:time :severity :progname :pid :message :tags).freeze
     MILLISECOND_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%3N"
     MICROSECOND_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%6N"
+    PLACEHOLDER_PATTERN = /:(([a-z0-9_]+)|({[^}]+}))/i.freeze
 
     # Create a new template from the markup. The +first_line+ argument is used to format only the first
     # line of a message. Additional lines will be added to the message unformatted. If you wish to format
@@ -85,8 +88,10 @@ module Lumberjack
 
       tags_string = String.new
       tags.each do |name, value|
-        unless tag_vars.include?(name)
-          tags_string << "[#{name}:#{value.inspect}] "
+        unless value.nil? || tag_vars.include?(name)
+          value = value.to_s
+          value = value.gsub(Lumberjack::LINE_SEPARATOR, " ") if value.include?(Lumberjack::LINE_SEPARATOR)
+          tags_string << "[#{name}:#{value}] "
         end
       end
 
@@ -100,12 +105,13 @@ module Lumberjack
     # Compile the template string into a value that can be used with sprintf.
     def compile(template) #:nodoc:
       tag_vars = []
-      template = template.gsub(/:[a-z0-9_]+/) do |match|
-        position = TEMPLATE_ARGUMENT_ORDER.index(match)
+      template = template.gsub(PLACEHOLDER_PATTERN) do |match|
+        var_name = match.sub("{", "").sub("}", "")
+        position = TEMPLATE_ARGUMENT_ORDER.index(var_name)
         if position
           "%#{position + 1}$s"
         else
-          tag_vars << match[1, match.length]
+          tag_vars << var_name[1, var_name.length]
           "%#{TEMPLATE_ARGUMENT_ORDER.size + tag_vars.size}$s"
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Brian Durand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-09 00:00:00.000000000 Z
+date: 2020-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -95,6 +95,7 @@ files:
 - lib/lumberjack/formatter/object_formatter.rb
 - lib/lumberjack/formatter/pretty_print_formatter.rb
 - lib/lumberjack/formatter/string_formatter.rb
+- lib/lumberjack/formatter/strip_formatter.rb
 - lib/lumberjack/formatter/structured_formatter.rb
 - lib/lumberjack/log_entry.rb
 - lib/lumberjack/logger.rb
@@ -103,6 +104,8 @@ files:
 - lib/lumberjack/rack/request_id.rb
 - lib/lumberjack/rack/unit_of_work.rb
 - lib/lumberjack/severity.rb
+- lib/lumberjack/tag_formatter.rb
+- lib/lumberjack/tagged_logger_support.rb
 - lib/lumberjack/tags.rb
 - lib/lumberjack/template.rb
 - lumberjack.gemspec