legion-logging 1.3.4 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac6e65a10ce7708585f78114b5ee2d18303430e0d70b9039620f819a7de14325
-  data.tar.gz: fbf159026929b5d15668cd68aa5b0533f05d32ed67587389ade09a97bddc910c
+  metadata.gz: 87467334f127d64997e116d784a68d875c8180a6633dd068e4e095eb7e8bc22f
+  data.tar.gz: a934447ca2a89f43d3f4993a1df8e879b15945b966b4ade4f29b4d6b2272762d
 SHA512:
-  metadata.gz: 0a94512fdad36ed375ee678cc64bf7473496418cd3f25d560286d83f0db5af32c86eb262d489725bfc70b6e9e44724d197b8a85b4497073da6932f8a312c0682
-  data.tar.gz: f146a912510f6b0eba2e3b28bc86952330e8d31caaee509869ee116fa12c60a21c599af4c882c44524d674a0ccc1320eea5ab6a5f13afd9c770c5c0d5de35dd5
+  metadata.gz: bb9ece1de3b070fb58417992daf22fdaf3e0021f8a45e486a6d5fa4bdca8536c9ed6bdaec8b867f8aef854b52a1496d462260c7cf31d1faae4b0769a91995ef2
+  data.tar.gz: 00f6510d46e38bb7a638aace8818cdccdefe9bfb8c857ecc2d6b11a43f55461ea25bd56a37b0b325749971808491679160930ba11014a453d7fbd5b096d50368

data/.github/CODEOWNERS

@@ -0,0 +1,7 @@
+# Auto-generated from team-config.yml
+# Team: core
+#
+# To apply: scripts/apply-codeowners.sh legion-logging
+
+* @LegionIO/maintainers
+* @LegionIO/core

data/.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"

data/.rubocop.yml

@@ -16,6 +16,9 @@ Layout/HashAlignment:
 Metrics/MethodLength:
   Max: 50
 
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
 Metrics/ClassLength:
   Max: 1500
 

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Legion::Logging Changelog
 
+## [1.4.1] - 2026-03-27
+
+### Fixed
+- `require 'time'` added to `event_builder.rb` so `Time#iso8601` is always available in minimal Ruby environments
+- `log_writer` / `exception_writer` accessors no longer memoize the no-op default via `||=`; `@log_writer` stays `nil` until a real writer is assigned, which allows `build_writer_context` to correctly short-circuit event building when no writer is configured
+- README writer lambda examples updated to show correct keyword argument signatures matching actual call sites
+
+## [1.4.0] - 2026-03-27
+
+### Added
+- `log_exception` method in `Methods` — single call for complete structured exception events
+- `EventBuilder.build_exception` — builds rich exception payloads with fingerprint, versions, flat caller keys
+- `EventBuilder.fingerprint` — MD5 fingerprint of stable error fields for dedup
+- `log_writer` / `exception_writer` pluggable lambda slots on `Legion::Logging`
+- Size enforcement: 4KB message cap, 8KB payload_summary cap, 64KB total cap
+- Vault token, JWT, lease ID, and URI patterns added to Redactor
+
+### Removed
+- `Legion::Logging::Hooks` module (`on_fatal`, `on_error`, `on_warn`, `enable_hooks!`, `disable_hooks!`, `clear_hooks!`)
+- Hooks replaced by `log_writer` and `exception_writer` lambdas
+
+### Changed
+- `AsyncWriter::LogEntry` uses `writer_context` field instead of `hook_context`
+- `runner_exception` now delegates to `log_exception` internally
+
+## [1.3.5] - 2026-03-24
+
+### Added
+- Automatic PII/PHI redaction in log write path: all log methods (`debug`, `info`, `warn`, `error`, `fatal`, `unknown`) pass string messages through `Legion::Logging::Redactor.redact_string` when `logging.redaction.enabled` is `true` (default: `false`)
+- `maybe_redact(message)` private helper on `Legion::Logging::Methods` — no-ops when redaction is disabled, `Redactor` is not defined, or message is not a string
+- Hook callbacks (`on_warn`, `on_error`, `on_fatal`) receive already-redacted message so no PHI leaks through hook dispatch
+
+### Fixed
+- `redaction_enabled?` guards against recursive `Legion::Settings::Loader` initialization by checking `@loader` ivar directly before calling `dig`; prevents infinite recursion when settings bootstrap calls `Legion::Logging.warn`
+
 ## [1.3.4] - 2026-03-24
 
 ### Fixed

