legion-logging 1.5.5 → 1.5.19

data/lib/legion/logging/builder.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'monitor'
+require_relative 'output_logger'
 
 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,17 +25,33 @@ 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]
           entry[:segments] = segments if segments
           method_ctx = Thread.current[:legion_log_method]
           entry[:method] = method_ctx if method_ctx
+          conv_id = Thread.current[:legion_log_conv_id]
+          entry[:conversation_id] = conv_id if conv_id.is_a?(String) && !conv_id.empty?
+          request_id = Thread.current[:legion_log_request_id]
+          entry[:request_id] = request_id if request_id.is_a?(String) && !request_id.empty?
+          exchange_id = Thread.current[:legion_log_exchange_id]
+          entry[:exchange_id] = exchange_id if exchange_id.is_a?(String) && !exchange_id.empty?
+          chain_id = Thread.current[:legion_log_chain_id]
+          entry[:chain_id] = chain_id if chain_id.is_a?(String) && !chain_id.empty?
           "#{::JSON.generate(entry)}\n"
         rescue StandardError => e
           warn("Legion::Logging::Builder#json_format formatter failed: #{e.message}")
@@ -40,6 +61,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
 
@@ -49,7 +71,12 @@ module Legion
           if runner_trace.is_a?(Hash) && (options[:extended] || severity == 'debug')
             string.concat("[#{runner_trace[:type]}:#{runner_trace[:file]}:#{runner_trace[:function]}:#{runner_trace[:line_number]}]")
           end
-          string.concat(" #{severity} #{msg}\n")
+          ctx_pairs = build_context_kv_pairs
+          if ctx_pairs.empty?
+            string.concat(" #{severity} #{msg}\n")
+          else
+            string.concat(" #{severity} #{msg} #{ctx_pairs}\n")
+          end
           string
         end
       end
@@ -66,9 +93,23 @@ module Legion
 
         method_ctx = Thread.current[:legion_log_method]
         tag = "#{tag}{#{method_ctx}}" if tag && method_ctx
+
+        context_id = Thread.current[:legion_log_conv_id]
+        tag = "#{tag}{#{context_id}}" if tag && context_id.is_a?(String) && !context_id.empty?
         tag
       end
 
+      def build_context_kv_pairs
+        pairs = []
+        request_id = Thread.current[:legion_log_request_id]
+        pairs << "request_id=#{request_id}" if request_id.is_a?(String) && !request_id.empty?
+        exchange_id = Thread.current[:legion_log_exchange_id]
+        pairs << "exchange_id=#{exchange_id}" if exchange_id.is_a?(String) && !exchange_id.empty?
+        chain_id = Thread.current[:legion_log_chain_id]
+        pairs << "chain_id=#{chain_id}" if chain_id.is_a?(String) && !chain_id.empty?
+        pairs.join(' ')
+      end
+
       def build_runner_trace(loc = caller_locations(6, 1)&.first)
         return unless loc
 
@@ -90,25 +131,31 @@ module Legion
       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
+        with_lifecycle_lock do
+          return false if @async_writer && stop_async_writer == false
+
+          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 = Legion::Logging::OutputLogger.new(io)
+          elsif logfile
+            file = File.new(prepare_log_path(logfile), 'a')
+            file.sync = true
+            @log = Legion::Logging::OutputLogger.new(file)
+          else
+            @log = Legion::Logging::OutputLogger.new($stdout)
+          end
+
+          @log.async_writer = @async_writer
 
-        close_replaced_log(previous_log)
-        @log
+          close_replaced_log(previous_log)
+          @log
+        end
       end
 
       def prepare_log_path(path)
@@ -148,31 +195,39 @@ 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
+          return true unless @async_writer
 
-        close_replaced_log(writer.logger) if writer.respond_to?(:logger)
-        @async_writer = nil if @async_writer.equal?(writer)
-        @async = false
-        true
+          @async_writer.stop(timeout: timeout)
+        end
       end
