semantic_logger 4.6.1 → 4.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22f95d79aaeb38befe2e1c242063464be93f05d16eed7cf17540256c1064f7b2
-  data.tar.gz: 2ae7b4e00a4415c88d66afd552c4fa03e68dcf2d354994bfe98621d0e08bcdd0
+  metadata.gz: 0d3b45427759ee16967074aada7eb8dade063d1705172fd8a082de9bb12e1aaf
+  data.tar.gz: 4db9de710bf8b713a61903a16bde0e436f603de1fa017a410cfebaac00f8a245
 SHA512:
-  metadata.gz: bc5bd0ce964de270119c5ef3bcab46c8178eb7120c5ad76afd99c0f5c1acbe4d7011eaf88c4d983e943d1e25f09baffd803121cba5a580be168ac874f09e539e
-  data.tar.gz: 0e64868d3f9363007114fce5c10ced420282edd098816df92e60da755c380434fe42075b5be3ebcb8ca03ff2b8746681a30317e33b88563bd2e3af5579ad9b4f
+  metadata.gz: 9a7e25591485879924fe5f438a6d0266bd5b590dfcd45cc7a6810e3b679a94eef066e23b3ebc1fe51f2f91f3dbbbdbb681ebeef8292188e7917872202cd178b6
+  data.tar.gz: 1e74f739dc87c03a41cd1e1a3df7d1d62c36ea175ee93817b21fc7f3039ddde1c4a25dfff8caecfa20a182f2e7c222c76f52d5dbf7a0dc10dfce009206d55726

data/Rakefile

@@ -1,22 +1,22 @@
-require 'rake/clean'
-require 'rake/testtask'
+require "rake/clean"
+require "rake/testtask"
 
-$LOAD_PATH.unshift File.expand_path('lib', __dir__)
-require 'semantic_logger/version'
+$LOAD_PATH.unshift File.expand_path("lib", __dir__)
+require "semantic_logger/version"
 
 task :gem do
-  system 'gem build semantic_logger.gemspec'
+  system "gem build semantic_logger.gemspec"
 end
 
 task publish: :gem do
   system "git tag -a v#{SemanticLogger::VERSION} -m 'Tagging #{SemanticLogger::VERSION}'"
-  system 'git push --tags'
+  system "git push --tags"
   system "gem push semantic_logger-#{SemanticLogger::VERSION}.gem"
   system "rm semantic_logger-#{SemanticLogger::VERSION}.gem"
 end
 
 Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
+  t.pattern = "test/**/*_test.rb"
   t.verbose = true
   t.warning = false
 end

data/lib/semantic_logger.rb

@@ -1,43 +1,44 @@
-require 'semantic_logger/core_ext/thread'
-require 'semantic_logger/version'
+require "semantic_logger/core_ext/thread"
+require "semantic_logger/version"
 
 # @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'
-  autoload :Processor,          'semantic_logger/processor'
-  autoload :Subscriber,         'semantic_logger/subscriber'
-  autoload :Utils,              'semantic_logger/utils'
+  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"
+  autoload :Processor,          "semantic_logger/processor"
+  autoload :Subscriber,         "semantic_logger/subscriber"
+  autoload :SyncProcessor,      "semantic_logger/sync_processor"
+  autoload :Utils,              "semantic_logger/utils"
 
   module Concerns
-    autoload :Compatibility,    'semantic_logger/concerns/compatibility'
+    autoload :Compatibility, "semantic_logger/concerns/compatibility"
   end
 
   module Metric
-    autoload :NewRelic,          'semantic_logger/metric/new_relic'
-    autoload :Signalfx,          'semantic_logger/metric/signalfx'
-    autoload :Statsd,            'semantic_logger/metric/statsd'
+    autoload :NewRelic,          "semantic_logger/metric/new_relic"
+    autoload :Signalfx,          "semantic_logger/metric/signalfx"
+    autoload :Statsd,            "semantic_logger/metric/statsd"
   end
 
   module Reporters
-    autoload :Minitest,          'semantic_logger/reporters/minitest'
+    autoload :Minitest,          "semantic_logger/reporters/minitest"
   end
 
   if defined?(JRuby)
     module JRuby
-      autoload :GarbageCollectionLogger, 'semantic_logger/jruby/garbage_collection_logger'
+      autoload :GarbageCollectionLogger, "semantic_logger/jruby/garbage_collection_logger"
     end
   end
 end
-require 'semantic_logger/semantic_logger'
+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

@@ -1,47 +1,46 @@
 module SemanticLogger
   module Appender
     # @formatter:off
-    autoload :Async,             'semantic_logger/appender/async'
-    autoload :AsyncBatch,        'semantic_logger/appender/async_batch'
-    autoload :Bugsnag,           'semantic_logger/appender/bugsnag'
-    autoload :Elasticsearch,     'semantic_logger/appender/elasticsearch'
-    autoload :ElasticsearchHttp, 'semantic_logger/appender/elasticsearch_http'
-    autoload :File,              'semantic_logger/appender/file'
-    autoload :Graylog,           'semantic_logger/appender/graylog'
-    autoload :Honeybadger,       'semantic_logger/appender/honeybadger'
-    autoload :Kafka,             'semantic_logger/appender/kafka'
-    autoload :Sentry,            'semantic_logger/appender/sentry'
-    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'
-    autoload :Tcp,               'semantic_logger/appender/tcp'
-    autoload :Udp,               'semantic_logger/appender/udp'
-    autoload :Wrapper,           'semantic_logger/appender/wrapper'
+    autoload :Async,             "semantic_logger/appender/async"
+    autoload :AsyncBatch,        "semantic_logger/appender/async_batch"
+    autoload :Bugsnag,           "semantic_logger/appender/bugsnag"
+    autoload :Elasticsearch,     "semantic_logger/appender/elasticsearch"
+    autoload :ElasticsearchHttp, "semantic_logger/appender/elasticsearch_http"
+    autoload :File,              "semantic_logger/appender/file"
+    autoload :Graylog,           "semantic_logger/appender/graylog"
+    autoload :Honeybadger,       "semantic_logger/appender/honeybadger"
+    autoload :Kafka,             "semantic_logger/appender/kafka"
+    autoload :Sentry,            "semantic_logger/appender/sentry"
+    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"
+    autoload :Tcp,               "semantic_logger/appender/tcp"
+    autoload :Udp,               "semantic_logger/appender/udp"
+    autoload :Wrapper,           "semantic_logger/appender/wrapper"
     # @formatter:on
 
     # Returns [SemanticLogger::Subscriber] appender for the supplied options
     def self.factory(async: false, batch: nil,
-      max_queue_size: 10_000, lag_check_interval: 1_000, lag_threshold_s: 30,
-      batch_size: 300, batch_seconds: 5,
-      **args,
-      &block
-    )
+                     max_queue_size: 10_000, lag_check_interval: 1_000, lag_threshold_s: 30,
+                     batch_size: 300, batch_seconds: 5,
+                     **args,
+                     &block)
       appender = build(**args, &block)
 
       # If appender implements #batch, then it should use the batch proxy by default.
-      batch    = true if batch.nil? && appender.respond_to?(:batch)
+      batch = true if batch.nil? && appender.respond_to?(:batch)
 
       if batch == true
         Appender::AsyncBatch.new(
-          appender:           appender,
-          max_queue_size:     max_queue_size,
-          lag_threshold_s:    lag_threshold_s,
-          batch_size:         batch_size,
-          batch_seconds:      batch_seconds
+          appender:        appender,
+          max_queue_size:  max_queue_size,
+          lag_threshold_s: lag_threshold_s,
+          batch_size:      batch_size,
+          batch_seconds:   batch_seconds
         )
       elsif async == true
         Appender::Async.new(
@@ -71,14 +70,14 @@ module SemanticLogger
         end
       elsif metric
         if metric.is_a?(Symbol)
-          SemanticLogger::Utils.constantize_symbol(metric, 'SemanticLogger::Metric').new(**args)
+          SemanticLogger::Utils.constantize_symbol(metric, "SemanticLogger::Metric").new(**args)
         elsif metric.is_a?(Subscriber)
           metric
         else
           raise(ArgumentError, "Parameter :metric must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
         end
       else
-        raise(ArgumentError, 'To create an appender it must supply one of the following: :io, :file_name, :appender, :metric, or :logger')
+        raise(ArgumentError, "To create an appender it must supply one of the following: :io, :file_name, :appender, :metric, or :logger")
       end
     end
 

data/lib/semantic_logger/appender/async.rb

@@ -1,4 +1,4 @@
-require 'forwardable'
+require "forwardable"
 
 module SemanticLogger
   module Appender
@@ -73,6 +73,7 @@ module SemanticLogger
       # Starts the worker thread if not running.
       def thread
         return @thread if @thread&.alive?
+
         @thread = Thread.new { process }
       end
 
@@ -115,21 +116,21 @@ module SemanticLogger
         # This thread is designed to never go down unless the main thread terminates
         # or the appender is closed.
         Thread.current.name = logger.name
-        logger.trace 'Async: Appender thread active'
+        logger.trace "Async: Appender thread active"
         begin
           process_messages
-        rescue StandardError => exception
+        rescue StandardError => e
           # This block may be called after the file handles have been released by Ruby
           begin
-            logger.error('Async: Restarting due to exception', exception)
+            logger.error("Async: Restarting due to exception", e)
           rescue StandardError
             nil
           end
           retry
-        rescue Exception => exception
+        rescue Exception => e
           # This block may be called after the file handles have been released by Ruby
           begin
-            logger.error('Async: Stopping due to fatal exception', exception)
+            logger.error("Async: Stopping due to fatal exception", e)
           rescue StandardError
             nil
           end
@@ -137,7 +138,7 @@ module SemanticLogger
           @thread = nil
           # This block may be called after the file handles have been released by Ruby
           begin
-            logger.trace('Async: Thread has stopped')
+            logger.trace("Async: Thread has stopped")
           rescue StandardError
             nil
           end
@@ -159,7 +160,7 @@ module SemanticLogger
             break unless process_message(message)
           end
         end
-        logger.trace 'Async: Queue Closed'
+        logger.trace "Async: Queue Closed"
       end
 
       # Returns false when message processing should be stopped

data/lib/semantic_logger/appender/async_batch.rb

@@ -1,4 +1,4 @@
-require 'concurrent'
+require "concurrent"
 
 module SemanticLogger
   module Appender
@@ -42,7 +42,9 @@ module SemanticLogger
           lag_threshold_s: lag_threshold_s
         )
 
-        raise(ArgumentError, "#{appender.class.name} does not support batching. It must implement #batch") unless appender.respond_to?(:batch)
+        unless appender.respond_to?(:batch)
+          raise(ArgumentError, "#{appender.class.name} does not support batching. It must implement #batch")
+        end
       end
 
       # Add log message for processing.

data/lib/semantic_logger/appender/bugsnag.rb

@@ -1,7 +1,7 @@
 begin
-  require 'bugsnag'
+  require "bugsnag"
 rescue LoadError
-  raise LoadError.new('Gem bugsnag is required for logging purposes. Please add the gem "bugsnag" to your Gemfile.')
+  raise LoadError, 'Gem bugsnag is required for logging purposes. Please add the gem "bugsnag" to your Gemfile.'
 end
 
 # Send log messages to Bugsnag
@@ -30,7 +30,7 @@ module SemanticLogger
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
       def initialize(level: :error, **args, &block)
-        raise 'Bugsnag only supports :info, :warn, or :error log levels' unless %i[info warn error fatal].include?(level)
+        raise "Bugsnag only supports :info, :warn, or :error log levels" unless %i[info warn error fatal].include?(level)
 
         # Replace the Bugsnag logger so that we can identify its log messages and not forward them to Bugsnag
         ::Bugsnag.configure { |config| config.logger = SemanticLogger[Bugsnag] }
@@ -51,7 +51,7 @@ module SemanticLogger
       # Send an error notification to Bugsnag
       def log(log)
         # Ignore logs coming from Bugsnag itself
-        return false if log.name == 'Bugsnag'
+        return false if log.name == "Bugsnag"
 
         # Send error messages as Runtime exceptions
         exception =
@@ -77,11 +77,11 @@ module SemanticLogger
       def log_level(log)
         case log.level
         when :error, :fatal
-          'error'
+          "error"
         when :warn
-          'warning'
+          "warning"
         else
-          'info'
+          "info"
         end
       end
     end

data/lib/semantic_logger/appender/elasticsearch.rb

@@ -1,10 +1,10 @@
 begin
-  require 'elasticsearch'
+  require "elasticsearch"
 rescue LoadError
-  raise LoadError.new('Gem elasticsearch is required for logging to Elasticsearch. Please add the gem "elasticsearch" to your Gemfile.')
+  raise LoadError, 'Gem elasticsearch is required for logging to Elasticsearch. Please add the gem "elasticsearch" to your Gemfile.'
 end
 
-require 'date'
+require "date"
 
 # Forward all log messages to Elasticsearch.
 #
@@ -123,10 +123,10 @@ module SemanticLogger
       #   send_get_body_as [String]
       #     Specify the HTTP method to use for GET requests with a body.
       #     Default: 'GET'
-      def initialize(url: 'http://localhost:9200',
-                     index: 'semantic_logger',
-                     date_pattern: '%Y.%m.%d',
-                     type: 'log',
+      def initialize(url: "http://localhost:9200",
+                     index: "semantic_logger",
+                     date_pattern: "%Y.%m.%d",
+                     type: "log",
                      level: nil,
                      formatter: nil,
                      filter: nil,
@@ -174,15 +174,15 @@ module SemanticLogger
 
       def write_to_elasticsearch(messages)
         bulk_result = @client.bulk(body: messages)
-        return unless bulk_result['errors']
+        return unless bulk_result["errors"]
 
-        failed = bulk_result['items'].reject { |x| x['status'] == 201 }
+        failed = bulk_result["items"].reject { |x| x["status"] == 201 }
         logger.error("ElasticSearch: Write failed. Messages discarded. : #{failed}")
       end
 
       def bulk_index(log)
         expanded_index_name = log.time.strftime("#{index}-#{date_pattern}")
-        {'index' => {'_index' => expanded_index_name, '_type' => type}}
+        {"index" => {"_index" => expanded_index_name, "_type" => type}}
       end
 
       def default_formatter

data/lib/semantic_logger/appender/elasticsearch_http.rb

@@ -1,4 +1,4 @@
-require 'date'
+require "date"
 # Forward all log messages to Elasticsearch one at a time via a HTTP post.
 #
 # Note:
@@ -50,9 +50,9 @@ module SemanticLogger
       #   application: [String]
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
-      def initialize(index: 'semantic_logger',
-                     type: 'log',
-                     url: 'http://localhost:9200',
+      def initialize(index: "semantic_logger",
+                     type: "log",
+                     url: "http://localhost:9200",
                      **http_args,
                      &block)
 

data/lib/semantic_logger/appender/file.rb

@@ -64,7 +64,8 @@ module SemanticLogger
           @log = io
         else
           @file_name = file_name
-          raise 'SemanticLogging::Appender::File missing mandatory parameter :file_name or :io' unless file_name
+          raise "SemanticLogging::Appender::File missing mandatory parameter :file_name or :io" unless file_name
+
           reopen
         end
 

data/lib/semantic_logger/appender/graylog.rb

@@ -1,8 +1,8 @@
-require 'uri'
+require "uri"
 begin
-  require 'gelf'
+  require "gelf"
 rescue LoadError
-  raise LoadError.new('Gem gelf is required for logging to Graylog. Please add the gem "gelf" to your Gemfile.')
+  raise LoadError, 'Gem gelf is required for logging to Graylog. Please add the gem "gelf" to your Gemfile.'
 end
 
 # Forward log entries to a Graylog server.
@@ -82,8 +82,8 @@ module SemanticLogger
       #   application: [String]
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
-      def initialize(url: 'udp://localhost:12201',
-                     max_size: 'WAN',
+      def initialize(url: "udp://localhost:12201",
+                     max_size: "WAN",
                      gelf_options: {},
                      level_map: LevelMap.new,
                      **args,
@@ -105,7 +105,9 @@ module SemanticLogger
         @port     = uri.port
         @protocol = uri.scheme.to_sym
 
-        raise(ArgumentError, "Invalid protocol value: #{@protocol}. Must be :udp or :tcp") unless %i[udp tcp].include?(@protocol)
+        unless %i[udp tcp].include?(@protocol)
+          raise(ArgumentError, "Invalid protocol value: #{@protocol}. Must be :udp or :tcp")
+        end
 
         gelf_options[:protocol] ||= (@protocol == :tcp ? GELF::Protocol::TCP : GELF::Protocol::UDP)
         gelf_options[:facility] ||= application
@@ -120,11 +122,11 @@ module SemanticLogger
 
         h[:short_message] = h.delete(:message)
         if h[:short_message].nil?
-          h[:short_message] = log.exception.nil?  ? '<no-exception-message>' : log.exception.message
+          h[:short_message] = log.exception.nil? ? "<no-exception-message>" : log.exception.message
         end
-        h[:level]         = logger.level_map[log.level]
-        h[:level_str]     = log.level.to_s
-        h[:duration_str]  = h.delete(:duration)
+        h[:level]        = logger.level_map[log.level]
+        h[:level_str]    = log.level.to_s
+        h[:duration_str] = h.delete(:duration)
         h
       end