semantic_logger 4.0.0 → 4.1.0

data/lib/semantic_logger/appender/file.rb

@@ -9,9 +9,11 @@ module SemanticLogger
       # Create a File Logger appender instance.
       #
       # Parameters
-      #  :file_name [String|IO]
+      #  :file_name [String]
       #    Name of file to write to.
-      #    Or, an IO stream to which to write the log message to.
+      #  Or,
+      #  :io [IO]
+      #    An IO stream to which to write the log messages to.
       #
       #  :level [:trace | :debug | :info | :warn | :error | :fatal]
       #    Override the log level for this appender.
@@ -58,34 +60,16 @@ module SemanticLogger
       #
       #    logger =  SemanticLogger['test']
       #    logger.info 'Hello World'
-      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
-            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)
+      def initialize(io: nil, file_name: nil, level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+        if io
           @log = io
         else
-          @file_name = options.delete(:file_name)
-          raise 'SemanticLogging::Appender::File missing mandatory parameter :file_name or :io' unless @file_name
+          @file_name = 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(options, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
       end
 
       # After forking an active process call #reopen to re-open

data/lib/semantic_logger/appender/graylog.rb

@@ -20,16 +20,25 @@ end
 #  `duration`, `level`, `message`, `metric`, `name`, `tags
 class SemanticLogger::Appender::Graylog < SemanticLogger::Subscriber
   # Map Semantic Logger levels to Graylog levels
-  LEVEL_MAP = {
-    fatal: GELF::FATAL,
-    error: GELF::ERROR,
-    warn:  GELF::WARN,
-    info:  GELF::INFO,
-    debug: GELF::DEBUG,
-    trace: GELF::DEBUG
-  }
+  class LevelMap
+    attr_accessor :trace, :debug, :info, :warn, :error, :fatal
 
-  attr_reader :notifier
+    def initialize(trace: GELF::DEBUG, debug: GELF::DEBUG, info: GELF::INFO, warn: GELF::WARN, error: GELF::ERROR, fatal: GELF::FATAL)
+      @trace = trace
+      @debug = debug
+      @info  = info
+      @warn  = warn
+      @error = error
+      @fatal = fatal
+    end
+
+    def [](level)
+      public_send(level)
+    end
+  end
+
+  attr_accessor :url, :max_size, :gelf_options, :level_map
+  attr_reader :notifier, :server, :port, :protocol
 
   # Create Graylog log appender.
   #
@@ -46,6 +55,9 @@ class SemanticLogger::Appender::Graylog < SemanticLogger::Subscriber
   #     Max udp packet size. Ignored when protocol is :tcp
   #     Default: "WAN"
   #
+  #   gelf_options: [Hash]
+  #     Custom gelf options. See Graylog documentation.
+  #
   #   level: [:trace | :debug | :info | :warn | :error | :fatal]
   #     Override the log level for this appender.
   #     Default: SemanticLogger.default_level
@@ -68,46 +80,44 @@ class SemanticLogger::Appender::Graylog < SemanticLogger::Subscriber
   #   application: [String]
   #     Name of this application to appear in log messages.
   #     Default: SemanticLogger.application
-  def initialize(options = {}, &block)
-    options   = options.dup
-    @url      = options.delete(:url) || 'udp://localhost:12201'
-    @max_size = options.delete(:max_size) || 'WAN'
-
-    uri      = URI.parse(@url)
-    @server  = uri.host
-    @port    = uri.port
-    protocol = uri.scheme.to_sym
-
-    raise(ArgumentError, "Invalid protocol value: #{protocol}. Must be :udp or :tcp") unless [:udp, :tcp].include?(protocol)
+  def initialize(url: 'udp://localhost:12201', max_size: 'WAN', gelf_options: {}, level_map: LevelMap.new,
+    level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
 
-    options[:protocol] = protocol == :tcp ? GELF::Protocol::TCP : GELF::Protocol::UDP
+    @url          = url
+    @max_size     = max_size
+    @gelf_options = gelf_options
+    @level_map    = level_map.is_a?(LevelMap) ? level_map : LevelMap.new(level_map)
 
-    @gelf_options = options
-    options       = extract_subscriber_options!(options)
-
-    super(options, &block)
+    super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
     reopen
   end
 
   # Re-open after process fork
   def reopen
-    @gelf_options[:facility]        = application
-    @notifier                       = GELF::Notifier.new(@server, @port, @max_size, @gelf_options)
+    uri       = URI.parse(@url)
+    @server   = uri.host
+    @port     = uri.port
+    @protocol = uri.scheme.to_sym
+
+    raise(ArgumentError, "Invalid protocol value: #{@protocol}. Must be :udp or :tcp") unless [:udp, :tcp].include?(@protocol)
+
+    gelf_options[:protocol] ||= (@protocol == :tcp ? GELF::Protocol::TCP : GELF::Protocol::UDP)
+    gelf_options[:facility] ||= application
+
+    @notifier                       = GELF::Notifier.new(server, port, max_size, gelf_options)
     @notifier.collect_file_and_line = false
   end
 
   # Returns [Hash] of parameters to send
   def call(log, logger)
-    h = log.to_h(host, application)
+    h = SemanticLogger::Formatters::Raw.new.call(log, logger)
     h.delete(:time)
-    h.delete(:message) if log.message
 
-    short_message = log.message || log.exception.message
+    h[:short_message] = h.delete(:message) || log.exception.message
     h[:timestamp]     = log.time.utc.to_f
-    h[:level]         = logger.map_level(log)
+    h[:level]         = logger.level_map[log.level]
     h[:level_str]     = log.level.to_s
     h[:duration_str]  = h.delete(:duration)
-    h[:short_message] = short_message
     h
   end
 
@@ -115,13 +125,8 @@ class SemanticLogger::Appender::Graylog < SemanticLogger::Subscriber
   def log(log)
     return false unless should_log?(log)
 
-    @notifier.notify!(formatter.call(log, self))
+    notifier.notify!(formatter.call(log, self))
     true
   end
 
-  # Returns the Graylog level for the supplied log message
-  def map_level(log)
-    LEVEL_MAP[log.level]
-  end
-
 end

data/lib/semantic_logger/appender/honeybadger.rb

@@ -10,7 +10,7 @@ end
 #   SemanticLogger.add_appender(appender: :honeybadger)
 #
 class SemanticLogger::Appender::Honeybadger < SemanticLogger::Subscriber
-  # Create Appender
+  # Honeybadger Appender
   #
   # Parameters
   #   level: [:trace | :debug | :info | :warn | :error | :fatal]
@@ -35,10 +35,8 @@ class SemanticLogger::Appender::Honeybadger < 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 honeybadger

data/lib/semantic_logger/appender/http.rb

@@ -77,18 +77,17 @@ class SemanticLogger::Appender::Http < SemanticLogger::Subscriber
   #
   #   continue_timeout: [Float]
   #     Default: 1.0
-  def initialize(options, &block)
-    options           = options.dup
-    @url              = options.delete(:url)
-    @ssl_options      = options.delete(:ssl)
-    @username         = options.delete(:username)
-    @password         = options.delete(:password)
-    @compress         = options.delete(:compress) || false
-    @open_timeout     = options.delete(:open_timeout) || 2.0
-    @read_timeout     = options.delete(:read_timeout) || 1.0
-    @continue_timeout = options.delete(:continue_timeout) || 1.0
-
-    raise(ArgumentError, 'Missing mandatory parameter :url') unless @url
+  def initialize(url:, compress: false, ssl: {}, username: nil, password: nil, open_timeout: 2.0, read_timeout: 1.0, continue_timeout: 1.0,
+    level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+
+    @url              = url
+    @ssl_options      = ssl
+    @username         = username
+    @password         = password
+    @compress         = compress
+    @open_timeout     = open_timeout
+    @read_timeout     = read_timeout
+    @continue_timeout = continue_timeout
 
     @header                     = {
       'Accept'       => 'application/json',
@@ -111,7 +110,6 @@ class SemanticLogger::Appender::Http < SemanticLogger::Subscriber
     @path     = '/' if @path == ''
 
     if uri.scheme == 'https'
-      @ssl_options               ||= {}
       @ssl_options[:use_ssl]     = true
       @ssl_options[:verify_mode] ||= OpenSSL::SSL::VERIFY_PEER
       @port                      ||= HTTP.https_default_port
@@ -120,8 +118,7 @@ class SemanticLogger::Appender::Http < SemanticLogger::Subscriber
     end
     @http = nil
 
-    # Pass on the level and custom formatter if supplied
-    super(options)
+    super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
     reopen
   end
 

data/lib/semantic_logger/appender/kafka.rb

@@ -0,0 +1,183 @@
+begin
+  require 'kafka'
+rescue LoadError
+  raise 'Gem ruby-kafka is required for logging to Elasticsearch. Please add the gem "ruby-kafka" to your Gemfile.'
+end
+
+require 'date'
+
+# Forward all log messages to Apache Kafka.
+#
+# Example:
+#
+#   SemanticLogger.add_appender(
+#     appender: :kafka,
+#
+#     # At least one of these nodes must be available:
+#     seed_brokers: ["kafka1:9092", "kafka2:9092"],
+#
+#     # Set an optional client id in order to identify the client to Kafka:
+#     client_id: "my-application",
+#   )
+class SemanticLogger::Appender::Kafka < SemanticLogger::Subscriber
+  attr_accessor :seed_brokers, :client_id, :connect_timeout, :socket_timeout,
+    :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_key,
+    :delivery_threshold, :delivery_interval,
+    :topic, :partition, :partition_key, :key
+
+  # Send log messages to Kafka in JSON format.
+  #
+  # Kafka Parameters:
+  #
+  #   seed_brokers: [Array<String>, String]
+  #     The list of brokers used to initialize the client. Either an Array of connections,
+  #     or a comma separated string of connections.
+  #     Connections can either be a string of "port:protocol" or a full URI with a scheme.
+  #     If there's a scheme it's ignored and only host/port are used.
+  #
+  #   client_id: [String]
+  #     The identifier for this application.
+  #     Default: semantic-logger
+  #
+  #   topic: [String]
+  #     Topic to publish log messages to.
+  #     Default: 'log_messages'
+  #
+  #   partition: [Integer]
+  #     The partition that the message should be written to.
+  #     Default: nil
+  #
+  #   partition_key: [String]
+  #     The key that should be used to assign a partition.
+  #     Default: nil
+  #
+  #   key: [String]
+  #     The message key.
+  #     Default: nil
+  #
+  #   connect_timeout: [Integer]
+  #     The timeout setting for connecting to brokers.
+  #     Default: nil
+  #
+  #   socket_timeout: [Integer]
+  #     The timeout setting for socket connections.
+  #     Default: nil
+  #
+  #   ssl_ca_cert: [String, Array<String>]
+  #     A PEM encoded CA cert, or an Array of PEM encoded CA certs, to use with a SSL connection.
+  #     Default: nil
+  #
+  #   ssl_client_cert: [String]
+  #     A PEM encoded client cert to use with a SSL connection.
+  #     Must be used in combination with ssl_client_cert_key.
+  #     Default: nil
+  #
+  #   ssl_client_cert_key [String]
+  #     A PEM encoded client cert key to use with a SSL connection.
+  #     Must be used in combination with ssl_client_cert.
+  #     Default: nil
+  #
+  #    delivery_threshold: [Integer]
+  #      Number of messages between triggering a delivery of messages to Apache Kafka.
+  #      Default: 100
+  #
+  #    delivery_interval: [Integer]
+  #      Number of seconds between triggering a delivery of messages to Apache Kafka.
+  #      Default: 5
+  #
+  # Semantic Logger Parameters:
+  #
+  #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+  #     Override the log level for this appender.
+  #     Default: SemanticLogger.default_level
+  #
+  #   formatter: [Object|Proc|Symbol|Hash]
+  #     An instance of a class that implements #call, or a Proc to be used to format
+  #     the output from this appender
+  #     Default: :raw_json (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.
+  #
+  #   host: [String]
+  #     Name of this host to appear in log messages.
+  #     Default: SemanticLogger.host
+  #
+  #   application: [String]
+  #     Name of this application to appear in log messages.
+  #     Default: SemanticLogger.application
+  def initialize(seed_brokers:, client_id: 'semantic-logger', connect_timeout: nil, socket_timeout: nil,
+    ssl_ca_cert: nil, ssl_client_cert: nil, ssl_client_cert_key: nil,
+    topic: 'log_messages', partition: nil, partition_key: nil, key: nil,
+    delivery_threshold: 100, delivery_interval: 10,
+    level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+
+    @seed_brokers        = seed_brokers
+    @client_id           = @client_id
+    @connect_timeout     = connect_timeout
+    @socket_timeout      = socket_timeout
+    @ssl_ca_cert         = ssl_ca_cert
+    @ssl_client_cert     = ssl_client_cert
+    @ssl_client_cert_key = ssl_client_cert_key
+    @topic               = topic
+    @partition           = partition
+    @partition_key       = partition_key
+    @key                 = key
+    @delivery_threshold  = delivery_threshold
+    @delivery_interval   = delivery_interval
+
+    super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+    reopen
+  end
+
+  def reopen
+    @kafka = ::Kafka.new(
+      seed_brokers:        seed_brokers,
+      client_id:           client_id,
+      connect_timeout:     connect_timeout,
+      socket_timeout:      socket_timeout,
+      ssl_ca_cert:         ssl_ca_cert,
+      ssl_client_cert:     ssl_client_cert,
+      ssl_client_cert_key: ssl_client_cert_key,
+      logger:              SemanticLogger::Processor.logger.clone
+    )
+
+    @producer = @kafka.async_producer(
+      delivery_threshold: delivery_threshold,
+      delivery_interval:  delivery_interval
+    )
+  end
+
+  def close
+    @producer.shutdown if @producer
+    @producer = nil
+    @kafka.close if @kafka
+    @kafka = nil
+  end
+
+  # Forward log messages to Kafka producer thread.
+  def log(log)
+    return false unless should_log?(log)
+
+    json = formatter.call(log, self)
+    @producer.produce(json, topic: topic, partition: partition, partition_key: partition_key, key: key)
+  end
+
+  # Use JSON Formatter by default.
+  def default_formatter
+    SemanticLogger::Formatters::Json.new
+  end
+
+  # Restart producer thread since there is no other way to flush.
+  def flush
+    @producer.shutdown
+    @producer = @kafka.async_producer(
+      delivery_threshold: delivery_threshold,
+      delivery_interval:  delivery_interval
+    )
+  end
+
+end

data/lib/semantic_logger/appender/mongodb.rb

@@ -104,7 +104,8 @@ module SemanticLogger
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
       def initialize(uri:, collection_name: 'semantic_logger', write_concern: 0, collection_size: 1024**3, collection_max: nil,
-        level: nil, formatter: nil, filter: nil, host: SemanticLogger.host, application: SemanticLogger.application, &block)
+        level: nil, formatter: nil, filter: nil, host: nil, application: nil, &block)
+
         @client          = Mongo::Client.new(uri, logger: SemanticLogger::Processor.logger.clone)
         @collection_name = collection_name
         @options         = {
@@ -119,8 +120,7 @@ module SemanticLogger
         # Create the collection and necessary indexes
         create_indexes
 
-        # Set the log level and formatter
-        super(level: level, formatter: formatter, filter: filter, host: host, application: application, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
       end
 
       # After forking an active process call #reopen to re-open