semantic_logger 4.6.1 → 4.10.0

data/lib/semantic_logger/semantic_logger.rb

@@ -1,5 +1,5 @@
-require 'concurrent'
-require 'socket'
+require "concurrent"
+require "socket"
 
 module SemanticLogger
   # Logging levels in order of most detailed to most severe
@@ -52,7 +52,7 @@ module SemanticLogger
   # Returns [String] name of this host for logging purposes
   # Note: Not all appenders use `host`
   def self.host
-    @host ||= Socket.gethostname.force_encoding('UTF-8')
+    @host ||= Socket.gethostname.force_encoding("UTF-8")
   end
 
   # Override the default host name
@@ -82,8 +82,8 @@ module SemanticLogger
     @environment = environment
   end
 
-  @application = ENV['SEMANTIC_LOGGER_APP'] || 'Semantic Logger'
-  @environment = ENV['SEMANTIC_LOGGER_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV']
+  @application = ENV["SEMANTIC_LOGGER_APP"] || "Semantic Logger"
+  @environment = ENV["SEMANTIC_LOGGER_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"]
 
   # Add a new logging appender as a new destination for all log messages
   # emitted from Semantic Logger
@@ -101,7 +101,7 @@ module SemanticLogger
   #   Or,
   #   io: [IO]
   #     An IO Stream to log to.
-  #     For example STDOUT, STDERR, etc.
+  #     For example $stdout, $stderr, etc.
   #
   #   Or,
   #   appender: [Symbol|SemanticLogger::Subscriber]
@@ -122,7 +122,7 @@ module SemanticLogger
   #     Default: SemanticLogger.default_level
   #
   #   formatter: [Symbol|Object|Proc]
-  #     Any of the following symbol values: :default, :color, :json
+  #     Any of the following symbol values: :default, :color, :json, :logfmt, etc...
   #       Or,
   #     An instance of a class that implements #call
   #       Or,
@@ -138,14 +138,14 @@ module SemanticLogger
   # Examples:
   #
   #   # Send all logging output to Standard Out (Screen)
-  #   SemanticLogger.add_appender(io: STDOUT)
+  #   SemanticLogger.add_appender(io: $stdout)
   #
   #   # Send all logging output to a file
   #   SemanticLogger.add_appender(file_name: 'logfile.log')
   #
   #   # Send all logging output to a file and only :info and above to standard output
   #   SemanticLogger.add_appender(file_name: 'logfile.log')
-  #   SemanticLogger.add_appender(io: STDOUT, level: :info)
+  #   SemanticLogger.add_appender(io: $stdout, level: :info)
   #
   # Log to log4r, Logger, etc.:
   #
@@ -154,7 +154,7 @@ module SemanticLogger
   #   require 'semantic_logger'
   #
   #   # Built-in Ruby logger
-  #   log = Logger.new(STDOUT)
+  #   log = Logger.new($stdout)
   #   log.level = Logger::DEBUG
   #
   #   SemanticLogger.default_level = :debug
@@ -164,7 +164,7 @@ module SemanticLogger
   #   logger.info "Hello World"
   #   logger.debug("Login time", user: 'Joe', duration: 100, ip_address: '127.0.0.1')
   def self.add_appender(**args, &block)
-    appender = Logger.processor.appenders.add(**args, &block)
+    appender = appenders.add(**args, &block)
     # Start appender thread if it is not already running
     Logger.processor.start
     appender
@@ -173,7 +173,15 @@ module SemanticLogger
   # Remove an existing appender
   # Currently only supports appender instances
   def self.remove_appender(appender)
-    Logger.processor.appenders.delete(appender)
+    return unless appender
+
+    appenders.delete(appender)
+    appender.close
+  end
+
+  # Clear out all previously registered appenders
+  def self.clear_appenders!
+    Logger.processor.close
   end
 
   # Returns [SemanticLogger::Subscriber] a copy of the list of active
@@ -181,7 +189,7 @@ module SemanticLogger
   # Use SemanticLogger.add_appender and SemanticLogger.remove_appender
   # to manipulate the active appenders list
   def self.appenders
-    Logger.processor.appenders.to_a
+    Logger.processor.appenders
   end
 
   # Flush all queued log entries disk, database, etc.
