legionio 1.6.18 → 1.6.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5796d0724836fec4f8426fa337d5c6de420fbdf81c94fa9d070ca2a1a6abd9c7
-  data.tar.gz: bbaa73b5ee1d36c1c8b7cb9536d1c7e4144464cacfe68c1b4fee55b9bfea08df
+  metadata.gz: 4d50e1efc9398c0e2d380c7a921e2ccc8b6e6db3a142d4f4a700ff536555a2e4
+  data.tar.gz: e44d47e0c4d04362d9a35c6ad6953d0b4a42a5f0f2225dd0420e7f2d1c544ad4
 SHA512:
-  metadata.gz: 2c1a641e20d067fddcf0d949c3d2f11bbbcca141783b20e581f361bb916821c07e3538037e00c21f7866a12399d3a2c3ce56ad040f8af5713ff2969ea4ee1463
-  data.tar.gz: 568b3efc39291f9e2593b373eb3009db4d708fc7030b38237924d52acf2933c5a64e0aafb4e39265fe8997a7fd7a66aded647d969a4dcb3a8af1e3207afe0c29
+  metadata.gz: f4cc63f869d21abc423f7836a25b91f62a815d01d1972004b85728be0b969e332a5f95c9172ab6177f3759e837b6e40bbb30afba1ecd3a817cd5088fff4c675b
+  data.tar.gz: 719f9a8e3d316937be26ed610b7ba86c653317b476b271d821591fecf5ff8157c02788b03df1468c7fe3af19d76ec1a55cf48312d911a502e30873c51d378bb0

data/CHANGELOG.md

@@ -2,8 +2,41 @@
 
 ## [Unreleased]
 
+## [1.6.21] - 2026-03-27
+
+### Added
+- `legionio knowledge capture transcript` CLI command: ingests Claude Code session transcripts into Apollo knowledge store
+- Stop hook for automatic transcript capture at session end (installed via `legion setup claude-code`)
+
+## [1.6.20] - 2026-03-27
+
+### Changed
+- Bump `legion-logging` dependency to `>= 1.4.0` (required for `log_exception`, writer lambdas)
+
+### Fixed
+- `subscription.rb` (both `on_delivery` and `subscribe` blocks): initialize `fn = nil` before `process_message` so the rescue interpolation never raises `NameError` if message processing fails before `fn` is assigned
+- `Helpers::Logger#lex_name` removed to avoid overriding `Helpers::Base#lex_name` (underscore contract used by settings/routing); renamed to private `log_lex_name` used only within this module for gem name derivation
+- `Helpers::Logger#handle_exception`: use `spec&.version&.to_s` so nil spec version produces `nil` rather than `""` in structured log output
+- README: update version badge from `v1.6.18` to `v1.6.20`
+
+## [1.6.19] - 2026-03-27
+
+### Fixed
+- `teardown_logging_transport`: rescue block in `setup_logging_transport` now calls `teardown_logging_transport` to clean up any partially-created `@log_session` on failure
+- `teardown_logging_transport`: guard `open?` call with `respond_to?(:open?)` check to avoid `NoMethodError` on session objects that do not implement the method
+- `service_logging_transport_spec`: early-return specs now assert `create_dedicated_session` was not called and `@log_session` remains nil, rather than the vacuous `respond_to(:call)` check
+- `service_logging_transport_spec`: replaced vacuous `not_to eq(owner)` assertion with `have_received(:create_dedicated_session)` to verify the dedicated session was actually created
+
 ## [1.6.18] - 2026-03-27
 
+### Added
+- `setup_logging_transport`: dedicated AMQP session for log and exception forwarding, replacing the previous `register_logging_hooks` approach; writer lambda wiring is gated by `Settings[:logging][:transport]` feature flags
+- `teardown_logging_transport`: cleanly shuts down the dedicated logging AMQP session during the shutdown sequence
+
+### Changed
+- Split `log.error(e.message); log.error(e.backtrace)` patterns replaced with `log.log_exception` across 14 files for structured, single-call exception logging
+- `Extensions::Helpers::Logger#handle_exception` rewritten to use `log.log_exception` with full lex context
+
 ### Fixed
 - `legionio pipeline image analyze`: `call_llm` no longer passes unsupported `messages:` keyword to `Legion::LLM.chat`; now creates a chat object and sends multimodal content via `chat.ask`, returning a plain hash with `:content` and `:usage` keys
 - `legionio ai trace search/summarize`: both commands now call `setup_connection` before invoking `TraceSearch`, ensuring `Legion::LLM` is booted so `TraceSearch.generate_filter` can use structured LLM output instead of returning "no filter generated"; added `class_option :config_dir` and `class_option :verbose` to `TraceCommand`

