semantic_logger 4.6.1 → 4.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22f95d79aaeb38befe2e1c242063464be93f05d16eed7cf17540256c1064f7b2
-  data.tar.gz: 2ae7b4e00a4415c88d66afd552c4fa03e68dcf2d354994bfe98621d0e08bcdd0
+  metadata.gz: 2ff7d4bcb345581f6ba19f834bb1bf2f921e97904f4b6236142b87af75a4526d
+  data.tar.gz: b1069d5360296c61c9796f630b1ec065eb1a0a7dc549778c66c5e26c90d0eadb
 SHA512:
-  metadata.gz: bc5bd0ce964de270119c5ef3bcab46c8178eb7120c5ad76afd99c0f5c1acbe4d7011eaf88c4d983e943d1e25f09baffd803121cba5a580be168ac874f09e539e
-  data.tar.gz: 0e64868d3f9363007114fce5c10ced420282edd098816df92e60da755c380434fe42075b5be3ebcb8ca03ff2b8746681a30317e33b88563bd2e3af5579ad9b4f
+  metadata.gz: c5cfbac7dd8795b11cf79ed3fa9a4a086128d5ee030f0e9db40b75f30f58997c1674a4284b4b287939216bc8de83372e2b7fe00d73e7856c3cc6830310740f0d
+  data.tar.gz: 2150a809562247d771103a5d387ae5852ff5b0649a4f4288a7dd07a94420bafcfb6b36f3e21077fcc053c2d8bcaffe80a110ab65b52178fb612b7368fd79d87d

data/README.md

@@ -1,25 +1,13 @@
 # Semantic Logger
