semantic_logger 4.6.1 → 4.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22f95d79aaeb38befe2e1c242063464be93f05d16eed7cf17540256c1064f7b2
-  data.tar.gz: 2ae7b4e00a4415c88d66afd552c4fa03e68dcf2d354994bfe98621d0e08bcdd0
+  metadata.gz: b8023caa61e185f752a8e1cec7af81ce9a8570c5287df17a4a958fd313563363
+  data.tar.gz: 9a11150db987ee52f0e0ae7ac3a2ec7086a7f5430832510d64c10eb865444ac9
 SHA512:
-  metadata.gz: bc5bd0ce964de270119c5ef3bcab46c8178eb7120c5ad76afd99c0f5c1acbe4d7011eaf88c4d983e943d1e25f09baffd803121cba5a580be168ac874f09e539e
-  data.tar.gz: 0e64868d3f9363007114fce5c10ced420282edd098816df92e60da755c380434fe42075b5be3ebcb8ca03ff2b8746681a30317e33b88563bd2e3af5579ad9b4f
+  metadata.gz: e366df7c3b382c412fd788aa567e9a88768d8e70beb14e60d08edc85554a041b511a26befe6a3e59e5759aefc27d2db6046a0fd97ce28b63befede5a68f64d34
+  data.tar.gz: 87d676b2fda89d82e8e329a10ac5df93e47af226d5da56073bd43f429fdb4f16019214948811f5d825193542cf71f5a09188ec63899b1083a20282ad92bd464e

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)
+        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 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] }
@@ -40,48 +40,61 @@ module SemanticLogger
 
       # Returns [Hash] of parameters to send to Bugsnag.
       def call(log, logger)
-        h            = SemanticLogger::Formatters::Raw.new.call(log, logger)
-        h[:severity] = log_level(log)
-        h.delete(:message) if h[:exception] && (h[:message] == h[:exception][:message])
-        h.delete(:time)
-        h.delete(:exception)
-        h
+        hash = SemanticLogger::Formatters::Raw.new.call(log, logger)
+        hash.delete(:message) if hash[:exception] && (hash[:message] == hash[:exception][:message])
+        hash.delete(:time)
+        hash.delete(:level_index)
+        hash.delete(:exception)
+        hash[:file] = "#{hash[:file]}:#{hash.delete(:line)}" if hash.key?(:file)
+        hash
       end
 
-      # 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 =
-          if log.exception
-            # Manually constructed Exception, without a backtrace.
-            log.exception.set_backtrace(log.backtrace) if !log.exception.backtrace && log.backtrace
-            log.exception
-          else
-            error = RuntimeError.new(log.message)
-            error.set_backtrace(log.backtrace) if log.backtrace
-            error
-          end
-
-        # For more documentation on the Bugsnag.notify method see:
-        # https://bugsnag.com/docs/notifiers/ruby#sending-handled-exceptions
-        ::Bugsnag.notify(exception, formatter.call(log, self))
+        exception = extract_exception(log)
+        hash      = formatter.call(log, self)
+        bugsnag_notify(exception, hash, log_level(log.level))
         true
       end
 
       private
 
+      def bugsnag_notify(exception, hash, level)
+        if ::Bugsnag::VERSION.to_i >= 6
+          ::Bugsnag.notify(exception) do |report|
+            report.severity = level
+            hash.each_pair { |key, value| report.add_tab(key, value) }
+          end
+        else
+          hash[:severity] = level
+          ::Bugsnag.notify(exception, hash)
+        end
+      end
+
+      def extract_exception(log)
+        if log.exception
+          # Manually constructed Exception, without a backtrace.
+          log.exception.set_backtrace(log.backtrace) if !log.exception.backtrace && log.backtrace
+          return log.exception
+        end
+
+        error = RuntimeError.new(log.message)
+        error.set_backtrace(log.backtrace) if log.backtrace
+        error
+      end
+
       # Bugsnag supports: error, warning or info
-      def log_level(log)
-        case log.level
+      def log_level(level)
+        case 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)