data/README.md

@@ -14,7 +14,7 @@ Schedule tasks, chain services into dependency graphs, run them concurrently via
          ╰──────────────────────────────────────╯
 ```
 
-**Ruby >= 3.4** | **v1.5.20** | **Apache-2.0** | [@Esity](https://github.com/Esity)
+**Ruby >= 3.4** | **v1.6.20** | **Apache-2.0** | [@Esity](https://github.com/Esity)
 
 ---
 

data/legionio.gemspec

@@ -56,7 +56,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-crypt', '>= 1.4.17'
   spec.add_dependency 'legion-data', '>= 1.6.7'
   spec.add_dependency 'legion-json', '>= 1.2.1'
-  spec.add_dependency 'legion-logging', '>= 1.3.2'
+  spec.add_dependency 'legion-logging', '>= 1.4.0'
   spec.add_dependency 'legion-settings', '>= 1.3.19'
   spec.add_dependency 'legion-transport', '>= 1.4.4'
 

data/lib/legion/api/hooks.rb

@@ -66,8 +66,7 @@ module Legion
 
           dispatch_hook(context, payload: payload, runner: runner, function: function)
         rescue StandardError => e
-          Legion::Logging.error "API #{request.request_method} #{request.path_info}: #{e.class} — #{e.message}"
-          Legion::Logging.error e.backtrace&.first(5)
+          Legion::Logging.log_exception(e, payload_summary: "API #{request.request_method} #{request.path_info}", component_type: :api)
           context.json_error('internal_error', e.message, status_code: 500)
         end
 

data/lib/legion/api/lex.rb

@@ -53,8 +53,7 @@ module Legion
           context.json_response({ task_id: result[:task_id], status: result[:status],
                                    result: result[:result] }.compact)
         rescue StandardError => e
-          Legion::Logging.error "API POST /api/lex/#{request.path_info.sub(%r{^/api/lex/}, '')}: #{e.class} — #{e.message}"
-          Legion::Logging.error e.backtrace&.first(5)
+          Legion::Logging.log_exception(e, payload_summary: "API POST /api/lex/#{request.path_info.sub(%r{^/api/lex/}, '')}", component_type: :api)
           context.json_error('internal_error', e.message, status_code: 500)
         end
 

data/lib/legion/api.rb

@@ -95,8 +95,7 @@ module Legion
     error do
       content_type :json
       err = env['sinatra.error']
-      Legion::Logging.error "API #{request.request_method} #{request.path_info} returned 500: #{err.class} — #{err.message}"
-      Legion::Logging.error err.backtrace&.first(10)
+      Legion::Logging.log_exception(err, payload_summary: "API #{request.request_method} #{request.path_info} returned 500", component_type: :api)
       Legion::JSON.dump({
                           error: { code: 'internal_error', message: err.message },
                           meta:  { timestamp: Time.now.utc.iso8601, node: Legion::Settings[:client][:name] }

data/lib/legion/cli/knowledge_command.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'shellwords'
+
 module Legion
   module CLI
     class MonitorCommand < Thor
@@ -173,10 +175,130 @@ module Legion
         end
       end
 
-      no_commands do
+      desc 'transcript', 'Capture a Claude Code session transcript as knowledge'
+      option :session_id, type: :string, desc: 'Session ID (defaults to CLAUDE_SESSION_ID env)'
+      option :cwd,        type: :string, desc: 'Working directory (defaults to CLAUDE_CWD env)'
+      option :max_chunks, type: :numeric, default: 50, desc: 'Max conversation turn chunks to ingest'
+      def transcript
+        session_id = options[:session_id] || ENV.fetch('CLAUDE_SESSION_ID', nil)
+        cwd        = options[:cwd] || ENV.fetch('CLAUDE_CWD', nil) || ::Dir.pwd
+
+        unless session_id
+          formatter.warn('No session ID provided (set CLAUDE_SESSION_ID or --session-id)')
+          return
+        end
+
+        jsonl_path = resolve_transcript_path(session_id, cwd)
+        unless jsonl_path && ::File.exist?(jsonl_path)
+          formatter.warn("Transcript not found: #{jsonl_path || 'could not resolve path'}")
+          return
+        end
+
+        turns = extract_turns(jsonl_path)
+        if turns.empty?
+          formatter.warn('No conversation turns found in transcript')
+          return
+        end
+
+        repo      = `git -C #{Shellwords.escape(cwd)} rev-parse --show-toplevel 2>/dev/null`.strip.split('/').last
+        base_tags = ['claude-code', 'transcript', "session:#{session_id}", ::Time.now.strftime('%Y-%m-%d')]
+        base_tags << "repo:#{repo}" unless repo.to_s.empty?
+
+        ingested = 0
+        turns.first(options[:max_chunks]).each_with_index do |turn, idx|
+          content = format_turn(turn, idx + 1)
+          next if content.strip.empty?
+
+          result = ingest_content(
+            content: content,
+            tags:    base_tags + ["turn:#{idx + 1}"],
+            source:  "claude-code:#{session_id}:turn-#{idx + 1}"
+          )
+          ingested += 1 if result[:success]
+        end
+
+        out = formatter
+        if options[:json]
+          out.json(success: true, session_id: session_id, turns: turns.size, ingested: ingested)
+        else
+          out.success("Captured #{ingested}/#{[turns.size, options[:max_chunks]].min} turns from session #{session_id[0, 8]}")
+        end
+      end
+
+      no_commands do # rubocop:disable Metrics/BlockLength
         def formatter
           @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
         end
