legion-logging 1.5.6 → 1.5.21

data/lib/legion/logging/builder.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'monitor'
+require_relative 'output_logger'
+require_relative 'rotation'
 
 module Legion
   module Logging
     module Builder
+      LIFECYCLE_MUTEX = Mutex.new
+      private_constant :LIFECYCLE_MUTEX
+
       def log_format(format: :text, include_pid: false, **)
         @format = format.to_sym
         if @format == :json
@@ -20,11 +26,19 @@ module Legion
 
       def json_format(include_pid: false)
         log.formatter = proc do |severity, datetime, _progname, msg|
+          origin = Thread.current[:legion_log_origin]
+          if origin
+            timestamp = origin[:timestamp]
+            thread_id = origin[:thread]
+          else
+            timestamp = datetime.utc
+            thread_id = Thread.current.object_id
+          end
           entry = {
-            timestamp: datetime.utc.iso8601(3),
+            timestamp: timestamp.iso8601(3),
             level:     severity.downcase,
             message:   msg.is_a?(String) ? msg.gsub(/\e\[[0-9;]*m/, '') : msg.to_s,
-            thread:    Thread.current.object_id
+            thread:    thread_id
           }
           entry[:pid] = ::Process.pid if include_pid
           segments = Thread.current[:legion_log_segments]
@@ -48,6 +62,7 @@ module Legion
 
       def text_format(include_pid: false, **options)
         log.formatter = proc do |severity, datetime, _progname, msg|
+          datetime = Thread.current[:legion_log_origin]&.[](:timestamp)&.getlocal || datetime
           lex_name = resolve_lex_tag(options)
           runner_trace = Thread.current[:legion_log_caller] || build_runner_trace if lex_name
 
@@ -109,33 +124,40 @@ module Legion
       end
 
       def output(**options)
-        set_log(logfile: options[:log_file], log_stdout: options[:log_stdout])
+        set_log(logfile: options[:log_file], log_stdout: options[:log_stdout], rotation: options[:rotation],
+                shutdown_timeout: options.fetch(:shutdown_timeout, 2))
       end
 
       def log
         @log ||= set_log
       end
 
-      def set_log(logfile: nil, log_stdout: nil, **)
-        previous_log = @log
-
-        if logfile && log_stdout != false
-          path = prepare_log_path(logfile)
-          require_relative 'multi_io'
-          file = File.new(path, 'a')
-          file.sync = true
-          io = MultiIO.new($stdout, file)
-          @log = ::Logger.new(io)
-        elsif logfile
-          file = File.new(prepare_log_path(logfile), 'a')
-          file.sync = true
-          @log = ::Logger.new(file)
-        else
-          @log = ::Logger.new($stdout)
-        end
+      # A nil rotation option reads loaded Settings; false disables rotation.
+      def set_log(logfile: nil, log_stdout: nil, rotation: nil, shutdown_timeout: 2, **)
+        with_lifecycle_lock do
+          deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + shutdown_timeout if shutdown_timeout
+          return false if @async_writer && stop_async_writer(timeout: shutdown_timeout) == false
+
+          previous_log = @log
+          rotation_opts = Legion::Logging::Rotation.resolve(raw: rotation.nil? ? Legion::Logging::Rotation.from_settings : rotation)
+          remaining = [deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC), 0].max if deadline
+          stdout = stdout_target(rotation_opts: rotation_opts, uses_stdout: !logfile || log_stdout != false, timeout: remaining)
+          return false if stdout == false
+
+          if logfile && log_stdout != false
+            require_relative 'multi_io'
+            io = Legion::Logging::MultiIO.new(stdout, open_log_file(path: prepare_log_path(logfile), rotation_opts: rotation_opts))
+            @log = Legion::Logging::OutputLogger.new(io)
+          elsif logfile
+            @log = Legion::Logging::OutputLogger.new(open_log_file(path: prepare_log_path(logfile), rotation_opts: rotation_opts))
+          else
+            @log = Legion::Logging::OutputLogger.new(stdout)
+          end
 
-        close_replaced_log(previous_log)
-        @log
+          @log.async_writer = @async_writer
+          close_replaced_log(previous_log)
+          @log
+        end
       end
 
       def prepare_log_path(path)
@@ -175,31 +197,77 @@ module Legion
         (@async == true && @async_writer&.alive?) || false
       end
 
-      # rubocop:disable Naming/PredicateMethod
-      def start_async_writer(buffer_size: 10_000)
-        require_relative 'async_writer'
-        return false if @async_writer&.alive? && stop_async_writer == false
+      def start_async_writer(buffer_size: 10_000, timeout: 2)
+        with_lifecycle_lock do
+          require_relative 'async_writer'
+          return false if @async_writer && stop_async_writer(timeout: timeout) == false
 
-        @async_writer = AsyncWriter.new(log, buffer_size: buffer_size)
-        @async_writer.start
-        @async = true
-        true
+          @async_writer = AsyncWriter.new(log, buffer_size: buffer_size)
+          log.async_writer = @async_writer
+          @async_writer.start
+          @async = true
+          true
+        end
       end
 
