legion-settings 1.3.25 → 1.3.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '028759fea7f4684e657e735676b17ebe147f71781e8bf3aac758fb226c8be81d'
-  data.tar.gz: 56d57df1ca491e5976c2f654701aad0d93fd8d3cf8347c4a4e2c9eb3a487941a
+  metadata.gz: 6a096c46e4b074a4e77c104f21b1dc89b953ad15370e514ccd7face8cf8a7b8f
+  data.tar.gz: 06475bdc9bf41c6219e2c61fef17006346bb57b833a9a6c992a02f1d1178047a
 SHA512:
-  metadata.gz: c75da04c00df4cd9db84c50c3327e9b5c80ad5a4137531cb1aad9d5e8efc8809736d97359c8de2c791aed1848e1b2b0c2948d27a50fee24ed3263e54de9d63ab
-  data.tar.gz: 51d80d06a89f8ccc4284d6ff90741e2f083f08827ecd8c6ab853d7ff913aad24780ac22e25b0999fcd9464544161b15f5983bd824ea62ac3cfce6ca4e3b1acd2
+  metadata.gz: 30cc986020bd6c2f4c783193f65fb07b935e08ddadd1a00608a90001a8312da19e88612e99449bc283ae4d716d119f22517c37809670f50e854a8658502c645f
+  data.tar.gz: 7d41547be02a86b3afc065e8865dbe16c02ebde7b592bd7f9a83585b22d7f07cfc1fe078eb171b754f2398d9fce9942410e8b9b999e744a73ee6abf378ada1bb

data/.gitignore

@@ -9,7 +9,8 @@
 /tmp/
 /legion/.idea/
 /.idea/
+*.gem
 *.key
 # rspec failure tracking
 .rspec_status
-legionio.key
+legionio.key

data/.pre-commit-config.yaml

@@ -0,0 +1,29 @@
+# Standard LegionIO pre-commit configuration
+# Install: pre-commit install
+# Manual:  pre-commit run --all-files
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-json
+        exclude: Gemfile\.lock
+      - id: check-merge-conflict
+
+  - repo: local
+    hooks:
+      - id: rubocop
+        name: RuboCop (autofix)
+        entry: scripts/pre-commit-rubocop.sh
+        language: script
+        types: [ruby]
+        pass_filenames: true
+
+      - id: ruby-syntax
+        name: Ruby syntax check
+        entry: ruby -c
+        language: system
+        types: [ruby]
+        pass_filenames: true

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Legion::Settings Changelog
 
+## [1.3.27] - 2026-04-27
+
+### Added
+- `Settings.reload!` — re-reads all previously loaded config files and re-resolves vault://, env://, and lease:// references; returns a hash of changed keys with old/new values; thread-safe via internal mutex
+- `Settings.watch!` — registers a SIGHUP handler that triggers `reload!` in a background thread; optionally accepts a block for change notification
+- `Settings.on_reload(&block)` — register callbacks invoked after `reload!` detects changes; multiple callbacks supported, called in order, rescue-safe
+- Private `diff_settings` helper for deep comparison of old vs new config hashes
+- Private `fire_reload_callbacks` for executing registered change callbacks
+
+### Fixed
+- `reload!` preserves programmatic module merges and reapplies `.legionio.env` overrides to the reloaded settings loader
+- `watch!` no-ops when SIGHUP is unavailable and coalesces repeated SIGHUP events through a single reload worker
+- Replaced deprecated helper logging method calls with direct `log.debug/info/warn/error` usage
+
+## [1.3.26] - 2026-04-02
+
+### Changed
+- Added a runtime dependency on `legion-logging >= 1.4.0` and moved `Settings`, `Loader`, `Resolver`, `ProjectEnv`, and `AgentLoader` onto component-aware logging helpers
+- Added `Legion::Logging::Helper` integration to top-level `Settings` access and DNS bootstrap logging so component tags and per-component levels apply consistently
+- `extensions.default_extension_settings` now defaults to `{}` instead of injecting a synthetic logger config
+- `Legion::Settings::Helper#settings` now returns `{}` when an extension has no explicit settings
+- `region.default_affinity` now defaults to `any`
+- `[]`, `dig`, and no-arg `load` now share the same project-env-aware load path, and the README now documents the actual `load`/`Loader.default_directories` split
+
+### Fixed
+- `validate!` now clears stale validation errors before rebuilding state, and nested schema branches now fail when a hash-shaped setting is replaced with a scalar
+- Loader mutation paths now invalidate indifferent-access and digest caches consistently, `load_module_default` no longer overwrites existing scalar settings, and resolver traversal now handles arrays of hashes
+- `Resolver` now treats clustered Vault connectivity from `Legion::Crypt` as available for `vault://` resolution instead of relying only on the top-level `crypt.vault.connected` flag
+- Logger-backed settings code paths now use consistent `log.debug/info/warn/error` behavior instead of mixed direct `Legion::Logging.*` calls
+
 ## [1.3.25] - 2026-03-31
 
 ### Added

