semantic_logger 3.0.1 → 3.1.0

data/lib/semantic_logger/appender/file.rb

@@ -9,15 +9,20 @@ module SemanticLogger
       # Create a File Logger appender instance.
       #
       # Parameters
-      #  filename [String|IO]
+      #  :file_name [String|IO]
       #    Name of file to write to.
       #    Or, an IO stream to which to write the log message to.
       #
-      #  level [:trace | :debug | :info | :warn | :error | :fatal]
+      #  :level [:trace | :debug | :info | :warn | :error | :fatal]
       #    Override the log level for this appender.
       #    Default: SemanticLogger.default_level
       #
-      #  filter [Regexp|Proc]
+      #  :formatter: [Object|Proc]
+      #    An instance of a class that implements #call, or a Proc to be used to format
+      #    the output from this appender
+      #    Default: Use the built-in formatter (See: #call)
+      #
+      #  :filter [Regexp|Proc]
       #    RegExp: Only include log messages where the class name matches the supplied
       #    regular expression. All other messages will be ignored.
       #    Proc: Only include log messages where the supplied Proc returns true
@@ -30,10 +35,10 @@ module SemanticLogger
       #    SemanticLogger.default_level = :info
       #
       #    # Log to screen
-      #    SemanticLogger.add_appender(STDOUT)
+      #    SemanticLogger.add_appender(io: STDOUT, formatter: :color)
       #
       #    # And log to a file at the same time
-      #    SemanticLogger::Logger.add_appender('application.log')
+      #    SemanticLogger::Logger.add_appender(file_name: 'application.log', formatter: :color)
       #
       #    logger = SemanticLogger['test']
       #    logger.info 'Hello World'
@@ -46,36 +51,53 @@ module SemanticLogger
       #    SemanticLogger.default_level = :trace
       #
       #    # Log to screen but only display :info and above
-      #    SemanticLogger.add_appender(STDOUT, :info)
+      #    SemanticLogger.add_appender(io: STDOUT, level: :info)
       #
       #    # And log to a file at the same time, including all :trace level data
-      #    SemanticLogger.add_appender('application.log')
+      #    SemanticLogger.add_appender(file_name: 'application.log')
       #
       #    logger =  SemanticLogger['test']
       #    logger.info 'Hello World'
-      def initialize(filename, level=nil, filter=nil, &block)
-        raise 'filename cannot be null when initializing the SemanticLogging::Appender::File' unless filename
-        @log =
-          if filename.respond_to?(:write) and filename.respond_to?(:close)
-            filename
+      def initialize(options={}, deprecated_level = nil, deprecated_filter = nil, &block)
+        # Old style arguments: (file_name, level=nil, filter=nil, &block)
+        options =
+          if options.is_a?(Hash)
+            options.dup
           else
-            @filename = filename
-            reopen
+            file_name = options
+            opts      = {}
+            if file_name.respond_to?(:write) && file_name.respond_to?(:close)
+              opts[:io] = file_name
+            else
+              opts[:file_name] = file_name
+            end
+            opts[:level]  = deprecated_level if deprecated_level
+            opts[:filter] = deprecated_filter if deprecated_filter
+            opts
           end
 
+        if io = options.delete(:io)
+          @log = io
+        else
+          @file_name = options.delete(:file_name)
+          raise 'SemanticLogging::Appender::File missing mandatory parameter :file_name or :io' unless @file_name
+          reopen
+        end
+
         # Set the log level and formatter if supplied
-        super(level, filter, &block)
+        super(options, &block)
       end
 
       # After forking an active process call #reopen to re-open
       # open the file handles etc to resources
       #
-      # Note: This method will only work if a String filename was supplied
+      # Note: This method will only work if :file_name was supplied
       #       on the initializer.
+      #       If :io was supplied, it will need to be re-opened manually.
       def reopen
-        return unless @filename
+        return unless @file_name
 