-      def stop_async_writer
-        writer = @async_writer
-        stopped = writer&.stop
-        return false if stopped == false
+      def stop_async_writer(timeout: 2)
+        with_lifecycle_lock do
+          deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + timeout if timeout
+          return false if @async_writer && @async_writer.stop(timeout: timeout) == false
 
-        close_replaced_log(writer.logger) if writer.respond_to?(:logger)
-        @async_writer = nil if @async_writer.equal?(writer)
-        @async = false
-        true
+          remaining = [deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC), 0].max if deadline
+          flush_stdio_output!(timeout: remaining)
+        end
       end
-      # rubocop:enable Naming/PredicateMethod
 
       private
 
+      def open_log_file(path:, rotation_opts:)
+        if rotation_opts[:enabled]
+          return Legion::Logging::RotatingFile.new(path: path, max_bytes: rotation_opts[:max_bytes], max_files: rotation_opts[:max_files])
+        end
+
+        file = File.new(path, 'a')
+        file.sync = true
+        file
+      end
+
+      def stdout_target(rotation_opts:, uses_stdout:, timeout:)
+        if rotation_opts[:enabled] && rotation_opts[:stdio]
+          return $stdout unless uses_stdout || equal?(Legion::Logging)
+
+          return Legion::Logging::StdioRotator.shared(max_bytes: rotation_opts[:max_bytes], max_files: rotation_opts[:max_files]) || $stdout
+        end
+
+        return false if equal?(Legion::Logging) && !Legion::Logging::StdioRotator.reset!(timeout: timeout)
+
+        $stdout
+      end
+
+      def flush_stdio_output!(timeout:) # rubocop:disable Naming/PredicateMethod -- Performs a drain; false signals its deadline.
+        deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + timeout if timeout
+        device = @log&.instance_variable_get(:@logdev)&.dev
+        targets = defined?(Legion::Logging::MultiIO) && device.is_a?(Legion::Logging::MultiIO) ? device.targets : [device]
+        captures = targets.grep(Legion::Logging::StdioRotator)
+        current = Legion::Logging::StdioRotator.current
+        captures << current if equal?(Legion::Logging) && current && !captures.include?(current)
+        captures.each do |capture|
+          remaining = [deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC), 0].max if deadline
+          return false if capture.flush(timeout: remaining) == false
+        end
+        true
+      end
+
+      def with_lifecycle_lock
+        lock = LIFECYCLE_MUTEX.synchronize { @lifecycle_lock ||= Monitor.new }
+        entered = lock.try_enter
+        return false unless entered
+
+        yield
+      ensure
+        lock.exit if entered
+      end
+
       def close_replaced_log(logger)
         return unless logger
         return if logger.equal?(@log)

data/lib/legion/logging/event_builder.rb

@@ -69,9 +69,10 @@ module Legion
           bt = Array(exception.backtrace)
           cf_file, cf_line, cf_func = parse_backtrace_location(bt.first) ||
                                       caller_location(caller_offset)
+          origin = Thread.current[:legion_log_origin]
 
           event = {
-            timestamp:       Time.now.utc.iso8601(3),
+            timestamp:       (origin&.[](:timestamp) || Time.now.utc).iso8601(3),
             level:           level,
             exception_class: exception.class.name,
             message:         truncate_bytes(exception.message.to_s, MAX_MESSAGE_BYTES),
@@ -89,7 +90,7 @@ module Legion
             ruby_version:    "#{RUBY_VERSION} #{RUBY_PLATFORM}",
             handled:         handled,
             pid:             ::Process.pid,
-            thread:          Thread.current.object_id
+            thread:          origin&.[](:thread) || Thread.current.object_id
           }
 
           event[:task_id] = task_id if task_id
@@ -147,12 +148,13 @@ module Legion
         private
 
         def base_fields(level, message)
+          origin = Thread.current[:legion_log_origin]
           {
-            timestamp: Time.now.utc.iso8601(3),
+            timestamp: (origin&.[](:timestamp) || Time.now.utc).iso8601(3),
             level:     level,
             message:   message.is_a?(Exception) ? message.message : strip_ansi(message.to_s),
             pid:       ::Process.pid,
-            thread:    Thread.current.object_id
+            thread:    origin&.[](:thread) || Thread.current.object_id
           }
         end
 
@@ -166,6 +168,7 @@ module Legion
 
         def add_node(event)
           return unless defined?(Legion::Settings)
+          return unless Legion::Settings.respond_to?(:loaded?) ? Legion::Settings.loaded? : true
 
           name = begin
             Legion::Settings[:client][:name]
@@ -177,7 +180,7 @@ module Legion
         end
 
         def add_caller_info(event, offset)
