teelogger 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a05f90f38dfc709f361c48700fd75abc7b4cae97
-  data.tar.gz: 21adf664c10e60ff5788c4b1b6b782cda65158ca
+  metadata.gz: 374fbb37a9d2c70a80c83f6c52ec70501fef456a
+  data.tar.gz: 43ff68bc53641a1805f21e76916ec5241b0e5549
 SHA512:
-  metadata.gz: 4088feb8ab68f3635e0ae30d88bbefc2ec498c0f6fb3c05b20158b73eeb47ca1253c5c1ba2fe69668f3fcce4dcb103c4b0e96036c0d77e63b91060dccc693605
-  data.tar.gz: edcccbf758d9b8cc6b95ae5694ab60869c565062447ccef2fa1b78916a1d67e16e411082f4639135f355c22276fd15e82e4d2563d3c0433b8614c0ba81088a79
+  metadata.gz: 704c17de207b1a44bb1886ea9291c27c77c67b8e38140dcca144f21009705dae5e58c50a8ce056e877195320be3413985915d2d96651a7e691042846126ad0b8
+  data.tar.gz: 0797bc600ca9c252c61ec27289cc61103143ab7df846760b025f0039f5222d98aa0fd13db267fd6042053fc614bcad71e7e2bb005e97ea50f8a198d5f663bd2e

data/.travis.yml

@@ -9,6 +9,12 @@ language: ruby
 rvm:
   - 1.9.3  
   - 2.0.0
+  - 2.1.0
+  - 2.2.2
+  - jruby
+matrix:
+  allow_failures:
+    rvm: 2.2.2
 env:
   CODECLIMATE_REPO_TOKEN=e37a93224a40c36fd6a24465c063e7627661921a868a2d1321ad2937d7889de6
 notifications:

data/features/filter.feature

@@ -0,0 +1,80 @@
+@filter
+Feature: Filter
+  As a user of the teelogger gem
+  When I use the Filter class
+  I expect it to work as documented.
+
+  @filter_01
+  Scenario Outline: Replace patterns in Strings
+    Given I create a TeeLogger for testing filters
+    And I write a log message containing the word "<word>"
+    Then I expect the log message to <condition> the word "<word>"
+
+    Examples:
+      | word           | condition   |
+      | hello          | contain     |
+      | hello=123      | contain     |
+      | --hello=123    | contain     |
+      | hello: 123     | contain     |
+      | password=123   | not contain |
+      | password: 123  | not contain |
+      | --password=123 | not contain |
+
+  @filter_02
+  Scenario Outline: Replace patterns in Strings in Arrays
+    Given I create a TeeLogger for testing filters
+    And I write a log message containing the word "<word>" in an Array
+    Then I expect the log message to <condition> the word "<word>"
+
+    Examples:
+      | word           | condition   |
+      | hello          | contain     |
+      | hello=123      | contain     |
+      | --hello=123    | contain     |
+      | hello: 123     | contain     |
+      | password=123   | not contain |
+      | password: 123  | not contain |
+      | --password=123 | not contain |
+
+  @filter_03
+  Scenario Outline: Replace patterns in Strings in Hashes
+    Given I create a TeeLogger for testing filters
+    And I write a log message containing the value "<word>" for the key "<key>" in a Hash
+    Then I expect the log message to <condition> the word "<word>"
+
+    Examples:
+      | key      | word         | condition   |
+      | hello    | MUST REMAIN  | contain     |
+      | password | TO BE HIDDEN | not contain |
+
+  @filter_04
+  Scenario Outline: Replace patterns in CLI-like arrays
+    Given I create a TeeLogger for testing filters
+    And I write a log message containing the word sequence "<word1>", "<word2>"
+    Then I expect the log message to <condition> the word "<word2>"
+
+    Examples:
+      | word1    | word2        | condition   |
+      | hello    | MUST REMAIN  | contain     |
+      | password | TO BE HIDDEN | not contain |
+
+  @filter_05
+  Scenario Outline: Ensure custom filter words work
+    Given I create a TeeLogger for testing filters
+    And I set filter words to include "<filter>"
+    And I write a log message containing the word "<word>"
+    Then I expect the log message to <condition> the word "<word>"
+
+    Examples:
+      | filter | word    | condition   |
+      | foo    | foo=123 | not contain |
+      | bar    | foo=123 | contain     |
+      | foo    | bar=123 | contain     |
+      | bar    | bar=123 | not contain |
+
+  @filter_06
+  Scenario: Custom filter
+    Given I create a TeeLogger for testing filters
+    And I register a custom filter
+    And I write a log message containing the word "foo"
+    Then I expect the log message to not contain the word "foo"

data/features/formatter.feature

