legion-logging 1.4.2 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31ec07f7a93713fb708102528d4e61525a4c3b4fa39de510d29a454726b49436
-  data.tar.gz: 62a67fc723d1e865ef3e632d1987b6ce73c2fe9aa033686df5fe3b2fb89bc14c
+  metadata.gz: 707d2460ca4e016ca62cc8ef83bf2d646819439ed67ef5549a164518ba2d3bf5
+  data.tar.gz: a013c59d975f901f25b153cbbfe4ed288dbedb262098627aed6d71baeb70031a
 SHA512:
-  metadata.gz: 5e0b2171b6ca1b1acbb3ad0f40cbd23a77bf5824a3b2f37a5c9b3484f7edf2cf9cf1a8dc23a9f0ed0acd426e139fb0d7ce13ac0a3ae2a77b3113dd0569cc6d53
-  data.tar.gz: e4e599809e26c6b7a0f9c1a81f05e390175cad0568b6b99f26888b675590972ff9148e27bc53f36461e1d6f09f83fcf7a818b01bd793098c5809910affabb0a2
+  metadata.gz: f5f3d87c609bca88c501e32d241fabc796e48b8aae8912fed39ac3615e0565f2a7d4672b66f12b0fdf606c6d3e0b40abb2b04b9b38d554edca4e9fa4b063a40a
+  data.tar.gz: 741697e72078cb1cbede684a8729d8a9a0b79c25a8beb4ed465aa53ae89711e11f482b9e93f434f51dae0778dfdf3bf49855282e80a7df17f98054d980d3e037

data/.github/workflows/ci.yml

@@ -3,13 +3,31 @@ on:
   push:
     branches: [main]
   pull_request:
+  schedule:
+    - cron: '0 9 * * 1'
 
 jobs:
   ci:
     uses: LegionIO/.github/.github/workflows/ci.yml@main
 
+  lint:
+    uses: LegionIO/.github/.github/workflows/lint-patterns.yml@main
+
+  security:
+    uses: LegionIO/.github/.github/workflows/security-scan.yml@main
+
+  version-changelog:
+    uses: LegionIO/.github/.github/workflows/version-changelog.yml@main
+
+  dependency-review:
+    uses: LegionIO/.github/.github/workflows/dependency-review.yml@main
+
+  stale:
+    if: github.event_name == 'schedule'
+    uses: LegionIO/.github/.github/workflows/stale.yml@main
+
   release:
-    needs: ci
+    needs: [ci, lint]
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     uses: LegionIO/.github/.github/workflows/release.yml@main
     secrets:

data/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Legion::Logging Changelog
 
+## [1.4.3] - 2026-04-01
+
+### Added
+- `TaggedLogger` lightweight proxy: delegates to singleton for shared stdout/file/async output
+- `Helper#derive_log_segments` with class-level `SEGMENT_CACHE` — auto-derives `[llm][router]` from namespace
+- `Helper#with_log_context` for block-scoped method name thread-locals (`{dispatch}` in log output)
+- `Helper#handle_exception` with direct EventBuilder calls, per-line Rainbow coloring, structured AMQP publish
+- `Helper.current_log_method`, `.current_log_segments`, `.current_context` thread-local readers
+- `Legion::Logging::Settings` module with logger defaults
+- `COMPONENT_MAP` with 18 component types (runners, actors, hooks, absorbers, tools, adapters, middleware, etc.)
+- `EXCEPTION_COLORS` map for per-level exception coloring (bold first line, faint backtrace)
+- `Thread.current[:legion_context]` support for wire protocol fields (task_id, conversation_id, chain_id)
+- Redaction applied to exception stdout output when redaction is enabled
+- Method context (`legion_log_method`) included in structured exception events
+- `AsyncWriter::LogEntry` carries `segments` and `method_ctx` for thread-local propagation to writer thread
+- `Builder#resolve_lex_tag` and `#build_runner_trace` extracted from `text_format`
+
+### Changed
+- `Helper#log` returns `TaggedLogger` instead of `Logger.new` (shared output, one async thread)
+- `Helper#log_name`/`gem_name`/`gem_spec` replace `log_lex_name`/`lex_gem_name`/`gem_spec_for_lex` with multi-prefix resolution
+- `gem_name` and `gem_spec` memoized per instance
+- `COMPONENT_REGEX` in Methods expanded from 5 to 18 component types
+- `build_writer_context` reads `Thread.current[:legion_log_segments]` instead of stale `@lex_segments` ivar
+- `Builder#output` delegates to `set_log` (was parallel implementation)
+- `Builder#caller_locations` allocates single frame instead of full stack
+- Unknown log level strings default to INFO instead of DEBUG
+- `EventBuilder#legion_versions` and `#resolve_gem_spec` memoized
+- `EXCEPTION_PRIORITY` extracted to frozen constant in Methods (was inline hash allocation per call)
+- `text_format` and `json_format` in Builder read thread-locals for segments and method context
+
+### Fixed
+- `fire_log_writer` rescue no longer references undefined `routing_key` variable
+- Splunk auth header in `http_transport` — `apply_auth` receives actual URI instead of always evaluating against `URI('/')`
+- `TaggedLogger#initialize` accepts `**_opts` splat for unexpected settings keys
+- `TaggedLogger#trace` guards nil `size` to prevent `TypeError` on `caller_locations`
+
+### Removed
+- `TaggedLogger#runner_exception` (runner business logic, not logging concern)
+- `TaggedLogger#log_exception` (use `Helper#handle_exception` instead)
+- `Builder#log_level` no-op `@log = log` self-assignment
+
 ## [1.4.2] - 2026-03-28
 
 ### Added

