semantic_logger 5.0.0 → 5.2.0

data/lib/semantic_logger/subscriber.rb

@@ -7,11 +7,6 @@ module SemanticLogger
     attr_reader :formatter
     attr_writer :application, :environment, :host, :logger, :metrics
 
-    # Returns the current log level if set, otherwise it logs everything it receives.
-    def level
-      @level || :trace
-    end
-
     # A subscriber should implement flush if it can.
     def flush
       # NOOP
@@ -84,6 +79,26 @@ module SemanticLogger
       !console_stream.nil?
     end
 
+    # Returns [String] the class and object address of this appender, like Kernel#inspect, followed
+    # by #inspect_details, but none of its instance variables.
+    #
+    # Appenders hold credentials in their instance variables: passwords and urls holding them, api
+    # keys and tokens, request headers, private keys, and the options passed to a client gem.
+    # Printing SemanticLogger.appenders, for example in a console or an error report, must not
+    # show them.
+    def inspect
+      address = Kernel.instance_method(:to_s).bind_call(self).delete_suffix(">")
+      details = inspect_details
+      details ? "#{address} #{details}>" : "#{address}>"
+    end
+
+    # Returns [String] what #inspect shows about this appender, such as its url without its
+    # credentials, or nil for nothing. Only an appender knows which of its settings are safe to
+    # show, so each one overrides this.
+    def inspect_details
+      nil
+    end
+
     # Whether an appender that implements #batch should be wrapped in a batch
     # proxy automatically. Appenders that support batching but should only batch
     # when explicitly requested (via `batch: true`) override this to return false.
@@ -91,8 +106,77 @@ module SemanticLogger
       true
     end
 
+    # Raised by #format_log and #format_batch when the formatter fails, with the formatter's
+    # error as its cause. A formatter has no destination, so it can only fail because of the
+    # content of the log message, whatever it raises.
+    class FormatError < StandardError; end
+
+    # Errors raised by writing a log message whose content cannot be written, such as a
+    # value that cannot be serialized. Excludes JSON::ParserError, which comes from parsing a
+    # response rather than from the message, except its subclass JSON::NestingError, which
+    # JSON.generate raises for a value nested too deeply.
+    MESSAGE_ERRORS = [FormatError, JSON::GeneratorError, JSON::NestingError, EncodingError, FloatDomainError].freeze
+
+    # Whether the supplied exception, raised by #log or #batch, was caused by the content of a
+    # log message, rather than by the destination, for example being unavailable.
+    #
+    # Retrying cannot write such a message, so an asynchronous appender discards it and carries
+    # on, instead of backing off and retrying. Any other exception is retried with a back-off.
+    #
+    # Every error raised by the formatter is one (see #format_log). An appender whose client
+    # raises its own errors for bad content can override this to recognize them.
+    def message_error?(exception)
+      MESSAGE_ERRORS.any? { |error_class| exception.is_a?(error_class) }
+    end
+
+    # Whether #batch writes none of the log messages when it raises a message error (see
+    # #message_error?), for example because it formats every message before sending any.
+    #
+    # When true, a batch that fails with a message error is split up and each part retried,
+    # so that only the offending message is discarded. When false, retrying could write some
+    # messages twice, so the whole batch is discarded instead.
+    def batch_all_or_nothing?
+      false
+    end
+
     private
 
+    # Returns the log message formatted by this appender's formatter.
+    #
+    # Any StandardError the formatter raises is raised as a FormatError, with the formatter's
+    # error as its cause, so that #message_error? recognizes it: an asynchronous appender then
+    # discards the message instead of backing off. Appenders call this rather than formatter.call.
+    #
+    # A SystemStackError is raised as it is, so that rescuing StandardError does not swallow it:
+    # the thread that overflowed must not keep writing (see Appenders#log).
+    #
+    # The block, when given, turns the formatter's output into what the appender sends, such as
+    # its JSON. An error doing so is also caused by the content of the message.
+    def format_log(log)
+      formatted = formatter.call(log, self)
+      block_given? ? yield(formatted) : formatted
+    rescue StandardError => e
+      raise FormatError, "Could not format the log message (#{e.class})"
+    end
+
+    # Returns the log messages formatted by the formatter's #batch, as for #format_log.
+    #
+    # A formatter that cannot format a batch is a configuration error rather than bad content, so
+    # it raises ArgumentError instead, which is retried with a back-off and reported like any
+    # other. That includes an appender that is its own formatter (it implements #call), whose
+    # #batch is the appender's own.
+    def format_batch(logs)
+      unless formatter.respond_to?(:batch) && !formatter.equal?(self)
+        raise(ArgumentError, "#{formatter.class.name} cannot format a batch. It must implement #batch(logs, logger)")
+      end
+
+      begin
+        formatter.batch(logs, self)
+      rescue StandardError => e
+        raise FormatError, "Could not format the batch of log messages (#{e.class})"
+      end
+    end
+
     # Initializer for Abstract Class SemanticLogger::Subscriber
     #
     # Parameters