-          loc = caller_locations(offset + 1, 1)&.first
+          loc = Thread.current[:legion_log_origin]&.[](:location) || caller_locations(offset + 1, 1)&.first
           return unless loc
 
           event[:caller] = {
@@ -268,7 +271,7 @@ module Legion
         end
 
         def caller_location(offset)
-          loc = caller_locations(offset + 2, 1)&.first
+          loc = Thread.current[:legion_log_origin]&.[](:location) || caller_locations(offset + 2, 1)&.first
           return [nil, nil, nil] unless loc
 
           [loc.absolute_path || loc.path, loc.lineno, loc.base_label]

data/lib/legion/logging/helper.rb

@@ -80,6 +80,13 @@ module Legion
       end
 
       def handle_exception(exception, task_id: nil, level: :error, handled: true, **opts)
+        if Legion::Logging.async_producer?
+          return Legion::Logging.defer_log_call(
+            receiver: self, method_name: :handle_exception, arguments: [exception],
+            keywords: { task_id: task_id, level: level, handled: handled, **opts }
+          )
+        end
+
         segments = derive_log_segments
         spec = gem_spec
         ctx = Thread.current[:legion_context] || {}
@@ -101,7 +108,7 @@ module Legion
         event = Legion::Logging::Redactor.redact(event) if defined?(Legion::Logging::Redactor)
 
         write_exception_to_log(exception, event, level, segments)
-        publish_exception(event, level) if structured_exception_support?
+        Legion::Logging.publish_exception(event: event, level: level) if structured_exception_support?
       end
 
       def self.included(base)
@@ -519,7 +526,9 @@ module Legion
         lines << "  #{context_line}" unless context_line.empty?
 
         max_frames = if event[:backtrace_limit].nil?
-                       defined?(Legion::Settings) ? Legion::Settings[:logging][:backtrace_limit] : nil
+                       if defined?(Legion::Settings) && (!Legion::Settings.respond_to?(:loaded?) || Legion::Settings.loaded?)
+                         Legion::Settings.dig(:logging, :backtrace_limit)
+                       end
                      else
                        event[:backtrace_limit]
                      end
@@ -555,23 +564,6 @@ module Legion
         parts.join(' | ')
       end
 
-      # -- Exception structured publish --
-
-      def publish_exception(event, level)
-        return unless structured_exception_support?
-
-        lex_name = event[:lex] || 'core'
-        comp = event[:component_type] || :unknown
-        routing_key = "legion.logging.exception.#{level}.#{lex_name}.#{comp}"
-
-        headers = build_exception_headers(event, comp, level)
-        properties = build_exception_properties(event, level)
-
-        Legion::Logging.exception_writer.call(event, routing_key: routing_key, headers: headers, properties: properties)
-      rescue StandardError => e
-        Legion::Logging.warn("Failed to publish exception event: #{e.class}: #{e.message}") if Legion::Logging.respond_to?(:warn)
-      end
-
       def structured_exception_support?
         defined?(Legion::Logging::EventBuilder) &&
           Legion::Logging.respond_to?(:exception_writer)

data/lib/legion/logging/logger.rb

@@ -13,7 +13,7 @@ module Legion
 
       def initialize(level: 'info', log_file: nil, log_stdout: nil, lex: nil, trace: false, extended: false, trace_size: 4, format: :text, async: true, **opts)
         @lex = lex
-        set_log(logfile: log_file, log_stdout: log_stdout)
+        set_log(logfile: log_file, log_stdout: log_stdout, rotation: opts[:rotation])
         log_level(level)
         log_format(format: format, lex: lex, extended: extended, **opts)
         @color = opts[:color]

data/lib/legion/logging/method_tracer.rb

@@ -16,6 +16,8 @@ module Legion
 
           base_name = base.to_s
           tp = TracePoint.new(:call, :return) do |trace|
+            next if Thread.current[:legion_trace_emitting]
+
             next unless trace.defined_class == base || (match_singleton && trace.defined_class == base.singleton_class)
 
             stack = (Thread.current[:_legion_trace_stack] ||= [])
@@ -25,12 +27,12 @@ module Legion
               params = format_params(trace)
               params_segment = params.empty? ? '' : ", #{params.join(', ')}"
               indent = '  ' * stack.size
-              puts "#{indent}-> #{trace.method_id}, #{base_name}#{params_segment}"
+              emit_trace(message: "#{indent}-> #{trace.method_id}, #{base_name}#{params_segment}")
               stack.push(trace.method_id)
             when :return
               stack.pop
               indent = '  ' * stack.size
-              puts "#{indent}<- #{trace.method_id}, #{base_name}"
+              emit_trace(message: "#{indent}<- #{trace.method_id}, #{base_name}")
             end
           end
           tp.enable
@@ -52,6 +54,15 @@ module Legion
         end
       end
 
+      def self.emit_trace(message:)
+        previous = Thread.current[:legion_trace_emitting]
+        Thread.current[:legion_trace_emitting] = true
+        Legion::Logging.unknown(message)
+      ensure
+        Thread.current[:legion_trace_emitting] = previous
+      end
+      private_class_method :emit_trace
+
       def self.format_params(trace_point)
         trace_point.parameters.filter_map do |type, name|
           next unless name