data/Gemfile

@@ -11,5 +11,6 @@ group :test do
   gem 'rspec'
   gem 'rspec_junit_formatter'
   gem 'rubocop'
+  gem 'rubocop-legion'
   gem 'simplecov'
 end

data/lib/legion/logging/async_writer.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'methods'
+
 module Legion
   module Logging
     class AsyncWriter
-      LogEntry = ::Data.define(:level, :message, :writer_context)
+      LogEntry = ::Data.define(:level, :message, :writer_context, :segments, :method_ctx)
       SHUTDOWN = :shutdown
 
       def initialize(logger, buffer_size: 10_000)
@@ -54,10 +56,17 @@ module Legion
       end
 
       def write_entry(entry)
+        prev_segments   = Thread.current[:legion_log_segments]
+        prev_method_ctx = Thread.current[:legion_log_method]
+        Thread.current[:legion_log_segments] = entry.segments
+        Thread.current[:legion_log_method]   = entry.method_ctx
         @logger.send(entry.level, entry.message)
         fire_writer(entry) if entry.writer_context
       rescue StandardError => e
         warn("legion-log-writer error: #{e.message} (#{e.backtrace&.first})")
+      ensure
+        Thread.current[:legion_log_segments] = prev_segments
+        Thread.current[:legion_log_method]   = prev_method_ctx
       end
 
       def drain
@@ -74,9 +83,10 @@ module Legion
         event = ctx[:event]
         level = ctx[:level]
         lex_name = event[:lex] || 'core'
-        component = event.dig(:caller, :file).to_s[%r{/(runners|actors|transport|helpers|builders)/}, 1] || 'unknown'
+        component = event.dig(:caller, :file).to_s[Legion::Logging::Methods::COMPONENT_REGEX, 1] || 'unknown'
         routing_key = "legion.logging.log.#{level}.#{lex_name}.#{component}"
         Legion::Logging.log_writer.call(event, routing_key: routing_key)
+        Legion::Logging::Hooks.fire(level, entry.message, event) if defined?(Legion::Logging::Hooks)
       rescue StandardError => e
         warn("legion-log-writer writer error: #{e.message}")
       end

data/lib/legion/logging/builder.rb

@@ -27,6 +27,10 @@ module Legion
             thread:    Thread.current.object_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
           "#{::JSON.generate(entry)}\n"
         rescue StandardError => e
           warn("Legion::Logging::Builder#json_format formatter failed: #{e.message}")
@@ -36,24 +40,12 @@ module Legion
 
       def text_format(include_pid: false, **options)
         log.formatter = proc do |severity, datetime, _progname, msg|
-          options[:lex_name] = if options.key?(:lex_segments)
-                                 options[:lex_segments].map { |s| "[#{s}]" }.join
-                               elsif options.key?(:lex) && !options[:lex].nil?
-                                 "[#{options[:lex]}]"
-                               end
-          unless options[:lex_name].nil?
-            loc  = caller_locations[4]
-            path = loc.to_s.split('/').last(2)
-            runner_trace = {
-              type:        path[0],
-              file:        File.basename(loc.path, '.*'),
-              function:    loc.base_label,
-              line_number: loc.lineno
-            }
-          end
+          lex_name = resolve_lex_tag(options)
+          runner_trace = build_runner_trace if lex_name
+
           string = "[#{datetime}]"
           string.concat("[#{::Process.pid}]") if include_pid
-          string.concat(options[:lex_name]) unless options[:lex_name].nil?
+          string.concat(lex_name) if lex_name
           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
