semantic_logger 4.3.1 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 285869f2b402ea378eab2606d3d72f7b7be3db56102bea2c530a98411a077d6c
-  data.tar.gz: cab30b7d7bcfda6083716a530aeedf20192b1fa1c3a83c7cb237d475516d0ca7
+  metadata.gz: 88a1f36f6ef4d857e13b696e283f6bbd643329a0ca7f3fd9ac4c9ef1e670aaae
+  data.tar.gz: 01a175a96d750f9692bb28512d914434e442336c68eadd9f7b9f409a4d2f4a2b
 SHA512:
-  metadata.gz: e67d39bfbedb72f64b191f75d5786f521d311d78fb243bb97cbfa948333fcfa21f89ebcfa6a9ac34696a24c359bd8b67a9617228a25a1958bbf3092ed6324472
-  data.tar.gz: c446a8410247e2b8393f401182f0bc1a266d329ce1190328a3f7253bf5b64273c87c5db05a4bb4f808caf9435b0e8a8d2a37a69c9ac245b43f3215f67f1f9710
+  metadata.gz: e06dd57a7ee95bfc5aea5d4b2948101a1fbdb00dd76ac1b9ac0b68a4a3f666670b227d559451d4137e510d1c63b9ec9bd8f99326bfe765f9a610294221c2259f
+  data.tar.gz: 0e2b66a5da5f5e2d21c185555f3502e7982d8d197ec9bade63092acae1750dcf1d8191de71dc8fbe0598d844b2c5f85931c407030a599260f41ad35470802a14

data/lib/semantic_logger.rb

@@ -1,14 +1,15 @@
 require 'semantic_logger/core_ext/thread'
 require 'semantic_logger/version'
-require 'semantic_logger/semantic_logger'
 
 # @formatter:off
 module SemanticLogger
   autoload :AnsiColors,         'semantic_logger/ansi_colors'
   autoload :Appender,           'semantic_logger/appender'
+  autoload :Appenders,          'semantic_logger/appenders'
   autoload :Base,               'semantic_logger/base'
   autoload :DebugAsTraceLogger, 'semantic_logger/debug_as_trace_logger'
   autoload :Formatters,         'semantic_logger/formatters'
+  autoload :Levels,             'semantic_logger/levels'
   autoload :Log,                'semantic_logger/log'
   autoload :Logger,             'semantic_logger/logger'
   autoload :Loggable,           'semantic_logger/loggable'
@@ -26,12 +27,17 @@ module SemanticLogger
     autoload :Statsd,            'semantic_logger/metric/statsd'
   end
 
+  module Reporters
+    autoload :Minitest,          'semantic_logger/reporters/minitest'
+  end
+
   if defined?(JRuby)
     module JRuby
       autoload :GarbageCollectionLogger, 'semantic_logger/jruby/garbage_collection_logger'
     end
   end
 end
+require 'semantic_logger/semantic_logger'
 # @formatter:on
 
 # Flush all appenders at exit, waiting for outstanding messages on the queue

data/lib/semantic_logger/appender.rb

@@ -14,6 +14,7 @@ module SemanticLogger
     autoload :Http,              'semantic_logger/appender/http'
     autoload :MongoDB,           'semantic_logger/appender/mongodb'
     autoload :NewRelic,          'semantic_logger/appender/new_relic'
+    autoload :Rabbitmq,          'semantic_logger/appender/rabbitmq'
     autoload :Splunk,            'semantic_logger/appender/splunk'
     autoload :SplunkHttp,        'semantic_logger/appender/splunk_http'
     autoload :Syslog,            'semantic_logger/appender/syslog'
@@ -56,6 +57,8 @@ module SemanticLogger
       elsif async == true
         proxy_options[:appender] = appender
         Appender::Async.new(proxy_options)
+
+
       else
         appender
       end

data/lib/semantic_logger/appender/async.rb

@@ -6,8 +6,8 @@ module SemanticLogger
     class Async
       extend Forwardable
 
