semantic_logger 4.0.0 → 4.1.0

data/lib/semantic_logger/appender/new_relic.rb

@@ -29,17 +29,13 @@ class SemanticLogger::Appender::NewRelic < SemanticLogger::Subscriber
   #     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)
-    # Backward compatibility
-    options         = {level: options} unless options.is_a?(Hash)
-    options         = options.dup
-    options[:level] = :error unless options.has_key?(:level)
-    super(options)
+  def initialize(level: :error, formatter: nil, filter: nil, application: nil, host: nil, &block)
+    super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
   end
 
   # Returns [Hash] of parameters to send to New Relic.
   def call(log, logger)
-    h = log.to_h(host, application)
+    h = SemanticLogger::Formatters::Raw.new.call(log, logger)
     h.delete(:time)
     h.delete(:exception)
     {metric: log.metric, custom_params: h}

data/lib/semantic_logger/appender/sentry.rb

@@ -35,11 +35,8 @@ class SemanticLogger::Appender::Sentry < SemanticLogger::Subscriber
   #   application: [String]
   #     Name of this application to appear in log messages.
   #     Default: SemanticLogger.application
-  def initialize(options = {}, &block)
-    options         = options.is_a?(Hash) ? options.dup : {level: options}
-    options[:level] ||= :error
-
-    super(options, &block)
+  def initialize(level: :error, formatter: nil, filter: nil, application: nil, host: nil, &block)
+    super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
   end
 
   # Send an error notification to sentry

data/lib/semantic_logger/appender/splunk.rb

@@ -86,15 +86,11 @@ class SemanticLogger::Appender::Splunk < SemanticLogger::Subscriber
   #     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 = {}, _deprecated_level = nil, &block)