@@ -62,17 +54,36 @@ module Legion
         end
       end
 
+      def resolve_lex_tag(options)
+        segments = Thread.current[:legion_log_segments]
+        tag = if segments
+                segments.map { |s| "[#{s}]" }.join
+              elsif options.key?(:lex_segments)
+                options[:lex_segments].map { |s| "[#{s}]" }.join
+              elsif options.key?(:lex) && !options[:lex].nil?
+                "[#{options[:lex]}]"
+              end
+
+        method_ctx = Thread.current[:legion_log_method]
+        tag = "#{tag}{#{method_ctx}}" if tag && method_ctx
+        tag
+      end
+
+      def build_runner_trace
+        loc = caller_locations(6, 1)&.first
+        return unless loc
+
+        path = loc.to_s.split('/').last(2)
+        {
+          type:        path[0],
+          file:        File.basename(loc.path, '.*'),
+          function:    loc.base_label,
+          line_number: loc.lineno
+        }
+      end
+
       def output(**options)
-        if options[:log_file] && options[:log_stdout] != false
-          path = prepare_log_path(options[:log_file])
-          require_relative 'multi_io'
-          io = MultiIO.new($stdout, File.open(path, 'a'))
-          @log = ::Logger.new(io)
-        elsif options[:log_file]
-          @log = ::Logger.new(prepare_log_path(options[:log_file]))
-        else
-          @log = ::Logger.new($stdout)
-        end
+        set_log(logfile: options[:log_file], log_stdout: options[:log_stdout])
       end
 
       def log
@@ -120,10 +131,9 @@ module Legion
                       if level.is_a? Integer
                         level
                       else
-                        0
+                        1
                       end
                     end
-        @log = log
       end
 
       def async?

data/lib/legion/logging/event_builder.rb

@@ -12,6 +12,9 @@ module Legion
       MAX_TOTAL_BYTES          = 65_536
       BACKTRACE_FALLBACK_FRAMES = 20
 
+      GEM_SPEC_CACHE_MUTEX = Mutex.new
+      private_constant :GEM_SPEC_CACHE_MUTEX
+
       class << self
         def build(level:, message:, lex: nil, lex_segments: nil, context: nil, category: nil, caller_offset: 2)
           event = base_fields(level, message)
@@ -187,12 +190,18 @@ module Legion
         end
 
         def resolve_gem_spec(name)
-          [name, "lex-#{name}", "legion-#{name}"].each do |candidate|
-            return Gem::Specification.find_by_name(candidate)
+          cache = (@gem_spec_cache ||= {})
+          return cache[name] if cache.key?(name)
+
+          spec = nil
+          ["lex-#{name}", "legion-#{name}", name].each do |candidate|
+            spec = Gem::Specification.find_by_name(candidate)
+            break
           rescue Gem::MissingSpecError
             next
           end
-          nil
+
+          GEM_SPEC_CACHE_MUTEX.synchronize { cache[name] = spec }
         end
 
         def strip_ansi(str)
@@ -254,9 +263,13 @@ module Legion
         end
 
         def legion_versions
-          Gem::Specification
-            .select { |s| s.name.start_with?('legion-', 'lex-') }
-            .to_h { |s| [s.name, s.version.to_s] }
+          @legion_versions ||= Gem::Specification
+                               .select { |s| s.name.start_with?('legion-', 'lex-') }
+                               .to_h do |s|
+            [s.name,
+             s.version.to_s]
+          end
+                               .freeze
         end
 
         def truncate_bytes(str, max)

data/lib/legion/logging/helper.rb

@@ -1,47 +1,296 @@
 # frozen_string_literal: true
 
+require 'securerandom'
+require_relative 'tagged_logger'
+
 module Legion
   module Logging
     module Helper
+      SEGMENT_CACHE = {} # rubocop:disable Style/MutableConstant
+      SEGMENT_CACHE_MUTEX = Mutex.new
+      private_constant :SEGMENT_CACHE_MUTEX
+      COMPONENT_MAP = {
+        'runners'    => :runner,
+        'actors'     => :actor,
+        'actor'      => :actor,
+        'helpers'    => :helper,
+        'hooks'      => :hook,
+        'absorbers'  => :absorber,
+        'matchers'   => :matcher,
+        'transport'  => :transport,
+        'exchanges'  => :exchange,
+        'queues'     => :queue,
+        'messages'   => :message,
+        'data'       => :data,
+        'builders'   => :builder,
+        'tools'      => :tool,
+        'adapters'   => :adapter,
+        'engines'    => :engine,
+        'formatters' => :formatter,
+        'parsers'    => :parser,
+        'middleware' => :middleware
+      }.freeze
+
+      EXCEPTION_BACKTRACE_LIMIT = 10
+      EXCEPTION_PRIORITY = { warn: 0, error: 5, fatal: 9 }.freeze
+      EXCEPTION_COLORS = {
+        fatal:   :darkred,
+        error:   :red,
+        warn:    :yellow,
+        debug:   :aqua,
+        unknown: :magenta
+      }.freeze
+
+      def self.current_log_method
+        Thread.current[:legion_log_method]
+      end
+
+      def self.current_log_segments
+        Thread.current[:legion_log_segments]
+      end
+
+      def self.current_context
+        Thread.current[:legion_context]
+      end
+
       def log