@@ -0,0 +1,49 @@
+@formatter
+Feature: Formatter
+  As a user of the teelogger gem
+  When I use the Formatter class
+  I expect it to work as documented.
+
+  @formatter_01
+  Scenario Outline: Placeholders
+    Given I create a Formatter with "{<placeholder>}" in the format string
+    And I call it with parameters "<severity>", "<time>", "<progname>" and "<message>"
+    Then I expect the result to match "<result>"
+
+    Examples:
+      | placeholder           | severity | time                     | progname | message      | result                       |
+      | severity              | INFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | INFO                         |
+      | severity              | InfO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | INFO                         |
+      | short_severity        | iNFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | I                            |
+      | short_severity        | infO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | I                            |
+      | logger_timestamp      | INFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | 2015-07-03T12:10:57.000000   |
+      | logger_timestamp      | InfO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | 2015-07-03T12:10:57.000000   |
+      | logger_timestamp      | InfO     | 2015-07-03T12:10:57+0100 | STDOUT   | test message | 2015-07-03T11:10:57.000000   |
+      | iso8601_timestamp     | INFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | 2015-07-03T12:10:57\\\\+0000 |
+      | iso8601_timestamp     | InfO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | 2015-07-03T12:10:57\\\\+0000 |
+      | iso8601_timestamp     | InfO     | 2015-07-03T12:10:57+0100 | STDOUT   | test message | 2015-07-03T11:10:57\\\\+0000 |
+      | iso8601_timestamp_utc | INFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | 2015-07-03T12:10:57Z         |
+      | iso8601_timestamp_utc | InfO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | 2015-07-03T12:10:57Z         |
+      | iso8601_timestamp_utc | InfO     | 2015-07-03T12:10:57+0100 | STDOUT   | test message | 2015-07-03T11:10:57Z         |
+      | tai64n_timestamp      | INFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | @4000000055967bdb000001f4    |
+      | tai64n_timestamp      | InfO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | @4000000055967bdb000001f4    |
+      | tai64n_timestamp      | InfO     | 2015-07-03T12:10:57+0100 | STDOUT   | test message | @4000000055966dcb000001f4    |
+      | logger                | iNFO     | 2015-07-03T12:10:57Z     | sTDouT   | test message | sTDouT                       |
+      | message               | iNFO     | 2015-07-03T12:10:57Z     | STDOUT   | teSt mESsage | teSt mESsage                 |
+      | pid                   | iNFO     | 2015-07-03T12:10:57Z     | STDOUT   | teSt mESsage | \\\\d+                       |
+
+
+      # Note 1: need four \ to escape a special character in the regex field
+
+  @formatter_02
+  Scenario Outline: Format strings
+    Given I create a Formatter with the "<format>" format string
+    And I call it with parameters "<severity>", "<time>", "<progname>" and "<message>"
+    Then I expect the result to match "<result>"
+
+    Examples:
+      | format         | severity | time                     | progname | message      | result                                                                       |
+      | FORMAT_LOGGER  | INFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | I, \\\\[2015-07-03T12:10:57.000000 #\\\\d+\\\\] INFO -- STDOUT: test message |
+      | FORMAT_DEFAULT | INFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | I, \\\\[2015-07-03T12:10:57\\\\+0000 #\\\\d+\\\\] STDOUT: test message       |
+      | FORMAT_SHORT   | INFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | I, \\\\[2015-07-03T12:10:57\\\\+0000\\\\] test message                       |
+      | FORMAT_DJB     | INFO     | 2015-07-03T12:10:57Z     | STDOUT   | test message | @4000000055967bdb000001f4 INFO: test message                                 |

data/features/logger.feature

@@ -89,4 +89,24 @@ Feature: Logger
       | ERROR | appear     |
       | FATAL | not appear |
 
+  @logger_07
+  Scenario Outline: Bad log levels
+    Given I create a TeeLogger with default parameters
+    And I set the log level to "<initial>"
+    And I set the log level to "<level>"
+    Then I expect this to <raise> an exception
+    And I expect the log level to be "<result>"
+
+    Examples:
+      | initial | level    | raise     | result |
+      | fatal   | DeBuG    | not raise | debug  |
+      | fatal   | debugFOO | raise     | fatal  |
+      | fatal   | InfO     | not raise | info   |
+      | fatal   | infoFOO  | raise     | fatal  |
+      | fatal   | wARn     | not raise | warn   |
+      | fatal   | warnFOO  | raise     | fatal  |
+      | fatal   | eRrOR    | not raise | error  |
+      | fatal   | errorFOO | raise     | fatal  |
+      | debug   | faTAl    | not raise | fatal  |
+      | debug   | fatalFOO | raise     | debug  |
 

data/features/step_definitions/filter_steps.rb

@@ -0,0 +1,70 @@
+io = nil
+logger = nil
+
+Given(/^I create a TeeLogger for testing filters$/) do
+  io = StringIO.new
+  logger = TeeLogger::TeeLogger.new io
+  assert [TeeLogger::DEFAULT_FLUSH_INTERVAL] == logger.flush_interval, "Flush interval is not default: #{logger.flush_interval}"
+end
+
+Given(/^I write a log message containing the word "([^"]*)"$/) do |word|
+  # Log a string
+  logger.error(word)
+end
+
+Given(/^I write a log message containing the word "([^"]*)" in an Array$/) do |word|
+  # Log an Array
+  logger.error([1, word, 3])
+end
+
+Given(/^I write a log message containing the value "([^"]*)" for the key "([^"]*)" in a Hash$/) do |value, key|
+  # Log a Hash
+  val = {
+    1 => 2,
+    2 => {
+      key => value
+    },
+    3 => [
+      'a', "#{key}=#{value}", 'b',
+    ],
+  }
+  logger.error(val)
+end
+
+Given(/^I set filter words to include "([^"]*)"$/) do |filter_word|
+  logger.filter_words = [filter_word]
+end
+
+Given(/^I register a custom filter$/) do
+  class MyFilter < TeeLogger::Filter::FilterBase
+    FILTER_TYPES = [String]
+    WINDOW_SIZE  = 1
+    def process(*args)
+      # Nil everything
+      args.each_with_index do |dummy, idx|
+        args[idx] = nil
+      end
+      return args
+    end
+  end
+
+  logger.register_filter(MyFilter)
+end
+
+Given(/^I write a log message containing the word sequence "([^"]*)", "([^"]*)"$/) do |word1, word2|
+  logger.error(word1, word2)
+end
+
+Then(/^I expect the log message to ([^ ]* ?)contain the word "([^"]*)"$/) do |mod, word|
+  mod = mod.strip
+  message = io.string
+
+  case mod
+  when "not"
+    assert !message.include?(word), "Log message contains '#{word}' when it must not!:\n#{message}"
+  else
+    assert message.include?(word), "Log message does not contain '#{word}' when it should!:\n#{message}"
+  end
+end
+
+