-      attr_accessor :logger, :lag_check_interval, :lag_threshold_s
-      attr_reader :queue, :appender
+      attr_accessor :lag_check_interval, :lag_threshold_s
+      attr_reader :queue, :appender, :max_queue_size
 
       # Forward methods that can be called directly
       def_delegator :@appender, :name
@@ -18,6 +18,7 @@ module SemanticLogger
       def_delegator :@appender, :level
       def_delegator :@appender, :level=
       def_delegator :@appender, :logger
+      def_delegator :@appender, :logger=
 
       # Appender proxy to allow an existing appender to run asynchronously in a separate thread.
       #
@@ -43,17 +44,24 @@ module SemanticLogger
         @lag_check_interval = lag_check_interval
         @lag_threshold_s    = lag_threshold_s
         @thread             = nil
-
-        if max_queue_size == -1
-          @queue  = Queue.new
-          @capped = false
-        else
-          @queue  = SizedQueue.new(max_queue_size)
-          @capped = true
-        end
+        @max_queue_size     = max_queue_size
+        create_queue
         thread
       end
 
+      # Re-open appender after a fork
+      def reopen
+        # Workaround CRuby crash on fork by recreating queue on reopen
+        #   https://github.com/rocketjob/semantic_logger/issues/103
+        @queue&.close
+        create_queue
+
+        appender.reopen if appender.respond_to?(:reopen)
+
+        @thread.kill if @thread&.alive?
+        @thread = Thread.new { process }
+      end
+
       # Returns [true|false] if the queue has a capped size.
       def capped?
         @capped
@@ -91,6 +99,16 @@ module SemanticLogger
 
       private
 
+      def create_queue
+        if max_queue_size == -1
+          @queue  = Queue.new
+          @capped = false
+        else
+          @queue  = SizedQueue.new(max_queue_size)
+          @capped = true
+        end
+      end
+
       # Separate thread for batching up log messages before writing.
       def process
         # This thread is designed to never go down unless the main thread terminates
@@ -140,6 +158,7 @@ module SemanticLogger
             break unless process_message(message)
           end
         end
+        logger.trace 'Async: Queue Closed'
       end
 
       # Returns false when message processing should be stopped

data/lib/semantic_logger/appender/rabbitmq.rb

@@ -0,0 +1,120 @@
+begin
+  require 'bunny'
+rescue LoadError
+  raise 'Gem bunny is required for logging to RabbitMQ. Please add the gem "bunny" to your Gemfile.'
+end
+
+# Forward all log messages to RabbitMQ.
+#
+# Example:
+#
+#   SemanticLogger.add_appender(
+#     appender: :rabbitmq,
+#
+#     # Name of the queue in RabbitMQ where to publish the logs. This queue will be bound to "amqp.direct" exchange.
+#     queue: 'semantic_logger',
+#
+#     # This host will be used for RabbitMQ connection. 
+#     # NOTE this is different than :host option which is used by the logger directly.
+#     rabbitmq_host: '127.0.0.1',
+#
+#     # RabbitMQ credentials
+#     username: 'my-username',
+#     password: 'my-secrect-pass',
+#
+#     # All other options accepted by Bunny.new call
+#     vhost: 'production',
+#   )
+module SemanticLogger
+  module Appender
+    class Rabbitmq < SemanticLogger::Subscriber
+      # Create RabbitMQ appender using Bunny gem
+      #
+      # Parameters:
+      #
+      #   queue_name: [String]
+      #     Name of RabbitMQ queue where to stream logs to.
+      #     This will be a queue bound to AMQP Default exchange
+      #     Default: semantic_logger
+      #
+      #   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: :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
+      #
+      # RabbitMQ Parameters:
+      #
+      #   rabbitmq_host: [String]
+      #     Host for AMQP connection. in Bunny this is called :host but here it has 
+      #     been remapped to avoid conflicting with SemanticLogger's :host param.
+      #     Default: localhost
+      #
+      #   username: [String]
+      #     Username for AMQP connection
+      #     Default: nil
+      #
+      #   password: [String]
+      #     Password for AMQP connection
+      #     Default: nil
+      #
+      #   more parameters supported by Bunny: http://rubybunny.info/articles/connecting.html
+      def initialize(queue_name: 'semantic_logger', rabbitmq_host: nil, metrics: false, **args, &block)
+        @queue_name             = queue_name
+        @rabbitmq_args          = args.dup
+        @rabbitmq_args[:host]   = rabbitmq_host
+        @rabbitmq_args[:logger] = logger
+
+        super(level: level, formatter: formatter, filter: filter, application: application, host: host, metrics: metrics, &block)
+        reopen
+      end
+
+      def reopen
+        @connection = Bunny.new(@rabbitmq_args)
+        @connection.start
+        @channel = @connection.create_channel
+      end
+
+      def close
+        @channel&.close
+        @channel = nil
+        @connection&.close
+        @connection = nil
+      end
+
+      def log(log)
+        queue.publish(formatter.call(log, self))
+      end
+
+      def flush
+        # NOOP
+      end
+
+      # Use JSON Formatter by default.
+      def default_formatter
+        SemanticLogger::Formatters::Json.new
+      end
+
+      def queue
+        @queue ||= @channel.queue(@queue_name)
+      end
+    end
+  end
+end