@@ -268,22 +276,23 @@ module SemanticLogger
   # Note:
   #   To only register one of the signal handlers, set the other to nil
   #   Set gc_log_microseconds to nil to not enable JRuby Garbage collections
-  def self.add_signal_handler(log_level_signal = 'USR2', thread_dump_signal = 'TTIN', gc_log_microseconds = 100_000)
+  def self.add_signal_handler(log_level_signal = "USR2", thread_dump_signal = "TTIN", gc_log_microseconds = 100_000)
     if log_level_signal
       Signal.trap(log_level_signal) do
         index     = default_level == :trace ? LEVELS.find_index(:error) : LEVELS.find_index(default_level)
         new_level = LEVELS[index - 1]
-        self['SemanticLogger'].warn "Changed global default log level to #{new_level.inspect}"
+        self["SemanticLogger"].warn "Changed global default log level to #{new_level.inspect}"
         self.default_level = new_level
       end
     end
 
     if thread_dump_signal
       Signal.trap(thread_dump_signal) do
-        logger = SemanticLogger['Thread Dump']
+        logger = SemanticLogger["Thread Dump"]
         Thread.list.each do |thread|
           # MRI re-uses the main thread for signals, JRuby uses `SIGTTIN handler` thread.
           next if defined?(JRuby) && (thread == Thread.current)
+
           logger.backtrace(thread: thread)
         end
       end
@@ -302,7 +311,7 @@ module SemanticLogger
   # If the tag being supplied is definitely a string then this fast
   # tag api can be used for short lived tags
   def self.fast_tag(tag)
-    return yield if tag.nil? || tag == ''
+    return yield if tag.nil? || tag == ""
 
     t = Thread.current[:semantic_logger_tags] ||= []
     begin
@@ -379,7 +388,7 @@ module SemanticLogger
   # :nodoc
   def self.named_tagged(hash)
     return yield if hash.nil? || hash.empty?
-    raise(ArgumentError, '#named_tagged only accepts named parameters (Hash)') unless hash.is_a?(Hash)
+    raise(ArgumentError, "#named_tagged only accepts named parameters (Hash)") unless hash.is_a?(Hash)
 
     begin
       push_named_tags(hash)
@@ -488,11 +497,23 @@ module SemanticLogger
     Thread.current[:semantic_logger_silence] || @default_level_index
   end
 
-  private
+  # Run Semantic Logger in Synchronous mode.
+  #
+  # I.e. Instead of logging messages in a separate thread for better performance,
+  # log them using the current thread.
+  def self.sync!
+    Logger.sync!
+  end
+
+  # Running in synchronous mode?
+  def self.sync?
+    Logger.sync?
+  end
 
   # Initial default Level for all new instances of SemanticLogger::Logger
   @default_level         = :info
   @default_level_index   = Levels.index(@default_level)
   @backtrace_level       = :error
   @backtrace_level_index = Levels.index(@backtrace_level)
+  @sync                  = false
 end

data/lib/semantic_logger/subscriber.rb

@@ -22,6 +22,11 @@ module SemanticLogger
       # NOOP
     end
 
+    # Method called to log an event
+    def log(log)
+      raise NotImplementedError
+    end
+
     # Returns [SemanticLogger::Formatters::Default] default formatter for this subscriber.
     def default_formatter
       SemanticLogger::Formatters::Default.new
@@ -45,11 +50,12 @@ module SemanticLogger
     # Give each appender its own logger for logging.
     # For example trace messages sent to services or errors when something fails.
     def logger
-      @logger ||= begin
-        logger      = SemanticLogger::Processor.logger.clone
-        logger.name = self.class.name
-        logger
-      end
+      @logger ||=
+        begin
+          logger      = SemanticLogger::Processor.logger.clone
+          logger.name = self.class.name
+          logger
+        end
     end
 
     # Set the formatter from Symbol|Hash|Block
@@ -67,6 +73,11 @@ module SemanticLogger
       super(log) && (log.metric_only? ? metrics? : true)
     end
 
+    # Whether this appender is logging to stdout or stderror
+    def console_output?
+      false
+    end
+
     private
 
     # Initializer for Abstract Class SemanticLogger::Subscriber