data/features/step_definitions/formatter_steps.rb

@@ -0,0 +1,30 @@
+formatter = nil
+result = nil
+
+Given(/^I create a Formatter with "([^"]*)" in the format string$/) do |format|
+  formatter = ::TeeLogger::Formatter.new(format)
+end
+
+Given(/^I create a Formatter with the "([^"]*)" format string$/) do |constant|
+  format = ::TeeLogger::Formatter.const_get(constant)
+  formatter = ::TeeLogger::Formatter.new(format)
+end
+
+Given(/^I call it with parameters "([^"]*)", "([^"]*)", "([^"]*)" and "([^"]*)"$/) do |severity, time, progname, message|
+  # The time needs to be parsed to make some kind of sense; anything else
+  # can just be passed through. For time parsing, we need to temporarily force
+  # the timezone to UTC, otherwise the tests will run differently on different
+  # machines.
+  zone = ENV["TZ"]
+  ENV["TZ"] = "UTC"
+  t = Time.parse(time)
+  ENV["TZ"] = zone
+
+  result = formatter.call(severity, t, progname, message)
+end
+
+Then(/^I expect the result to match "([^"]*)"$/) do |expected|
+  regex = Regexp.new("^#{expected}$")
+  assert regex.match(result), "Expected to match '#{regex}' (#{expected}), but got '#{result}'"
+end
+

data/features/step_definitions/{steps.rb → logger_steps.rb}

@@ -1,9 +1,3 @@
-begin
-  require 'test/unit/assertions'
-rescue LoadError
-  require 'minitest/assertions'
-end
-
 message = "test message"
 io = nil
 logger = nil
@@ -19,9 +13,14 @@ Given(/^I set the flush_interval to "([^"]*)"$/) do |interval|
   assert [i] == logger.flush_interval, "Setting flush interval did not take: #{logger.flush_interval}"
 end
 
-
+level_set_exception = nil
 Given(/^I set the log level to "(.*?)"$/) do |level|
-  logger.level = level
+  begin
+    logger.level = level
+    level_set_exception = nil
+  rescue StandardError => err
+    level_set_exception = err
+  end
 end
 
 Given(/^I write a log message at log level "(.*?)"$/) do |level|
@@ -33,6 +32,17 @@ Then(/^I expect the log message to appear on the screen$/) do
   puts "Can't test this; please check manually"
 end
 
+Then(/^I expect this to ([^ ]*?) ?raise an exception$/) do |mod|
+  if mod.strip != "not"
+    assert !level_set_exception.nil?, "Expected an exception, but none was raised."
+  end
+end
+
+Then(/^I expect the log level to be "([^"]*)"$/) do |result|
+  expected = TeeLogger::TeeLogger.convert_level(result.strip)
+  assert logger.level == [expected], "Expected numeric level #{expected} but got #{logger.level[0]}."
+end
+
 Then(/^I expect the log level "(.*?)" to (.*?) taken hold$/) do |level, condition|
   meth = "#{level.downcase}?".to_sym
   res = logger.send(meth)

data/features/support/env.rb

@@ -1,4 +1,10 @@
 require "codeclimate-test-reporter"
 CodeClimate::TestReporter.start
 
+begin
+  require 'test/unit/assertions'
+rescue LoadError
+  require 'minitest/assertions'
+end
+
 require "teelogger"

data/lib/teelogger.rb

@@ -6,53 +6,16 @@
 # All rights reserved.
 #
 require "teelogger/version"
+require "teelogger/extensions"
+require "teelogger/levels"
+require "teelogger/formatter"
+require "teelogger/filter"
 
 require "logger"
 
 module TeeLogger
   DEFAULT_FLUSH_INTERVAL = 2000
 
