Julia Logging Module ↔ Deployment Logs: Interoperability Question

Answer

JULIA_DEBUG does not automatically propagate to all submodules of a named module; it only affects loggers whose name matches the exact string (or a prefix that the default logger treats as a hierarchy). When a custom logger such as LoggingExtras.FileLogger replaces the global logger, JULIA_DEBUG has no effect unless that logger forwards messages to the default logger or explicitly reads the environment variable. To obtain uniform debug visibility across a multi‑module deployment, either list every top‑level module in JULIA_DEBUG (comma‑separated) or use JULIA_DEBUG=* and ensure any custom logger is configured to forward to the default logger.

Confirmed Facts

• JULIA_DEBUG is read at process start by the default logger (Logging.global_logger()) and sets the minimum enabled level for the exact module name(s) supplied.
• The default logger treats logger names hierarchically: a submodule whose logger name begins with the supplied prefix (e.g., MyMod.Sub when JULIA_DEBUG=MyMod) inherits the setting only if the submodule’s logger is created via @logger MyMod.Sub or similar and the default logger is in use.
• In Julia 1.0‑1.5 the prefix‑matching behavior was inconsistent; starting with Julia 1.6 the default logger reliably propagates JULIA_DEBUG to prefix‑matching submodule loggers.
• If the global logger is replaced (e.g., LoggingExtras.FileLogger("log.txt")) and the replacement does not forward messages to the default logger, JULIA_DEBUG is ignored entirely.
• Setting JULIA_DEBUG=* enables debug level for all module names known to the default logger at startup.

Likely Explanation / Version‑Dependent Nuance

The exact inheritance rule changed between Julia 1.5 and 1.6, so older releases may require explicit listing of each submodule. Third‑party logging packages that create independent logger instances (e.g., LoggingExtras.ConsoleLogger with its own min_level) ignore JULIA_DEBUG unless they are wrapped to forward to the default logger.

Steps to Achieve Consistent Debug Visibility

1. Determine the Julia version in use (julia --version). If ≥ 1.6, prefix matching works; otherwise plan to list submodules explicitly.
2. If using the default logger only:
   • Set JULIA_DEBUG=MyMod,OtherMod (comma‑separated list of top‑level modules) or JULIA_DEBUG=* for all modules.
   • Launch the application and verify that @debug statements appear from both top‑level modules and their submodules.
3. If a custom logger is required (e.g., LoggingExtras.FileLogger):
   • Create the custom logger and then forward its output to the default logger, e.g.,

     using Logging, LoggingExtras
     file_logger = FileLogger("app.log")
     global_logger(Logger(file_logger, Logging.global_logger()))
     

   • Alternatively, configure the custom logger to read ENV["JULIA_DEBUG"] and set its own min_level accordingly.
   • After launching with the desired JULIA_DEBUG setting, inspect the log file to confirm debug messages appear.
4. Validate the configuration by emitting a test debug message from a known submodule and checking its presence in the output.

Missing Diagnostic Detail

To refine the recommendation, please confirm the exact Julia version you are targeting (e.g., 1.4, 1.5, 1.6, 1.10). This determines whether prefix‑matching inheritance is reliable or if explicit submodule listing is required.