class Auth::Sanitizer::SanitizedLogger

Logger wrapper that redacts sensitive values from debug output before delegating to the underlying logger instance.

This class is intentionally narrow in scope: it only sanitizes string messages emitted through the logging path and leaves request/response behavior unchanged.

The underlying {ThingFilter} is initialized once when the logger wrapper is created, so later config changes do not alter the behavior of existing logger instances.

Attributes

thing_filter[R]

The initialized thing filter used by this logger.

This is a per-logger snapshot created during initialization.

@return [ThingFilter]

Public Class Methods

new(logger, filtered_keys: Auth::Sanitizer.default_filtered_keys, label: Auth::Sanitizer.filtered_label) click to toggle source

Create a new sanitized logger wrapper.

@param [#add, debug, info, warn, error, fatal, unknown] logger

The underlying logger instance that will receive sanitized messages.

@param [Array<String>] filtered_keys

Key names whose values should be redacted in debug output.
Defaults to {Auth::Sanitizer.default_filtered_keys}.

@param [String] label

Replacement label for redacted values.
Defaults to {Auth::Sanitizer.filtered_label}.

   # File lib/auth/sanitizer/sanitized_logger.rb
26 def initialize(logger, filtered_keys: Auth::Sanitizer.default_filtered_keys, label: Auth::Sanitizer.filtered_label)
27   @logger = logger
28   @thing_filter = ThingFilter.new(filtered_keys, label: label)
29 end

Public Instance Methods

<<(message) click to toggle source

Append a message to the underlying logger after sanitization.

@param [String] message Message to append @return [Object] The underlying logger result

   # File lib/auth/sanitizer/sanitized_logger.rb
50 def <<(message)
51   @logger << sanitize(message)
52 end

add(severity, message = nil, progname = nil) { || ... } click to toggle source

Add a log entry after sanitizing any string payloads.

@param [Integer, Symbol, String, nil] severity Logger severity @param [Object, nil] message Optional log message @param [Object, nil] progname Optional program name @yieldreturn [Object] Deferred log message @return [Object] The underlying logger result

   # File lib/auth/sanitizer/sanitized_logger.rb
38 def add(severity, message = nil, progname = nil)
39   if block_given?
40     @logger.add(severity, sanitize(message), sanitize(progname)) { sanitize(yield) }
41   else
42     @logger.add(severity, sanitize(message), sanitize(progname))
43   end
44 end

close() click to toggle source

Close the underlying logger if supported.

@return [void]

    # File lib/auth/sanitizer/sanitized_logger.rb
111 def close
112   @logger.close if @logger.respond_to?(:close)
113 end

debug(progname = nil, &block) click to toggle source

Log a debug message after sanitization.

@param [Object, nil] progname Optional program name @yieldreturn [Object] Deferred log message @return [Object] The underlying logger result

   # File lib/auth/sanitizer/sanitized_logger.rb
59 def debug(progname = nil, &block)
60   log(:debug, progname, &block)
61 end

error(progname = nil, &block) click to toggle source

Log an error message after sanitization.

@param [Object, nil] progname Optional program name @yieldreturn [Object] Deferred log message @return [Object] The underlying logger result

   # File lib/auth/sanitizer/sanitized_logger.rb
86 def error(progname = nil, &block)
87   log(:error, progname, &block)
88 end

fatal(progname = nil, &block) click to toggle source

Log a fatal message after sanitization.

@param [Object, nil] progname Optional program name @yieldreturn [Object] Deferred log message @return [Object] The underlying logger result

   # File lib/auth/sanitizer/sanitized_logger.rb
95 def fatal(progname = nil, &block)
96   log(:fatal, progname, &block)
97 end

formatter() click to toggle source

Access the formatter of the underlying logger if supported.

@return [Object, nil]

    # File lib/auth/sanitizer/sanitized_logger.rb
118 def formatter
119   @logger.formatter if @logger.respond_to?(:formatter)
120 end

formatter=(formatter) click to toggle source

Set the formatter of the underlying logger if supported.

@param [Object] formatter Formatter object @return [void]

    # File lib/auth/sanitizer/sanitized_logger.rb
126 def formatter=(formatter)
127   @logger.formatter = formatter if @logger.respond_to?(:formatter=)
128 end

info(progname = nil, &block) click to toggle source

Log an info message after sanitization.

@param [Object, nil] progname Optional program name @yieldreturn [Object] Deferred log message @return [Object] The underlying logger result

   # File lib/auth/sanitizer/sanitized_logger.rb
68 def info(progname = nil, &block)
69   log(:info, progname, &block)
70 end

level() click to toggle source

Access the logger level if supported.

@return [Object, nil]

    # File lib/auth/sanitizer/sanitized_logger.rb
133 def level
134   @logger.level if @logger.respond_to?(:level)
135 end

level=(level) click to toggle source

Set the logger level if supported.

@param [Object] level Logger level @return [void]

    # File lib/auth/sanitizer/sanitized_logger.rb
141 def level=(level)
142   @logger.level = level if @logger.respond_to?(:level=)
143 end

method_missing(method_name, *args, &block) click to toggle source

Delegate unsupported methods to the wrapped logger.

@param [Symbol] method_name Method to invoke @param [Array<Object>] args Method arguments @yield Deferred block forwarded to the wrapped logger @return [Object] The delegated result

Calls superclass method

    # File lib/auth/sanitizer/sanitized_logger.rb
175 def method_missing(method_name, *args, &block)
176   return super unless @logger.respond_to?(method_name)
177 
178   @logger.public_send(method_name, *args, &block)
179 end

progname() click to toggle source

Access the logger progname if supported.

@return [Object, nil]

    # File lib/auth/sanitizer/sanitized_logger.rb
148 def progname
149   @logger.progname if @logger.respond_to?(:progname)
150 end

progname=(progname) click to toggle source

Set the logger progname if supported.

@param [Object] progname Logger progname @return [void]

    # File lib/auth/sanitizer/sanitized_logger.rb
156 def progname=(progname)
157   @logger.progname = progname if @logger.respond_to?(:progname=)
158 end

respond_to_missing?(method_name, include_private = false) click to toggle source

Report support for methods provided by the wrapped logger.

@param [Symbol] method_name Method name to check @param [Boolean] include_private Whether private methods are considered @return [Boolean]

Calls superclass method

    # File lib/auth/sanitizer/sanitized_logger.rb
165 def respond_to_missing?(method_name, include_private = false)
166   @logger.respond_to?(method_name, include_private) || super
167 end

unknown(progname = nil, &block) click to toggle source

Log an unknown-severity message after sanitization.

@param [Object, nil] progname Optional program name @yieldreturn [Object] Deferred log message @return [Object] The underlying logger result

    # File lib/auth/sanitizer/sanitized_logger.rb
104 def unknown(progname = nil, &block)
105   log(:unknown, progname, &block)
106 end

warn(progname = nil, &block) click to toggle source

Log a warning message after sanitization.

@param [Object, nil] progname Optional program name @yieldreturn [Object] Deferred log message @return [Object] The underlying logger result

   # File lib/auth/sanitizer/sanitized_logger.rb
77 def warn(progname = nil, &block)
78   log(:warn, progname, &block)
79 end

Private Instance Methods

log(level, progname = nil) { || ... } click to toggle source

Dispatch a severity-specific log call after sanitization.

@param [Symbol] level Logger method name @param [Object, nil] progname Optional program name @yieldreturn [Object] Deferred log message @return [Object] The underlying logger result

    # File lib/auth/sanitizer/sanitized_logger.rb
189 def log(level, progname = nil)
190   if block_given?
191     @logger.public_send(level, sanitize(progname)) { sanitize(yield) }
192   else
193     @logger.public_send(level, sanitize(progname))
194   end
195 end

sanitize(message) click to toggle source

Sanitize a logger message when it is a String.

@param [Object] message Potential logger payload @return [Object] Unchanged non-String payloads, sanitized String payloads

    # File lib/auth/sanitizer/sanitized_logger.rb
201 def sanitize(message)
202   return message unless message.is_a?(String)
203 
204   sanitized = message.dup
205   sanitized = sanitize_authorization_header(sanitized)
206   sanitized = sanitize_json_pairs(sanitized)
207   sanitize_form_and_query_pairs(sanitized)
208 end

sanitize_authorization_header(message) click to toggle source

Redact Authorization header values.

@param [String] message Logger message @return [String] Sanitized logger message

    # File lib/auth/sanitizer/sanitized_logger.rb
221 def sanitize_authorization_header(message)
222   message.gsub(/(Authorization:\s*)(?:"[^"]*"|[^\r\n]+)/i, "\\1\"#{thing_filter.label}\"")
223 end

sanitize_form_and_query_pairs(message) click to toggle source

Redact form-encoded and query-string values for configured sensitive key names.

@param [String] message Logger message @return [String] Sanitized logger message

    # File lib/auth/sanitizer/sanitized_logger.rb
239 def sanitize_form_and_query_pairs(message)
240   message.gsub(/(\b(?:#{thing_filter.pattern_source})=)([^&\s"]+)/i, "\\1#{thing_filter.label}")
241 end

sanitize_json_pairs(message) click to toggle source

Redact JSON-style values for configured sensitive key names.

@param [String] message Logger message @return [String] Sanitized logger message

    # File lib/auth/sanitizer/sanitized_logger.rb
229 def sanitize_json_pairs(message)
230   message.gsub(/(["'])(#{thing_filter.pattern_source})\1(\s*:\s*)(["'])(.*?)\4/i) do
231     %(#{$1}#{$2}#{$1}#{$3}#{$4}#{thing_filter.label}#{$4})
232   end
233 end