-  ##
-  # Extensions for the ruby logger
-  module LoggerExtensions
-    attr_accessor :teelogger_io
-    attr_accessor :flush_interval
-
-    ##
-    # Flush ruby and OS buffers for this logger
-    def flush
-      if @teelogger_io.nil?
-        raise "TeeLogger logger without IO object, can't do anything"
-      end
-
-      @teelogger_io.flush
-      begin
-        @teelogger_io.fsync
-      rescue NotImplementedError, Errno::EINVAL
-        # pass
-      end
-    end
-
-
-    ##
-    # This function invokes flush if it's been invoked more often than
-    # flush_interval.
-    def auto_flush
-      if @written.nil?
-        @written = 0
-      end
-
-      @written += 1
-
-      if @written >= self.flush_interval
-        self.flush
-        @written = 0
-      end
-    end
-  end # module LoggerExtensions
-
-
-
   ##
   # Logger that writes to multiple outputs. Behaves just like Ruby's Logger,
   # and like a hash of String => Logger.
@@ -73,44 +36,22 @@ module TeeLogger
   #     end
   #   end
   class TeeLogger
+    # Extends and includes
+    extend  ::TeeLogger::Levels
+    include ::TeeLogger::Levels
+    include ::TeeLogger::Filter
+
+    # Properties
     @default_level
+    @formatter
     @loggers
     @ios
 
-    ##
-    # Convert a log level to its string name
-    def self.string_level(level)
-      if level.is_a? String
-        return level
-      end
-
-      Logger::Severity.constants.each do |const|
-        if level == Logger.const_get(const)
-          return const
-        end
-      end
-
-      return nil
-    end
-
-    ##
-    # Convert a string log level to its constant value
-    def self.convert_level(val)
-      if val.is_a? String
-        begin
-          val = Logger.const_get(val.upcase)
-        rescue NameError
-          val = Logger::Severity::WARN
-        end
-      end
-
-      return val
-    end
 
 private
     ##
     # Define log functions as strings, for internal re-use
-    LOG_FUNCTIONS = Logger::Severity.constants.map { |level| TeeLogger.string_level(level.to_s).downcase }
+    LOG_FUNCTIONS = Logger::Severity.constants.map { |level| string_level(level.to_s).downcase }
 
 public
 
@@ -129,26 +70,40 @@ public
         logger = Logger.new(io)
 
         # Initialize logger
-        io.write "Logging to '#{arg}' initialized with level #{TeeLogger.string_level(@default_level)}.\n"
-        logger.level = TeeLogger.convert_level(@default_level)
+        io.write "Logging to '#{arg}' initialized with level #{string_level(@default_level)}.\n"
+        logger.level = convert_level(@default_level)
       else
         # We have some other object - let's hope it's an IO object
-        key = arg.to_s
+        key = nil
+        case arg
+        when STDOUT
+          key = 'STDOUT'
+        when STDERR
+          key = 'STDERR'
+        else
+          key = arg.to_s
+        end
 
         # Try to create the logger.
         io = arg
         logger = Logger.new(io)
 
         # Initialize logger
-        io.write "Logging to #{key} initialized with level #{TeeLogger.string_level(@default_level)}.\n"
-        logger.level = TeeLogger.convert_level(@default_level)
+        io.write "Logging to #{key} initialized with level #{string_level(@default_level)}.\n"
+        logger.level = convert_level(@default_level)
       end
 
+      # Set the logger formatter
+      logger.formatter = @formatter
+
       # Extend logger instances with extra functionality
-      logger.extend(LoggerExtensions)
+      logger.extend(::TeeLogger::LoggerExtensions)
       logger.teelogger_io = io
       logger.flush_interval = DEFAULT_FLUSH_INTERVAL
 
+      # Flush the "Logging to..." line
+      logger.flush
+
       if not key.nil? and not logger.nil? and not io.nil?
         @loggers[key] = logger
         @ios[key] = io
@@ -166,9 +121,13 @@ public
 
       # Initialization
       @default_level = Logger::Severity::INFO
+      @formatter = ::TeeLogger::Formatter.new
       @loggers = {}
       @ios = {}
 
+      # Load built-in filters
+      load_filters(*args)
+
       # Create logs for all arguments
       args.each do |arg|
         add_logger(arg)
@@ -180,7 +139,7 @@ public
     # Set log level; override this to also accept strings
     def level=(val)
       # Convert strings to the constant value
-      val = TeeLogger.convert_level(val)
+      val = convert_level(val)
 
       # Update the default log level
       @default_level = val
@@ -192,6 +151,19 @@ public
     end
 
 
+    ##
+    # Set the formatter
+    def formatter=(formatter)
+      # Update the default formatter
+      @formatter = formatter
+
+      # Set all loggers' formatters
+      @loggers.each do |key, logger|
+        logger.formatter = formatter
+      end
+    end
+
+
     ##
     # Log an exception
     def exception(message, ex)
@@ -254,6 +226,7 @@ public
     end
 
     def method_missing(meth, *args, &block)