@@ -134,11 +218,13 @@ module SemanticLogger
       super(self.class, level, filter)
     end
 
-    # Return the level index for fast comparisons.
-    # Returns the lowest level index if the level has not been explicitly
-    # set for this instance.
-    def level_index
-      @level_index || 0
+    # Without a level of its own, a subscriber logs everything it receives.
+    def fallback_level
+      :trace
+    end
+
+    def fallback_level_index
+      0
     end
 
     # Whether to log metric only entries with this subscriber

data/lib/semantic_logger/sync_processor.rb

@@ -8,11 +8,16 @@ module SemanticLogger
       @monitor.synchronize { @appenders.add(...) }
     end
 
+    # Logs on the calling thread, which belongs to the application, so a stack overflow while
+    # writing (see Appenders#log) is reported rather than raised from the log call.
     def log(...)
       @monitor.synchronize do
         @processed_count += 1
         @appenders.log(...)
       end
+    rescue SystemStackError => e
+      @appenders.logger.error("Failed to log a message: the stack overflowed", e)
+      false
     end
 
     # Returns [Hash] operational statistics for the logging pipeline.
@@ -67,6 +72,12 @@ module SemanticLogger
 
     attr_reader :appenders
 
+    # Returns the internal logger of the appenders, for reporting a problem while logging, such as
+    # an exception raised by an on_log subscriber. The same logger as the asynchronous Processor's.
+    def logger
+      @appenders.logger
+    end
+
     def initialize(appenders = nil)
       @monitor         = Monitor.new
       @appenders       = appenders || Appenders.new(self.class.logger.dup)

data/lib/semantic_logger/test/capture_log_events.rb

@@ -24,7 +24,7 @@ module SemanticLogger
 
       # By default collect all log levels, and collect metric only log events.
       def initialize(level: :trace, metrics: true)
-        super(level: level, metrics: true)
+        super
         @events = []
       end
 
@@ -42,14 +42,17 @@ module SemanticLogger
         @events.clear
       end
 
-      # Support silencing of log messages
-      def level_index
-        @level_index || SemanticLogger.default_level_index
-      end
-
       def to_h
         events.map(&:to_h)
       end
+
+      private
+
+      # Without a level of its own, follow the global default level the way a logger does,
+      # so that `SemanticLogger.silence` applies.
+      def fallback_level_index
+        SemanticLogger.default_level_index
+      end
     end
   end
 end

data/lib/semantic_logger/utils.rb

@@ -1,4 +1,5 @@
 require "json"
+require "uri"
 
 module SemanticLogger
   # Internal-use only utility functions for Semantic Logger.
@@ -25,6 +26,38 @@ module SemanticLogger
       constant
     end
 
+    # Returns [URI] the parsed url, supplied as the named option.
+    #
+    # Raises URI::InvalidURIError for an invalid url, including nil, as .without_url_in_errors does.
+    def self.parse_url(url, option: ":url", hint: nil)
+      without_url_in_errors(option: option, hint: hint) { URI.parse(url) }
+    end
+
+    # Returns the result of the block, which uses the url supplied as the named option, for example
+    # to build a client gem's connection.
+    #
+    # Raises any of the errors from the block again, of the same class, without the url in its
+    # message, or as its cause, since a url can hold a user and password, or a token in its path or
+    # query string, and URI and client gems put the url in the error for an invalid one.
+    def self.without_url_in_errors(option: ":url", hint: nil, errors: [URI::InvalidURIError])
+      yield
+    rescue *errors => e
+      raise(e.class, ["Invalid #{option}, it is not a valid URI.", hint].compact.join(" "), cause: nil)
+    end
+
+    # Returns [String] the scheme, host, and any non-default port of the url, which is safe to log.
+    #
+    # Everything else is left out, since log services carry credentials in each part of a url: the
+    # user and password, the query string (for example a Datadog api key), and the path (for example
+    # the token at the end of a Sumo Logic HTTP source url). An invalid url is not shown at all.
+    def self.redacted_url(url)
+      uri  = URI.parse(url.to_s)
+      port = uri.port == uri.default_port ? nil : uri.port
+      uri.class.build(scheme: uri.scheme, host: uri.host, port: port).to_s
+    rescue URI::Error
+      "(invalid url)"
+    end
+
     # Borrow from Rails, when not running Rails
     def self.camelize(term)
       string = term.to_s
@@ -48,11 +81,9 @@ module SemanticLogger
 
     # Extract the backtrace stripping off the leading semantic logger entries.
     # Leaves all other system and gem path entries in place.
+    # Returns a new Array, leaving the supplied stack unchanged since it can belong to the caller.
     def self.extract_backtrace(stack = caller)
-      while (first = stack.first) && extract_path?(first)
-        stack.shift
-      end
-      stack
+      stack.drop_while { |path| extract_path?(path) }
     end
 
     def self.extract_paths
@@ -90,24 +121,221 @@ module SemanticLogger
       strip_paths.any? { |exclude| path.start_with?(exclude) }
     end
 
-    # Serializes the value to JSON, repairing invalid UTF-8 only when necessary.
+    # Serializes the value to JSON, repairing the data only when necessary.
     #
-    # Non UTF-8 data appears in well under 1% of log events, so it is wasteful to
-    # walk and reallocate the entire structure (see .encode_utf8) on every call.
-    # Instead this attempts `.to_json` directly and only falls back to cleansing
-    # when serialization fails because of an encoding problem.
+    # Data that JSON cannot represent appears in well under 1% of log events, so it
+    # is wasteful to walk and reallocate the entire structure (see .json_safe) on
+    # every call. Instead this attempts `.to_json` directly and only falls back to a
+    # repaired copy when serialization fails because of the data:
+    # * Invalid UTF-8. Depending on the json gem version this raises
+    #   Encoding::UndefinedConversionError (an EncodingError) or JSON::GeneratorError.
+    # * Infinity and NaN, which raise JSON::GeneratorError.
+    # * Structures nested deeper than the json gem allows, which raise
+    #   JSON::NestingError (a JSON::ParserError, not a GeneratorError).
+    # * A Struct, Data, Set, or OpenStruct instance. The json gem writes one as the String
+    #   returned by its #to_s, which for each is #inspect: every member is written with
+    #   #inspect, exposing the instance variables of any object it holds, and without a
+    #   depth limit, so a deep enough structure raises SystemStackError. The output is
+    #   checked for that rendering (a JSON String starting with "#<", or "Set[" for a Set on
+    #   Ruby 4.0), and SystemStackError is rescued, so .json_safe can write the members as a JSON object
+    #   or array instead. The json gem offers no hook for these short of strict mode,
+    #   which also rejects common values such as Time, and finding one up front would mean
+    #   walking every payload on the hot path. ActiveSupport already writes them through
+    #   #as_json, and escapes "<", so its output never matches the check.
     #
-    # The exception raised for non UTF-8 data depends on the json gem version:
-    # older versions raise Encoding::UndefinedConversionError (an EncodingError),
-    # newer versions wrap it as JSON::GeneratorError, so both are rescued. The
-    # retry is attempted only once: if it still fails (for example a
-    # JSON::GeneratorError caused by something other than encoding, such as NaN),
-    # the error propagates unchanged rather than being swallowed.
+    # Log data can come from untrusted input, for example a float parsed from a request
+    # parameter or a deeply nested request body. Without the repair, such a value would
+    # make the whole log event impossible to serialize, and so silently dropped.
+    #
+    # The retry is attempted only once: if it still fails (for example an object whose
+    # own #to_json raises), the error propagates unchanged rather than being swallowed.
     def self.to_json(value)
+      clean_json(value) || json_safe(value).to_json
+    end
+
+    # Returns the value when JSON writes it as it is, otherwise a .json_safe copy, for a writer
+    # that serializes the value itself, such as GELF. The check costs one #to_json; only the
+    # rare value that needs repairing is copied.
+    def self.json_ready(value)
+      clean_json(value) ? value : json_safe(value)
+    end
+
+    # Returns [String] the value's JSON, or nil when .to_json has to repair the data.
+    def self.clean_json(value)
+      json = value.to_json
+      # Almost no JSON holds a "<", and Ruby finds one byte several times faster than a longer
+      # substring, so it is looked for first. A String that merely starts with the same text is
+      # also repaired; that only costs time, since .json_safe leaves such a String as it is.
+      return if json.include?("<") && json.include?(INSPECTED_OBJECT)
+      return if INSPECTED_SET && json.include?(INSPECTED_SET)
+
+      json
+    rescue JSON::GeneratorError, JSON::NestingError, EncodingError, SystemStackError
+      nil
+    end
+    private_class_method :clean_json
+
+    # How the json gem writes an object through its #to_s: a JSON String starting with "#<", as
+    # for a Struct, Data, Set, or OpenStruct, whose #to_s is its #inspect.
+    INSPECTED_OBJECT = "\"#<".freeze
+
+    # How the json gem writes a Set where Set#inspect is "Set[...]" (Ruby 4.0), which holds no
+    # "#<" unless the Set holds an object. Nil where Set#inspect starts with "#<" too.
+    INSPECTED_SET = (::Set.new.inspect.start_with?("#<") ? nil : "\"Set[").freeze
+
+    # Nesting depth after which .json_safe replaces a Hash, Array, Struct, or Data with a
+    # placeholder. Well below the json gem's default max_nesting of 100, leaving room for
+    # the levels that a formatter wraps the payload in.
+    MAX_JSON_SAFE_DEPTH = 32
+
+    # Returns [String] value#inspect, or what the block renders the value as (for example with
+    # Amazing Print), without overflowing the stack for a value nested too deeply.
+    #
+    # #inspect has no depth limit: a Hash a few hundred levels deep overflows the stack of a
+    # thread. Rescuing the SystemStackError is not enough, since on macOS a second such overflow
+    # on the same thread crashes Ruby instead. A value that holds a structure nested deeper than
+    # MAX_JSON_SAFE_DEPTH is therefore rendered from a .json_safe copy, as the JSON formatters
+    # write it, cut off at that depth with their placeholder. Only that case pays for the copy.
+    def self.safe_inspect(value)
+      value = json_safe(value) if nested_too_deeply?(value)
+      block_given? ? yield(value) : value.inspect
+    end
+
+    # Returns [true|false] whether the value holds a Hash, Array, Struct, or Data nested deeper
+    # than MAX_JSON_SAFE_DEPTH, which .json_safe would replace with a placeholder. Never recurses
+    # deeper than that itself, and follows the same rules as .json_safe.
+    def self.nested_too_deeply?(value, depth = 0)
+      case value
+      when String, Symbol, Integer, NilClass
+        # The most common values, ruled out before the slower checks below.
+        false
+      when Hash
+        depth >= MAX_JSON_SAFE_DEPTH ||
+          value.any? { |key, val| nested_too_deeply?(key, depth + 1) || nested_too_deeply?(val, depth + 1) }
+      when Array, ::Set
+        depth >= MAX_JSON_SAFE_DEPTH || value.any? { |element| nested_too_deeply?(element, depth + 1) }
+      when Struct, ::Data
+        members_nested_too_deeply?(value, depth)
+      else
+        open_struct?(value) && members_nested_too_deeply?(value, depth)
+      end
+    end
+
+    # Whether the members of a Struct, Data, or OpenStruct are nested too deeply. As in
+    # .json_safe_members, a #to_h that does not return a Hash is one level deeper.
+    def self.members_nested_too_deeply?(value, depth)
+      return true if depth >= MAX_JSON_SAFE_DEPTH
+
+      members = value.to_h
+      members.is_a?(Hash) ? nested_too_deeply?(members, depth) : nested_too_deeply?(members, depth + 1)
+    end
+    private_class_method :members_nested_too_deeply?
+
+    # Returns [true|false] whether .json_safe writes the value as a JSON object or array: a Hash,
+    # Array, Set, Struct, Data, or OpenStruct. Every one of them would otherwise be written by its
+    # #to_s, which is its #inspect.
+    def self.structure?(value)
+      case value
+      when Hash, Array, ::Set, Struct, ::Data
+        true
+      else
+        open_struct?(value)
+      end
+    end
+
+    # Whether the value is an OpenStruct. The ostruct gem is only loaded by the application, and
+    # is a bundled gem since Ruby 4.0, so Semantic Logger never requires it.
+    def self.open_struct?(value)
+      # Only recognizes an OpenStruct, so that it is not written through its #inspect.
+      defined?(::OpenStruct) && value.is_a?(::OpenStruct) # rubocop:disable Style/OpenStructUse
+    end
+    private_class_method :open_struct?
+
+    # Returns a copy of the supplied value that JSON can represent:
+    # * Every String is converted to valid UTF-8, as by .encode_utf8.
+    # * Infinity and NaN floats become the Strings "Infinity", "-Infinity", and "NaN".
+    # * A Struct, Data, or OpenStruct instance becomes a Hash of its members (from #to_h),
+    #   and a Set an Array, as ActiveSupport's #as_json does, so that its members follow
+    #   these same rules.
+    # * A Hash key that is itself a structure becomes the JSON of its copy, since JSON writes a
+    #   key with #to_s, which for a structure is its #inspect.
+    # * Any other object whose JSON raises because of invalid UTF-8, such as an exception
+    #   message or a Pathname built from an uploaded file name, becomes its #to_s converted to
+    #   valid UTF-8.
+    # * A Hash, Array, Set, Struct, or Data nested deeper than MAX_JSON_SAFE_DEPTH is replaced
+    #   with a placeholder String naming its class, such as "#<Hash nested too deeply>".
+    #   So is one that holds itself, at the point where it would repeat.
+    # Any other value is returned as-is.
+    #
+    # The recursion never goes deeper than MAX_JSON_SAFE_DEPTH, and the placeholder does
+    # not look inside the structure it replaces. Rendering it instead (for example with
+    # #inspect) would recurse without limit through an arbitrarily deep structure,
+    # raising SystemStackError (or crashing Ruby) on the appender's thread, and would
+    # expose the instance variables of any object inside it. Ending a self-referencing
+    # structure where it repeats, rather than at that depth, keeps one that holds itself
+    # more than once from being copied an exponential number of times.
+    def self.json_safe(value, depth = 0, ancestors = nil)
+      case value
+      when String
+        encode_utf8_string(value)
+      when Float
+        value.finite? ? value : value.to_s
+      when Symbol, Integer, NilClass, TrueClass, FalseClass
+        value
+      when Hash, Array, ::Set, Struct, ::Data
+        json_safe_structure(value, depth, ancestors)
+      else
+        open_struct?(value) ? json_safe_structure(value, depth, ancestors) : json_safe_object(value)
+      end
+    end
+
+    # Returns a copy of a Hash, Array, Set, Struct, Data, or OpenStruct, or the placeholder for
+    # one nested too deeply or that holds itself.
+    def self.json_safe_structure(value, depth, ancestors)
+      ancestors ||= []
+      if depth >= MAX_JSON_SAFE_DEPTH || ancestors.any? { |ancestor| ancestor.equal?(value) }
+        return "#<#{value.class} nested too deeply>"
+      end
+
+      ancestors.push(value)
+      begin
+        json_safe_members(value, depth + 1, ancestors)
+      ensure
+        ancestors.pop
+      end
+    end
+    private_class_method :json_safe_structure
+
+    # Returns any other object as it is, when JSON can write it, otherwise its #to_s converted
+    # to valid UTF-8.
+    def self.json_safe_object(value)
       value.to_json
+      value
     rescue JSON::GeneratorError, EncodingError
-      encode_utf8(value).to_json
+      encode_utf8_string(value.to_s)
+    end
+    private_class_method :json_safe_object
+
+    # Returns a copy of the elements of a Hash, Array, Set, Struct, or Data, each made safe
+    # by .json_safe at the supplied depth.
+    def self.json_safe_members(value, depth, ancestors)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, val), hash|
+          key       = json_safe(key, depth, ancestors)
+          key       = key.to_json if key.is_a?(Hash) || key.is_a?(Array)
+          hash[key] = json_safe(val, depth, ancestors)
+        end
+      when Array, ::Set
+        value.map { |element| json_safe(element, depth, ancestors) }
+      else
+        # A Struct, Data, or OpenStruct. A #to_h that does not return a Hash is made safe one
+        # level deeper, so that the recursion still ends.
+        members = value.to_h
+        members.is_a?(Hash) ? json_safe_members(members, depth, ancestors) : json_safe(members, depth, ancestors)
+      end
     end
+    private_class_method :json_safe_members
 
     # Returns a copy of the supplied value with every String converted to valid UTF-8.
     #

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger
-  VERSION = "5.0.0".freeze
+  VERSION = "5.2.0".freeze
 end

data/lib/semantic_logger.rb

@@ -1,11 +1,11 @@
 require "concurrent"
-require "semantic_logger/core_ext/thread"
 require "semantic_logger/version"
 require "semantic_logger/utils"
 require "semantic_logger/ansi_colors"
 require "semantic_logger/levels"
 require "semantic_logger/base"
 require "semantic_logger/formatters"
+require "semantic_logger/exception_details"
 require "semantic_logger/log"
 require "semantic_logger/subscriber"
 require "semantic_logger/loggable"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Reid Morrison
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
 description: Semantic Logger is a high-performance, asynchronous structured logging
   framework for Ruby & Rails. It logs to multiple destinations via a background thread,
   preserving structured (semantic) payloads.
@@ -33,6 +47,17 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/api.md
+- docs/appenders.md
+- docs/config.md
+- docs/index.md
+- docs/log.md
+- docs/metrics.md
+- docs/operations.md
+- docs/rails.md
+- docs/security.md
+- docs/testing.md
+- docs/upgrading.md
 - lib/semantic_logger.rb
 - lib/semantic_logger/ansi_colors.rb
 - lib/semantic_logger/appender.rb
@@ -68,8 +93,8 @@ files:
 - lib/semantic_logger/base.rb
 - lib/semantic_logger/concerns/compatibility.rb
 - lib/semantic_logger/core_ext/process.rb
-- lib/semantic_logger/core_ext/thread.rb
 - lib/semantic_logger/debug_as_trace_logger.rb
+- lib/semantic_logger/exception_details.rb
 - lib/semantic_logger/formatters.rb
 - lib/semantic_logger/formatters/base.rb
 - lib/semantic_logger/formatters/color.rb
@@ -97,6 +122,8 @@ files:
 - lib/semantic_logger/metric/statsd.rb
 - lib/semantic_logger/processor.rb
 - lib/semantic_logger/queue_processor.rb
+- lib/semantic_logger/queue_processor/request.rb
+- lib/semantic_logger/queue_processor/throttled_counter.rb
 - lib/semantic_logger/reporters/minitest.rb
 - lib/semantic_logger/semantic_logger.rb
 - lib/semantic_logger/subscriber.rb
@@ -107,14 +134,14 @@ files:
 - lib/semantic_logger/test/rspec.rb
 - lib/semantic_logger/utils.rb
 - lib/semantic_logger/version.rb
-homepage: https://logger.rocketjob.io
+homepage: https://logger.reidmorrison.com
 licenses:
 - Apache-2.0
 metadata:
   bug_tracker_uri: https://github.com/reidmorrison/semantic_logger/issues
-  changelog_uri: https://github.com/reidmorrison/semantic_logger/releases
-  documentation_uri: https://logger.rocketjob.io
-  source_code_uri: https://github.com/reidmorrison/semantic_logger/tree/v5.0.0
+  changelog_uri: https://github.com/reidmorrison/semantic_logger/blob/main/CHANGELOG.md
+  documentation_uri: https://logger.reidmorrison.com
+  source_code_uri: https://github.com/reidmorrison/semantic_logger/tree/v5.2.0
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:

data/lib/semantic_logger/core_ext/thread.rb

@@ -1,30 +0,0 @@
-class Thread
-  undef :name if method_defined? :name
-  undef :name= if method_defined? :name=
-
-  # Returns the name of the current thread
-  # Default:
-  #    JRuby: The underlying Java thread name
-  #    Other: String representation of this thread's object_id
-  if defined? JRuby
-    def name
-      @name ||= JRuby.reference(self).native_thread.name
-    end
-  else
-    def name
-      @name ||= object_id.to_s
-    end
-  end
-
-  # Set the name of this thread
-  #   On JRuby it also sets the underlying Java Thread name
-  if defined? JRuby
-    def name=(name)
-      JRuby.reference(self).native_thread.name = @name = name.to_s
-    end
-  else
-    def name=(name)
-      @name = name.to_s
-    end
-  end
-end