+
+        def resolve_transcript_path(session_id, cwd)
+          project_dir = cwd.gsub('/', '-')
+          ::File.expand_path("~/.claude/projects/#{project_dir}/#{session_id}.jsonl")
+        end
+
+        def extract_turns(path)
+          turns = []
+          current_turn = nil
+
+          ::File.foreach(path) do |line|
+            entry = ::JSON.parse(line, symbolize_names: true)
+            type  = entry[:type]
+
+            case type
+            when 'user'
+              turns << current_turn if current_turn
+              current_turn = { user: extract_message_text(entry), assistant: +'', timestamp: entry[:timestamp] }
+            when 'assistant'
+              next unless current_turn
+
+              text = extract_message_text(entry)
+              current_turn[:assistant] << text unless text.empty?
+            end
+          rescue ::JSON::ParserError
+            next
+          end
+
+          turns << current_turn if current_turn
+          turns
+        end
+
+        def extract_message_text(entry)
+          msg = entry[:message]
+          return '' unless msg
+
+          content = msg[:content]
+          case content
+          when String then content
+          when Array
+            content.filter_map { |block| block[:text] if block[:type] == 'text' }.join("\n")
+          else ''
+          end
+        end
+
+        def format_turn(turn, number)
+          text = "## Turn #{number}\n"
+          text << "Timestamp: #{turn[:timestamp]}\n\n" if turn[:timestamp]
+          text << "### User\n#{truncate_text(turn[:user], 4096)}\n\n"
+          text << "### Assistant\n#{truncate_text(turn[:assistant], 4096)}\n"
+          text
+        end
+
+        def truncate_text(text, max_bytes)
+          return text if text.bytesize <= max_bytes
+
+          "#{text.byteslice(0, max_bytes - 20)}\n\n[truncated]"
+        end
+
+        def ingest_content(content:, tags:, source:)
+          if defined?(Legion::Extensions::Knowledge::Runners::Ingest)
+            Legion::Extensions::Knowledge::Runners::Ingest.ingest_file(
+              content: content, tags: tags, source: source
+            )
+          elsif defined?(Legion::Apollo)
+            Legion::Apollo.ingest(content: content, tags: tags, source: source)
+          else
+            { success: false, error: 'neither lex-knowledge nor legion-apollo available' }
+          end
+        end
       end
     end
 