data/lib/semantic_logger/sync.rb

@@ -0,0 +1,12 @@
+# Run Semantic Logger in Synchronous mode.
+#
+# I.e. Instead of logging messages in a separate thread for better performance,
+# log them using the current thread.
+#
+# Usage:
+#   require "semantic_logger/sync"
+#
+# Or, when using a Gemfile:
+#   gem "semantic_logger", require: "semantic_logger/sync"
+require "semantic_logger"
+SemanticLogger.sync!

data/lib/semantic_logger/sync_processor.rb

@@ -0,0 +1,43 @@
+module SemanticLogger
+  # Thread that submits and processes log requests
+  class SyncProcessor
+    extend Forwardable
+
+    # Forward methods that can be called directly
+    def_delegator :@appenders, :add
+    def_delegator :@appenders, :log
+    def_delegator :@appenders, :flush
+    def_delegator :@appenders, :close
+    def_delegator :@appenders, :reopen
+
+    # Allow the internal logger to be overridden from its default of $stderr
+    #   Can be replaced with another Ruby logger or Rails logger, but never to
+    #   SemanticLogger::Logger itself since it is for reporting problems
+    #   while trying to log to the various appenders
+    class << self
+      attr_writer :logger
+    end
+
+    # Internal logger for SemanticLogger
+    #   For example when an appender is not working etc..
+    #   By default logs to $stderr
+    def self.logger
+      @logger ||=
+        begin
+          l      = SemanticLogger::Appender::IO.new($stderr, level: :warn)
+          l.name = name
+          l
+        end
+    end
+
+    attr_reader :appenders
+
+    def initialize(appenders = nil)
+      @appenders = appenders || Appenders.new(self.class.logger.dup)
+    end
+
+    def start
+      # NOP
+    end
+  end
+end

data/lib/semantic_logger/test/capture_log_events.rb

@@ -0,0 +1,34 @@
+module SemanticLogger
+  module Test
+    # Logging class to captures all logging events in memory.
+    #
+    # Example:
+    #
+    # class UserTest < ActiveSupport::TestCase
+    #   describe User do
+    #     let(:capture_logger) { SemanticLogger::Test::CaptureLogEvents.new }
+    #     let(:user) { User.new }
+    #
+    #     it "logs message" do
+    #       user.stub(:logger, capture_logger) do
+    #         user.enable!
+    #       end
+    #       assert_equal "Hello World", capture_logger.events.last.message
+    #       assert_equal :info, capture_logger.events.last.level
+    #     end
+    #   end
+    # end
+    class CaptureLogEvents < SemanticLogger::Subscriber
+      attr_accessor :events
+
+      # By default collect all log levels, and collect metric only log events.
+      def initialize(level: :trace, metrics: true)
+        super(level: level, metrics: true)
+      end
+
+      def log(log)
+        (@events ||= []) << log
+      end
+    end
+  end
+end

data/lib/semantic_logger/utils.rb

@@ -2,7 +2,7 @@ module SemanticLogger
   # Internal-use only utility functions for Semantic Logger.
   # Not intended for public use.
   module Utils
-    def self.constantize_symbol(symbol, namespace = 'SemanticLogger::Appender')
+    def self.constantize_symbol(symbol, namespace = "SemanticLogger::Appender")
       klass = "#{namespace}::#{camelize(symbol.to_s)}"
       begin
         Object.const_get(klass)
@@ -15,8 +15,8 @@ module SemanticLogger
     def self.camelize(term)
       string = term.to_s
       string = string.sub(/^[a-z\d]*/, &:capitalize)
-      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
-      string.gsub!('/'.freeze, '::'.freeze)
+      string.gsub!(%r{(?:_|(/))([a-z\d]*)}i) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
+      string.gsub!("/".freeze, "::".freeze)
       string
     end
 
@@ -32,29 +32,48 @@ module SemanticLogger
       end
     end
 
-    SELF_PATTERN = File.join('lib', 'semantic_logger')
-
-    # Extract the backtrace leaving out the last few Semantic Logger lines.
+    # Extract the backtrace stripping off the leading semantic logger entries.
+    # Leaves all other system and gem path entries in place.
     def self.extract_backtrace(stack = caller)