data/lib/semantic_logger/appenders.rb

@@ -0,0 +1,89 @@
+module SemanticLogger
+  # Manage a collection of appenders.
+  class Appenders < Concurrent::Array
+    attr_accessor :logger
+
+    def initialize(logger = Processor.logger.dup)
+      @logger      = logger
+      @logger.name = self.class.name
+    end
+
+    def add(options, deprecated_level = nil, &block)
+      options  = options.is_a?(Hash) ? options.dup : convert_old_appender_args(options, deprecated_level)
+      appender = SemanticLogger::Appender.factory(options, &block)
+      self << appender
+      appender
+    end
+
+    def log(log)
+      each do |appender|
+        begin
+          appender.log(log) if appender.should_log?(log)
+        rescue Exception => exc
+          logger.error "Failed to log to appender: #{appender.inspect}", exc
+        end
+      end
+    end
+
+    def flush
+      each do |appender|
+        begin
+          logger.trace "Flushing appender: #{appender.name}"
+          appender.flush
+        rescue Exception => exc
+          logger.error "Failed to flush appender: #{appender.inspect}", exc
+        end
+      end
+      logger.trace 'All appenders flushed'
+    end
+
+    def close
+      each do |appender|
+        begin
+          logger.trace "Closing appender: #{appender.name}"
+          appender.flush
+          appender.close
+          appenders.delete(appender)
+        rescue Exception => exc
+          logger.error "Failed to close appender: #{appender.inspect}", exc
+        end
+      end
+      logger.trace 'All appenders closed and removed from appender list'
+    end
+
+    # After a fork the appender thread is not running, start it if it is not running.
+    def reopen
+      each do |appender|
+        begin
+          next unless appender.respond_to?(:reopen)
+
+          logger.trace "Reopening appender: #{appender.name}"
+          appender.reopen
+        rescue Exception => exc
+          logger.error "Failed to re-open appender: #{appender.inspect}", exc
+        end
+      end
+      logger.trace 'All appenders re-opened'
+    end
+
+    private
+
+    # Backward compatibility
+    def convert_old_appender_args(appender, level)
+      options         = {}
+      options[:level] = level if level
+
+      if appender.is_a?(String)
+        options[:file_name] = appender
+      elsif appender.is_a?(IO)
+        options[:io] = appender
+      elsif appender.is_a?(Symbol) || appender.is_a?(Subscriber)
+        options[:appender] = appender
+      else
+        options[:logger] = appender
+      end
+      warn "[DEPRECATED] SemanticLogger.add_appender parameters have changed. Please use: #{options.inspect}"
+      options
+    end
+  end
+end

data/lib/semantic_logger/base.rb

@@ -23,8 +23,8 @@ module SemanticLogger
         @level_index = nil
         @level       = nil
       else
