extends java.util.logging.Logger not working

Question

I want to extend the java.util.logging.Logger class.

I have the following code. I am "forcing an error" in our app and the class I created is not being called.

Here is the error I am generating on purpose but it doesn't go in the code I wrote:

//Generate error to test the logger
String[] myStringArray = new String[3];
String test;
test = myStringArray[5];    

I also tried this but it still doesn't go in my code even if I have the same function definition:

logger.log(Level.FINE, "test my logger");

Here is my logger extension. Is it possible for this to get triggered when an unhandled exception is "raised".

import java.util.logging.Level;
import java.util.logging.LogRecord;

public class MyLogger extends java.util.logging.Logger
{

    public MyLogger(String name, String resourceBundleName)
    {
        super(name, resourceBundleName);
        runMyLog();
    }


    public void log(Level level, String msg) {
        runMyLog();
    }   

    public void error(String msg)
    {
        super.log(Level.SEVERE, msg);
        runMyLog();
    }

    public void log(LogRecord record)
    {
        super.log(Level.SEVERE, record.getMessage());
        runMyLog();
    }

    public void severe(String msg) {
        log(Level.SEVERE, msg);
        runMyLog();
    }

    public void runMyLog(){
        String str = "lll";

        str="fdsafasdfdasfasd";
    }
}

Answer 1

As @leonbloy and @E-Riz pointed out, per the documentation:

Therefore, any subclasses of Logger (unless they are implemented in conjunction with a new LogManager class) should take care to obtain a Logger instance from the LogManager class and should delegate operations such as "isLoggable" and "log(LogRecord)" to that instance. Note that in order to intercept all logging output, subclasses need only override the log(LogRecord) method. All the other logging methods are implemented as calls on this log(LogRecord) method.

So here would be an example that must be run with -Djava.util.logging.manager=bad.idea.OdiousLogManager so the JVM uses the new LogManager:

package bad.idea;

import java.awt.Toolkit;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

public class OdiousLogManager extends LogManager {

    @Override
    public synchronized Logger getLogger(String name) {
        Logger l = super.getLogger(name);
        if (l == null) {
            l = new AbhorentLogger(name, null);
            super.addLogger(l);
        }
        return l;
    }


    private static class AbhorentLogger extends Logger {

        AbhorentLogger(String name, String resourceBundleName) {
            super(name, resourceBundleName);
        }

        @Override
        public void log(LogRecord record) {
            super.log(record);
            mightyCatHearMeRoar(record);
        }

        private void mightyCatHearMeRoar(LogRecord record) {
            if (super.isLoggable(record.getLevel())) {
                Toolkit.getDefaultToolkit().beep();
            }
        }
    }


    //...
    private static final Logger logger = Logger.getLogger("godaweful");
    public static void main(String[] args) {
        logger.severe(logger.getClass().getName());
    }
}

If you only want to listen to events then you should simply implement a custom handler and avoid extending logger.