-        return @log unless @log.nil?
-
-        logger_hash = if respond_to?(:segments)
-                        { lex_segments: Array(segments) }
-                      else
-                        { lex: derive_log_tag }
-                      end
-
-        if respond_to?(:settings) && settings.is_a?(Hash) && settings.key?(:logger)
-          ls = settings[:logger]
-          logger_hash[:level] = ls[:level] if ls.key?(:level)
-          logger_hash[:log_file] = ls[:log_file] if ls.key?(:log_file)
-          logger_hash[:trace] = ls[:trace] if ls.key?(:trace)
-          logger_hash[:extended] = ls[:extended] if ls.key?(:extended)
-        end
+        @log ||= Legion::Logging::TaggedLogger.new(segments: derive_log_segments, **resolve_logger_settings)
+      end
 
-        @log = Legion::Logging::Logger.new(**logger_hash)
+      def with_log_context(method_name)
+        prev = Thread.current[:legion_log_method]
+        Thread.current[:legion_log_method] = method_name.to_s
+        yield
+      ensure
+        Thread.current[:legion_log_method] = prev
+      end
+
+      def handle_exception(exception, task_id: nil, level: :error, handled: true, **opts)
+        segments = derive_log_segments
+        spec = gem_spec
+        ctx = Thread.current[:legion_context] || {}
+
+        event = Legion::Logging::EventBuilder.build_exception(
+          exception:       exception,
+          level:           level,
+          lex:             log_name,
+          component_type:  derive_component_type,
+          gem_name:        gem_name,
+          lex_version:     spec&.version&.to_s,
+          gem_path:        spec&.full_gem_path,
+          source_code_uri: spec&.metadata&.[]('source_code_uri'),
+          handled:         handled,
+          task_id:         task_id || ctx[:task_id],
+          payload_summary: opts.empty? ? nil : opts,
+          caller_offset:   3
+        )
+
+        event[:conversation_id] ||= ctx[:conversation_id]
+        event[:chain_id] ||= ctx[:chain_id]
+        event[:log_segments] = segments
+        event[:method] = Thread.current[:legion_log_method]
+
+        event = Legion::Logging::Redactor.redact(event) if defined?(Legion::Logging::Redactor)
+
+        write_exception_to_log(exception, event, level, segments)
+        publish_exception(event, level)
       end
 
       private
 
-      def derive_log_tag
+      def derive_log_segments
+        key = respond_to?(:ancestors) ? ancestors.first : self.class
+        return SEGMENT_CACHE[key] if SEGMENT_CACHE.key?(key)
+
+        segments = begin
+          parts = key.to_s.split('::')
+          parts.shift if parts.first == 'Legion'
+          parts.shift if parts.first == 'Extensions'
+          parts.map! do |p|
+            p.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+             .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+             .downcase
+          end
+          parts.freeze
+        end
+
+        SEGMENT_CACHE_MUTEX.synchronize { SEGMENT_CACHE[key] ||= segments }
+      end
+
+      def derive_component_type
+        segments = derive_log_segments
+        match = segments.find { |s| COMPONENT_MAP.key?(s) }
+        return COMPONENT_MAP[match] if match
+
+        segments.last&.to_sym || :unknown
+      end
+
+      def log_name
         if respond_to?(:lex_filename)
           fname = lex_filename
           return fname.is_a?(Array) ? fname.first : fname
         end
 
