[FIXED] Logging not showing

Issue

I am using JUL in my application. Normally, Netbeans opens an output tab that reads "Tomcat" and shows the logs I produce. It was working fine. But suddenly, I realise that my logs are not shown at all, only the System.out get printed. Not even the higuest LOG.log(Level.SEVERE, ".....

} catch(Exception e) {
      System.out.println("This gets printed in Netbeans tab");
      LOG.log(Level.SEVERE, "This doesnt");
}

I suspect it can be a library I included, which is messing with my logs. Is that possible at all? Can a librray change the way my logs are shown? How can I investigate this, since I am a bit lost?

Solution

I suspect it can be a library I included, which is messing with my logs. Is that possible at all?

Yes. The JUL to SLF4J Bridge can remove the console handler from the JUL root logger. Some libraries invoke LogManager.reset which can remove and close all handlers.

Can a library change the way my logs are shown?

Yes. Once the a log bridge is installed the JUL records are no longer formatted by the JUL formatters.

How can I investigate this, since I am a bit lost?

Modifying the logger tree requires permissions so you can install a SecurityManager with all permissions but then turn on debug tracing with -Djava.security.debug="access,stack" to determine the caller that is modifying the logger tree.

If that doesn't work you can use good ole' System.out to print the logger tree and the attached handlers before and after a library is loaded. Then start adding an removing libraries until you see the logger change.

import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Enumeration;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;

public class DebugLogging {

    private static final Logger log = Logger.getLogger("test");

    public static void main(String[] a) {
        log.log(Level.FINEST, "Finest");
        log.log(Level.FINER, "FINER");
        log.log(Level.FINE, "FINE");
        log.log(Level.CONFIG, "CONFIG");
        log.log(Level.INFO, "INFO");
        log.log(Level.WARNING, "WARNING");
        log.log(Level.SEVERE, "SEVERE");
        log.finest("Finest Log");
        log.finer("Finer Log");
        log.fine("Fine Log");
        log.config("Config Log");
        log.info("Info Log");
        log.warning("Warning Log");
        log.severe("Severe Log");
        printConfig(System.err);
    }

    private static void printConfig(PrintStream ps) {
        String cname = System.getProperty("java.util.logging.config.class");
        if (cname != null) {
            try {
                ClassLoader sys = ClassLoader.getSystemClassLoader();
                Class<?> c = Class.forName(cname, false, sys);
                ps.println(sys.getClass().getName() +" found log configuration class " + c.getName());
            } catch (LinkageError | ClassNotFoundException | RuntimeException cnfe) {
                ps.println("Unable to load " + cname);
                cnfe.printStackTrace(ps);
            }
        } else {
            ps.println("java.util.logging.config.class was null");
        }
        
        String file = System.getProperty("java.util.logging.config.file");
        if (file != null) {
           ps.println("java.util.logging.config.file=" + file);
           try {
               ps.println("CanonicalPath=" + new File(file).getCanonicalPath());
           } catch (RuntimeException | IOException ioe) {
               ps.println("Unable to resolve path for " + file);
               ioe.printStackTrace(ps);
           }

           try {
               Path p = Paths.get(file);
               if (Files.isReadable(p)) {
                   ps.println(file + " is readable and has size " + Files.size(p));
               } else {
                   if (Files.exists(p)) {
                       ps.println(file + " exists for " + System.getProperty("user.name") + " but is not readable.");
                   } else {
                       ps.println(file + " doesn't exist for " + System.getProperty("user.name"));
                   }
               }
           } catch (RuntimeException | IOException ioe) {
               ps.println("Unable to read " + file);
               ioe.printStackTrace(ps);
           }
        } else {
            ps.println("java.util.logging.config.file was null");
        }

        LogManager lm = LogManager.getLogManager();
        ps.append("LogManager=").println(lm.getClass().getName());
        synchronized (lm) {
            Enumeration<String> e = lm.getLoggerNames();
            while (e.hasMoreElements()) {
                Logger l = lm.getLogger(e.nextElement());
                if (l != null) {
                    print(l, ps);
                }
            }
        }
    }

    private static void print(Logger l, PrintStream ps) {
        String scn = l.getClass().getSimpleName();
        ps.append("scn=").append(scn).append(", n=").append(l.getName())
                .append(", uph=").append(String.valueOf(l.getUseParentHandlers()))
                .append(", l=").append(String.valueOf(l.getLevel()))
                .append(", fl=").println(l.getFilter());
        for (Handler h : l.getHandlers()) {
            ps.append("\t").append(l.getName()).append("->")
                    .append(h.getClass().getName()).append(", h=")
                    .append(String.valueOf(h.getLevel())).append(", fl=")
                    .append(String.valueOf(h.getFilter())).println();
        }
    }
}

Answered By - jmehrens
Answer Checked By - David Marino (JavaFixing Volunteer)