-      # rubocop:enable Naming/PredicateMethod
 
       private
 
+      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/header_builder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Logging
+    module HeaderBuilder
+      EXCEPTION_PRIORITY = { warn: 0, error: 5, fatal: 9 }.freeze
+
+      private
+
+      def build_exception_headers(event, comp, level)
+        headers = {
+          'legion_protocol_version' => '2.0',
+          'x-error-fingerprint'     => event[:error_fingerprint],
+          'x-exception-class'       => event[:exception_class],
+          'x-handled'               => event[:handled].to_s,
+          'x-gem-name'              => event[:gem_name].to_s,
+          'x-lex-version'           => event[:lex_version].to_s,
+          'x-component-type'        => comp.to_s,
+          'x-level'                 => level.to_s
+        }
+        append_legion_version_header(headers)
+        append_optional_header(headers, 'x-task-id', event[:task_id])
+        append_optional_header(headers, 'x-conversation-id', event[:conversation_id])
+        append_optional_header(headers, 'x-chain-id', event[:chain_id])
+        append_optional_header(headers, 'x-user', event[:user])
+        append_identity_headers(headers)
+        headers
+      end
+
+      def build_exception_properties(event, level)
+        {
+          content_type:   'application/json',
+          message_id:     SecureRandom.uuid,
+          correlation_id: event[:error_fingerprint],
+          timestamp:      Time.now.to_i,
+          app_id:         'legionio',
+          type:           'exception_event',
+          priority:       EXCEPTION_PRIORITY[level] || 5,
+          delivery_mode:  2
+        }
+      end
+
+      def append_identity_headers(headers)
+        return unless defined?(Legion::Identity::Process)
+        return if Legion::Identity::Process.respond_to?(:resolved?) && !Legion::Identity::Process.resolved?
+
+        id = identity_hash
+        append_optional_header(headers, 'x-legion-identity-canonical-name', id[:canonical_name])
+        append_optional_header(headers, 'x-legion-identity-trust', id[:trust])
+        append_optional_header(headers, 'x-legion-identity-id', id[:id])
+        append_optional_header(headers, 'x-legion-identity-kind', id[:kind])
+        append_optional_header(headers, 'x-legion-identity-mode', id[:mode])
+        append_optional_header(headers, 'x-legion-identity-source', id[:source])
+        headers['x-legion-identity-db-principal-id'] = id[:db_principal_id] if id[:db_principal_id]
+        headers['x-legion-identity-db-identity-id'] = id[:db_identity_id] if id[:db_identity_id]
+      rescue StandardError
+        nil
+      end
+
+      def append_optional_header(headers, key, value)
+        return if value.nil?
+        return if value.respond_to?(:empty?) && value.empty?
+
+        headers[key] = value.to_s
+      end
+
+      def append_legion_version_header(headers)
+        append_optional_header(headers, 'x-legion-version', Legion::VERSION) if defined?(Legion::VERSION)
+      end
+
+      def identity_hash
+        process = Legion::Identity::Process
+        return process.identity_hash if process.respond_to?(:identity_hash)
+
+        {
+          canonical_name: identity_value(process, :canonical_name),
+          id:             identity_value(process, :id),
+          kind:           identity_value(process, :kind),
+          mode:           identity_value(process, :mode),
+          source:         identity_value(process, :source),
+          trust:          identity_value(process, :trust)
+        }
+      end
+
+      def identity_value(process, method_name)
+        process.public_send(method_name) if process.respond_to?(method_name)
+      end
+
+      def redaction_enabled?
+        return false unless defined?(Legion::Settings)
+
+        loader = Legion::Settings.instance_variable_get(:@loader)
+        return false unless loader
+
+        loader.dig(:logging, :redaction, :enabled) == true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/legion/logging/helper.rb

@@ -3,10 +3,13 @@
 require 'securerandom'
 require_relative 'tagged_logger'
 require_relative 'method_tracer'
+require_relative 'header_builder'
 
 module Legion
   module Logging
     module Helper