data/lib/legion/cli/setup_command.rb

@@ -350,9 +350,9 @@ module Legion
 
           hooks = existing['hooks'] || {}
 
-          has_commit  = Array(hooks['PostToolUse']).any? { |h| h['command']&.include?('knowledge capture commit') }
-          has_session = Array(hooks['Stop']).any? { |h| h['command']&.include?('knowledge capture session') }
-          if has_commit && has_session && !options[:force]
+          has_commit     = Array(hooks['PostToolUse']).any? { |h| h['command']&.include?('knowledge capture commit') }
+          has_transcript = Array(hooks['Stop']).any? { |h| h['command']&.include?('knowledge capture transcript') }
+          if has_commit && has_transcript && !options[:force]
             puts '  Write-back hooks already present (use --force to overwrite)' unless options[:json]
             return
           end
@@ -368,10 +368,10 @@ module Legion
             }
           end
 
-          unless has_session
+          unless has_transcript
             hooks['Stop'] << {
-              'command' => 'legionio knowledge capture session',
-              'timeout' => 15_000
+              'command' => 'legionio knowledge capture transcript',
+              'timeout' => 30_000
             }
           end
 

data/lib/legion/events.rb

@@ -31,8 +31,7 @@ module Legion
         listeners[event_name.to_s].each do |listener|
           listener.call(event)
         rescue StandardError => e
-          Legion::Logging.warn "[Events] listener error on #{event_name}: #{e.message}"
-          Legion::Logging.error e.backtrace&.first(5)
+          Legion::Logging.log_exception(e, payload_summary: "[Events] listener error on #{event_name}", component_type: :event)
         end
 
         # Also fire wildcard listeners

data/lib/legion/extensions/actors/base.rb

@@ -9,8 +9,7 @@ module Legion
         def runner
           Legion::Runner.run(runner_class: runner_class, function: function, check_subtask: check_subtask?, generate_task: generate_task?)
         rescue StandardError => e
-          Legion::Logging.error e.message
-          Legion::Logging.error e.backtrace
+          Legion::Logging.log_exception(e, component_type: :actor)
         end
 
         def manual
@@ -23,8 +22,7 @@ module Legion
             klass.send(func, **args)
           end
         rescue StandardError => e
-          Legion::Logging.error e.message
-          Legion::Logging.error e.backtrace
+          Legion::Logging.log_exception(e, component_type: :actor)
         end
 
         def function

data/lib/legion/extensions/actors/every.rb

@@ -16,15 +16,13 @@ module Legion
             begin
               skip_or_run { use_runner? ? runner : manual }
             rescue StandardError => e
-              log.error "[Every] tick failed for #{self.class}: #{e.message}" if defined?(log)
-              log.error e.backtrace if defined?(log)
+              log.log_exception(e, payload_summary: "[Every] tick failed for #{self.class}", component_type: :actor) if defined?(log)
             end
           end
 
           @timer.execute
         rescue StandardError => e
-          log.error e.message
-          log.error e.backtrace
+          log.log_exception(e, component_type: :actor)
         end
 
         def time
@@ -49,8 +47,7 @@ module Legion
 
           @timer.shutdown
         rescue StandardError => e
-          log.error e.message
-          log.error e.backtrace
+          log.log_exception(e, component_type: :actor)
         end
       end
     end

data/lib/legion/extensions/actors/loop.rb

@@ -13,8 +13,7 @@ module Legion
           @loop = true
           async.run
         rescue StandardError => e
-          Legion::Logging.error e
-          Legion::Logging.error e.backtrace
+          Legion::Logging.log_exception(e, component_type: :actor)
         end
 
         def run

data/lib/legion/extensions/actors/poll.rb

@@ -17,13 +17,11 @@ check_subtask: check_subtask? }}"
           @timer = Concurrent::TimerTask.new(execution_interval: time, run_now: run_now?) do
             skip_or_run { poll_cycle }
           rescue StandardError => e
-            Legion::Logging.fatal e.message
-            Legion::Logging.fatal e.backtrace
+            Legion::Logging.log_exception(e, level: :fatal, component_type: :actor)
           end
           @timer.execute
         rescue StandardError => e