-        name = respond_to?(:ancestors) ? ancestors.first.to_s : self.class.to_s
-        parts = name.split('::')
-        ext_idx = parts.index('Extensions')
-        target = if ext_idx && parts[ext_idx + 1]
-                   parts[ext_idx + 1]
-                 else
-                   parts.last
-                 end
-        target.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-              .downcase
+        derive_log_segments.first
+      rescue StandardError
+        nil
+      end
+
+      def gem_name
+        @gem_name_resolved ? @gem_name_value : resolve_gem_name
+      end
+
+      def gem_spec
+        @gem_spec_resolved ? @gem_spec_value : resolve_gem_spec
+      end
+
+      def resolve_gem_name
+        @gem_name_resolved = true
+        base = log_name
+        @gem_name_value = if base
+                            %W[lex-#{base} legion-#{base} #{base}].find do |candidate|
+                              Gem::Specification.find_by_name(candidate)
+                              candidate
+                            rescue Gem::MissingSpecError
+                              nil
+                            end
+                          end
+      rescue StandardError
+        @gem_name_value = nil
+      end
+
+      def resolve_gem_spec
+        @gem_spec_resolved = true
+        name = gem_name
+        @gem_spec_value = name ? Gem::Specification.find_by_name(name) : nil
+      rescue Gem::MissingSpecError
+        @gem_spec_value = nil
+      end
+
+      def settings
+        { logger: logger_settings }
+      end
+
+      def logger_settings
+        return Legion::Settings[:logging] if defined?(Legion::Settings) && Legion::Settings[:logging].is_a?(Hash)
+
+        Legion::Logging::Settings.default
+      end
+
+      def resolve_logger_settings
+        s = settings
+        return Legion::Logging::Settings.default unless s.is_a?(Hash)
+
+        raw = s[:logger]
+        raw.is_a?(Hash) ? raw : Legion::Logging::Settings.default
+      end
+
+      # -- Exception stdout/file output --
+
+      def write_exception_to_log(exception, event, level, segments)
+        prev_segs = Thread.current[:legion_log_segments]
+        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.color
+
+        Legion::Logging.log.public_send(level, message)
+      ensure
+        Thread.current[:legion_log_segments] = prev_segs
+      end
+
+      def format_exception_output(exception, event)
+        lines = ["#{exception.class}: #{exception.message}"]
+
+        context_line = build_context_line(event)
+        lines << "  #{context_line}" unless context_line.empty?
+
+        bt = exception.backtrace
+        if bt&.any?
+          bt.first(EXCEPTION_BACKTRACE_LIMIT).each { |frame| lines << "  #{frame}" }
+          remaining = bt.length - EXCEPTION_BACKTRACE_LIMIT
+          lines << "  ... #{remaining} more" if remaining.positive?
+        end
+
+        lines.join("\n")
+      end
+
+      def colorize_exception(message, level)
+        color = EXCEPTION_COLORS[level] || :red
+        lines = message.split("\n")
+        lines[0] = Rainbow(lines[0]).color(color).bright
+        lines[1..].each_with_index do |line, i|
+          lines[i + 1] = Rainbow(line).color(color).faint
+        end
+        lines.join("\n")
+      end
+
+      def build_context_line(event)
+        parts = []
+        gn = event[:gem_name]
+        gv = event[:lex_version]
+        parts << (gv ? "#{gn}@#{gv}" : gn.to_s) if gn
+        parts << "task:#{event[:task_id]}" if event[:task_id]
+        parts << "conversation:#{event[:conversation_id]}" if event[:conversation_id]
+        parts << "chain:#{event[:chain_id]}" if event[:chain_id]
+        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)
+        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}")
+      end
+
+      def build_exception_headers(event, comp, level)
+        headers = {
+          '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
+        }
+        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]
+        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
     end
   end

data/lib/legion/logging/hooks.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Legion
+  module Logging
+    module Hooks
+      class << self
+        def on_fatal(&block)
+          fatal_hooks << block
+        end
+
+        def on_error(&block)
+          error_hooks << block
+        end
+
+        def on_warn(&block)
+          warn_hooks << block
+        end
+
+        def fire(level, message, event)
+          return unless @enabled
+
+          hooks_for(level).each do |hook|
+            hook.call(message, event)
+          rescue StandardError => e
+            warn("Legion::Logging::Hooks#fire callback failed: #{e.message}")
+          end
+        end
+
+        def enable_hooks!
+          @enabled = true
+        end
+
+        def disable_hooks!
+          @enabled = false
+        end
+
+        def enabled?
+          @enabled || false
+        end
+
+        def clear_hooks!
+          @fatal_hooks = []
+          @error_hooks = []
+          @warn_hooks = []
+        end
+
+        private
+
+        def hooks_for(level)
+          case level.to_sym
+          when :fatal then fatal_hooks
+          when :error then error_hooks
+          when :warn  then warn_hooks
+          else []
+          end
+        end
+
+        def fatal_hooks
+          @fatal_hooks ||= []
+        end
+
+        def error_hooks
+          @error_hooks ||= []
+        end
+
+        def warn_hooks
+          @warn_hooks ||= []
+        end
+      end
+    end
+  end
+end