data/README.md

@@ -2,7 +2,7 @@
 
 Logging module for the [LegionIO](https://github.com/LegionIO/LegionIO) framework. Provides colorized console output via Rainbow, structured JSON logging, multi-output IO, and a consistent logging interface across all Legion gems and extensions.
 
-**Version**: 1.3.2
+**Version**: 1.4.1
 
 ## Installation
 
@@ -94,6 +94,35 @@ class MyRunner
 end
 ```
 
+### Exception Logging
+
+`log_exception` provides a single call for complete structured exception events with component context:
+
+```ruby
+Legion::Logging.log_exception(exception,
+  handled: true,
+  component_type: :runner,
+  lex: 'my_extension',
+  task_id: 'abc-123')
+```
+
+### Writer Lambdas
+
+`log_writer` and `exception_writer` are pluggable lambda slots that replace the old Hooks system. Assign them to forward events to external systems:
+
+```ruby
+Legion::Logging.exception_writer = ->(payload, routing_key:, headers:, properties:) { publish_to_amqp(payload) }
+Legion::Logging.log_writer = ->(context, routing_key:) { publish_log(context) }
+```
+
+### EventBuilder
+
+`EventBuilder.build_exception` constructs rich structured exception payloads including caller location, lex identity, and gem metadata. `EventBuilder.fingerprint` produces an MD5 fingerprint of stable error fields for deduplication in log aggregation pipelines.
+
+### Redactor
+
+`Legion::Logging::Redactor` redacts PII/PHI patterns (SSN, phone, MRN, DOB) plus Vault tokens, JWTs, bearer tokens, and lease IDs from log messages. Redaction is opt-in: load the module (for example via `require 'legion/logging/redactor'`) and enable it with `logging.redaction.enabled: true`. When loaded and enabled, it is wired into all log methods in the write path.
+
 ## Requirements
 
 - Ruby >= 3.4

data/lib/legion/logging/async_writer.rb

@@ -3,7 +3,7 @@
 module Legion
   module Logging
     class AsyncWriter
-      LogEntry = ::Data.define(:level, :message, :hook_context)
+      LogEntry = ::Data.define(:level, :message, :writer_context)
       SHUTDOWN = :shutdown
 
       def initialize(logger, buffer_size: 10_000)
@@ -55,7 +55,7 @@ module Legion
 
       def write_entry(entry)
         @logger.send(entry.level, entry.message)
-        fire_hooks(entry) if entry.hook_context
+        fire_writer(entry) if entry.writer_context
       rescue StandardError => e
         warn("legion-log-writer error: #{e.message} (#{e.backtrace&.first})")
       end
@@ -69,11 +69,16 @@ module Legion
         nil
       end
 
-      def fire_hooks(entry)
-        ctx = entry.hook_context
-        Legion::Logging::Hooks.fire(ctx[:level], ctx[:event])
+      def fire_writer(entry)
+        ctx = entry.writer_context
+        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'
+        routing_key = "legion.logging.log.#{level}.#{lex_name}.#{component}"
+        Legion::Logging.log_writer.call(event, routing_key: routing_key)
       rescue StandardError => e
-        warn("legion-log-writer hook error: #{e.message}")
+        warn("legion-log-writer writer error: #{e.message}")
       end
     end
   end

data/lib/legion/logging/event_builder.rb

@@ -1,10 +1,19 @@
 # frozen_string_literal: true
 
+require 'digest'
+require 'json'
+require 'time'
+
 module Legion
   module Logging
     module EventBuilder
+      MAX_MESSAGE_BYTES        = 4096
+      MAX_PAYLOAD_BYTES        = 8192
+      MAX_TOTAL_BYTES          = 65_536
+      BACKTRACE_FALLBACK_FRAMES = 20
+
       class << self
-        def build(level:, message:, lex: nil, lex_segments: nil, context: nil, caller_offset: 2) # rubocop:disable Metrics/ParameterLists
+        def build(level:, message:, lex: nil, lex_segments: nil, context: nil, caller_offset: 2)
           event = base_fields(level, message)
           event[:lex] = derive_lex_source(lex, lex_segments)
           add_node(event)
@@ -15,6 +24,99 @@ module Legion
           event.compact
         end
 
+        def build_exception(
+          exception:,
+          level:,
+          lex: nil,
+          component_type: nil,
+          gem_name: nil,
+          lex_version: nil,
+          gem_path: nil,
+          source_code_uri: nil,
+          handled: false,
+          payload_summary: nil,
+          task_id: nil,
+          caller_offset: 2,
+          **extra
+        )
+          bt = Array(exception.backtrace)
+          cf_file, cf_line, cf_func = parse_backtrace_location(bt.first) ||
+                                      caller_location(caller_offset)
+
+          event = {
+            timestamp:       Time.now.utc.iso8601(3),
+            level:           level,
+            exception_class: exception.class.name,
+            message:         truncate_bytes(exception.message.to_s, MAX_MESSAGE_BYTES),
+            backtrace:       bt,
+            caller_file:     cf_file,
+            caller_line:     cf_line,
+            caller_function: cf_func,
+            lex:             lex,
+            component_type:  component_type,
+            gem_name:        gem_name,
+            lex_version:     lex_version,
+            gem_path:        gem_path,
+            source_code_uri: source_code_uri,
+            legion_versions: legion_versions,
+            ruby_version:    "#{RUBY_VERSION} #{RUBY_PLATFORM}",
+            handled:         handled,
+            pid:             ::Process.pid,
+            thread:          Thread.current.object_id
+          }
+
+          event[:task_id] = task_id if task_id
+          event[:payload_summary] = truncate_payload(payload_summary) if payload_summary
+
+          add_node(event)
+          add_user(event)
+          add_session_context(event)
+
+          event[:error_fingerprint] = fingerprint(
+            exception_class: exception.class.name,
+            message:         event[:message],
+            caller_file:     cf_file.to_s,
+            caller_line:     cf_line.to_i,
+            caller_function: cf_func.to_s,
+            gem_name:        gem_name.to_s,
+            component_type:  component_type.to_s,
+            backtrace:       bt
+          )
+
+          extra.each { |k, v| event[k] = v unless event.key?(k) }
+
+          enforce_total_size!(event)
+          event.compact
+        end
+
+        def fingerprint(
+          exception_class:,
+          message:,
+          caller_file:,
+          caller_line:,
+          caller_function:,
+          gem_name:,
+          component_type:,
+          backtrace:
+        )
+          norm_msg = normalize_message(message.to_s)
+          norm_file = normalize_path(caller_file.to_s)
+          norm_bt = Array(backtrace).first(5).map { |l| normalize_path(l.to_s) }.join('|')
+
+          raw = [
+            exception_class.to_s,
+            norm_msg,
+            norm_file,
+            caller_line.to_s,
+            caller_function.to_s,
+            gem_name.to_s,
+            component_type.to_s,
+            norm_bt
+          ].join(':')
+
+          Digest::MD5.hexdigest(raw)
+        end
+
         private
 
         def base_fields(level, message)
@@ -95,6 +197,106 @@ module Legion
         def strip_ansi(str)
           str.gsub(/\e\[[0-9;]*m/, '')
         end
+
+        # New private helpers for build_exception
+
+        def add_user(event)
+          identity = if defined?(Legion::Extensions::Helpers::Secret) &&
+                        Legion::Extensions::Helpers::Secret.respond_to?(:resolved_identity)
+                       Legion::Extensions::Helpers::Secret.resolved_identity
+                     else
+                       ENV.fetch('USER', nil)
+                     end
+          event[:user] = identity
+        end
+
+        def add_session_context(event)
+          return unless defined?(Legion::Context)
+
+          session = begin
+            Legion::Context.current_session
+          rescue StandardError
+            nil
+          end
+          return unless session
+
+          event[:conversation_id] = session.session_id
+        end
+
+        def parse_backtrace_location(frame)
+          return nil unless frame.is_a?(String)
+
+          # Format: /path/to/file.rb:42:in `method_name`
+          if (m = frame.match(/\A(.+):(\d+):in `([^`]+)`\z/))
+            [m[1], m[2].to_i, m[3]]
+          elsif (m = frame.match(/\A(.+):(\d+)\z/))
+            [m[1], m[2].to_i, nil]
+          end
+        end
+
+        def caller_location(offset)
+          loc = caller_locations(offset + 2, 1)&.first
+          return [nil, nil, nil] unless loc
+
+          [loc.absolute_path || loc.path, loc.lineno, loc.base_label]
+        end
+
+        def normalize_message(msg)
+          msg
+            .gsub(/0x[0-9a-f]+/i, '0xXXX')
+            .gsub(/#<[A-Z][A-Za-z:]*:0xXXX>/, '#<Class:0xXXX>')
+            .gsub(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/, 'X.X.X.X')
+        end
+
+        def normalize_path(path)
+          path.gsub(/-\d+\.\d+[\d.]*/, '')
+        end
+
+        def legion_versions
+          Gem::Specification
+            .select { |s| s.name.start_with?('legion-', 'lex-') }
+            .to_h { |s| [s.name, s.version.to_s] }
+        end
+
+        def truncate_bytes(str, max)
+          return str if str.bytesize <= max
+
+          str.byteslice(0, max).scrub
+        end
+
+        def safe_json_bytesize(object)
+          ::JSON.generate(object).bytesize
+        rescue ::JSON::GeneratorError, TypeError
+          object.to_s.bytesize
+        end
+
+        def truncate_payload(payload)
+          return nil unless payload
+
+          str = if payload.is_a?(String)
+                  payload
+                else
+                  begin
+                    ::JSON.generate(payload)
+                  rescue ::JSON::GeneratorError, TypeError
+                    payload.to_s
+                  end
+                end
+          truncate_bytes(str, MAX_PAYLOAD_BYTES)
+        end
+
+        def enforce_total_size!(event)
+          return if safe_json_bytesize(event) <= MAX_TOTAL_BYTES
+
+          event.delete(:payload_summary)
+          return if safe_json_bytesize(event) <= MAX_TOTAL_BYTES
+
+          bt = event[:backtrace]
+          event[:backtrace] = bt.first(BACKTRACE_FALLBACK_FRAMES) if bt.is_a?(Array)
+          return if safe_json_bytesize(event) <= MAX_TOTAL_BYTES
+
+          event[:message] = truncate_bytes(event[:message].to_s, 1024)
+        end
       end
     end
   end

data/lib/legion/logging/logger.rb

@@ -11,7 +11,7 @@ module Legion
       include Legion::Logging::Methods
       include Legion::Logging::Builder
 
-      def initialize(level: 'info', log_file: nil, log_stdout: nil, lex: nil, trace: false, extended: false, trace_size: 4, format: :text, async: false, **opts) # rubocop:disable Metrics/ParameterLists
+      def initialize(level: 'info', log_file: nil, log_stdout: nil, lex: nil, trace: false, extended: false, trace_size: 4, format: :text, async: false, **opts)
         @lex = lex
         set_log(logfile: log_file, log_stdout: log_stdout)
         log_level(level)

data/lib/legion/logging/methods.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'securerandom'
+
 module Legion
   module Logging
     module Methods
@@ -21,10 +23,11 @@ module Legion
         return unless log.level < 1
 
         message = yield if message.nil? && block_given?
+        message = maybe_redact(message)
         message = Rainbow(message).blue if @color
         writer = @async_writer
         if writer&.alive?
-          writer.push(AsyncWriter::LogEntry.new(level: :debug, message: message, hook_context: nil))
+          writer.push(AsyncWriter::LogEntry.new(level: :debug, message: message, writer_context: nil))
         else
           log.debug(message)
         end
@@ -34,10 +37,11 @@ module Legion
         return unless log.level < 2
 
         message = yield if message.nil? && block_given?
+        message = maybe_redact(message)
         message = Rainbow(message).green if @color
         writer = @async_writer
         if writer&.alive?
-          writer.push(AsyncWriter::LogEntry.new(level: :info, message: message, hook_context: nil))
+          writer.push(AsyncWriter::LogEntry.new(level: :info, message: message, writer_context: nil))
         else
           log.info(message)
         end
@@ -47,15 +51,16 @@ module Legion
         return unless log.level < 3
 
         message = yield if message.nil? && block_given?
+        message = maybe_redact(message)
         raw = message
         message = Rainbow(message).yellow if @color
         writer = @async_writer
         if writer&.alive?
-          ctx = build_hook_context(:warn, raw)
-          writer.push(AsyncWriter::LogEntry.new(level: :warn, message: message, hook_context: ctx))
+          ctx = build_writer_context(:warn, raw)
+          writer.push(AsyncWriter::LogEntry.new(level: :warn, message: message, writer_context: ctx))
         else
           log.warn(message)
-          fire_hooks(:warn, raw)
+          fire_log_writer(:warn, raw)
         end
       end
 
@@ -63,15 +68,16 @@ module Legion
         return unless log.level < 4
 
         message = yield if message.nil? && block_given?
+        message = maybe_redact(message)
         raw = message
         message = Rainbow(message).red if @color
         writer = @async_writer
         if writer&.alive?
-          ctx = build_hook_context(:error, raw)
-          writer.push(AsyncWriter::LogEntry.new(level: :error, message: message, hook_context: ctx))
+          ctx = build_writer_context(:error, raw)
+          writer.push(AsyncWriter::LogEntry.new(level: :error, message: message, writer_context: ctx))
         else
           log.error(message)
-          fire_hooks(:error, raw)
+          fire_log_writer(:error, raw)
         end
       end
 
@@ -79,30 +85,69 @@ module Legion
         return unless log.level < 5
 
         message = yield if message.nil? && block_given?
+        message = maybe_redact(message)
         raw = message
         message = Rainbow(message).darkred if @color
         log.fatal(message)
-        fire_hooks(:fatal, raw)
+        fire_log_writer(:fatal, raw)
       end
 
       def unknown(message = nil)
         message = yield if message.nil? && block_given?
+        message = maybe_redact(message)
         message = Rainbow(message).purple if @color
         writer = @async_writer
         if writer&.alive?
-          writer.push(AsyncWriter::LogEntry.new(level: :unknown, message: message, hook_context: nil))
+          writer.push(AsyncWriter::LogEntry.new(level: :unknown, message: message, writer_context: nil))
         else
           log.unknown(message)
         end
       end
 
       def runner_exception(exc, **opts)
-        Legion::Logging.error exc.message
-        Legion::Logging.error exc.backtrace
-        Legion::Logging.error opts
+        log_exception(exc, handled: true, **opts)
         { success: false, message: exc.message, backtrace: exc.backtrace }.merge(opts)
       end
 
+      def log_exception(exception, level: :error, lex: nil, component_type: nil,
+                        gem_name: nil, lex_version: nil, gem_path: nil,
+                        source_code_uri: nil, handled: false, payload_summary: nil,
+                        task_id: nil, **extra)
+        level = level.to_sym if level.respond_to?(:to_sym)
+        # 1. Log human-readable line to stdout/file (bypass writer callbacks)
+        msg = exception.respond_to?(:message) ? exception.message : exception.to_s
+        log.public_send(level, msg) if respond_to?(:log) && log.respond_to?(level)
+
+        # 2. Build rich exception event
+        event = Legion::Logging::EventBuilder.build_exception(
+          exception:       exception,
+          level:           level,
+          lex:             lex,
+          component_type:  component_type,
+          gem_name:        gem_name,
+          lex_version:     lex_version,
+          gem_path:        gem_path,
+          source_code_uri: source_code_uri,
+          handled:         handled,
+          payload_summary: payload_summary,
+          task_id:         task_id,
+          caller_offset:   3,
+          **extra
+        )
+
+        # 3. Redact secrets before publishing
+        event = Legion::Logging::Redactor.redact(event) if defined?(Legion::Logging::Redactor)
+
+        # 4. Publish rich event via exception_writer
+        publish_exception_event(event, level)
+      rescue StandardError => e
+        if respond_to?(:log) && log.respond_to?(:warn)
+          log.warn("Failed to publish structured exception event: #{e.class}: #{e.message}")
+        else
+          warn("Failed to publish structured exception event: #{e.class}: #{e.message}")
+        end
+      end
+
       def thread(kvl: false, **_opts)
         if kvl
           "thread=#{Thread.current.object_id}"
@@ -113,9 +158,74 @@ module Legion
 
       private
 
-      def build_hook_context(level, message)
-        return nil unless Legion::Logging::Hooks.enabled?
-        return nil if Legion::Logging::Hooks.hooks[level].empty?
+      def maybe_redact(message)
+        return message unless message.is_a?(String)
+        return message unless redaction_enabled?
+        return message unless defined?(Legion::Logging::Redactor)
+
+        Legion::Logging::Redactor.redact_string(message)
+      rescue StandardError
+        message
+      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
+
+      def publish_exception_event(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)
+      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
+        }
+        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-user', event[:user])
+        headers
+      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 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:       { warn: 0, error: 5, fatal: 9 }[level] || 5,
+          delivery_mode:  2
+        }
+      end
+
+      def build_writer_context(level, message)
+        return nil if Legion::Logging.instance_variable_get(:@log_writer).nil?
 
         lex_val  = instance_variable_defined?(:@lex) ? @lex : nil
         lex_segs = instance_variable_defined?(:@lex_segments) ? @lex_segments : nil
