semantic_logger 4.18.0 → 5.0.0

data/lib/semantic_logger/appender/open_telemetry.rb

@@ -29,7 +29,11 @@ module SemanticLogger
                      formatter: SemanticLogger::Formatters::OpenTelemetry.new,
                      metrics: true,
                      **args,
-                     &block)
+                     &)
+        # Base#initialize (via Subscriber) overwrites @name with the class name,
+        # so call super first and then assign our own attributes.
+        super(formatter: formatter, metrics: metrics, **args, &)
+
         @name      = name
         @version   = version
         @provider  = ::OpenTelemetry.logger_provider
@@ -38,8 +42,6 @@ module SemanticLogger
         # Capture the current Open Telemetry context when a log entry is captured.
         # Prevents duplicate subscribers as long as it is from a constant.
         SemanticLogger.on_log(CAPTURE_CONTEXT)
-
-        super(formatter: formatter, metrics: metrics, **args, &block)
       end
 
       def log(log)
@@ -57,7 +59,7 @@ module SemanticLogger
           timestamp:       time,
           body:            body.transform_keys!(&:to_s),
           attributes:      payload,
-          context:         log.context[:open_telemetry] || ::OpenTelemetry::Context.current
+          context:         (log.context && log.context[:open_telemetry]) || ::OpenTelemetry::Context.current
         )
         true
       end
@@ -69,7 +71,7 @@ module SemanticLogger
         @provider.force_flush if @provider.respond_to?(:force_flush)
       rescue StandardError => e
         # Swallow to avoid noisy shutdown exceptions.
-        SemanticLogger.logger.warn("Flush failed: #{e.class}: #{e.message}")
+        SemanticLogger::Processor.logger.warn("Flush failed: #{e.class}: #{e.message}")
       end
 
       # Close the appender and release resources.
@@ -78,7 +80,7 @@ module SemanticLogger
 
         @provider.shutdown if @provider.respond_to?(:shutdown)
       rescue StandardError => e
-        SemanticLogger.logger.warn("Shutdown failed: #{e.class}: #{e.message}")
+        SemanticLogger::Processor.logger.warn("Shutdown failed: #{e.class}: #{e.message}")
       ensure
         @provider = nil
       end

data/lib/semantic_logger/appender/opensearch.rb

@@ -0,0 +1,35 @@
+begin
+  require "opensearch-ruby"
+rescue LoadError
+  raise LoadError,
+        'Gem opensearch-ruby is required for logging to OpenSearch. Please add the gem "opensearch-ruby" to your Gemfile.'
+end
+
+require "semantic_logger/appender/elasticsearch_base"
+
+# Forward all log messages to OpenSearch (e.g. AWS OpenSearch).
+#
+# OpenSearch is a fork of Elasticsearch 7.10. The client API and bulk
+# protocol are identical, so this appender reuses the same pipeline as the
+# Elasticsearch appender; only the backing client gem differs. Use this
+# appender (with the `opensearch-ruby` gem) instead of `:elasticsearch`
+# when talking to an OpenSearch server, since modern `elasticsearch` gems
+# reject non-Elasticsearch servers via a product check.
+#
+# Example:
+#
+#   SemanticLogger.add_appender(
+#     appender: :opensearch,
+#     url:      'http://localhost:9200'
+#   )
+module SemanticLogger
+  module Appender
+    class Opensearch < ElasticsearchBase
+      private
+
+      def client_class
+        ::OpenSearch::Client
+      end
+    end
+  end
+end

data/lib/semantic_logger/appender/rabbitmq.rb

@@ -12,7 +12,7 @@ end
 #     appender: :rabbitmq,
 #
 #     # Name of the queue in RabbitMQ where to publish the logs. This queue will be bound to "amqp.direct" exchange.
-#     queue: 'semantic_logger',
+#     queue_name: 'semantic_logger',
 #
 #     # This host will be used for RabbitMQ connection.
 #     # NOTE this is different than :host option which is used by the logger directly.
@@ -82,13 +82,13 @@ module SemanticLogger
       #   more parameters supported by Bunny: http://rubybunny.info/articles/connecting.html
       def initialize(queue_name: "semantic_logger", rabbitmq_host: nil,
                      level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil, metrics: true,
-                     **args, &block)
+                     **args, &)
         @queue_name             = queue_name
         @rabbitmq_args          = args.dup
         @rabbitmq_args[:host]   = rabbitmq_host
         @rabbitmq_args[:logger] = logger
 