+      include Legion::Logging::HeaderBuilder
+
       SEGMENT_CACHE = {} # rubocop:disable Style/MutableConstant
       SEGMENT_CACHE_MUTEX = Mutex.new
       private_constant :SEGMENT_CACHE_MUTEX
@@ -32,7 +35,6 @@ module Legion
         'middleware' => :middleware
       }.freeze
 
-      EXCEPTION_PRIORITY = { warn: 0, error: 5, fatal: 9 }.freeze
       EXCEPTION_COLORS = {
         fatal:   :darkred,
         error:   :red,
@@ -78,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] || {}
@@ -99,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)
@@ -359,27 +368,64 @@ module Legion
         return unless defined?(Legion::Settings)
         return unless Legion::Settings.respond_to?(:loaded?) ? Legion::Settings.loaded? : true
 
-        key = derive_component_settings_key
-        return unless key
+        keys = derive_component_settings_keys
+        return unless keys&.any?
 
-        top_level = Legion::Settings[key]
+        if keys.length > 1
+          result = dig_settings(Legion::Settings[:extensions], keys)
+          return result if result.is_a?(Hash)
+        end
+
+        single_key = keys.length == 1 ? keys.first : keys.join('_').to_sym
+        top_level = Legion::Settings[single_key]
         return top_level if top_level.is_a?(Hash)
 
-        extension_settings = Legion::Settings.dig(:extensions, key)
+        extension_settings = if keys.length > 1
+                               dig_settings(Legion::Settings[:extensions], keys)
+                             else
+                               Legion::Settings.dig(:extensions, single_key)
+                             end
         extension_settings if extension_settings.is_a?(Hash)
       rescue StandardError
         nil
       end
 
-      def derive_component_settings_key
+      def derive_component_settings_keys
+        key = respond_to?(:ancestors) ? ancestors.first : self.class
+        parts = key.to_s.split('::')
+        parts.shift if parts.first == 'Legion'
+
+        if parts.first == 'Extensions'
+          parts.shift
+          ext_parts = parts.take_while { |p| !COMPONENT_MAP.key?(p.downcase) }
+          return ext_parts.map { |p| camelize_to_snake_key(p).to_sym } if ext_parts.any?
+        elsif parts.first && !parts.first.start_with?('#')
+          return [camelize_to_snake_key(parts.first).to_sym]
+        end
+
         base = log_name
         return unless base
 
-        base.to_s.tr('-', '_').to_sym
+        base.to_s.split('-').map { |s| s.tr('-', '_').to_sym }
       rescue StandardError
         nil
       end
 
+      def camelize_to_snake_key(str)
+        str.to_s
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+
+      def dig_settings(hash, keys)
+        keys.reduce(hash) do |current, key|
+          return nil unless current.is_a?(Hash)
+
+          current[key] || current[key.to_s]
+        end
+      end
+
       def global_log_level
         runtime_level = if defined?(Legion::Logging) &&
                            Legion::Logging.respond_to?(:current_settings)
@@ -468,15 +514,7 @@ module Legion
         Thread.current[:legion_log_segments] = segments
 
         message = format_exception_output(exception, event)
-        message = Legion::Logging::Redactor.redact_string(message) if defined?(Legion::Logging::Redactor) && redaction_enabled?
-        message = colorize_exception(message, level) if Legion::Logging.respond_to?(:color) && Legion::Logging.color
-
-        logger = Legion::Logging.respond_to?(:log) ? Legion::Logging.log : nil
-        if logger.respond_to?(level)
-          logger.public_send(level, message)
-        elsif Legion::Logging.respond_to?(level)
-          Legion::Logging.public_send(level, message)
-        end
+        Legion::Logging.public_send(level, message) if Legion::Logging.respond_to?(level)
       ensure
         Thread.current[:legion_log_segments] = prev_segs
       end
@@ -488,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
@@ -524,117 +564,10 @@ module Legion
         parts.join(' | ')
       end
 