-[![Gem Version](https://img.shields.io/gem/v/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![Build Status](https://travis-ci.org/rocketjob/semantic_logger.svg?branch=master)](https://travis-ci.org/rocketjob/semantic_logger) [![Downloads](https://img.shields.io/gem/dt/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg) [![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-Support-brightgreen.svg)](https://gitter.im/rocketjob/support)
+[![Gem Version](https://img.shields.io/gem/v/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![Build Status](https://github.com/reidmorrison/semantic_logger/workflows/build/badge.svg)](https://github.com/reidmorrison/semantic_logger/actions?query=workflow%3Abuild) [![Downloads](https://img.shields.io/gem/dt/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg)
 
 Semantic Logger is a feature rich logging framework, and replacement for existing Ruby & Rails loggers.  
 
-* https://rocketjob.github.io/semantic_logger/
+* https://logger.rocketjob.io/
 
 ## Documentation
 
-[Semantic Logger Guide](http://rocketjob.github.io/semantic_logger)
-
-[Reference Documentation](http://www.rubydoc.info/gems/semantic_logger/)
-
-## Upgrading to Semantic Logger v4.4
-
-With some forking frameworks it is necessary to call `reopen` after the fork. With v4.4 the
-workaround for Ruby 2.5 crashes is no longer needed. 
-I.e. Please remove the following line if being called anywhere:
-
-~~~ruby
-SemanticLogger::Processor.instance.instance_variable_set(:@queue, Queue.new)
-~~~
+[Semantic Logger Guide](https://logger.rocketjob.io/)
 
 ## Logging Destinations
 
@@ -34,7 +22,7 @@ Logging to the following destinations are all supported "out-of-the-box":
 * Splunk
 * MongoDB
 * Honeybadger
-* Sentry
+* Sentry (both with legacy `sentry-raven` and modern `sentry-ruby` gem)
 * HTTP
 * TCP
 * UDP
@@ -50,7 +38,7 @@ handles saving log information to multiple destinations / appenders.
 
 ## Rails
 
-When running Rails, use [rails_semantic_logger](http://github.com/rocketjob/rails_semantic_logger)
+When running Rails, use [rails_semantic_logger](http://github.com/reidmorrison/rails_semantic_logger)
 instead of Semantic Logger directly since it will automatically replace the Rails default logger with Semantic Logger.
 
 ## Rocket Job
@@ -72,8 +60,50 @@ and are therefore not automatically included by this gem:
 - Splunk Appender: gem 'splunk-sdk-ruby'
 - Elasticsearch Appender: gem 'elasticsearch'
 - Kafka Appender: gem 'ruby-kafka'
+- Legacy Sentry Appender: gem 'sentry-raven' (deprecated)
+- Sentry Appender: gem 'sentry-ruby'
+
+## Upgrading to Semantic Logger v4.9
+
+These changes should not be noticeable by the majority of users of Semantic Logger, since
+they are to the internal API. It is possible that advanced users may be using these internal
+API's directly.
+
+This does not affect any calls to the public api `SemanticLogger.add_appender`.
+
+File and IO are now separate appenders. When creating the File appender explicitly, its arguments
+have changed. For example, when requesting an IO stream, it needs to be changed from:
+
+~~~ruby
+SemanticLogger::Appender::File.new(io: $stderr)
+~~~
+to:
+~~~ruby
+SemanticLogger::Appender::IO.new($stderr)
+~~~
+
+Additionally, this needs to be changed from:
+~~~ruby
+SemanticLogger::Appender::File.new(file_name: "file.log")
+~~~
+to:
+~~~ruby
+SemanticLogger::Appender::File.new("file.log")
+~~~
+
+Rails Semantic Logger, if used, needs to be upgraded to v4.9 when upgrading to Semantic Logger v4.9.
+
+## Upgrading to Semantic Logger v4.4
+
+With some forking frameworks it is necessary to call `reopen` after the fork. With v4.4 the
+workaround for Ruby 2.5 crashes is no longer needed.
+I.e. Please remove the following line if being called anywhere:
+
+~~~ruby
+SemanticLogger::Processor.instance.instance_variable_set(:@queue, Queue.new)
+~~~
 
-## V4 Upgrade notes
+## Upgrading to Semantic Logger v4.0
 
 The following changes need to be made when upgrading to V4:
 - Ruby V2.3 / JRuby V9.1 is now the minimum runtime version.
@@ -129,13 +159,13 @@ SemanticLogger.default_level = :trace
 SemanticLogger.add_appender(file_name: 'development.log', formatter: :color)
 ~~~
 
-If running rails, see: [Semantic Logger Rails](http://rocketjob.github.io/semantic_logger/rails.html)
+If running rails, see: [Semantic Logger Rails](https://logger.rocketjob.io/rails.html)
 
 ## Author
 
 [Reid Morrison](https://github.com/reidmorrison)
 
-[Contributors](https://github.com/rocketjob/semantic_logger/graphs/contributors)
+[Contributors](https://github.com/reidmorrison/semantic_logger/graphs/contributors)
 
 ## Versioning
 

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/appender/async.rb

@@ -1,4 +1,4 @@
-require 'forwardable'
+require "forwardable"
 
 module SemanticLogger
   module Appender
@@ -53,7 +53,7 @@ module SemanticLogger
       # 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
+        #   https://github.com/reidmorrison/semantic_logger/issues/103
         @queue&.close
         create_queue
 
@@ -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.
@@ -62,6 +64,7 @@ module SemanticLogger
           signal.wait(batch_seconds)
 
           logs          = []
+          messages      = []
           first         = true
           message_count = queue.length
           message_count.times do
@@ -74,10 +77,11 @@ module SemanticLogger
                 first = false
               end
             else
-              process_message(message)
+              messages << message
             end
           end
           appender.batch(logs) if logs.size.positive?
+          messages.each { |message| process_message(message) }
           signal.reset unless queue.size >= batch_size
         end
       end

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,11 @@
 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.
 #
@@ -17,7 +18,8 @@ require 'date'
 module SemanticLogger
   module Appender
     class Elasticsearch < SemanticLogger::Subscriber
-      attr_accessor :url, :index, :date_pattern, :type, :client, :flush_interval, :timeout_interval, :batch_size, :elasticsearch_args
+      attr_accessor :url, :index, :date_pattern, :type, :client, :flush_interval, :timeout_interval, :batch_size,
+                    :elasticsearch_args
 
       # Create Elasticsearch appender over persistent HTTP(S)
       #
@@ -123,17 +125,17 @@ 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,
+                     data_stream: false,
                      **elasticsearch_args,
                      &block)
 
@@ -144,6 +146,7 @@ module SemanticLogger
         @elasticsearch_args          = elasticsearch_args.dup
         @elasticsearch_args[:url]    = url if url && !elasticsearch_args[:hosts]
         @elasticsearch_args[:logger] = logger
+        @data_stream = data_stream
 
         super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: false, &block)
         reopen
@@ -173,20 +176,35 @@ module SemanticLogger
       private
 
       def write_to_elasticsearch(messages)
-        bulk_result = @client.bulk(body: messages)
-        return unless bulk_result['errors']
+        bulk_result = if @data_stream
+                        @client.bulk(index: index, body: messages)
+                      else
+                        @client.bulk(body: messages)
+                      end
 
-        failed = bulk_result['items'].reject { |x| x['status'] == 201 }
+        return unless bulk_result["errors"]
+
+        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}}
+        if @data_stream
+          {"create" => {}}
+        else
+          {"index" => {"_index" => expanded_index_name, "_type" => type}}
+        end
       end
 
       def default_formatter
-        SemanticLogger::Formatters::Raw.new(time_format: :iso_8601, time_key: :timestamp)
+        time_key = if @data_stream
+                     "@timestamp"
+                   else
+                     :timestamp
+                   end
+
+        SemanticLogger::Formatters::Raw.new(time_format: :iso_8601, time_key: time_key)
       end
     end
   end

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)