-    @config         = options.dup
-    @config[:level] = _deprecated_level if _deprecated_level
-    @index          = @config.delete(:index) || 'main'
-    @source_type    = options.delete(:source_type)
+  def initialize(index: 'main', source_type: nil, level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+    @index       = index
+    @source_type = source_type
 
-    options = extract_subscriber_options!(@config)
-    # Pass on the level and custom formatter if supplied
-    super(options, &block)
+    super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
     reopen
   end
 
@@ -116,11 +112,12 @@ class SemanticLogger::Appender::Splunk < SemanticLogger::Subscriber
     true
   end
 
-  # Returns [Hash] To send to Splunk
+  # Returns [Hash] To send to Splunk.
+  #
   # For splunk format requirements see:
   #   http://dev.splunk.com/view/event-collector/SP-CAAAE6P
   def call(log, logger)
-    h = log.to_h(nil, nil)
+    h = SemanticLogger::Formatters::Raw.new.call(log, logger)
     h.delete(:time)
     message               = {
       source:  logger.application,

data/lib/semantic_logger/appender/splunk_http.rb

@@ -13,6 +13,8 @@ require 'json'
 #     token:    '70CA900C-3D7E-42A4-9C79-7975D1C422A8'
 #   )
 class SemanticLogger::Appender::SplunkHttp < SemanticLogger::Appender::Http
+  attr_accessor :source_type, :index
+
   # Create Splunk appender over persistent HTTP(S)
   #
   # Parameters:
@@ -42,7 +44,7 @@ class SemanticLogger::Appender::SplunkHttp < SemanticLogger::Appender::Http
   #     Default: SemanticLogger.host
   #
   #   compress: [true|false]
-  #     Whether to compress the JSON string with GZip.
+  #     Splunk supports HTTP Compression, enable by default.
   #     Default: true
   #
   #   ssl: [Hash]
@@ -64,26 +66,26 @@ class SemanticLogger::Appender::SplunkHttp < SemanticLogger::Appender::Http
   #     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)
-    raise(ArgumentError, 'Missing mandatory parameter :token') unless token
+  def initialize(token: nil, source_type: nil, index: nil,
+    url:, compress: true, ssl: {}, open_timeout: 2.0, read_timeout: 1.0, continue_timeout: 1.0,
+    level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
 
-    # Splunk supports HTTP Compression, enable by default
-    options[:compress] = true unless options.key?(:compress)
+    @source_type       = source_type
+    @index             = index
 
-    super(options, &block)
+    super(url: url, compress: compress, ssl: ssl, open_timeout: 2.0, read_timeout: open_timeout, continue_timeout: continue_timeout,
+      level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
 
+    # Put splunk auth token in the header of every HTTP post.
     @header['Authorization'] = "Splunk #{token}"
   end
 
-  # Returns [String] JSON to send to Splunk
+  # Returns [String] JSON to send to Splunk.
+  #
   # For splunk format requirements see:
   #   http://dev.splunk.com/view/event-collector/SP-CAAAE6P
   def call(log, logger)
-    h = log.to_h(nil, nil)
+    h = SemanticLogger::Formatters::Raw.new.call(log, logger)
     h.delete(:time)
     message               = {
       source: logger.application,
@@ -91,10 +93,8 @@ class SemanticLogger::Appender::SplunkHttp < SemanticLogger::Appender::Http
       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[:source_type] = source_type if source_type
+    message[:index]       = index if index
     message.to_json
   end
 

data/lib/semantic_logger/appender/syslog.rb

@@ -1,46 +1,37 @@
 require 'syslog'
 require 'uri'
 require 'socket'
-
 # Send log messages to local syslog, or remote syslog servers over TCP or UDP.
 #
-# Example: Log to a local Syslog daemon
+# Example:
+#   # Log to a local Syslog daemon
 #   SemanticLogger.add_appender(appender: :syslog)
 #
-# Example: Log to a remote Syslog server using TCP:
+# Example:
+#   # Log to a remote Syslog server over TCP:
 #   SemanticLogger.add_appender(
 #     appender: :syslog,
 #     url:      'tcp://myloghost:514'
 #   )
 #
-# Example: Log to a remote Syslog server using UDP:
+# Example:
+#   # Log to a remote Syslog server over UDP:
 #   SemanticLogger.add_appender(
 #     appender: :syslog,
 #     url:      'udp://myloghost:514'
 #   )
+#
+# Example:
+#   # Log to a remote Syslog server using the CEE format over TCP:
+#   SemanticLogger.add_appender(
+#     appender: :syslog,
+#     url:      'tcp://myloghost:514'
+#   )
+#
 module SemanticLogger
   module Appender
     class Syslog < SemanticLogger::Subscriber
-
-      # Default mapping of ruby log levels to syslog log levels
-      #
-      # ::Syslog::LOG_EMERG   - "System is unusable"
-      # ::Syslog::LOG_ALERT   - "Action needs to be taken immediately"
-      # ::Syslog::LOG_CRIT    - "A critical condition has occurred"
-      # ::Syslog::LOG_ERR     - "An error occurred"
-      # ::Syslog::LOG_WARNING - "Warning of a possible problem"
-      # ::Syslog::LOG_NOTICE  - "A normal but significant condition occurred"
-      # ::Syslog::LOG_INFO    - "Informational message"
-      # ::Syslog::LOG_DEBUG   - "Debugging information"
-      DEFAULT_LEVEL_MAP = {
-        fatal: ::Syslog::LOG_CRIT,
-        error: ::Syslog::LOG_ERR,
-        warn:  ::Syslog::LOG_WARNING,
-        info:  ::Syslog::LOG_NOTICE,
-        debug: ::Syslog::LOG_INFO,
-        trace: ::Syslog::LOG_DEBUG
-      }
-      attr_reader :remote_syslog, :url, :server, :port, :protocol, :facility
+      attr_reader :remote_syslog, :url, :server, :port, :protocol, :facility, :options, :level_map
 
       # Create a Syslog appender instance.
       #
@@ -72,11 +63,6 @@ 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.
@@ -96,6 +82,9 @@ module SemanticLogger
       #       ::Syslog::LOG_ODELAY
       #       ::Syslog::LOG_PERROR
       #       ::Syslog::LOG_PID
+      #    Note:
+      #      - Only applicable when logging to a local syslog instance.
+      #        I.e. When `url: 'syslog://localhost'`
       #
       #   facility: [Integer]
       #     Default: ::Syslog::LOG_USER
@@ -124,46 +113,30 @@ module SemanticLogger
       #       ::Syslog::LOG_LOCAL6
       #       ::Syslog::LOG_LOCAL7
       #
-      #   level_map: [Hash]
+      #   level_map: [Hash | SemanticLogger::Formatters::Syslog::LevelMap]
       #     Supply a custom map of SemanticLogger levels to syslog levels.
-      #     For example, passing in { warn: ::Syslog::LOG_NOTICE }
-      #       would result in a log mapping that matches the default level map,
-      #       except for :warn, which ends up with a LOG_NOTICE level instead of a
-      #       LOG_WARNING one.
-      #     Without overriding any parameters, the level map will be
-      #       LEVEL_MAP = {
-      #         fatal:   ::Syslog::LOG_CRIT,
-      #         error:   ::Syslog::LOG_ERR,
-      #         warn:    ::Syslog::LOG_WARNING,
-      #         info:    ::Syslog::LOG_NOTICE,
-      #         debug:   ::Syslog::LOG_INFO,
-      #         trace:   ::Syslog::LOG_DEBUG
-      #       }
       #
-      #   format: [Symbol]
-      #     Format for the Syslog message
-      #       :syslog uses the default syslog format
-      #       :json uses the CEE JSON Syslog format
-      #          Example: "@cee: #{JSON.dump(data)}"
-      #     Default: :syslog
-      def initialize(options = {}, &block)
-        options             = options.dup
-        @options            = options.delete(:options) || (::Syslog::LOG_PID | ::Syslog::LOG_CONS)
-        @facility           = options.delete(:facility) || ::Syslog::LOG_USER
-        level_map           = options.delete(:level_map)
-        @url                = options.delete(:url) || options.delete(:server) || 'syslog://localhost'
+      #   Example:
+      #     # Change the warn level to LOG_NOTICE level instead of a the default of LOG_WARNING.
+      #     SemanticLogger.add_appender(appender: :syslog, level_map: {warn: ::Syslog::LOG_NOTICE})
+      def initialize(url: 'syslog://localhost',
+        facility: ::Syslog::LOG_USER, level_map: SemanticLogger::Formatters::Syslog::LevelMap.new, options: ::Syslog::LOG_PID|::Syslog::LOG_CONS,
+        tcp_client: {},
+        level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+
+        @options            = options
+        @facility           = facility
+        @level_map          = level_map
+        @url                = url
         uri                 = URI(@url)
         @server             = uri.host || 'localhost'
         @protocol           = (uri.scheme || :syslog).to_sym
         @port               = uri.port || 514
         @server             = 'localhost' if @protocol == :syslog
-        @tcp_client_options = options.delete(:tcp_client)
+        @tcp_client_options = tcp_client
 
         raise "Unknown protocol #{@protocol}!" unless [:syslog, :tcp, :udp].include?(@protocol)
 
-        @level_map = DEFAULT_LEVEL_MAP.dup
-        @level_map.update(level_map) if level_map
-
         # The syslog_protocol gem is required when logging over TCP or UDP.
         if [:tcp, :udp].include?(@protocol)
           begin
@@ -174,8 +147,6 @@ module SemanticLogger
 
           # The net_tcp_client gem is required when logging over TCP.
           if protocol == :tcp
-            @tcp_client_options          ||= {}
-            @tcp_client_options[:server] = "#{@server}:#{@port}"
             begin
               require 'net/tcp_client'
             rescue LoadError
@@ -184,7 +155,7 @@ module SemanticLogger
           end
         end
 
-        super(options, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
         reopen
       end
 
@@ -193,10 +164,11 @@ module SemanticLogger
       def reopen
         case @protocol
         when :syslog
-          ::Syslog.open(application, @options, @facility)
+          ::Syslog.open(application, options, facility)
         when :tcp
           # Use the local logger for @remote_syslog so errors with the remote logger can be recorded locally.
           @tcp_client_options[:logger] = SemanticLogger::Processor.logger.clone
+          @tcp_client_options[:server] = "#{@server}:#{@port}"
           @remote_syslog               = Net::TCPClient.new(@tcp_client_options)
         when :udp
           @remote_syslog = UDPSocket.new
@@ -215,9 +187,9 @@ module SemanticLogger
           message = formatter.call(log, self).gsub '%', '%%'
           ::Syslog.log @level_map[log.level], message
         when :tcp
-          @remote_syslog.retry_on_connection_failure { @remote_syslog.write("#{syslog_packet_formatter(log)}\r\n") }
+          @remote_syslog.retry_on_connection_failure { @remote_syslog.write("#{formatter.call(log, self)}\r\n") }
         when :udp
-          @remote_syslog.send syslog_packet_formatter(log), 0, @server, @port
+          @remote_syslog.send(formatter.call(log, self), 0, @server, @port)
         else
           raise "Unsupported protocol: #{protocol}"
         end
@@ -229,67 +201,16 @@ module SemanticLogger
         @remote_syslog.flush if @remote_syslog && @remote_syslog.respond_to?(:flush)
       end
 
-      # Custom log formatter for syslog.
-      # Only difference is the removal of the timestamp string since it is in the syslog packet.
-      def call(log, logger)
-        # Header with date, time, log level and process info
-        message = "#{log.level_to_s} [#{log.process_info}]"
-
-        # Tags
-        message << ' ' << log.tags.collect { |tag| "[#{tag}]" }.join(' ') if log.tags && (log.tags.size > 0)
-
-        # Duration
-        message << " (#{log.duration_human})" if log.duration
-
-        # Class / app name
-        message << " #{log.name}"
-
-        # Log message
-        message << " -- #{log.message}" if log.message
-
-        # Payload
-        if payload = log.payload_to_s
-          message << ' -- ' << payload
-        end
-
-        # Exceptions
-        if log.exception
-          message << " -- Exception: #{log.exception.class}: #{log.exception.message}\n"
-          message << log.backtrace_to_s
-        end
-        message
-      end
-
-      private
-
-      # Extract Syslog formatter options
-      def format_options(options, protocol, &block)
-        opts      = options.delete(:options)
-        facility  = options.delete(:facility)
-        level_map = options.delete(:level_map)
-        if formatter = options.delete(:formatter)
-          extract_formatter(formatter)
+      # Returns [SemanticLogger::Formatters::Base] default formatter for this Appender depending on the protocal selected
+      def default_formatter
+        if protocol == :syslog
+          # Format is text output without the time
+          SemanticLogger::Formatters::Default.new(time_format: nil)
         else
-          case protocol
-          when :syslog
-            extract_formatter(syslog: {options: opts, facility: facility, level_map: level_map})
-          when :tcp, :udp
-            extract_formatter(syslog: {options: opts, facility: facility, level_map: level_map})
-          end
+          SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map)
         end
       end
 
-      # Format the syslog packet so it can be sent over TCP or UDP
-      def syslog_packet_formatter(log)
-        packet          = SyslogProtocol::Packet.new
-        packet.hostname = host
-        packet.facility = @facility
-        packet.severity = @level_map[log.level]
-        packet.tag      = application.gsub(' ', '')
-        packet.content  = formatter.call(log, self)
-        packet.time     = log.time
-        packet.to_s
-      end
     end
   end
 end

data/lib/semantic_logger/appender/tcp.rb

@@ -181,22 +181,41 @@ module SemanticLogger
       #     connect_retry_interval: 0.1,
       #     connect_retry_count:    5
       #   )
-      def initialize(options = {}, &block)
-        @tcp_client                = nil
-        @options                   = options.dup
-        @separator                 = @options.delete(:separator) || "\n"
+      def initialize(server: nil, servers: nil, separator: "\n",
+        policy: :ordered, buffered: true, #keepalive: true,
+        connect_timeout: 10.0, read_timeout: 60.0, write_timeout: 60.0,
+        connect_retry_count: 10, retry_count: 3, connect_retry_interval: 0.5, close_on_error: true,
+        on_connect: nil, proxy_server: nil, ssl: nil,
+        level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block
+      )
+        @separator                 = separator
+        @options                   = {
+          server:                 server,
+          servers:                servers,
+          policy:                 policy,
+          buffered:               buffered,
+          #keepalive:              keepalive,
+          connect_timeout:        connect_timeout,
+          read_timeout:           read_timeout,
+          write_timeout:          write_timeout,
+          connect_retry_count:    connect_retry_count,
+          retry_count:            retry_count,
+          connect_retry_interval: connect_retry_interval,
+          close_on_error:         close_on_error,
+          on_connect:             on_connect,
+          proxy_server:           proxy_server,
+          ssl:                    ssl
+        }
 
         # Use the internal logger so that errors with remote logging are only written locally.
         Net::TCPClient.logger      = SemanticLogger::Processor.logger.clone
         Net::TCPClient.logger.name = 'Net::TCPClient'
 
-        options = extract_subscriber_options!(@options)
-        super(options, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
         reopen
       end
 
-      # After forking an active process call #reopen to re-open
-      # open the handles to resources
+      # After forking an active process call #reopen to re-open the handles to resources.
       def reopen
         close
         @tcp_client = Net::TCPClient.new(@options)
@@ -215,7 +234,7 @@ module SemanticLogger
 
       # Flush is called by the semantic_logger during shutdown.
       def flush
-        @tcp_client.flush if @tcp_client && @tcp_client.respond_to?(:flush)
+        @tcp_client.flush if @tcp_client
       end
 
       # Close is called during shutdown, or with reopen