data/README.md

@@ -2,7 +2,7 @@
 
 Configuration management module for the [LegionIO](https://github.com/LegionIO/LegionIO) framework. Loads settings from JSON files, directories, and environment variables. Provides a unified `Legion::Settings[:key]` accessor used by all other Legion gems.
 
-**Version**: 1.3.22
+**Version**: 1.3.27
 
 ## Installation
 
@@ -21,20 +21,73 @@ gem 'legion-settings'
 ```ruby
 require 'legion/settings'
 
-Legion::Settings.load(config_dir: './')  # loads all .json files in the directory
+Legion::Settings.load                          # loads defaults, env, DNS bootstrap, and nearest .legionio.env
+Legion::Settings.load(config_dir: './settings') # also loads all .json files in the directory
 
 Legion::Settings[:client][:hostname]
-Legion::Settings[:transport][:connection][:host]
+Legion::Settings.dig(:transport, :connection, :host)
 ```
 
-### Config Paths (checked in order)
+`[]` and `dig` will auto-load settings on first access, and implicit access follows the same overlay/project-env/base precedence as explicit `load`.
 
-1. `/etc/legionio/`
-2. `~/.legionio/settings/`
-3. `~/legionio/`
-4. `./settings/`
+### Config Loading
 
-Each Legion module registers its own defaults via `merge_settings` during startup.
+`Legion::Settings.load` only consumes the paths you pass via `config_file`, `config_dir`, or `config_dirs`.
+
+If a caller wants the canonical Legion search directories, use `Legion::Settings::Loader.default_directories`:
+
+1. `~/.legionio/settings`
+2. `/etc/legionio/settings` on Unix-like systems
+3. `%APPDATA%\\legionio\\settings` on Windows when `APPDATA` is present
+
+`LegionIO` uses those directories during daemon boot. Library consumers can choose to pass any directory set they want.
+
+Each Legion module registers its own defaults via `merge_settings` during startup, and the nearest `.legionio.env` file is merged on top of base settings. Request overlays applied through `with_overlay` take highest precedence.
+
+### Hot Reload
+
+`Legion::Settings.reload!` re-reads the config files that were previously loaded, reapplies module defaults and the nearest `.legionio.env`, re-resolves secret references, and returns a hash describing the changed keys.
+
+```ruby
+changes = Legion::Settings.reload!
+
+changes
+# {
+#   "llm.default_model" => { old: "old-model", new: "new-model" }
+# }
+```
+
+Callbacks run only when changes are detected:
+
+```ruby
+Legion::Settings.on_reload do |changes|
+  Legion::Settings.logger.info("Settings changed: #{changes.keys.join(', ')}")
+end
+```
+
+`watch!` installs a SIGHUP handler when the platform supports it. Repeated signals are coalesced through one background reload worker, so rapid SIGHUP bursts do not create unbounded reload threads.
+
+```ruby
+Legion::Settings.watch! do |changes|
+  Legion::Settings.logger.info("Reloaded #{changes.size} setting(s)")
+end
+
+# Later, from a shell:
+# kill -HUP <daemon_pid>
+```
+
+On platforms without `HUP`, `watch!` logs and returns without raising. Direct `reload!` remains available for API endpoints, tests, or environments that use a different process-control mechanism.
+
+### Project Environment Overrides
+
+When present, the nearest `.legionio.env` file is loaded after base settings and module defaults. Dot notation maps to nested settings:
+
+```dotenv
+llm.default_model=claude-sonnet
+cache.driver=redis
+```
+
+Hot reload picks up changes to this file as part of the same `reload!` flow.
 
 ### Secret Resolution
 
@@ -76,25 +129,25 @@ Legion::Settings.validate!  # raises ValidationError if any settings are invalid
 
 # In development, warn instead of raising:
 # Set LEGION_DEV=true or Legion::Settings.set_prop(:dev, true)
-# validate! will warn to $stderr (or Legion::Logging) instead of raising
+# validate! will warn through the configured logger instead of raising
 ```
 
 ### Logging Defaults
 
-The `logging` key includes a `transport` sub-section (new in 1.3.22) that controls whether log events are forwarded over the message bus:
+The `logging` key includes a `transport` sub-section that controls whether log events are forwarded over the message bus:
 
 ```json
 {
   "logging": {
     "level": "info",
     "format": "text",
-    "log_file": null,
+    "log_file": "./legionio/logs/legion.log",
     "log_stdout": true,
     "trace": true,
     "async": true,
     "include_pid": false,
     "transport": {
-      "enabled": false,
+      "enabled": true,
       "forward_logs": true,
       "forward_exceptions": true
     }
@@ -102,7 +155,7 @@ The `logging` key includes a `transport` sub-section (new in 1.3.22) that contro
 }
 ```
 
-When `transport.enabled` is `true`, log events and unhandled exceptions are published to the AMQP bus so a central log consumer can aggregate them. Disabled by default to avoid a dependency on `legion-transport` at boot.
+When `transport.enabled` is `true`, log events and unhandled exceptions are published to the AMQP bus so a central log consumer can aggregate them.
 
 ## Requirements
 

data/legion-settings.gemspec

@@ -27,4 +27,5 @@ Gem::Specification.new do |spec|
   }
 
   spec.add_dependency 'legion-json', '>= 1.2.0'
+  spec.add_dependency 'legion-logging', '>= 1.5.0'
 end

data/lib/legion/settings/agent_loader.rb

@@ -2,10 +2,13 @@
 
 require 'yaml'
 require 'json'
+require 'legion/logging'
 
 module Legion
   module Settings
     module AgentLoader
+      extend Legion::Logging::Helper
+
       EXTENSIONS = %w[.yaml .yml .json].freeze
       GLOB = '*.{yaml,yml,json}'
 
@@ -17,7 +20,7 @@ module Legion
             definition = load_file(path)
             next unless definition && valid?(definition)
 
-            log_debug("Agent loaded: #{definition[:name]} (#{path})")
+            log.debug("Agent loaded: #{definition[:name]} (#{path})")
             definition.merge(_source_path: path, _source_mtime: File.mtime(path))
           end
         end
@@ -29,7 +32,7 @@ module Legion
           when '.json'         then ::JSON.parse(content, symbolize_names: true)
           end
         rescue StandardError => e
-          log_warn("Failed to parse agent file #{path}: #{e.message}")
+          log.warn("Failed to parse agent file #{path}: #{e.message}")
           nil
         end
 
@@ -44,12 +47,9 @@ module Legion
 
         private
 
-        def log_debug(message)
-          Legion::Logging.debug(message) if defined?(Legion::Logging)
-        end
-
-        def log_warn(message)
-          defined?(Legion::Logging) ? Legion::Logging.warn(message) : warn(message)
+        def resolve_logger_settings
+          raw_logging = Legion::Settings.loader&.settings&.dig(:logging) if Legion::Settings.respond_to?(:loader)
+          raw_logging.is_a?(Hash) ? raw_logging : Legion::Logging::Settings.default
         end
       end
     end

data/lib/legion/settings/dns_bootstrap.rb

@@ -5,10 +5,13 @@ require 'json'
 require 'net/http'
 require 'resolv'
 require 'uri'
+require 'legion/logging'
 
 module Legion
   module Settings
     class DnsBootstrap
+      include Legion::Logging::Helper
+
       CACHE_FILENAME = '_dns_bootstrap.json'
       HOSTNAME_PREFIX = 'legion-bootstrap'
       URL_PATH = '/legion/bootstrap.json'
@@ -28,7 +31,7 @@ module Legion
         Resolv.getaddress(@hostname)
         true
       rescue Resolv::ResolvError, Resolv::ResolvTimeout => e
-        log_debug("Legion::Settings::DnsBootstrap#resolve? could not resolve #{@hostname}: #{e.message}")
+        log.debug("Legion::Settings::DnsBootstrap#resolve? could not resolve #{@hostname}: #{e.message}")
         false
       end
 
@@ -45,7 +48,7 @@ module Legion
 
         ::JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_warn("DNS bootstrap fetch failed for #{@url}: #{e.message}")
+        log.warn("DNS bootstrap fetch failed for #{@url}: #{e.message}")
         nil
       end
 
@@ -67,11 +70,11 @@ module Legion
         return nil unless File.exist?(@cache_path)
 
         raw = ::JSON.parse(File.read(@cache_path), symbolize_names: true)
-        log_debug("DNS bootstrap cache hit: #{@cache_path}")
+        log.debug("DNS bootstrap cache hit: #{@cache_path}")
         raw.delete(:_dns_bootstrap_meta)
         raw
       rescue ::JSON::ParserError
-        log_warn("DNS bootstrap cache corrupt, deleting: #{@cache_path}")
+        log.warn("DNS bootstrap cache corrupt, deleting: #{@cache_path}")
         FileUtils.rm_f(@cache_path)
         nil
       end
@@ -82,12 +85,9 @@ module Legion
 
       private
 
-      def log_debug(message)
-        Legion::Logging.debug(message) if defined?(Legion::Logging)
-      end
-
-      def log_warn(message)
-        defined?(Legion::Logging) ? Legion::Logging.warn(message) : warn(message)
+      def resolve_logger_settings
+        raw_logging = Legion::Settings.loader&.settings&.dig(:logging) if Legion::Settings.respond_to?(:loader)
+        raw_logging.is_a?(Hash) ? raw_logging : Legion::Logging::Settings.default
       end
     end
   end

data/lib/legion/settings/helper.rb

@@ -8,7 +8,7 @@ module Legion
         if Legion::Settings[:extensions]&.key?(ext_key)
           Legion::Settings[:extensions][ext_key]
         else
-          { logger: { level: 'info', extended: false, internal: false } }
+          {}
         end
       end
 

data/lib/legion/settings/loader.rb

@@ -2,6 +2,9 @@
 
 require 'resolv'
 require 'socket'
+require 'digest'
+require 'tmpdir'
+require 'legion/logging'
 require 'legion/settings/os'
 require_relative 'dns_bootstrap'
 
@@ -9,9 +12,10 @@ module Legion
   module Settings
     class Loader
       include Legion::Settings::OS
+      include Legion::Logging::Helper
 
       class Error < RuntimeError; end
-      attr_reader :warnings, :errors, :loaded_files, :settings
+      attr_reader :warnings, :errors, :loaded_files, :settings, :merged_modules
 
       def self.default_directories
         env_dirs = ENV.fetch('LEGION_SETTINGS_DIRS', nil)
@@ -36,6 +40,8 @@ module Legion
         @settings = default_settings
         @indifferent_access = false
         @loaded_files = []
+        @merged_modules = {}
+        log.debug('Initialized Legion::Settings::Loader with default settings')
       end
 
       def dns_defaults
@@ -138,16 +144,14 @@ module Legion
           reload:                     false,
           reloading:                  false,
           auto_install_missing_lex:   true,
-          default_extension_settings: {
-            logger: { level: 'info', trace: false, extended: false }
-          },
+          default_extension_settings: {},
           logging:                    logging_defaults,
           absorbers:                  absorbers_defaults,
           transport:                  { connected: false },
           data:                       { connected: false },
           role:                       { profile: nil, extensions: [] },
           region:                     { current: nil, primary: nil, failover: nil, peers: [],
-                                        default_affinity: 'prefer_local', data_residency: {} },
+                                        default_affinity: 'any', data_residency: {} },
           process:                    { role: 'full' },
           dns:                        dns_defaults
         }
@@ -171,7 +175,7 @@ module Legion
 
       def []=(key, value)
         @settings[key] = value
-        @indifferent_access = false
+        mark_dirty!
       end
 
       def hexdigest
@@ -218,46 +222,44 @@ module Legion
 
       def load_module_settings(config)
         mod_name = config.keys.first
-        log_debug("Loading module settings: #{mod_name}")
+        log.debug("Loading module settings: #{mod_name}")
+        @merged_modules = deep_merge(@merged_modules, config)
         @settings = deep_merge(config, @settings)
-        @indifferent_access = false
+        mark_dirty!
       end
 
       def load_module_default(config)
         mod_name = config.keys.first
-        log_debug("Loading module defaults: #{mod_name}")
-        merged = deep_merge(@settings, config)
-        deep_diff(@settings, merged) unless @loaded_files.empty?
-        @settings = merged
-        @indifferent_access = false
+        log.debug("Loading module defaults: #{mod_name}")
+        @settings = deep_merge(config, @settings)
+        mark_dirty!
       end
 
       def load_file(file)
-        log_debug("Trying to load file #{file}")
+        log.debug("Trying to load file #{file}")
         if File.file?(file) && File.readable?(file)
           begin
             contents = read_config_file(file)
             config = contents.empty? ? {} : Legion::JSON.load(contents)
-            merged = deep_merge(@settings, config)
-            deep_diff(@settings, merged) unless @loaded_files.empty?
-            @settings = merged
-            # @indifferent_access = false
+            @settings = deep_merge(@settings, config)
+            mark_dirty!
             @loaded_files << file
+            log.debug("Loaded settings file #{file}")
           rescue Legion::JSON::ParseError => e
-            log_error("config file must be valid json: #{file}")
-            log_error("  parse error: #{e.message}")
+            log.error("config file must be valid json: #{file}")
+            log.error("  parse error: #{e.message}")
           end
         else
-          log_warn("Config file does not exist or is not readable file:#{file}")
+          log.warn("Config file does not exist or is not readable file:#{file}")
         end
       end
 
       def load_directory(directory)
         path = directory.gsub(/\\(?=\S)/, '/')
         if File.readable?(path) && File.executable?(path)
-          files = Dir.glob(File.join(path, '**{,/*/**}/*.json')).uniq
+          files = Dir.glob(File.join(path, '**', '*.json'))
           files.each { |file| load_file(file) }
-          log_info("Settings: loaded directory #{path} (#{files.size} files)")
+          log.info("Settings: loaded directory #{path} (#{files.size} files)")
         else
           load_error('insufficient permissions for loading', directory: directory)
         end
@@ -268,9 +270,9 @@ module Legion
         if @settings[:client][:subscriptions].is_a?(Array)
           @settings[:client][:subscriptions] << "client:#{@settings[:client][:name]}"
           @settings[:client][:subscriptions].uniq!
-          @indifferent_access = false
+          mark_dirty!
         else
-          log_warn('unable to apply legion client overrides, reason: client subscriptions is not an array')
+          log.warn('unable to apply legion client overrides, reason: client subscriptions is not an array')
         end
       end
 
@@ -290,6 +292,11 @@ module Legion
 
       private
 
+      def resolve_logger_settings
+        raw_logging = instance_variable_defined?(:@settings) ? @settings&.[](:logging) : nil
+        raw_logging.is_a?(Hash) ? raw_logging : Legion::Logging::Settings.default
+      end
+
       def load_dns_from_cache(bootstrap)
         config = bootstrap.read_cache
         start_dns_background_refresh(bootstrap) if config
@@ -297,7 +304,7 @@ module Legion
       end
 
       def load_dns_first_boot(bootstrap)
-        log_debug("DNS bootstrap: first boot, fetching from #{bootstrap.url}")
+        log.debug("DNS bootstrap: first boot, fetching from #{bootstrap.url}")
         config = bootstrap.fetch
         bootstrap.write_cache(config) if config
         config
@@ -311,7 +318,7 @@ module Legion
           hostname:   bootstrap.hostname,
           url:        bootstrap.url
         }
-        @indifferent_access = false
+        mark_dirty!
       end
 
       def start_dns_background_refresh(bootstrap)
@@ -319,7 +326,7 @@ module Legion
           fresh = bootstrap.fetch
           bootstrap.write_cache(fresh) if fresh
         rescue StandardError => e
-          log_warn("DNS background refresh failed: #{e.message}")
+          log.warn("DNS background refresh failed: #{e.message}")
         end
       end
 
@@ -356,15 +363,15 @@ module Legion
 
         @settings[:api] ||= {}
         @settings[:api][:port] = ENV['LEGION_API_PORT'].to_i
-        log_warn("using api port environment variable, api: #{@settings[:api]}")
-        @indifferent_access = false
+        log.warn("using api port environment variable, api: #{@settings[:api]}")
+        mark_dirty!
       end
 
       def load_privacy_env
         return unless ENV['LEGION_ENTERPRISE_PRIVACY'] == 'true'
 
         @settings[:enterprise_data_privacy] = true
-        @indifferent_access = false
+        mark_dirty!
       end
 
       def read_config_file(file)
@@ -394,19 +401,6 @@ module Legion
         merged
       end
 
-      def deep_diff(hash_one, hash_two)
-        keys = hash_one.keys.concat(hash_two.keys).uniq
-        keys.each_with_object({}) do |key, diff|
-          next if hash_one[key] == hash_two[key]
-
-          diff[key] = if hash_one[key].is_a?(Hash) && hash_two[key].is_a?(Hash)
-                        deep_diff(hash_one[key], hash_two[key])
-                      else
-                        [hash_one[key], hash_two[key]]
-                      end
-        end
-      end
-
       def create_loaded_tempfile!
         dir = ENV['LEGION_LOADED_TEMPFILE_DIR'] || Dir.tmpdir
         file_name = "legion_#{legion_service_name}_loaded_files"
@@ -415,6 +409,15 @@ module Legion
         path
       end
 
+      public
+
+      def mark_dirty!
+        @indifferent_access = false
+        @hexdigest = nil
+      end
+
+      private
+
       def legion_service_name
         File.basename($PROGRAM_NAME).split('-').last
       end
@@ -422,7 +425,7 @@ module Legion
       def system_hostname
         Socket.gethostname
       rescue StandardError => e
-        Legion::Logging.debug("Legion::Settings::Loader#system_hostname failed: #{e.message}") if defined?(Legion::Logging)
+        log.debug("Legion::Settings::Loader#system_hostname failed: #{e.message}")
         'unknown'
       end
 
@@ -431,7 +434,7 @@ module Legion
         preferred = addresses.find { |a| rfc1918?(a.ip_address) }
         (preferred || addresses.first)&.ip_address || 'unknown'
       rescue StandardError => e
-        Legion::Logging.debug("Legion::Settings::Loader#system_address failed: #{e.message}") if defined?(Legion::Logging)
+        log.debug("Legion::Settings::Loader#system_address failed: #{e.message}")
         'unknown'
       end
 
@@ -441,34 +444,18 @@ module Legion
           ip.start_with?('192.168.')
       end
 
-      def log_info(message)
-        defined?(Legion::Logging) ? Legion::Logging.info(message) : $stdout.puts(message)
-      end
-
-      def log_debug(message)
-        Legion::Logging.debug(message) if defined?(Legion::Logging)
-      end
-
-      def log_warn(message)
-        defined?(Legion::Logging) ? Legion::Logging.warn(message) : warn(message)
-      end
-
-      def log_error(message)
-        defined?(Legion::Logging) ? Legion::Logging.error(message) : warn(message)
-      end
-
       def warning(message, data = {})
         @warnings << {
           message: message
         }.merge(data)
-        log_warn(message)
+        log.warn(message)
       end
 
       def load_error(message, data = {})
         @errors << {
           message: message
         }.merge(data)
-        log_error(message)
+        log.error(message)
         raise(Error, message)
       end
 
@@ -479,7 +466,7 @@ module Legion
           nameservers:    config[:nameserver]&.map(&:to_s)&.uniq
         }
       rescue StandardError => e
-        log_warn("Failed to read resolv config: #{e.message}")
+        log.warn("Failed to read resolv config: #{e.message}")
         { search_domains: [], nameservers: [] }
       end
 
@@ -490,10 +477,10 @@ module Legion
 
         fqdn.include?('.') ? fqdn : nil
       rescue Timeout::Error
-        log_debug('FQDN detection skipped (DNS timeout)')
+        log.debug('FQDN detection skipped (DNS timeout)')
         nil
       rescue StandardError => e
-        log_debug("FQDN detection skipped (#{e.message.split(':').first})")
+        log.debug("FQDN detection skipped (#{e.message.split(':').first})")
         nil
       end
     end