+      puts "MISSING #{meth}"
       dispatch(meth, *args, &block)
     end
 
@@ -261,12 +234,36 @@ public
 
 
     def dispatch(meth, *args, &block)
-      meth_name = meth.to_s
-
       if @loggers.nil? or @loggers.empty?
         raise "No loggers created, can't do anything."
       end
 
+      # Try dispatching the call, with preprocessing based on whether it
+      # is a log function or not.
+      meth_name = meth.to_s
+
+      ret = []
+      if LOG_FUNCTIONS.include? meth_name
+        ret = dispatch_log(meth_name, *args)
+      else
+        ret = dispatch_other(meth_name, *args, &block)
+      end
+
+      # Some double checking on the return value(s).
+      if not ret.empty?
+        return ret
+      end
+
+      # If the method wasn't from the loggers, we'll try to send it to the
+      # hash.
+      return @loggers.send(meth_name, *args, &block)
+    end
+
+
+    def dispatch_log(meth_name, *args)
+      # Filter all arguments
+      args = apply_filters(*args)
+
       # Compose message
       msg = args.map do |arg|
         if arg.is_a? String
@@ -281,26 +278,23 @@ public
       ret = []
       @loggers.each do |key, logger|
         if logger.respond_to? meth_name
-          if LOG_FUNCTIONS.include? meth_name
-            ret << logger.send(meth_name, key) do
-              message
-            end
-          else
-            ret << logger.send(meth_name, *args, &block)
+          ret << logger.send(meth_name, key) do
+            message
           end
         end
       end
+      return ret
+    end
 
-      # Some double checking on the return value(s).
-      if not ret.empty?
-        return ret
-      end
 
-      # If the method wasn't from the loggers, we'll try to send it to the
-      # hash.
-      return @loggers.send(meth_name, *args, &block)
+    def dispatch_other(meth_name, *args, &block)
+      ret = []
+      @loggers.each do |key, logger|
+        if logger.respond_to? meth_name
+          ret << logger.send(meth_name, *args, &block)
+        end
+      end
+      return ret
     end
-
   end
-
 end

data/lib/teelogger/extensions.rb

@@ -0,0 +1,47 @@
+#
+# TeeLogger
+# https://github.com/spriteCloud/teelogger
+#
+# Copyright (c) 2014-2015 spriteCloud B.V. and other TeeLogger contributors.
+# All rights reserved.
+#
+module TeeLogger
+  ##
+  # Extensions for the ruby logger
+  module LoggerExtensions
+    attr_accessor :teelogger_io
+    attr_accessor :flush_interval
+
+    ##
+    # Flush ruby and OS buffers for this logger
+    def flush
+      if @teelogger_io.nil?
+        raise "TeeLogger logger without IO object, can't do anything"
+      end
+
+      @teelogger_io.flush
+      begin
+        @teelogger_io.fsync
+      rescue NotImplementedError, Errno::EINVAL
+        # pass
+      end
+    end
+
+
+    ##
+    # This function invokes flush if it's been invoked more often than
+    # flush_interval.
+    def auto_flush
+      if @written.nil?
+        @written = 0
+      end
+
+      @written += 1
+
+      if @written >= self.flush_interval
+        self.flush
+        @written = 0
+      end
+    end
+  end # module LoggerExtensions
+end # module TeeLogger

data/lib/teelogger/filter.rb