-      while (first = stack.first) && first.include?(SELF_PATTERN)
+      while (first = stack.first) && extract_path?(first)
         stack.shift
       end
       stack
     end
 
-    # Strips off all gems and built-in ruby code paths from the top of the stack until application code is found.
+    def self.extract_paths
+      @extract_paths ||= %w[lib/semantic_logger lib/rails_semantic_logger]
+    end
+
+    # Whether this path should be excluded from any cleansed backtrace
+    def self.extract_path?(path)
+      extract_paths.any? { |exclude| path.include?(exclude) }
+    end
+
+    # Try to strip everything off of the supplied backtrace, until the first application stack entry is at the top.
+    # For example all leading gem paths and built-in ruby code paths are removed from the top.
+    # Once the first application entry is found, the remaining stack is returned.
     def self.strip_backtrace(stack = caller)
-      while (first = stack.first) && system_path?(first)
+      while (first = stack.first) && (strip_path?(first) || extract_path?(first))
         stack.shift
       end
       stack
     end
 
-    GEM_ROOT = File.expand_path('../../..', __dir__) + '/'
+    # Paths to exclude in the stripped backtrace
+    # Includes Gems and built-in Ruby code paths
+    def self.strip_paths
+      @strip_paths ||=
+        begin
+          paths = Gem.path | [Gem.default_dir]
+          paths << RbConfig::CONFIG["rubylibdir"]
+          paths
+        end
+    end
 
-    def self.system_path?(path)
-      path.start_with?(GEM_ROOT) ||
-        path.start_with?(RbConfig::CONFIG['rubylibdir'])
+    # Whether this path should be excluded from any cleansed backtrace
+    def self.strip_path?(path)
+      strip_paths.any? { |exclude| path.start_with?(exclude) }
     end
   end
 end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger
-  VERSION = '4.6.1'.freeze
+  VERSION = "4.10.0".freeze
 end

data/lib/semantic_logger.rb

@@ -1,43 +1,48 @@
-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
+
+  module Test
+    autoload :CaptureLogEvents,  "semantic_logger/test/capture_log_events"
   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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.6.1
+  version: 4.10.0
 platform: ruby
 authors:
 - Reid Morrison
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-24 00:00:00.000000000 Z
+date: 2022-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -24,9 +24,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: 
+description:
 email:
-- reidmo@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -46,11 +45,13 @@ files:
 - lib/semantic_logger/appender/graylog.rb
 - lib/semantic_logger/appender/honeybadger.rb
 - lib/semantic_logger/appender/http.rb
+- lib/semantic_logger/appender/io.rb
 - lib/semantic_logger/appender/kafka.rb
 - lib/semantic_logger/appender/mongodb.rb
 - lib/semantic_logger/appender/new_relic.rb
 - lib/semantic_logger/appender/rabbitmq.rb
 - lib/semantic_logger/appender/sentry.rb
+- lib/semantic_logger/appender/sentry_ruby.rb
 - lib/semantic_logger/appender/splunk.rb
 - lib/semantic_logger/appender/splunk_http.rb
 - lib/semantic_logger/appender/syslog.rb
@@ -68,6 +69,7 @@ files:
 - lib/semantic_logger/formatters/default.rb
 - lib/semantic_logger/formatters/fluentd.rb
 - lib/semantic_logger/formatters/json.rb
+- lib/semantic_logger/formatters/logfmt.rb
 - lib/semantic_logger/formatters/one_line.rb
 - lib/semantic_logger/formatters/raw.rb
 - lib/semantic_logger/formatters/signalfx.rb
@@ -85,13 +87,16 @@ files:
 - lib/semantic_logger/reporters/minitest.rb
 - lib/semantic_logger/semantic_logger.rb
 - lib/semantic_logger/subscriber.rb
+- lib/semantic_logger/sync.rb
+- lib/semantic_logger/sync_processor.rb
+- lib/semantic_logger/test/capture_log_events.rb
 - lib/semantic_logger/utils.rb
 - lib/semantic_logger/version.rb
-homepage: https://github.com/rocketjob/semantic_logger
+homepage: https://logger.rocketjob.io
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -99,15 +104,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Feature rich logging framework, and replacement for existing Ruby & Rails
   loggers.