-      def redaction_enabled?
-        return false unless defined?(Legion::Settings)
-
-        loader = Legion::Settings.instance_variable_get(:@loader)
-        return false unless loader
-
-        loader.dig(:logging, :redaction, :enabled) == true
-      rescue StandardError
-        false
-      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)
       end
-
-      def build_exception_headers(event, comp, level)
-        headers = {
-          'legion_protocol_version' => '2.0',
-          'x-error-fingerprint'     => event[:error_fingerprint],
-          'x-exception-class'       => event[:exception_class],
-          'x-handled'               => event[:handled].to_s,
-          'x-gem-name'              => event[:gem_name].to_s,
-          'x-lex-version'           => event[:lex_version].to_s,
-          'x-component-type'        => comp.to_s,
-          'x-level'                 => level.to_s
-        }
-        append_legion_version_header(headers)
-        headers['x-task-id'] = event[:task_id].to_s if event[:task_id]
-        headers['x-conversation-id'] = event[:conversation_id].to_s if event[:conversation_id]
-        headers['x-chain-id'] = event[:chain_id].to_s if event[:chain_id]
-        headers['x-user'] = event[:user].to_s if event[:user]
-        append_identity_headers(headers)
-        headers
-      end
-
-      def append_identity_headers(headers)
-        return unless defined?(Legion::Identity::Process)
-        return if Legion::Identity::Process.respond_to?(:resolved?) && !Legion::Identity::Process.resolved?
-
-        id = identity_hash
-        append_optional_header(headers, 'x-legion-identity-canonical-name', id[:canonical_name])
-        append_optional_header(headers, 'x-legion-identity-trust', id[:trust])
-        append_optional_header(headers, 'x-legion-identity-id', id[:id])
-        append_optional_header(headers, 'x-legion-identity-kind', id[:kind])
-        append_optional_header(headers, 'x-legion-identity-mode', id[:mode])
-        append_optional_header(headers, 'x-legion-identity-source', id[:source])
-        headers['x-legion-identity-db-principal-id'] = id[:db_principal_id] if id[:db_principal_id]
-        headers['x-legion-identity-db-identity-id'] = id[:db_identity_id] if id[:db_identity_id]
-      rescue StandardError
-        nil
-      end
-
-      def append_optional_header(headers, key, value)
-        return if value.nil?
-        return if value.respond_to?(:empty?) && value.empty?
-
-        headers[key] = value.to_s
-      end
-
-      def append_legion_version_header(headers)
-        append_optional_header(headers, 'x-legion-version', Legion::VERSION) if defined?(Legion::VERSION)
-      end
-
-      def identity_hash
-        process = Legion::Identity::Process
-        return process.identity_hash if process.respond_to?(:identity_hash)
-
-        {
-          canonical_name: identity_value(process, :canonical_name),
-          id:             identity_value(process, :id),
-          kind:           identity_value(process, :kind),
-          mode:           identity_value(process, :mode),
-          source:         identity_value(process, :source),
-          trust:          identity_value(process, :trust)
-        }
-      end
-
-      def identity_value(process, method_name)
-        process.public_send(method_name) if process.respond_to?(method_name)
-      end
-
-      def build_exception_properties(event, level)
-        {
-          content_type:   'application/json',
-          message_id:     SecureRandom.uuid,
-          correlation_id: event[:error_fingerprint],
-          timestamp:      Time.now.to_i,
-          app_id:         'legionio',
-          type:           'exception_event',
-          priority:       EXCEPTION_PRIORITY[level] || 5,
-          delivery_mode:  2
-        }
-      end
     end
   end
 end

data/lib/legion/logging/hooks.rb

@@ -19,7 +19,7 @@ module Legion
         def fire(level, message, event)
           return unless @enabled
 
-          hooks_for(level).each do |hook|
+          hooks_for(level).dup.each do |hook|
             hook.call(message, event)
           rescue StandardError => e
             warn("Legion::Logging::Hooks#fire callback failed: #{e.message}")

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