data/lib/legion/logging/methods.rb

@@ -5,6 +5,13 @@ require 'securerandom'
 module Legion
   module Logging
     module Methods
+      COMPONENT_REGEX = %r{
+        /(runners|actors|actor|helpers|hooks|absorbers|matchers|transport|
+        exchanges|queues|messages|data|builders|tools|adapters|engines|
+        formatters|parsers|middleware)/
+      }x
+      EXCEPTION_PRIORITY = { warn: 0, error: 5, fatal: 9 }.freeze
+
       def trace(raw_message = nil, size: @trace_size, log_caller: true)
         return unless @trace_enabled
 
@@ -27,7 +34,11 @@ module Legion
         message = Rainbow(message).blue if @color
         writer = @async_writer
         if writer&.alive?
-          writer.push(AsyncWriter::LogEntry.new(level: :debug, message: message, writer_context: nil))
+          writer.push(AsyncWriter::LogEntry.new(
+                        level: :debug, message: message, writer_context: nil,
+                        segments: Thread.current[:legion_log_segments],
+                        method_ctx: Thread.current[:legion_log_method]
+                      ))
         else
           log.debug(message)
         end
@@ -41,7 +52,11 @@ module Legion
         message = Rainbow(message).green if @color
         writer = @async_writer
         if writer&.alive?
-          writer.push(AsyncWriter::LogEntry.new(level: :info, message: message, writer_context: nil))
+          writer.push(AsyncWriter::LogEntry.new(
+                        level: :info, message: message, writer_context: nil,
+                        segments: Thread.current[:legion_log_segments],
+                        method_ctx: Thread.current[:legion_log_method]
+                      ))
         else
           log.info(message)
         end
@@ -57,7 +72,11 @@ module Legion
         writer = @async_writer
         if writer&.alive?
           ctx = build_writer_context(:warn, raw)
-          writer.push(AsyncWriter::LogEntry.new(level: :warn, message: message, writer_context: ctx))
+          writer.push(AsyncWriter::LogEntry.new(
+                        level: :warn, message: message, writer_context: ctx,
+                        segments: Thread.current[:legion_log_segments],
+                        method_ctx: Thread.current[:legion_log_method]
+                      ))
         else
           log.warn(message)
           fire_log_writer(:warn, raw)
@@ -74,7 +93,11 @@ module Legion
         writer = @async_writer
         if writer&.alive?
           ctx = build_writer_context(:error, raw)
-          writer.push(AsyncWriter::LogEntry.new(level: :error, message: message, writer_context: ctx))
+          writer.push(AsyncWriter::LogEntry.new(
+                        level: :error, message: message, writer_context: ctx,
+                        segments: Thread.current[:legion_log_segments],
+                        method_ctx: Thread.current[:legion_log_method]
+                      ))
         else
           log.error(message)
           fire_log_writer(:error, raw)
@@ -98,7 +121,11 @@ module Legion
         message = Rainbow(message).purple if @color
         writer = @async_writer
         if writer&.alive?
-          writer.push(AsyncWriter::LogEntry.new(level: :unknown, message: message, writer_context: nil))
+          writer.push(AsyncWriter::LogEntry.new(
+                        level: :unknown, message: message, writer_context: nil,
+                        segments: Thread.current[:legion_log_segments],
+                        method_ctx: Thread.current[:legion_log_method]
+                      ))
         else
           log.unknown(message)
         end
@@ -219,16 +246,18 @@ module Legion
           timestamp:      Time.now.to_i,
           app_id:         'legionio',
           type:           'exception_event',
-          priority:       { warn: 0, error: 5, fatal: 9 }[level] || 5,
+          priority:       EXCEPTION_PRIORITY[level] || 5,
           delivery_mode:  2
         }
       end
 
       def build_writer_context(level, message)
-        return nil if Legion::Logging.instance_variable_get(:@log_writer).nil?
+        has_writer = !Legion::Logging.instance_variable_get(:@log_writer).nil?
+        has_hooks = defined?(Legion::Logging::Hooks) && Legion::Logging::Hooks.enabled?
+        return nil unless has_writer || has_hooks
 
         lex_val  = instance_variable_defined?(:@lex) ? @lex : nil