@@ -0,0 +1,215 @@
+#
+# TeeLogger
+# https://github.com/spriteCloud/teelogger
+#
+# Copyright (c) 2014,2015 spriteCloud B.V. and other TeeLogger contributors.
+# All rights reserved.
+#
+require 'require_all'
+
+module TeeLogger
+  module Filter
+    ##
+    # The default words to filter. It's up to each individual filter to decide
+    # what to do when they encounter a word, but these are the words the filters
+    # should process.
+    # Note that they can be strings or regular expressions. Regular expressions
+    # should by and large not be anchored to the beginning or end of strings.
+    DEFAULT_FILTER_WORDS = [
+      /password[a-z\-_]*/,
+      /salt[a-z\-_]*/,
+    ]
+
+    ##
+    # Filter words
+    def filter_words
+      @filter_words ||= DEFAULT_FILTER_WORDS
+      return @filter_words
+    end
+
+    def filter_words=(arg)
+      # Coerce into array
+      begin
+        arr = []
+        arg.each do |item|
+          arr << item
+        end
+        @filter_words = arr
+      rescue NameError, NoMethodError
+        raise "Can't set filter words, not iterable: #{arg}"
+      end
+    end
+
+
+    ##
+    # Load all built-in filters.
+    def load_filters(*args)
+      require_rel 'filters'
+      ::TeeLogger::Filter.constants.collect {|const_sym|
+        ::TeeLogger::Filter.const_get(const_sym)
+      }.each do |filter|
+        begin
+          register_filter(filter)
+          if not ENV['TEELOGGER_VERBOSE'].nil? and ENV['TEELOGGER_VERBOSE'].to_i > 0
+            puts "Registered filter #{filter}."
+          end
+        rescue StandardError => err
+          if not ENV['TEELOGGER_VERBOSE'].nil? and ENV['TEELOGGER_VERBOSE'].to_i > 0
+            puts "Not registering filter: #{err}"
+          end
+        end
+      end
+    end
+
+    ##
+    # Returns all registered filters.
+    def registered_filters
+      # Initialize if it doesn't exist
+      @filters ||= {}
+      return @filters
+    end
+
+    ##
+    # Expects a class, registers the class for use by the filter function
+    def register_filter(filter)
+      # Sanity checks/register filter
+      if filter.class != Class
+        raise "Ignoring '#{filter}', not a class."
+      end
+
+      if not filter < FilterBase
+        raise "Class '#{filter}' is not derived from FilterBase."
+      end
+
+      begin
+        window = filter::WINDOW_SIZE.to_i
+        window_filters = registered_filters.fetch(window, {})
+
+        filter::FILTER_TYPES.each do |type|
+          type_filters = window_filters.fetch(type, [])
+          type_filters.push(filter) unless type_filters.include?(filter)
+          window_filters[type] = type_filters
+        end
+
+        registered_filters[window] = window_filters
+      rescue NameError, NoMethodError
+        raise "Class '#{filter}' is missing a FILTER_TYPES Array or a WINDOW_SIZE Integer."
+      end
+    end
+
+    ##
+    # Applies all registered filters.
+    def apply_filters(*args)
+      # Pre-process filter words: we need to have regular expressions everywhere
+      words = []
+      filter_words.each do |word|
+        if word.is_a? Regexp
+          words << word
+        else
+          words << Regexp.new(word.to_s)
+        end
+      end
+
+      # We instanciate each filter once per application, and store the instnaces
+      # in a cache for that duration.
+      filter_cache = {}
+
+      # Pass state on to apply_filters_internal
+      state = {
+        :words => words,
+        :filter_cache => filter_cache,
+        :filters => self,
+      }
+      return apply_filters_internal(state, *args)
+    end
+
+
+    ##
+    # Implementation of apply_filters that doesn't initialize state, but carries
+    # it over. Used internally only.
+    def apply_filters_internal(state, *args)
+      filtered_args = args
+
+      # Iterate through filters
+      registered_filters.each do |window, window_filters|
+        # Determine actual window size
+        window_size = [window, filtered_args.size].min
+
+        # Process each window so that elements are updated in-place. This
+        # means we'll start at index 0 and process up to window_size elements.
+        idx = 0
+        while (idx + window_size - 1) < filtered_args.size
+          # We need to use *one* argument to determine whether the filter
+          # type applies. The current strategy is to match the first argument
+          # only, and let the filter cast to other types if necessary.
+          first_arg = filtered_args[idx]
+
+          window_filters.each do |class_match, type_filters|
+            # We process with these type filters if first_arg matches the
+            # class_match.
+            if not first_arg.is_a? class_match
+              next
+            end
+
+            # Now process with the given filters.
+            type_filters.each do |filter|
+              # XXX Do not turn this into a one-liner, or we'll instanciate
+              #     filters without using them.
+              filter_instance = state[:filter_cache].fetch(filter, nil)
+              if filter_instance.nil?
+                filter_instance = filter.new(state)
+                state[:filter_cache][filter] = filter_instance
+              end
+
+              # Single item windows need to be processed a bit differently from
+              # multi-item windows.
+              tuple = filtered_args[idx..idx + window_size - 1]
+              filtered = filter_instance.process(*tuple)
+
+              # Sanity check result
+              if filtered.size != tuple.size
+                raise "Filter #{filter} added or removed items to the log; don't know how to process!"
+              end
+
+              filtered.each_with_index do |item, offset|
+                filtered_args[idx + offset] = item
+              end
+            end # type_filters.each
+          end # window_filters.each
+
+          # Advance to the next window
+          idx += 1
+        end # each window
+      end # all registered filters
+
+      return filtered_args
+    end
+
+
+    ##
+    # Any filter implementations must derive from this
+    class FilterBase
+      # Define FILTER_TYPES = [class, class] to declare what types this filter
+      # applies to.
+      # Define WINDOW_SIZE = int to declare how many parameters the filter
+      # processes at a time. It will be a sliding window of arguments.
+      # Note that filters may receive fewer arguments if there are less than
+      # WINDOW_SIZE in total.
+
+      ##
+      # Initialize with filter words
+      attr_accessor :run_data
+
+      def initialize(run_data)
+        @run_data = run_data
+      end
+
+      ##
+      # Base filter leaves the argument untouched.
+      def process(*args)
+        args
+      end
+
+    end # class FilterBase
+  end # end module Filter
+end # end module TeeLogger

data/lib/teelogger/filters/assignment.rb