-          Legion::Logging.error e.message
-          Legion::Logging.error e.backtrace
+          Legion::Logging.log_exception(e, component_type: :actor)
         end
 
         def poll_cycle
@@ -55,8 +53,7 @@ check_subtask: check_subtask? }}"
           log.debug("#{self.class} result: #{results}")
           results
         rescue StandardError => e
-          Legion::Logging.fatal e.message
-          Legion::Logging.fatal e.backtrace
+          Legion::Logging.log_exception(e, level: :fatal, component_type: :actor)
         end
 
         def cache_name
@@ -91,7 +88,7 @@ check_subtask: check_subtask? }}"
           Legion::Logging.debug 'Cancelling Legion Poller'
           @timer.shutdown
         rescue StandardError => e
-          Legion::Logging.error e.message
+          Legion::Logging.log_exception(e, component_type: :actor)
         end
       end
     end

data/lib/legion/extensions/actors/subscription.rb

@@ -17,8 +17,7 @@ module Legion
           @queue = queue.new
           @queue.channel.prefetch(prefetch) if defined? prefetch
         rescue StandardError => e
-          log.fatal e.message
-          log.fatal e.backtrace
+          log.log_exception(e, level: :fatal, component_type: :actor)
         end
 
         def create_queue
@@ -48,12 +47,13 @@ module Legion
           true
         end
 
-        def prepare # rubocop:disable Metrics/AbcSize
+        def prepare
           @queue = queue.new
           @queue.channel.prefetch(prefetch) if defined? prefetch
           consumer_tag = "#{Legion::Settings[:client][:name]}_#{lex_name}_#{runner_name}_#{SecureRandom.uuid}"
           @consumer = Bunny::Consumer.new(@queue.channel, @queue, consumer_tag, false, false)
           @consumer.on_delivery do |delivery_info, metadata, payload|
+            fn = nil
             message = process_message(payload, metadata, delivery_info)
             fn = find_function(message)
             log.debug "[Subscription] message received: #{lex_name}/#{fn}" if defined?(log)
@@ -76,14 +76,12 @@ module Legion
 
             cancel if Legion::Settings[:client][:shutting_down]
           rescue StandardError => e
-            log.error "[Subscription] message processing failed: #{lex_name}/#{fn}: #{e.message}"
-            log.error e.backtrace
+            log.log_exception(e, payload_summary: "[Subscription] message processing failed: #{lex_name}/#{fn}", component_type: :actor)
             @queue.reject(delivery_info.delivery_tag) if manual_ack
           end
           log.info "[Subscription] prepared: #{lex_name}/#{runner_name}"
         rescue StandardError => e
-          log.fatal "Subscription#prepare failed: #{e.message}"
-          log.fatal e.backtrace
+          log.log_exception(e, level: :fatal, payload_summary: 'Subscription#prepare failed', component_type: :actor)
         end
 
         def activate
@@ -159,6 +157,7 @@ module Legion
             metadata = rmq_message.last
             delivery_info = rmq_message.first
 
+            fn = nil
             message = process_message(payload, metadata, delivery_info)
             fn = find_function(message)
             log.debug "[Subscription] message received: #{lex_name}/#{fn}" if defined?(log)
@@ -185,8 +184,7 @@ module Legion
 
             cancel if Legion::Settings[:client][:shutting_down]
           rescue StandardError => e
-            log.error "[Subscription] message processing failed: #{lex_name}/#{fn}: #{e.message}"
-            log.error e.backtrace
+            log.log_exception(e, payload_summary: "[Subscription] message processing failed: #{lex_name}/#{fn}", component_type: :actor)
             log.warn "[Subscription] nacking message for #{lex_name}/#{fn}"
             @queue.reject(delivery_info.delivery_tag) if manual_ack
           end

data/lib/legion/extensions/core.rb

@@ -220,9 +220,7 @@ module Legion
           lex_class.const_set(:Data, Module.new { extend Legion::Extensions::Data })
         end
       rescue StandardError => e
-        Legion::Logging.error "[Core] auto_generate_data failed for #{name}: #{e.message}" if defined?(Legion::Logging)
-        log.error e.message
-        log.error e.backtrace
+        log.log_exception(e, payload_summary: "[Core] auto_generate_data failed for #{name}", component_type: :builder)
       end
     end
   end