-        lex_segs = instance_variable_defined?(:@lex_segments) ? @lex_segments : nil
+        lex_segs = Thread.current[:legion_log_segments] || (instance_variable_defined?(:@lex_segments) ? @lex_segments : nil)
 
         event = Legion::Logging::EventBuilder.build(
           level:         level,
@@ -242,7 +271,7 @@ module Legion
 
       def fire_log_writer(level, message)
         lex_val  = instance_variable_defined?(:@lex) ? @lex : nil
-        lex_segs = instance_variable_defined?(:@lex_segments) ? @lex_segments : nil
+        lex_segs = Thread.current[:legion_log_segments] || (instance_variable_defined?(:@lex_segments) ? @lex_segments : nil)
 
         event = Legion::Logging::EventBuilder.build(
           level:         level,
@@ -252,13 +281,13 @@ module Legion
           caller_offset: 4
         )
         lex_name = event[:lex] || 'core'
-        component = event.dig(:caller, :file).to_s[%r{/(runners|actors|transport|helpers|builders)/}, 1] || 'unknown'
+        component = event.dig(:caller, :file).to_s[COMPONENT_REGEX, 1] || 'unknown'
         routing_key = "legion.logging.log.#{level}.#{lex_name}.#{component}"
         Legion::Logging.log_writer.call(event, routing_key: routing_key)
+        Legion::Logging::Hooks.fire(level, message, event) if defined?(Legion::Logging::Hooks)
       rescue StandardError => e
-        if respond_to?(:log) && log.respond_to?(:warn)
-          log.warn("fire_log_writer failed for level=#{level}, routing_key=#{routing_key}: #{e.class}: #{e.message}")
-        end
+        rk = defined?(routing_key) ? routing_key : 'unknown'
+        log.warn("fire_log_writer failed for level=#{level}, routing_key=#{rk}: #{e.class}: #{e.message}") if respond_to?(:log) && log.respond_to?(:warn)
       end
     end
   end

data/lib/legion/logging/settings.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Legion
+  module Logging
+    module Settings
+      def self.default
+        {
+          level:      :info,
+          trace:      false,
+          trace_size: 4,
+          extended:   false
+        }
+      end
+    end
+  end
+end

data/lib/legion/logging/shipper/http_transport.rb

@@ -29,7 +29,7 @@ module Legion
           def post(uri, body)
             req = Net::HTTP::Post.new(uri)
             req['Content-Type'] = 'application/json'
-            apply_auth(req)
+            apply_auth(req, uri)
 
             Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https',
                                                      open_timeout: 5, read_timeout: 10) do |http|
@@ -50,11 +50,11 @@ module Legion
             uri.path.include?('/services/collector')
           end
 
-          def apply_auth(req)
+          def apply_auth(req, uri)
             token = auth_token
             return unless token
 
-            req['Authorization'] = if splunk_hec?(URI(req.path.empty? ? '/' : req.uri&.to_s || '/'))
+            req['Authorization'] = if splunk_hec?(uri)
                                      "Splunk #{token}"
                                    else
                                      "Bearer #{token}"

data/lib/legion/logging/tagged_logger.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Logging
+    class TaggedLogger
+      LEVELS = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4, unknown: 5 }.freeze
+
+      attr_reader :segments, :trace_enabled, :extended
+
+      def initialize(segments:, level: :info, trace: false, trace_size: 4, extended: false, **_opts)
+        @segments = segments
+        @level_value =
+          if level.is_a?(Integer)
+            level
+          else
+            LEVELS.fetch(level.to_s.downcase.to_sym, LEVELS[:info])
+          end
+        @trace_enabled = trace
+        @trace_size = trace_size
+        @extended = extended
+      end
+
+      def level
+        @level_value
+      end
+
+      def debug(message = nil)
+        return unless @level_value < 1
+
+        message = yield if message.nil? && block_given?
+        with_segments { Legion::Logging.debug(message) }
+      end
+
+      def info(message = nil)
+        return unless @level_value < 2
+
+        message = yield if message.nil? && block_given?
+        with_segments { Legion::Logging.info(message) }
+      end
+
+      def warn(message = nil)
+        return unless @level_value < 3
+
+        message = yield if message.nil? && block_given?
+        with_segments { Legion::Logging.warn(message) }
+      end
+
+      def error(message = nil)
+        return unless @level_value < 4
+
+        message = yield if message.nil? && block_given?
+        with_segments { Legion::Logging.error(message) }
+      end
+
+      def fatal(message = nil)
+        return unless @level_value < 5
+
+        message = yield if message.nil? && block_given?
+        with_segments { Legion::Logging.fatal(message) }
+      end
+
+      def unknown(message = nil)
+        message = yield if message.nil? && block_given?
+        with_segments { Legion::Logging.unknown(message) }
+      end
+
+      def trace(raw_message = nil, size: @trace_size, log_caller: true)
+        return unless @trace_enabled
+
+        raw_message = yield if raw_message.nil? && block_given?
+        message = "Tracing: #{raw_message} "
+        if log_caller
+          frames = size ? caller_locations(2, size) : caller_locations(2)
+          message.concat(frames&.join(', ').to_s)
+        end
+        with_segments { Legion::Logging.unknown(message) }
+      end
+
+      def thread(kvl: false, **_opts)
+        if kvl
+          "thread=#{Thread.current.object_id}"
+        else
+          Thread.current.object_id.to_s
+        end
+      end
+
+      private
+
+      def with_segments
+        prev = Thread.current[:legion_log_segments]
+        Thread.current[:legion_log_segments] = @segments
+        yield
+      ensure
+        Thread.current[:legion_log_segments] = prev
+      end
+    end
+  end
+end