-        @log      = open(@filename, (::File::WRONLY | ::File::APPEND | ::File::CREAT))
+        @log      = open(@file_name, (::File::WRONLY | ::File::APPEND | ::File::CREAT))
         # Force all log entries to write immediately without buffering
         # Allows multiple processes to write to the same log file simultaneously
         @log.sync = true

data/lib/semantic_logger/appender/graylog.rb

@@ -8,15 +8,11 @@ end
 # Forward log entries to a Graylog server.
 #
 # Example:
-#   appender        = SemanticLogger::Appender::Graylog.new(
-#     url: 'udp://localhost:12201'
+#   SemanticLogger.add_appender(
+#     appender: :graylog,
+#     url:      'udp://localhost:12201'
 #   )
 #
-#   # Optional: Add filter to exclude health_check, or other log entries
-#   appender.filter = Proc.new { |log| log.message !~ /(health_check|Not logged in)/ }
-#
-#   SemanticLogger.add_appender(appender)
-#
 # Notes:
 # * trace is not supported by Graylog, so trace level logging will appear as debug in Graylog.
 #
@@ -62,17 +58,20 @@ class SemanticLogger::Appender::Graylog < SemanticLogger::Appender::Base
   #     Override the log level for this appender.
   #     Default: SemanticLogger.default_level
   #
+  #   formatter: [Object|Proc]
+  #     An instance of a class that implements #call, or a Proc to be used to format
+  #     the output from this appender
+  #     Default: Use the built-in formatter (See: #call)
+  #
   #   filter: [Regexp|Proc]
   #     RegExp: Only include log messages where the class name matches the supplied.
   #     regular expression. All other messages will be ignored.
   #     Proc: Only include log messages where the supplied Proc returns true
   #           The Proc must return true or false.
   def initialize(options = {}, &block)
-    @options  = options.dup
-    level     = @options.delete(:level)
-    filter    = @options.delete(:filter)
-    @url      = options.delete(:url) || 'udp://localhost:12201'
-    @max_size = @options.delete(:max_size) || 'WAN'
+    @gelf_options = options.dup
+    @url          = @gelf_options.delete(:url) || 'udp://localhost:12201'
+    @max_size     = @gelf_options.delete(:max_size) || 'WAN'
 
     uri      = URI.parse(@url)
     @server  = uri.host
@@ -81,29 +80,34 @@ class SemanticLogger::Appender::Graylog < SemanticLogger::Appender::Base
 
     raise(ArgumentError, "Invalid protocol value: #{protocol}. Must be :udp or :tcp") unless [:udp, :tcp].include?(protocol)
 
-    @options[:protocol] = protocol == :tcp ? GELF::Protocol::TCP : GELF::Protocol::UDP
-    @options[:facility] = @options.delete(:application) || SemanticLogger.application
+    @gelf_options[:protocol] = protocol == :tcp ? GELF::Protocol::TCP : GELF::Protocol::UDP
+    @gelf_options[:facility] = @gelf_options.delete(:application) || SemanticLogger.application
+
+    options = {
+      level:     @gelf_options.delete(:level),
+      filter:    @gelf_options.delete(:filter),
+      formatter: @gelf_options.delete(:formatter)
+    }
     reopen
-    super(level, filter, &block)
+
+    super(options, &block)
   end
 
   # Re-open after process fork
   def reopen
-    @notifier                       = GELF::Notifier.new(@server, @port, @max_size, @options)
+    @notifier                       = GELF::Notifier.new(@server, @port, @max_size, @gelf_options)
     @notifier.collect_file_and_line = false
   end
 
   # Returns [Hash] of parameters to send
-  def default_formatter
-    Proc.new do |log, logger|
-      h = log.to_h
-      h.delete(:time)
-      h[:timestamp]     = log.time.utc.to_f
-      h[:level]         = logger.map_level(log)
-      h[:level_str]     = log.level.to_s
-      h[:short_message] = h.delete(:message) if log.message
-      h
-    end
+  def call(log, logger)
+    h = log.to_h
+    h.delete(:time)
+    h[:timestamp]     = log.time.utc.to_f
+    h[:level]         = logger.map_level(log)
+    h[:level_str]     = log.level.to_s
+    h[:short_message] = h.delete(:message) if log.message
+    h
   end
 
   # Forward log messages