data/lib/legion/extensions/helpers/logger.rb

@@ -7,9 +7,17 @@ module Legion
         include Legion::Logging::Helper
 
         def handle_exception(exception, task_id: nil, **opts)
-          log.error exception.message + " for task_id: #{task_id} but was logged "
-          log.error exception.backtrace[0..10]
-          log.error opts
+          spec = gem_spec_for_lex
+          log.log_exception(exception,
+                            lex:             log_lex_name,
+                            component_type:  derive_component_type,
+                            gem_name:        lex_gem_name,
+                            lex_version:     spec&.version&.to_s,
+                            gem_path:        spec&.full_gem_path,
+                            source_code_uri: spec&.metadata&.[]('source_code_uri'),
+                            handled:         true,
+                            payload_summary: opts.empty? ? nil : opts,
+                            task_id:         task_id)
 
           unless task_id.nil?
             Legion::Transport::Messages::TaskLog.new(
@@ -25,6 +33,51 @@ module Legion
 
           raise Legion::Exception::HandledTask
         end
+
+        private
+
+        def derive_component_type
+          parts = respond_to?(:calling_class_array) ? calling_class_array : self.class.to_s.split('::')
+          match = parts.find { |p| Legion::Extensions::Helpers::Base::NAMESPACE_BOUNDARIES.include?(p) }
+          case match
+          when 'Runners'          then :runner
+          when 'Actor', 'Actors'  then :actor
+          when 'Transport'        then :transport
+          when 'Helpers'          then :helper
+          when 'Data'             then :data
+          else :unknown
+          end
+        rescue StandardError
+          :unknown
+        end
+
+        def lex_gem_name
+          base_name = log_lex_name
+          return nil unless base_name
+
+          "lex-#{base_name}"
+        rescue StandardError
+          nil
+        end
+
+        def gem_spec_for_lex
+          name = lex_gem_name
+          return nil unless name
+
+          Gem::Specification.find_by_name(name)
+        rescue Gem::MissingSpecError
+          nil
+        end
+
+        def log_lex_name
+          if respond_to?(:segments)
+            segments.join('-')
+          else
+            derive_log_tag
+          end
+        rescue StandardError
+          nil
+        end
       end
     end
   end

data/lib/legion/extensions/helpers/task.rb

@@ -16,8 +16,7 @@ module Legion
               return true if Legion::Data::Model::TaskLog.insert(task_id: task_id, function_id: function_id, entry: Legion::JSON.dump(payload))
             end
           rescue StandardError => e
-            log.warn e.backtrace
-            log.warn("generate_task_log failed, reverting to rmq message, e: #{e.message}")
+            log.log_exception(e, level: :warn, payload_summary: 'generate_task_log failed, reverting to rmq message', component_type: :helper)
           end
           Legion::Transport::Messages::TaskLog.new(task_id: task_id, runner_class: runner_class, function: function, entry: payload).publish
         end
@@ -41,8 +40,7 @@ module Legion
           end
           Legion::Transport::Messages::TaskUpdate.new(**update_hash).publish
         rescue StandardError => e
-          log.fatal e.message
-          log.fatal e.backtrace
+          log.log_exception(e, level: :fatal, component_type: :helper)
           raise e
         end
 

data/lib/legion/extensions/transport.rb

@@ -24,8 +24,7 @@ module Legion
         auto_create_dlx_queue
         log.info "[Transport] built exchanges=#{@exchanges.count} queues=#{@queues.count} for #{lex_name}"
       rescue StandardError => e
-        log.error "[Transport] build failed for #{lex_name}: #{e.message}"
-        log.error e.backtrace
+        log.log_exception(e, payload_summary: "[Transport] build failed for #{lex_name}", component_type: :transport)
       end
 
       def generate_base_modules
@@ -140,9 +139,7 @@ module Legion
         to = to.is_a?(String) ? Kernel.const_get(to).new : to.new
         to.bind(from, routing_key: routing_key)
       rescue StandardError => e
-        log.fatal e.message
-        log.fatal e.backtrace
-        log.fatal({ from: from, to: to, routing_key: routing_key })
+        log.log_exception(e, level: :fatal, payload_summary: { from: from, to: to, routing_key: routing_key }, component_type: :transport)
       end
 
       def e_to_q

data/lib/legion/extensions.rb

@@ -266,8 +266,7 @@ module Legion
         end
         true
       rescue StandardError => e
-        Legion::Logging.error e.message
-        Legion::Logging.error e.backtrace
+        Legion::Logging.log_exception(e, lex: entry[:gem_name], component_type: :boot)
         false
       end
 

data/lib/legion/runner/status.rb

@@ -21,8 +21,7 @@ module Legion
         Legion::Transport::Messages::TaskUpdate.new(task_id: task_id, status: status, **).publish
       rescue StandardError => e
         retries += 1
-        Legion::Logging.warn "[Status] update_rmq failed (attempt #{retries}/3): #{e.message}"
-        Legion::Logging.fatal e.backtrace
+        Legion::Logging.log_exception(e, level: :fatal, payload_summary: "[Status] update_rmq failed (attempt #{retries}/3)", component_type: :runner)
         retry if retries < 3
       end
 
@@ -32,9 +31,9 @@ module Legion
         task = Legion::Data::Model::Task[task_id]
         task.update(status: status)
       rescue StandardError => e
-        Legion::Logging.warn "[Status] update_db failed for task_id=#{task_id}: #{e.message}"
-        Legion::Logging.warn '[Status] falling back to RabbitMQ update'
-        Legion::Logging.warn e.backtrace
+        Legion::Logging.log_exception(e, level:           :warn,
+                                         payload_summary: "[Status] update_db failed for task_id=#{task_id}, falling back to RabbitMQ update",
+                                         component_type:  :runner)
         update_rmq(task_id: task_id, status: status, **)
       end
 
@@ -61,8 +60,7 @@ module Legion
 
         { success: true, task_id: Legion::Data::Model::Task.insert(insert), **insert }
       rescue StandardError => e
-        Legion::Logging.error e.message
-        Legion::Logging.error e.backtrace
+        Legion::Logging.log_exception(e, component_type: :runner)
         raise(e)
       end
     end

data/lib/legion/service.rb

@@ -48,7 +48,7 @@ module Legion
       if transport
         setup_transport
         Legion::Readiness.mark_ready(:transport)
-        register_logging_hooks
+        setup_logging_transport
       end
 
       setup_dispatch
@@ -248,14 +248,18 @@ module Legion
       Legion::Logging.setup(log_level: log_level, level: log_level, trace: true)
     end
 
-    def reconfigure_logging(cli_level)
-      logging_settings = Legion::Settings[:logging] || {}
-      level = cli_level || logging_settings[:level] || 'info'
+    def reconfigure_logging(cli_level = nil)
+      ls = Legion::Settings[:logging] || {}
+      level = cli_level || ls[:level] || 'info'
+
       Legion::Logging.setup(
-        level:      level,
-        log_file:   logging_settings[:log_file],
-        log_stdout: logging_settings[:log_stdout],
-        trace:      logging_settings.fetch(:trace, true)
+        level:       level,
+        format:      (ls[:format] || 'text').to_sym,
+        log_file:    ls[:log_file],
+        log_stdout:  ls.fetch(:log_stdout, true),
+        trace:       ls.fetch(:trace, true),
+        async:       ls.fetch(:async, true),
+        include_pid: ls.fetch(:include_pid, false)
       )
     end
 
@@ -365,34 +369,73 @@ module Legion
       Legion::Logging.info 'Legion::Transport connected'
     end
 
-    def register_logging_hooks
+    def setup_logging_transport # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       return unless defined?(Legion::Transport::Connection)
       return unless Legion::Transport::Connection.session_open?
-      return unless Legion::Transport::Connection.respond_to?(:log_channel)
 
-      log_ch = Legion::Transport::Connection.log_channel
-      unless log_ch
-        Legion::Logging.debug 'No dedicated log channel available, log forwarding disabled'
-        return
+      lt_settings = begin
+        Legion::Settings.dig(:logging, :transport) || {}
+      rescue StandardError
+        {}
       end
+      return unless lt_settings[:enabled] == true
 
-      require 'legion/transport/exchanges/logging' unless defined?(Legion::Transport::Exchanges::Logging)
-      exchange = Legion::Transport::Exchanges::Logging.new('legion.logging', channel: log_ch)
+      forward_logs       = lt_settings.fetch(:forward_logs, true)
+      forward_exceptions = lt_settings.fetch(:forward_exceptions, true)
+      return unless forward_logs || forward_exceptions
 
-      %i[fatal error warn].each do |level|
-        Legion::Logging.send(:"on_#{level}") do |event|
-          next unless log_ch&.open?
+      log_session = Legion::Transport::Connection.create_dedicated_session(name: 'legion-logging')
+      @log_session = log_session
+      log_channel = log_session.create_channel
+      log_channel.prefetch(1)
+      exchange = log_channel.topic('legion.logging', durable: true)
 
-          source = event[:lex] || 'core'
-          routing_key = "legion.#{source}.#{level}"
-          exchange.publish(Legion::JSON.dump(event), routing_key: routing_key)
-        rescue StandardError
-          nil
-        end
+      if forward_logs
+        Legion::Logging.log_writer = lambda { |event, routing_key:|
+          begin
+            next unless log_channel&.open?
+
+            exchange.publish(Legion::JSON.dump(event), routing_key: routing_key)
+          rescue StandardError
+            nil
+          end
+        }
       end
 
-      Legion::Logging.enable_hooks!
-      Legion::Logging.info('Logging hooks registered (dedicated channel)')
+      if forward_exceptions
+        Legion::Logging.exception_writer = lambda { |event, routing_key:, headers:, properties:|
+          begin
+            next unless log_channel&.open?
+
+            exchange.publish(
+              Legion::JSON.dump(event),
+              routing_key: routing_key,
+              headers:     headers,
+              **properties
+            )
+          rescue StandardError
+            nil
+          end
+        }
+      end
+
+      modes = []
+      modes << 'logs' if forward_logs
+      modes << 'exceptions' if forward_exceptions
+      Legion::Logging.info("Logging transport wired: #{modes.join(' + ')} (dedicated session)")
+    rescue StandardError => e
+      Legion::Logging.warn "Logging transport setup failed: #{e.message}"
+      teardown_logging_transport
+    end
+
+    def teardown_logging_transport
+      Legion::Logging.log_writer = nil
+      Legion::Logging.exception_writer = nil
+      @log_session&.close if @log_session.respond_to?(:close) &&
+                             (!@log_session.respond_to?(:open?) || @log_session.open?)
+      @log_session = nil
+    rescue StandardError
+      nil
     end
 
     def setup_alerts
@@ -547,6 +590,7 @@ module Legion
       shutdown_component('Cache') { Legion::Cache.shutdown }
       Legion::Readiness.mark_not_ready(:cache)
 
+      teardown_logging_transport
       shutdown_component('Transport') { Legion::Transport::Connection.shutdown }
       Legion::Readiness.mark_not_ready(:transport)
 
@@ -558,7 +602,7 @@ module Legion
       Legion::Events.emit('service.shutdown')
     end
 
-    def reload
+    def reload # rubocop:disable Metrics/MethodLength
       return if @reloading
 
       @reloading = true
@@ -583,6 +627,7 @@ module Legion
       shutdown_component('Cache') { Legion::Cache.shutdown }
       Legion::Readiness.mark_not_ready(:cache)
 
+      teardown_logging_transport
       shutdown_component('Transport') { Legion::Transport::Connection.shutdown }
       Legion::Readiness.mark_not_ready(:transport)
 
@@ -599,7 +644,8 @@ module Legion
 
       setup_transport
       Legion::Readiness.mark_ready(:transport)
-      register_logging_hooks
+      teardown_logging_transport
+      setup_logging_transport
 
       require 'legion/cache' unless defined?(Legion::Cache)
       Legion::Cache.setup

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.6.18'
+  VERSION = '1.6.21'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.18
+  version: 1.6.21
 platform: ruby
 authors:
 - Esity
@@ -281,14 +281,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.2
+        version: 1.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.2
+        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: legion-settings
   requirement: !ruby/object:Gem::Requirement