-        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: metrics, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: metrics, &)
         reopen
       end
 

data/lib/semantic_logger/appender/sentry_ruby.rb

@@ -133,10 +133,10 @@ module SemanticLogger
       #
       def extract_tags!(context)
         named_tags = context.delete(:named_tags) || {}
-        named_tags = named_tags.map { |k, v| [k.to_s, v.to_s] }.to_h
+        named_tags = named_tags.to_h { |k, v| [k.to_s, v.to_s] }
         tags = context.delete(:tags)
         named_tags.merge!("tag" => tags.join(", ")) { |_, v1, v2| "#{v1}, #{v2}" } if tags
-        named_tags.map { |k, v| [k[0...32], v[0...256]] }.to_h
+        named_tags.to_h { |k, v| [k[0...32], v[0...256]] }
       end
     end
   end

data/lib/semantic_logger/appender/splunk.rb

@@ -89,11 +89,11 @@ module SemanticLogger
       #     regular expression. All other messages will be ignored.
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
-      def initialize(index: "main", source_type: nil, **args, &block)
+      def initialize(index: "main", source_type: nil, **args, &)
         @index       = index
         @source_type = source_type
 
-        super(**args, &block)
+        super(**args, &)
         reopen
       end
 

data/lib/semantic_logger/appender/splunk_http.rb

@@ -73,11 +73,11 @@ module SemanticLogger
                      index: nil,
                      compress: true,
                      **args,
-                     &block)
+                     &)
         @source_type = source_type
         @index       = index
 
-        super(compress: compress, **args, &block)
+        super(compress: compress, **args, &)
 
         # Put splunk auth token in the header of every HTTP post.
         @header["Authorization"] = "Splunk #{token}"
@@ -98,7 +98,7 @@ module SemanticLogger
         }
         message[:sourcetype]  = source_type if source_type
         message[:index]       = index if index
-        message.to_json
+        Utils.to_json(message)
       end
     end
   end

data/lib/semantic_logger/appender/syslog.rb

@@ -130,7 +130,7 @@ module SemanticLogger
                      options: ::Syslog::LOG_PID | ::Syslog::LOG_CONS,
                      tcp_client: {},
                      **args,
-                     &block)
+                     &)
         @options            = options
         @facility           = facility
         @max_size           = max_size
@@ -165,7 +165,7 @@ module SemanticLogger
           end
         end
 
-        super(**args, &block)
+        super(**args, &)
         reopen
       end
 
@@ -213,8 +213,9 @@ module SemanticLogger
       # Returns [SemanticLogger::Formatters::Base] default formatter for this Appender depending on the protocal selected
       def default_formatter
         if protocol == :syslog
-          # Format is text output without the time
-          SemanticLogger::Formatters::Default.new(time_format: :notime)
+          # Format is text output without the time.
+          # Escape control characters so untrusted log data cannot forge syslog entries.
+          SemanticLogger::Formatters::Default.new(time_format: :notime, escape_control_chars: true)
         else
           SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map, max_size: max_size)
         end

data/lib/semantic_logger/appender/tcp.rb

@@ -184,7 +184,7 @@ module SemanticLogger
       #   )
       def initialize(separator: "\n",
                      level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil, metrics: false,
-                     **tcp_client_args, &block)
+                     **tcp_client_args, &)
         @separator       = separator
         @tcp_client_args = tcp_client_args
 
@@ -192,7 +192,7 @@ module SemanticLogger
         Net::TCPClient.logger      = logger
         Net::TCPClient.logger.name = "Net::TCPClient"
 
-        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: metrics, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: metrics, &)
         reopen
       end
 

data/lib/semantic_logger/appender/udp.rb

@@ -61,11 +61,11 @@ module SemanticLogger
       #     appender: :udp,
       #     server:   'server:3300'
       #   )
-      def initialize(server:, udp_flags: 0, metrics: true, **args, &block)
+      def initialize(server:, udp_flags: 0, metrics: true, **args, &)
         @server    = server
         @udp_flags = udp_flags
 