data/lib/semantic_logger/appender/http.rb

@@ -11,14 +11,10 @@ require 'json'
 # * SSL encryption (https).
 #
 # Example:
-#   appender = SemanticLogger::Appender::Http.new(
-#     url: 'http://localhost:8088/path'
+#   SemanticLogger.add_appender(
+#     appender: :http,
+#     url:      'http://localhost:8088/path'
 #   )
-#
-#   # Optional: Exclude health_check log entries, etc.
-#   appender.filter = Proc.new { |log| log.message !~ /(health_check|Not logged in)/}
-#
-#   SemanticLogger.add_appender(appender)
 class SemanticLogger::Appender::Http < SemanticLogger::Appender::Base
   attr_accessor :username, :application, :host, :compress, :header
   attr_reader :http, :url, :server, :port, :path, :ssl_options
@@ -61,15 +57,18 @@ class SemanticLogger::Appender::Http < SemanticLogger::Appender::Base
   #     Override the log level for this appender.
   #     Default: SemanticLogger.default_level
   #
+  #   formatter: [Object|Proc]
+  #     An instance of a class that implements #call, or a Proc to be used to format
+  #     the output from this appender
+  #     Default: Use the built-in formatter (See: #call)
+  #
   #   filter: [Regexp|Proc]
   #     RegExp: Only include log messages where the class name matches the supplied.
   #     regular expression. All other messages will be ignored.
   #     Proc: Only include log messages where the supplied Proc returns true
   #           The Proc must return true or false.
   def initialize(options, &block)
-    @options     = options.dup
-    level        = @options.delete(:level)
-    filter       = @options.delete(:filter)
+    options      = options.dup
     @url         = options.delete(:url)
     @ssl_options = options.delete(:ssl)
     @username    = options.delete(:username)
@@ -77,7 +76,9 @@ class SemanticLogger::Appender::Http < SemanticLogger::Appender::Base
     @application = options.delete(:application) || 'Semantic Logger'
     @host        = options.delete(:host) || SemanticLogger.host
     @compress    = options.delete(:compress) || false
-    raise(ArgumentError, "Unknown options: #{options.inspect}") if options.size > 0
+    unless options.has_key?(:formatter)
+      options[:formatter] = block || (respond_to?(:call) ? self : SemanticLogger::Formatters::Json.new)
+    end
 
     raise(ArgumentError, 'Missing mandatory parameter :url') unless @url
 
@@ -96,12 +97,12 @@ class SemanticLogger::Appender::Http < SemanticLogger::Appender::Base
     @port     = uri.port
     @username = uri.user if !@username && uri.user
     @password = uri.password if !@password && uri.password
-    @path     = uri.request_uri
+    @path     = uri.path
 
     reopen
 
     # Pass on the level and custom formatter if supplied
-    super(level, filter, &block)
+    super(options)
   end
 
   # Re-open after process fork
@@ -114,15 +115,9 @@ class SemanticLogger::Appender::Http < SemanticLogger::Appender::Base
   def log(log)
     return false if (level_index > (log.level_index || 0)) ||
       !include_message?(log) # Filtered out?
-
     post(formatter.call(log, self))
   end
 
-  # Use the JSON formatter
-  def default_formatter
-    self.class.json_formatter
-  end
-
   private
 
   def compress_data(data)

data/lib/semantic_logger/appender/mongodb.rb

@@ -42,7 +42,7 @@ module SemanticLogger
     #     db:              database,
     #     collection_size: 1024**3 # 1.gigabyte
     #   )
-    #   SemanticLogger.add_appender(appender)
+    #   SemanticLogger.add_appender(appender: appender)
     #
     #   logger = SemanticLogger['Example']
     #
@@ -91,25 +91,27 @@ module SemanticLogger
       #     Override the log level for this appender.
       #     Default: SemanticLogger.default_level
       #
+      #   formatter: [Object|Proc]
+      #     An instance of a class that implements #call, or a Proc to be used to format
+      #     the output from this appender
+      #     Default: Use the built-in formatter (See: #call)
+      #
       #   filter: [Regexp|Proc]
       #     RegExp: Only include log messages where the class name matches the supplied.
       #     regular expression. All other messages will be ignored.
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
       def initialize(options = {}, &block)
-        options          = options.dup
-        level            = options.delete(:level)
-        filter           = options.delete(:filter)
-        @db              = options.delete(:db) || raise('Missing mandatory parameter :db')
-        @collection_name = options.delete(:collection_name) || 'semantic_logger'
-        @host            = options.delete(:host) || options.delete(:host_name) || SemanticLogger.host
-        @write_concern   = options.delete(:write_concern) || 0
-        @application     = options.delete(:application) || SemanticLogger.application
+        options             = options.dup
+        @db                 = options.delete(:db) || raise('Missing mandatory parameter :db')
+        @collection_name    = options.delete(:collection_name) || 'semantic_logger'
+        @host               = options.delete(:host) || options.delete(:host_name) || SemanticLogger.host
+        @write_concern      = options.delete(:write_concern) || 0
+        @application        = options.delete(:application) || SemanticLogger.application
 
         # Create a collection that will hold the lesser of 1GB space or 10K documents
-        @collection_size = options.delete(:collection_size) || 1024**3
-        @collection_max  = options.delete(:collection_max)
-        raise(ArgumentError, "Unknown options: #{options.inspect}") if options.size > 0
+        @collection_size    = options.delete(:collection_size) || 1024**3
+        @collection_max     = options.delete(:collection_max)
 
         reopen
 
@@ -117,7 +119,7 @@ module SemanticLogger
         create_indexes
 
         # Set the log level and formatter
-        super(level, filter, &block)
+        super(options, &block)
       end
 
       # After forking an active process call #reopen to re-open
@@ -160,13 +162,11 @@ module SemanticLogger
 
       # Default log formatter
       #  Replace this formatter by supplying a Block to the initializer
-      def default_formatter
-        Proc.new do |log|
-          h               = log.to_h
-          h[:host]        = host
-          h[:application] = application
-          h
-        end
+      def call(log, logger)
+        h               = log.to_h
+        h[:host]        = host
+        h[:application] = application
+        h
       end
 
       # Log the message to MongoDB

data/lib/semantic_logger/appender/new_relic.rb

@@ -10,8 +10,7 @@ end
 # "Applications" > "Application Name" > "Events" > "Errors" in New Relic.
 #
 # Example:
-#   SemanticLogger.add_appender(SemanticLogger::Appender::NewRelic.new)
-#
+#   SemanticLogger.add_appender(appender: :new_relic)
 class SemanticLogger::Appender::NewRelic < SemanticLogger::Appender::Base
   # Create Appender
   #
@@ -20,6 +19,11 @@ class SemanticLogger::Appender::NewRelic < SemanticLogger::Appender::Base
   #     Override the log level for this appender.
   #     Default: :error
   #
+  #   formatter: [Object|Proc]
+  #     An instance of a class that implements #call, or a Proc to be used to format
+  #     the output from this appender
+  #     Default: Use the built-in formatter (See: #call)
+  #
   #   filter: [Regexp|Proc]
   #     RegExp: Only include log messages where the class name matches the supplied.
   #     regular expression. All other messages will be ignored.
@@ -27,22 +31,18 @@ class SemanticLogger::Appender::NewRelic < SemanticLogger::Appender::Base
   #           The Proc must return true or false.
   def initialize(options = {}, &block)
     # Backward compatibility
-    options  = {level: options} unless options.is_a?(Hash)
-    @options = options.dup
-    level    = @options.delete(:level) || :error
-    filter   = @options.delete(:filter)
-
-    super(level, filter, &block)
+    options         = {level: options} unless options.is_a?(Hash)
+    options         = options.dup
+    options[:level] = :error unless options.has_key?(:level)
+    super(options)
   end
 
   # Returns [Hash] of parameters to send to New Relic.
-  def default_formatter
-    Proc.new do |log, logger|
-      h = log.to_h
-      h.delete(:time)
-      h.delete(:exception)
-      {metric: log.metric, custom_params: h}
-    end
+  def call(log, logger)
+    h = log.to_h
+    h.delete(:time)
+    h.delete(:exception)
+    {metric: log.metric, custom_params: h}
   end
 
   # Send an error notification to New Relic

data/lib/semantic_logger/appender/splunk.rb

@@ -18,7 +18,7 @@ class SemanticLogger::Appender::Splunk < SemanticLogger::Appender::Base
     reopen
 
     # Pass on the level and custom formatter if supplied
-    super(level, &block)
+    super(level: level, &block)
   end
 
   # After forking an active process call #reopen to re-open

data/lib/semantic_logger/appender/splunk_http.rb

@@ -7,11 +7,11 @@ require 'json'
 #   http://dev.splunk.com/view/event-collector/SP-CAAAE7F
 #
 # Example
-#   appender = SemanticLogger::Appender::SplunkHttp.new(
-#     url:   'http://localhost:8080',
-#     token: '70CA900C-3D7E-42A4-9C79-7975D1C422A8'
+#   SemanticLogger.add_appender(
+#     appender: :splunk_http,
+#     url:      'http://localhost:8080',
+#     token:    '70CA900C-3D7E-42A4-9C79-7975D1C422A8'
 #   )
-#   SemanticLogger.add_appender(appender)
 class SemanticLogger::Appender::SplunkHttp < SemanticLogger::Appender::Http
   # Create Splunk appender over persistent HTTP(S)
   #
@@ -54,16 +54,21 @@ class SemanticLogger::Appender::SplunkHttp < SemanticLogger::Appender::Http
   #     Override the log level for this appender.
   #     Default: SemanticLogger.default_level
   #
+  #   formatter: [Object|Proc]
+  #     An instance of a class that implements #call, or a Proc to be used to format
+  #     the output from this appender
+  #     Default: Use the built-in formatter (See: #call)
+  #
   #   filter: [Regexp|Proc]
   #     RegExp: Only include log messages where the class name matches the supplied.
   #     regular expression. All other messages will be ignored.
   #     Proc: Only include log messages where the supplied Proc returns true
   #           The Proc must return true or false.
   def initialize(options, &block)
-    options      = options.dup
-    @source_type = options.delete(:source_type)
-    @index       = options.delete(:index)
-    token        = options.delete(:token)
+    options             = options.dup
+    @source_type        = options.delete(:source_type)
+    @index              = options.delete(:index)
+    token               = options.delete(:token)
     raise(ArgumentError, 'Missing mandatory parameter :token') unless token
 
     # Splunk supports HTTP Compression, enable by default
@@ -77,24 +82,22 @@ class SemanticLogger::Appender::SplunkHttp < SemanticLogger::Appender::Http
   # Returns [String] JSON to send to Splunk
   # For splunk format requirements see:
   #   http://dev.splunk.com/view/event-collector/SP-CAAAE6P
-  def default_formatter
-    Proc.new do |log, logger|
-      h = log.to_h
-      h.delete(:application)
-      h.delete(:host)
-      h.delete(:time)
-      message               = {
-        source: logger.application,
-        host:   logger.host,
-        time:   log.time.utc.to_f,
-        event:  h
-      }
-      message[:source_type] = @source_type if @source_type
-      message[:index]       = @index if @index
+  def call(log, logger)
+    h = log.to_h
+    h.delete(:application)
+    h.delete(:host)
+    h.delete(:time)
+    message               = {
+      source: logger.application,
+      host:   logger.host,
+      time:   log.time.utc.to_f,
+      event:  h
+    }
+    message[:source_type] = @source_type if @source_type
+    message[:index]       = @index if @index
 
-      # Render to JSON
-      message.to_json
-    end
+    # Render to JSON
+    message.to_json
   end
 
 end