@@ -130,10 +240,7 @@ module Legion
         { level: level, event: event }
       end
 
-      def fire_hooks(level, message)
-        return unless Legion::Logging::Hooks.enabled?
-        return if Legion::Logging::Hooks.hooks[level].empty?
-
+      def fire_log_writer(level, message)
         lex_val  = instance_variable_defined?(:@lex) ? @lex : nil
         lex_segs = instance_variable_defined?(:@lex_segments) ? @lex_segments : nil
 
@@ -144,7 +251,14 @@ module Legion
           lex_segments:  lex_segs,
           caller_offset: 4
         )
-        Legion::Logging::Hooks.fire(level, event)
+        lex_name = event[:lex] || 'core'
+        component = event.dig(:caller, :file).to_s[%r{/(runners|actors|transport|helpers|builders)/}, 1] || 'unknown'
+        routing_key = "legion.logging.log.#{level}.#{lex_name}.#{component}"
+        Legion::Logging.log_writer.call(event, routing_key: routing_key)
+      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
       end
     end
   end

data/lib/legion/logging/redactor.rb

@@ -4,12 +4,18 @@ module Legion
   module Logging
     module Redactor
       PATTERNS = {
-        ssn:         /\b\d{3}-\d{2}-\d{4}\b/,
-        email:       /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/,
-        phone:       /\b(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/,
-        mrn:         /\bMRN[:\s]*\d{6,10}\b/i,
-        dob:         %r{\bDOB[:\s]*\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b}i,
-        credit_card: /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/
+        ssn:            /\b\d{3}-\d{2}-\d{4}\b/,
+        email:          /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/,
+        phone:          /\b(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/,
+        mrn:            /\bMRN[:\s]*\d{6,10}\b/i,
+        dob:            %r{\bDOB[:\s]*\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b}i,
+        credit_card:    /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/,
+        vault_token:    /\bhvs\.[A-Za-z0-9_-]{20,}\b/,
+        vault_lease_id: %r{\b[a-z_-]+/creds/[a-z_-]+/[A-Za-z0-9-]{36}\b},
+        jwt:            /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/,
+        vault_uri:      %r{vault://[^"',\]\x7d\s]+},
+        lease_uri:      %r{lease://[^"',\]\x7d\s]+},
+        bearer_token:   %r{Bearer\s+[A-Za-z0-9._~+/=-]{20,}}i
       }.freeze
 
       SENSITIVE_FIELDS = %w[password secret token api_key authorization].freeze

data/lib/legion/logging/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Logging
-    VERSION = '1.3.4'
+    VERSION = '1.4.1'
   end
 end

data/lib/legion/logging.rb

@@ -4,7 +4,6 @@ require 'legion/logging/version'
 require 'legion/logging/logger'
 require 'legion/logging/methods'
 require 'legion/logging/builder'
-require 'legion/logging/hooks'
 require 'legion/logging/event_builder'
 require 'legion/logging/async_writer'
 require 'legion/logging/helper'
@@ -19,14 +18,19 @@ module Legion
       include Legion::Logging::Methods
       include Legion::Logging::Builder
 
-      def on_fatal(&)  = Hooks.register(:fatal, &)
-      def on_error(&)  = Hooks.register(:error, &)
-      def on_warn(&)   = Hooks.register(:warn, &)
-      def enable_hooks!     = Hooks.enable!
-      def disable_hooks!    = Hooks.disable!
-      def clear_hooks!      = Hooks.clear!
-
       attr_reader :color
+      attr_writer :log_writer, :exception_writer
+
+      DEFAULT_LOG_WRITER       = ->(_event, routing_key:) {}
+      DEFAULT_EXCEPTION_WRITER = ->(_event, routing_key:, headers:, properties:) {}
+
+      def log_writer
+        @log_writer || DEFAULT_LOG_WRITER
+      end
+
+      def exception_writer
+        @exception_writer || DEFAULT_EXCEPTION_WRITER
+      end
 
       def setup(level: 'info', format: :text, async: true, **options)
         output(**options)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-logging
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.4.1
 platform: ruby
 authors:
 - Esity
@@ -47,6 +47,8 @@ extra_rdoc_files:
 - LICENSE
 - README.md
 files:
+- ".github/CODEOWNERS"
+- ".github/dependabot.yml"
 - ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
@@ -61,7 +63,6 @@ files:
 - lib/legion/logging/builder.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

data/lib/legion/logging/hooks.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Logging
-    module Hooks
-      @hooks = { fatal: [], error: [], warn: [] }
-      @enabled = false
-
-      class << self
-        attr_reader :hooks
-
-        def enabled?
-          @enabled
-        end
-
-        def enable!
-          @enabled = true
-        end
-
-        def disable!
-          @enabled = false
-        end
-
-        def clear!
-          @hooks.each_value(&:clear)
-        end
-
-        def register(level, &block)
-          @hooks[level] << block
-        end
-
-        def fire(level, event)
-          return unless @enabled
-          return if @hooks[level].empty?
-
-          @hooks[level].each do |hook|
-            hook.call(event)
-          rescue StandardError => e
-            warn("Legion::Logging::Hooks#fire hook failed at level=#{level}: #{e.message}")
-            nil
-          end
-        end
-      end
-    end
-  end
-end