-        super(metrics: metrics, **args, &block)
+        super(metrics: metrics, **args, &)
         reopen
       end
 

data/lib/semantic_logger/appender/wrapper.rb

@@ -38,17 +38,17 @@ module SemanticLogger
       #    logger.info('Hello World', some: :payload)
       #
       # Install the `rails_semantic_logger` gem to replace the Rails logger with Semantic Logger.
-      def initialize(logger:, **args, &block)
+      def initialize(logger:, **args, &)
         @logger = logger
 
         # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
-        does_not_implement = LEVELS[1..-1].find { |i| !@logger.respond_to?(i) }
+        does_not_implement = LEVELS[1..].find { |i| !@logger.respond_to?(i) }
         if does_not_implement
           raise(ArgumentError,
-                "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}")
+                "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..].inspect}")
         end
 
-        super(**args, &block)
+        super(**args, &)
       end
 
       # Pass log calls to the underlying Rails, log4j or Ruby logger

data/lib/semantic_logger/appender.rb

@@ -2,10 +2,10 @@ 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 :CloudwatchLogs,      "semantic_logger/appender/cloudwatch_logs"
     autoload :Elasticsearch,       "semantic_logger/appender/elasticsearch"
+    autoload :ElasticsearchBase,   "semantic_logger/appender/elasticsearch_base"
     autoload :ElasticsearchHttp,   "semantic_logger/appender/elasticsearch_http"
     autoload :File,                "semantic_logger/appender/file"
     autoload :Graylog,             "semantic_logger/appender/graylog"
@@ -18,6 +18,7 @@ module SemanticLogger
     autoload :MongoDB,             "semantic_logger/appender/mongodb"
     autoload :NewRelic,            "semantic_logger/appender/new_relic"
     autoload :NewRelicLogs,        "semantic_logger/appender/new_relic_logs"
+    autoload :Opensearch,          "semantic_logger/appender/opensearch"
     autoload :OpenTelemetry,       "semantic_logger/appender/open_telemetry"
     autoload :Rabbitmq,            "semantic_logger/appender/rabbitmq"
     autoload :Splunk,              "semantic_logger/appender/splunk"
@@ -34,27 +35,37 @@ module SemanticLogger
     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,
+                     non_blocking: false, dropped_message_report_seconds: 30,
+                     async_max_retries: 100,
                      **args,
-                     &block)
-      appender = build(**args, &block)
+                     &)
+      appender = build(**args, &)
 
-      # If appender implements #batch, then it should use the batch proxy by default.
-      batch    = true if batch.nil? && appender.respond_to?(:batch)
+      # If appender implements #batch, then it should use the batch proxy by default,
+      # unless the appender opts out of batching by default (e.g. the HTTP appender).
+      batch    = true if batch.nil? && appender.respond_to?(:batch) && appender.batch_by_default?
 
       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::Async.new(
+          appender:                       appender,
+          batch:                          true,
+          max_queue_size:                 max_queue_size,
+          lag_threshold_s:                lag_threshold_s,
+          batch_size:                     batch_size,
+          batch_seconds:                  batch_seconds,
+          non_blocking:                   non_blocking,
+          dropped_message_report_seconds: dropped_message_report_seconds,
+          async_max_retries:              async_max_retries
         )
       elsif async == true
         Appender::Async.new(
-          appender:           appender,
-          max_queue_size:     max_queue_size,
-          lag_check_interval: lag_check_interval,
-          lag_threshold_s:    lag_threshold_s
+          appender:                       appender,
+          max_queue_size:                 max_queue_size,
+          lag_check_interval:             lag_check_interval,
+          lag_threshold_s:                lag_threshold_s,
+          non_blocking:                   non_blocking,
+          dropped_message_report_seconds: dropped_message_report_seconds,
+          async_max_retries:              async_max_retries
         )
       else
         appender
@@ -62,13 +73,13 @@ module SemanticLogger
     end
 
     # Returns [Subscriber] instance from the supplied options.
-    def self.build(io: nil, file_name: nil, appender: nil, metric: nil, logger: nil, **args, &block)
+    def self.build(io: nil, file_name: nil, appender: nil, metric: nil, logger: nil, **args, &)
       if file_name
-        SemanticLogger::Appender::File.new(file_name, **args, &block)
+        SemanticLogger::Appender::File.new(file_name, **args, &)
       elsif io
-        SemanticLogger::Appender::IO.new(io, **args, &block)
+        SemanticLogger::Appender::IO.new(io, **args, &)
       elsif logger
-        SemanticLogger::Appender::Wrapper.new(logger: logger, **args, &block)
+        SemanticLogger::Appender::Wrapper.new(logger: logger, **args, &)
       elsif appender
         if appender.is_a?(Symbol)
           SemanticLogger::Utils.constantize_symbol(appender).new(**args)

data/lib/semantic_logger/appenders.rb

@@ -9,11 +9,12 @@ module SemanticLogger
       super()
     end
 
-    def add(**args, &block)
-      appender = SemanticLogger::Appender.factory(**args, &block)
+    def add(**args, &)
+      appender = SemanticLogger::Appender.factory(**args, &)
 
-      if appender.respond_to?(:console_output?) && appender.console_output? && console_output?
-        logger.warn "Ignoring attempt to add a second console appender: #{appender.class.name} since it would result in duplicate console output."
+      stream = appender.respond_to?(:console_stream) && appender.console_stream
+      if stream && console_streams.include?(stream)
+        logger.warn "Ignoring attempt to add a second #{stream} console appender since it would result in duplicate console output."
         return
       end
 
@@ -21,10 +22,30 @@ module SemanticLogger
       appender
     end
 
+    # The console streams (:stdout and/or :stderr) already being written to by the existing appenders.
+    def console_streams
+      filter_map { |appender| appender.console_stream if appender.respond_to?(:console_stream) }
+    end
+
     # Whether any of the existing appenders already output to the console?
     # I.e. Writes to stdout or stderr.
     def console_output?
-      any? { |appender| appender.respond_to?(:console_output?) && appender.console_output? }
+      console_streams.any?
+    end
+
+    # Returns [Array<Hash>] operational statistics for each appender.
+    #
+    # Appenders that run asynchronously (see SemanticLogger::Appender::Async#stats) report
+    # their queue size and processed/dropped counts. Appenders that log inline on the
+    # processor thread report only their name with `async: false`.
+    def stats
+      map do |appender|
+        if appender.respond_to?(:stats)
+          appender.stats
+        else
+          {name: appender.name, async: false}
+        end
+      end
     end
 
     def log(log)

data/lib/semantic_logger/base.rb

@@ -198,7 +198,18 @@ module SemanticLogger
     #   to:
     #     `logger.tagged('first', 'more', 'other')`
     # - For better performance with clean tags, see `SemanticLogger.tagged`.
+    #
+    # Child logger:
+    # - When called *without* a block, returns a new logger instance that permanently
+    #   carries the supplied tags ("instance tags"). Those tags are added to every log
+    #   entry emitted by the returned logger, and _only_ that logger, even across threads.
+    #   Unlike the block form they are not pushed onto the thread, so other loggers are
+    #   unaffected. This is the recommended way to bind a logger to an object's identity:
+    #     logger = SemanticLogger['Cart'].tagged(cart_id: cart.id)
     def tagged(*tags)
+      # No block: build a child logger that carries these tags on every entry.
+      return tagged_child(tags) unless block_given?
+
       block = -> { yield(self) }
       # Allow named tags to be passed into the logger
       # Rails::Rack::Logger passes logs as an array with a single argument
@@ -226,6 +237,10 @@ module SemanticLogger
       SemanticLogger.named_tags
     end
 
+    # Tags permanently bound to this logger instance via `#tagged` (without a block).
+    # Empty for a regular (non-child) logger.
+    attr_reader :instance_tags, :instance_named_tags
+
     # Returns the list of tags pushed after flattening them out and removing blanks
     #
     # Note:
@@ -244,13 +259,13 @@ module SemanticLogger
     end
 
     # :nodoc:
-    def silence(new_level = :error, &block)
-      SemanticLogger.silence(new_level, &block)
+    def silence(new_level = :error, &)
+      SemanticLogger.silence(new_level, &)
     end
 
     # :nodoc:
-    def fast_tag(tag, &block)
-      SemanticLogger.fast_tag(tag, &block)
+    def fast_tag(tag, &)
+      SemanticLogger.fast_tag(tag, &)
     end
 
     # Write log data to underlying data storage
@@ -263,6 +278,11 @@ module SemanticLogger
       meets_log_level?(log) && !filtered?(log)
     end
 
+    protected
+
+    # Only assigned to when building a child logger via `#tagged` (see #tagged_child).
+    attr_writer :instance_tags, :instance_named_tags
+
     private
 
     # Initializer for Abstract Class SemanticLogger::Base
@@ -294,8 +314,13 @@ module SemanticLogger
         raise ":filter must be a Regexp, Proc, or implement :call"
       end
 
-      @filter = filter.is_a?(Regexp) ? filter.freeze : filter
-      @name   = klass.is_a?(String) ? klass : klass.name
+      @filter              = filter.is_a?(Regexp) ? filter.freeze : filter
+      @name                = klass.is_a?(String) ? klass : klass.name
+      # `[].freeze` / `{}.freeze` compile to `opt_ary_freeze` / `opt_hash_freeze`, which return
+      # a shared frozen singleton. Every logger points at the same two objects, so these default
+      # (empty) instance tags allocate no garbage. Child loggers replace them via #tagged_child.
+      @instance_tags       = [].freeze
+      @instance_named_tags = {}.freeze
       if level.nil?
         # Allow the global default level to determine this loggers log level
         @level_index = nil
@@ -324,13 +349,59 @@ module SemanticLogger
       (level_index <= (log.level_index || 0))
     end
 
+    # Build a new Log entry, layering this logger's instance tags on top of the
+    # current thread context.
+    def new_log(level, index = nil)
+      apply_instance_tags(Log.new(name, level, index))
+    end
+
+    # Merge this logger's instance tags into the supplied Log entry.
+    #
+    # Composition (mirrors the per-logger merge rule proposed in PR #301):
+    # - Positional: thread tags first, then this logger's instance tags appended.
+    # - Named: instance named tags merged on top of the thread named tags, so on a
+    #   key conflict the logger's own identity wins (it is the more specific value).
+    # Only this logger's entries are affected; the thread context is left untouched.
+    def apply_instance_tags(log)
+      unless @instance_tags.empty?
+        log.tags = log.tags.empty? ? @instance_tags.dup : log.tags + @instance_tags
+      end
+      unless @instance_named_tags.empty?
+        log.named_tags = log.named_tags.empty? ? @instance_named_tags.dup : log.named_tags.merge(@instance_named_tags)
+      end
+      log
+    end
+
+    # Returns a copy of this logger that permanently carries the supplied tags.
+    # Positional (string) and named (Hash) tags may be mixed; they are merged on
+    # top of any instance tags this logger already carries.
+    def tagged_child(tags)
+      positional = @instance_tags.dup
+      named      = @instance_named_tags.dup
+      tags.flatten.each do |tag|
+        case tag
+        when Hash
+          named = named.merge(tag)
+        when nil, ""
+          # Ignore blanks for Rails compatibility, matching the block form.
+        else
+          positional << tag.to_s
+        end
+      end
+
+      child                     = clone
+      child.instance_tags       = positional.freeze
+      child.instance_named_tags = named.freeze
+      child
+    end
+
     # Log message at the specified level
-    def log_internal(level, index, message = nil, payload = nil, exception = nil)
+    def log_internal(level, index, message = nil, payload = nil, exception = nil, &block)
       # Handle variable number of arguments by detecting exception object and payload hash.
       if exception.nil? && payload.nil? && message.respond_to?(:backtrace) && message.respond_to?(:message)
         exception = message
         message   = nil
-      elsif exception.nil? && payload && payload.respond_to?(:backtrace) && payload.respond_to?(:message)
+      elsif exception.nil? && payload.respond_to?(:backtrace) && payload.respond_to?(:message)
         exception = payload
         payload   = nil
       elsif payload && !payload.is_a?(Hash)
@@ -338,12 +409,12 @@ module SemanticLogger
         payload = nil
       end
 
-      log = Log.new(name, level, index)
+      log = new_log(level, index)
       should_log =
         if exception.nil? && payload.nil? && message.is_a?(Hash)
           # All arguments as a hash in the message.
           log.assign(**log.extract_arguments(message))
-        elsif exception.nil? && message && payload && payload.is_a?(Hash)
+        elsif exception.nil? && message && payload.is_a?(Hash)
           # Message supplied along with a hash with the remaining arguments.
           log.assign(**log.extract_arguments(payload, message))
         else
@@ -352,20 +423,28 @@ module SemanticLogger
         end
 
       # Add result of block to message or payload if not nil
-      if block_given?
-        result = yield(log)
-        case result
-        when String
-          log.message = log.message.nil? ? result : "#{log.message} -- #{result}"
-        when Hash
-          log.assign_hash(result)
-        end
-      end
+      apply_block_result(log, &block) if block
 
       # Log level may change during assign due to :on_exception_level
       self.log(log) if should_log && should_log?(log)
     end
 
+    # Merge the result of a logging block into the log entry.
+    #
+    # Zero-arity blocks (e.g. `logger.info { "msg" }` or a zero-arity lambda) are called without
+    # arguments. Lambdas enforce their arity, so yielding the log to a zero-arity lambda would
+    # raise ArgumentError. Blocks that accept an argument still receive the log so they can read
+    # or mutate it.
+    def apply_block_result(log, &block)
+      result = block.arity.zero? ? block.call : block.call(log)
+      case result
+      when String
+        log.message = log.message.nil? ? result : "#{log.message} -- #{result}"
+      when Hash
+        log.assign_hash(result)
+      end
+    end
+
     # Measure the supplied block and log the message
     def measure_internal(level, index, message, params)
       exception = nil
@@ -389,7 +468,7 @@ module SemanticLogger
         exception = e
       ensure
         # Must use ensure block otherwise a `return` in the yield above will skip the log entry
-        log = Log.new(name, level, index)
+        log = new_log(level, index)
         exception ||= params[:exception]
         message   = params[:message] if params[:message]
         duration  =
@@ -437,7 +516,7 @@ module SemanticLogger
       rescue Exception => e
         exception = e
       ensure
-        log = Log.new(name, level, index)
+        log = new_log(level, index)
         # May return false due to elastic logging
         should_log = log.assign(
           message:            message,

data/lib/semantic_logger/concerns/compatibility.rb

@@ -37,11 +37,11 @@ module SemanticLogger
       end
 
       # :nodoc:
-      def add(severity, message = nil, progname = nil, &block)
+      def add(severity, message = nil, progname = nil, &)
         index = Levels.index(severity)
         if level_index <= index
           level = Levels.level(index)
-          log_internal(level, index, message, progname, &block)
+          log_internal(level, index, message, progname, &)
           true
         else
           false

data/lib/semantic_logger/core_ext/process.rb

@@ -0,0 +1,34 @@
+module SemanticLogger
+  module CoreExt
+    # Reopen all appenders in the child process after a fork.
+    #
+    # Prepended onto `Process.singleton_class` when Semantic Logger is loaded.
+    # Enabled by default; opt out with `SemanticLogger.reopen_on_fork = false`.
+    #
+    # `Process._fork` (Ruby 3.1+) is the single method that every fork path routes
+    # through (`Kernel#fork`, `Process.fork`, `IO.popen`, `Kernel#system`, and
+    # backticks), so overriding it covers them all with one hook.
+    #
+    # Note: both `_fork` and `daemon` must be overridden to reliably restart the
+    # appender thread, since `Process.daemon` does not route through `_fork`
+    # (https://bugs.ruby-lang.org/issues/18911). Do not collapse this down to only
+    # `_fork`.
+    module Process
+      # `_fork` runs in both the parent and the child. It returns 0 in the child
+      # and the child's pid in the parent, so only reopen in the child. Reopening
+      # in the parent would needlessly recreate its queue and worker thread,
+      # risking the loss of messages still on the queue.
+      def _fork
+        child_pid = super
+        SemanticLogger.reopen if child_pid.zero? && SemanticLogger.reopen_on_fork?
+        child_pid
+      end
+
+      # `Process.daemon` does not route through `_fork`, so reopen explicitly. Once
+      # it returns, the caller is running as the daemon (child) process.
+      def daemon(...)
+        super.tap { SemanticLogger.reopen if SemanticLogger.reopen_on_fork? }
+      end
+    end
+  end
+end