data/lib/legion/logging/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Logging
-    VERSION = '1.4.2'
+    VERSION = '1.4.3'
   end
 end

data/lib/legion/logging.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 
 require 'legion/logging/version'
+require 'legion/logging/settings'
 require 'legion/logging/logger'
 require 'legion/logging/methods'
 require 'legion/logging/builder'
 require 'legion/logging/event_builder'
 require 'legion/logging/async_writer'
+require 'legion/logging/tagged_logger'
 require 'legion/logging/helper'
 require 'legion/logging/category_registry'
+require 'legion/logging/hooks'
 
 require 'json'
 require 'logger'
@@ -22,7 +25,7 @@ module Legion
       attr_reader :color
       attr_writer :log_writer, :exception_writer
 
-      DEFAULT_LOG_WRITER       = ->(_event, routing_key:) {}
+      DEFAULT_LOG_WRITER = ->(_event, routing_key:) {}
       DEFAULT_EXCEPTION_WRITER = ->(_event, routing_key:, headers:, properties:) {}
 
       def log_writer
@@ -41,6 +44,30 @@ module Legion
         CategoryRegistry.registered_categories
       end
 
+      def on_fatal(&)
+        Hooks.on_fatal(&)
+      end
+
+      def on_error(&)
+        Hooks.on_error(&)
+      end
+
+      def on_warn(&)
+        Hooks.on_warn(&)
+      end
+
+      def enable_hooks!
+        Hooks.enable_hooks!
+      end
+
+      def disable_hooks!
+        Hooks.disable_hooks!
+      end
+
+      def clear_hooks!
+        Hooks.clear_hooks!
+      end
+
       def setup(level: 'info', format: :text, async: true, **options)
         output(**options)
         log_level(level)

data/lib/legion/service.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Legion
+  module Service
+    def self.register_logging_hooks
+      return unless defined?(Legion::Logging::Hooks)
+      return unless defined?(Legion::Transport)
+
+      Legion::Logging::Hooks.on_warn do |message, event|
+        Legion::Transport::Exchanges::Logging.publish(event.merge(level: :warn, message: message))
+      rescue StandardError => e
+        Kernel.warn("register_logging_hooks on_warn publish failed: #{e.message}")
+      end
+
+      Legion::Logging::Hooks.on_error do |message, event|
+        Legion::Transport::Exchanges::Logging.publish(event.merge(level: :error, message: message))
+      rescue StandardError => e
+        Kernel.warn("register_logging_hooks on_error publish failed: #{e.message}")
+      end
+
+      Legion::Logging::Hooks.on_fatal do |message, event|
+        Legion::Transport::Exchanges::Logging.publish(event.merge(level: :fatal, message: message))
+      rescue StandardError => e
+        Kernel.warn("register_logging_hooks on_fatal publish failed: #{e.message}")
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-logging
 version: !ruby/object:Gem::Version
-  version: 1.4.2
+  version: 1.4.3
 platform: ruby
 authors:
 - Esity
@@ -64,15 +64,19 @@ files:
 - lib/legion/logging/category_registry.rb
 - lib/legion/logging/event_builder.rb
 - lib/legion/logging/helper.rb
+- lib/legion/logging/hooks.rb
 - lib/legion/logging/logger.rb
 - lib/legion/logging/methods.rb
 - lib/legion/logging/multi_io.rb
 - lib/legion/logging/redactor.rb
+- lib/legion/logging/settings.rb
 - lib/legion/logging/shipper.rb
 - lib/legion/logging/shipper/file_transport.rb
 - lib/legion/logging/shipper/http_transport.rb
 - lib/legion/logging/siem_exporter.rb
+- lib/legion/logging/tagged_logger.rb
 - lib/legion/logging/version.rb
+- lib/legion/service.rb
 - sonar-project.properties
 homepage: https://github.com/LegionIO/legion-logging
 licenses: