semantic_logger 4.5.0 → 4.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34b3b78799e196b270d81aba7deb9b0accd1187a900967a3943dd03301c63199
-  data.tar.gz: 775b6eeca4ca6b9c38e9213e7f32fee9d179ce36148433dfa91a8630f74873b3
+  metadata.gz: 53de576d3dea3ae2099d237648a027026469632dda0f8c3840557c648ddb0626
+  data.tar.gz: a2fe41e466fd682cc536f33331698a74b19d9026cde7604db93f859e70686d25
 SHA512:
-  metadata.gz: 7cda8a50c62a2dcdb079d5f96cbde61e5cc941c443122a3bbc102a1513bc3686d44a20cca28e7627444bf640a6329035aefc43cb6111a3e6b9cb91411fe33782
-  data.tar.gz: caf355bf16e08b133fe07ddd6b4cab813b6e7224b3e1f152e1ab54cf30f574fc8665f99ae3938078fb35fcfeea3643d565a814cbe2774d263135c93722147b06
+  metadata.gz: c9c53adbda24e55a427945f9c5953c6e53c244af0c00b4f81ba59c92c3e052d9f7306fc8941bbf0960d665757c56b4089bbc1214255fdfc5ec085fdda24b601e
+  data.tar.gz: 700143b4c0b34e347539b7b2fccd363683b45577a5520accd55a308175f92975ca041152ca03353f7e23ec71eb9189e6de54ff8f985eecf414d51b8900b2ad96

data/README.md

@@ -76,7 +76,7 @@ and are therefore not automatically included by this gem:
 ## V4 Upgrade notes
 
 The following changes need to be made when upgrading to V4:
-- Ruby V2.1 / JRuby V9.1 is now the minimum runtime version.
+- Ruby V2.3 / JRuby V9.1 is now the minimum runtime version.
 - Replace calls to Logger#with_payload with SemanticLogger.named_tagged.
 - Replace calls to Logger#payload with SemanticLogger.named_tags.
 - MongoDB Appender requires Mongo Ruby Client V2 or greater.

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/ansi_colors.rb

@@ -11,15 +11,5 @@ module SemanticLogger
     MAGENTA = "\e[35m".freeze
     CYAN    = "\e[36m".freeze
     WHITE   = "\e[37m".freeze
-
-    # DEPRECATED - NOT USED
-    LEVEL_MAP = {
-      trace: MAGENTA,
-      debug: GREEN,
-      info:  CYAN,
-      warn:  BOLD,
-      error: RED,
-      fatal: RED
-    }.freeze
   end
 end

data/lib/semantic_logger/appender.rb

@@ -1,93 +1,83 @@
 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
 
-    # DEPRECATED, use SemanticLogger::AnsiColors
-    AnsiColors = SemanticLogger::AnsiColors
-
-    # DEPRECATED: use SemanticLogger::Formatters::Color.new
-    def self.colorized_formatter
-      SemanticLogger::Formatters::Color.new
-    end
-
-    # DEPRECATED: use SemanticLogger::Formatters::Json.new
-    def self.json_formatter
-      SemanticLogger::Formatters::Json.new
-    end
-
     # Returns [SemanticLogger::Subscriber] appender for the supplied options
-    def self.factory(options, &block)
-      options = options.dup
-      async   = options.delete(:async)
-      batch   = options.delete(:batch)
-
-      # Extract batch and async options
-      proxy_options = {}
-      ASYNC_OPTION_KEYS.each { |key| proxy_options[key] = options.delete(key) if options.key?(key) }
-
-      appender = build(options, &block)
+    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)
+      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
-        proxy_options[:appender] = appender
-        Appender::AsyncBatch.new(proxy_options)
+        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
+        )
       elsif async == true
-        proxy_options[:appender] = appender
-        Appender::Async.new(proxy_options)
-
-
+        Appender::Async.new(
+          appender:           appender,
+          max_queue_size:     max_queue_size,
+          lag_check_interval: lag_check_interval,
+          lag_threshold_s:    lag_threshold_s
+        )
       else
         appender
       end
     end
 
-    ASYNC_OPTION_KEYS = %i[max_queue_size lag_threshold_s batch_size batch_seconds lag_check_interval].freeze
-
     # Returns [Subscriber] instance from the supplied options.
-    def self.build(options, &block)
-      if options[:io] || options[:file_name]
-        SemanticLogger::Appender::File.new(options, &block)
-      elsif (appender = options.delete(:appender))
+    def self.build(io: nil, file_name: nil, appender: nil, metric: nil, logger: nil, **args, &block)
+      if io || file_name
+        SemanticLogger::Appender::File.new(io: io, file_name: file_name, **args, &block)
+      elsif logger
+        SemanticLogger::Appender::Wrapper.new(logger: logger, **args, &block)
+      elsif appender
         if appender.is_a?(Symbol)
-          SemanticLogger::Utils.constantize_symbol(appender).new(options)
+          SemanticLogger::Utils.constantize_symbol(appender).new(**args)
         elsif appender.is_a?(Subscriber)
           appender
         else
           raise(ArgumentError, "Parameter :appender must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
         end
-      elsif (appender = options.delete(:metric))
-        if appender.is_a?(Symbol)
-          SemanticLogger::Utils.constantize_symbol(appender, 'SemanticLogger::Metric').new(options)
-        elsif appender.is_a?(Subscriber)
-          appender
+      elsif metric
+        if metric.is_a?(Symbol)
+          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
-      elsif options[:logger]
-        SemanticLogger::Appender::Wrapper.new(options, &block)
+      else
+        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
@@ -15,6 +15,7 @@ module SemanticLogger
       def_delegator :@appender, :filter
       def_delegator :@appender, :host
       def_delegator :@appender, :application
+      def_delegator :@appender, :environment
       def_delegator :@appender, :level
       def_delegator :@appender, :level=
       def_delegator :@appender, :logger
@@ -72,6 +73,7 @@ module SemanticLogger
       # Starts the worker thread if not running.
       def thread
         return @thread if @thread&.alive?
+
         @thread = Thread.new { process }
       end
 
@@ -114,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
@@ -136,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
@@ -158,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)
+        return if appender.respond_to?(:batch)
+
+        raise(ArgumentError, "#{appender.class.name} does not support batching. It must implement #batch")
       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 '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 '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,14 +123,15 @@ 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,
                      application: nil,
+                     environment: nil,
                      host: nil,
                      metrics: false,
                      **elasticsearch_args,
@@ -144,7 +145,7 @@ module SemanticLogger
         @elasticsearch_args[:url]    = url if url && !elasticsearch_args[:hosts]
         @elasticsearch_args[:logger] = logger
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, metrics: false, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: false, &block)
         reopen
       end
 
@@ -173,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