@@ -0,0 +1,42 @@
+#
+# TeeLogger
+# https://github.com/spriteCloud/teelogger
+#
+# Copyright (c) 2014,2015 spriteCloud B.V. and other TeeLogger contributors.
+# All rights reserved.
+#
+require 'teelogger/filter'
+
+module TeeLogger
+  module Filter
+    ##
+    # The Assignment filter takes strings of the form <prefix><word>=<value> and
+    # obfuscates the value.
+    class Assignment < FilterBase
+      FILTER_TYPES = [String]
+      WINDOW_SIZE  = 1
+
+      def initialize(*args)
+        super(*args)
+
+        # We create more complex matches out of the filter words passed.
+        @matches = []
+        run_data[:words].each do |word|
+          @matches << /(-{0,2}#{word} *[=:] *)(.*)/i
+        end
+      end
+
+      def process(*args)
+        # Note that due to the window size of one, args is only an element long.
+        args.each do |arg|
+          @matches.each do |match|
+            # Modify the matching arguments in place
+            arg.gsub!(match, '\1[REDACTED]')
+          end
+        end
+
+        return args
+      end
+    end # class Assignment
+  end # module Filter
+end # module TeeLogger

data/lib/teelogger/filters/cli.rb

@@ -0,0 +1,45 @@
+#
+# TeeLogger
+# https://github.com/spriteCloud/teelogger
+#
+# Copyright (c) 2014,2015 spriteCloud B.V. and other TeeLogger contributors.
+# All rights reserved.
+#
+require 'teelogger/filter'
+
+module TeeLogger
+  module Filter
+    ##
+    # The CLI filter takes sequences of strings of the form ["word", "value"]
+    # and obfuscates the value if the word matches.
+    class CLI < FilterBase
+      FILTER_TYPES = [String]
+      WINDOW_SIZE  = 2
+
+      def initialize(*args)
+        super(*args)
+
+        # We create more complex matches out of the filter words passed.
+        @matches = []
+        run_data[:words].each do |word|
+          @matches << /(-{0,2}#{word})(.*)/i
+        end
+      end
+
+      def process(*args)
+        # In case the window is too small, ignore it
+        if args.size < 2
+          return args
+        end
+
+        # Otherwise, if the first argument matches, we'll redact the second.
+        @matches.each do |word|
+          if word.match(args[0])
+            args[1] = '[REDACTED]'
+          end
+        end
+        return args
+      end
+    end # class CLI
+  end # module Filter
+end # module TeeLogger

data/lib/teelogger/filters/recursive.rb

@@ -0,0 +1,55 @@
+#
+# TeeLogger
+# https://github.com/spriteCloud/teelogger
+#
+# Copyright (c) 2014,2015 spriteCloud B.V. and other TeeLogger contributors.
+# All rights reserved.
+#
+require 'teelogger/filter'
+
+module TeeLogger
+  module Filter
+    ##
+    # The Recursive filter takes Hashes or Arrays, and recursively applies the
+    # other filters to their values.
+    class Recursive < FilterBase
+      FILTER_TYPES = [Enumerable]
+      WINDOW_SIZE  = 1
+
+      def process(*args)
+        # For each argument, recurse processing. Note that due to the window
+        # size of one, args is only an element long - but let's write this out
+        # properly.
+        args.each do |arg|
+          # Since we're matching enumerabls, the argument must respond to .each
+          arg.each do |expanded|
+            # The expanded variable can be a single item or a list of items.
+            # If expanded is itself an Enumarable, the first item is a key, the remainder
+            # values. We need to recursively process the values.
+            if expanded.is_a? Enumerable
+              # If the key matches any of the filter words, we'll just skip
+              # the value entirely.
+              key = expanded[0]
+              redacted = false
+              run_data[:words].each do |word|
+                if word.match(key.to_s)
+                  arg[key] = '[REDACTED]'
+                  redacted = true
+                  break
+                end
+              end
+
+              if not redacted
+                arg[key] = run_data[:filters].apply_filters_internal(run_data, *expanded[1..-1])
+              end
+            else
+              arg = run_data[:filters].apply_filters_internal(run_data, expanded)
+            end
+          end
+        end
+
+        return args
+      end
+    end # class Recursive
+  end # module Filter
+end # module TeeLogger

data/lib/teelogger/formatter.rb

@@ -0,0 +1,108 @@
+#
+# TeeLogger
+# https://github.com/spriteCloud/teelogger
+#
+# Copyright (c) 2014-2015 spriteCloud B.V. and other TeeLogger contributors.
+# All rights reserved.
+#
+require 'tai64'
+
+module TeeLogger
+  ##
+  # Placeholders for the formatter take a single argument, and convert it to
+  # a string argument using placeholder specific rules.
+  module FormatterPlaceholders
+    def severity(severity, time, progname, message)
+      severity.to_s.upcase
+    end
+
+    def short_severity(severity, time, progname, message)
+      severity.to_s.upcase[0..0]
+    end
+
+    def logger_timestamp(severity, time, progname, message)
+      time.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d" % time.usec
+    end
+
+    def iso8601_timestamp(severity, time, progname, message)
+      time.strftime("%Y-%m-%dT%H:%M:%S%z")
+    end
+
+    def iso8601_timestamp_utc(severity, time, progname, message)
+      time.dup.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+    end
+
+    def tai64n_timestamp(severity, time, progname, message)
+      Tai64::Time.new(time).to_label.to_s
+    end
+
+    def logger(severity, time, progname, message)
+      progname.to_s
+    end
+
+    def message(severity, time, progname, message)
+      message.to_s
+    end
+
+    def pid(severity, time, progname, message)
+      $$.to_s
+    end
+
+    extend self
+  end # module FormatterPlaceholders
+
+  ##
+  # The formatter class accepts a format string, but in a different format from
+  # Kernel#sprintf. Instead, placeholders enclosed in {} (but without the Ruby-
+  # typical #, so not #{}) will get replaced with the output of the functions
+  # defined in FormatterPlaceholders.
+  #
+  # The class also defines a few example format strings as constants.
+  class Formatter
+    # Valid placeholder to use in the format string
+    PLACEHOLDERS = ::TeeLogger::FormatterPlaceholders.instance_methods
+
+    ##
+    # Some format strings defined
+
+    # Format string most similar to the Ruby logger
+    FORMAT_LOGGER = "{short_severity}, [{logger_timestamp} \#{pid}] {severity} -- {logger}: {message}\n"
+
+    # Default format string
+    FORMAT_DEFAULT = "{short_severity}, [{iso8601_timestamp} \#{pid}] {logger}: {message}\n"
+
+    # Shorter format string
+    FORMAT_SHORT = "{short_severity}, [{iso8601_timestamp}] {message}\n"
+
+    # DJB format using Tai64N labels
+    FORMAT_DJB = "{tai64n_timestamp} {severity}: {message}\n"
+
+    ##
+    # Implementation
+    def initialize(format = FORMAT_DEFAULT)
+      @format = format
+    end
+
+    def call(*args) # shortern *args; the same pattern as placeholders is used
+      # Formatting the message means replacing each placeholder with results
+      # from the placeholder function. We're caching results to save some time.
+      cache = {}
+      message = @format.dup
+
+      PLACEHOLDERS.each do |placeholder|
+        value = nil
+        begin
+          value = cache.fetch(placeholder,
+                ::TeeLogger::FormatterPlaceholders.send(placeholder.to_sym, *args))
+          cache[placeholder] = value
+        rescue NoMethodError
+          raise "Invalid formatter placeholder used in format string: #{placeholder}"
+        end
+
+        message.gsub!(/{#{placeholder}}/, value)
+      end
+
+      return message
+    end
+  end # class Formatter
+end # module TeeLogger

data/lib/teelogger/levels.rb

@@ -0,0 +1,41 @@
+#
+# TeeLogger
+# https://github.com/spriteCloud/teelogger
+#
+# Copyright (c) 2014-2015 spriteCloud B.V. and other TeeLogger contributors.
+# All rights reserved.
+#
+module TeeLogger
+  module Levels
+    ##
+    # Convert a log level to its string name
+    def string_level(level)
+      if level.is_a? String
+        return level
+      end
+
+      Logger::Severity.constants.each do |const|
+        if level == Logger.const_get(const)
+          return const
+        end
+      end
+
+      return nil
+    end
+
+    ##
+    # Convert a string log level to its constant value
+    def convert_level(val)
+      if val.is_a? String
+        begin
+          val = Logger.const_get(val.upcase)
+        rescue NameError
+          raise "Invalid log level '#{val}' specified."
+        end
+      end
+
+      return val
+    end
+
+  end # module Levels
+end # module TeeLogger

data/lib/teelogger/version.rb

@@ -6,5 +6,5 @@
 # All rights reserved.
 #
 module TeeLogger
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/teelogger.gemspec

@@ -22,4 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "cucumber"
   spec.add_development_dependency "minitest"
+
+  spec.add_dependency "tai64", "~> 0.0"
+  spec.add_dependency "require_all", "~> 1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teelogger
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Jens Finkhaeuser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-23 00:00:00.000000000 Z
+date: 2015-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tai64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: Mini wrapper around Ruby Logger for logging to multiple destinations.
 email:
 - foss@spritecloud.com
@@ -79,10 +107,21 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- features/filter.feature
+- features/formatter.feature
 - features/logger.feature
-- features/step_definitions/steps.rb
+- features/step_definitions/filter_steps.rb
+- features/step_definitions/formatter_steps.rb
+- features/step_definitions/logger_steps.rb
 - features/support/env.rb
 - lib/teelogger.rb
+- lib/teelogger/extensions.rb
+- lib/teelogger/filter.rb
+- lib/teelogger/filters/assignment.rb
+- lib/teelogger/filters/cli.rb
+- lib/teelogger/filters/recursive.rb
+- lib/teelogger/formatter.rb
+- lib/teelogger/levels.rb
 - lib/teelogger/version.rb
 - teelogger.gemspec
 homepage: https://github.com/spriteCloud/teelogger
@@ -110,6 +149,10 @@ signing_key:
 specification_version: 4
 summary: Mini wrapper around Ruby Logger for logging to multiple destinations.
 test_files:
+- features/filter.feature
+- features/formatter.feature
 - features/logger.feature
-- features/step_definitions/steps.rb
+- features/step_definitions/filter_steps.rb
+- features/step_definitions/formatter_steps.rb
+- features/step_definitions/logger_steps.rb
 - features/support/env.rb