-        @level_index = SemanticLogger.send(:level_to_index, level)
-        @level       = SemanticLogger.send(:index_to_level, @level_index)
+        @level_index = Levels.index(level)
+        @level       = Levels.level(@level_index)
       end
     end
 
@@ -112,7 +112,7 @@ module SemanticLogger
 
     # Dynamically supply the log level with every measurement call
     def measure(level, message, params = {}, &block)
-      index = SemanticLogger.level_to_index(level)
+      index = Levels.index(level)
       if level_index <= index
         measure_internal(level, index, message, params, &block)
       elsif block

data/lib/semantic_logger/concerns/compatibility.rb

@@ -38,9 +38,9 @@ module SemanticLogger
 
       # :nodoc:
       def add(severity, message = nil, progname = nil, &block)
-        index = SemanticLogger.send(:level_to_index, severity)
+        index = Levels.index(severity)
         if level_index <= index
-          level = SemanticLogger.send(:index_to_level, index)
+          level = Levels.level(index)
           log_internal(level, index, message, progname, &block)
           true
         else

data/lib/semantic_logger/formatters.rb

@@ -9,6 +9,7 @@ module SemanticLogger
     autoload :OneLine,          'semantic_logger/formatters/one_line'
     autoload :Signalfx,         'semantic_logger/formatters/signalfx'
     autoload :Syslog,           'semantic_logger/formatters/syslog'
+    autoload :Fluentd,          'semantic_logger/formatters/fluentd'
     # @formatter:on
 
     # Return formatter that responds to call.

data/lib/semantic_logger/formatters/base.rb

@@ -2,7 +2,7 @@ require 'time'
 module SemanticLogger
   module Formatters
     class Base
-      attr_accessor :time_format, :log_host, :log_application
+      attr_accessor :time_format, :log_host, :log_application, :precision
 
       # Time precision varies by Ruby interpreter
       # JRuby 9.1.8.0 supports microseconds
@@ -17,7 +17,6 @@ module SemanticLogger
         else
           6
         end
-      TIME_FORMAT = "%Y-%m-%d %H:%M:%S.%#{PRECISION}N".freeze
 
       # Parameters
       #   time_format: [String|Symbol|nil]
@@ -25,11 +24,32 @@ module SemanticLogger
       #     :iso_8601 Outputs an ISO8601 Formatted timestamp.
       #     :ms       Output in miliseconds since epoch.
       #     nil:      Returns Empty string for time ( no time is output ).
-      #     Default: '%Y-%m-%d %H:%M:%S.%6N'
-      def initialize(time_format: TIME_FORMAT, log_host: true, log_application: true)
-        @time_format     = time_format
+      #     Default: '%Y-%m-%d %H:%M:%S.%<precision>N'
+      #   log_host: [Boolean]
+      #     Whether or not to include hostname in logs
+      #     Default: true
+      #   log_application: [Boolean]
+      #     Whether or not to include application name in logs
+      #     Default: true
+      #   precision: [Integer]
+      #     How many fractional digits to log times with.
+      #     Default: PRECISION (6, except on older JRuby, where 3)
+      def initialize(time_format: nil, log_host: true, log_application: true,
+                     precision: PRECISION)
+        @time_format     = time_format || self.class.build_time_format(precision)
         @log_host        = log_host
         @log_application = log_application
+        @precision       = precision
+      end
+
+      # Return default time format string
+      #
+      # Parameters
+      #   precision: [Integer]
+      #     How many fractional digits to log times with.
+      #     Default: PRECISION (6, except on older JRuby, where 3)
+      def self.build_time_format(precision=PRECISION)
+        "%Y-%m-%d %H:%M:%S.%#{precision}N"
       end
 
       # Date & time
@@ -42,8 +62,10 @@ module SemanticLogger
       # Return the Time as a formatted string
       def format_time(time)
         case time_format
+        when :rfc_3339
+          time.utc.to_datetime.rfc3339
         when :iso_8601
-          time.utc.iso8601(PRECISION)
+          time.utc.iso8601(precision)
         when :ms
           (time.to_f * 1_000).to_i
         when :none