Log4J - how to log an exception caught in an imported library?

Question

I am a pretty new user of Log4J v. 1.2.15, as a friend of mine convinced me of the advantages over console or other forms of logging. However, as i was doing some tests, i've encountered a test case that got me thinking. Here it is what i did :

1. I've configured the properties, added 2 appenders, a ConsoleAppender and a RollingFileAppender.
2. I've created a new log instance, using my main class : Logger mainLogger = Logger.getLogger(Main.class);

3. I have this collection of general-purpose, hand-made, java utils, in a library, called MyUtils.jar, added to the classpath of my main app. In the main app, i've called a static method from MyUtils.jar. This method has a try-catch{} block and the exception was handled there, printing the stack trace, using System.err. Now, using my IDE and the ConsoleAppender, I was able to spot the problem, however, the event was NOT logged in my file log. There are 2 problems that need answers here: a. I am currently using my mainLogger to log events from all classes of my app. Is that a good practice? Or should i use X logger instances for X classes? b. What can I do to be able to log errors already caught in my imports? It might sounds trivial, but I've used Object foo = MyLibrary.composeObjectFoo(), and inside the method looks similar to this example :

   public static Object composeObjectFoo() {
       try {
           .....statements.....
           .
           .
           //    something stupid here
           int a = 100/0; //an AritmethicException will be thrown 
       } catch Exception(e) {
           e.printStackTrace();
       }
   }
   

Thanks for your answers and please excuse the length of this...

---

Answer 1

I did one logical thing..i've deleted the try->catch{} block from my Utils class. The generated exception now was catched by the main app and logged. Awesome! But...is there any guarantee that the situation will not repeat itself when using libs/utils created by third partys?

Answer 2

There are a few things I recommend about logging:

1. Never use System.out.println(), System.err.println(), or e.printStackTrace(). Instead, use a logger. You can configure the logger to print to stdout or stderr instead, not to mention filter out unimportant information. Much more flexible.
2. It is a best practice to create a logger in each class that can generate events you would want to log, and to use the class to create the logger name (e.g. Logger.getLogger(Main.class)). By doing this, you can then use all those unique logger names to fine-tune your log filtering. For example, you can set class A to debug and class B to info if needed.
3. Use a logger abstraction layer like slf4j (I really like this) or commons-logging. This will allow you to change your logger implementation without having to go through all your code and change every location where you log from.

Regarding exceptions:

I also recommend you read up a bit on exception handling best practices. Everyone will argue about what is "best" but should all agree that you should do more than let everything leak up to main(). I like what this article has to say.

Answer 3

You can't log an exception caught in an imported library. You can't add code to the imported library. Once it's caught, you're done. The best you can hope for is that the imported library re-throws an exception and gives you a chance to log something.

I'd wonder about the quality of an imported library that DIDN'T do logging and wrote to the console instead. That's not a good design concept.

I don't like the idea of a main class doing logging. Your instinct is good, but your implementation is not. Logging is a cross-cutting concern that should be done using aspect-oriented programming.

Answer 4

a. I am currently using my mainLogger to log events from all classes of my app. Is that a good practice? Or should i use X logger instances for X classes?

It is generally a better idea to create and use multiple Logger. This gives you (or someone coming later) finer control over logging levels, etc via the logging configuration. But I wouldn't necessarily recommend creating a (static) Logger instance in every class.

b. What can I do to be able to log errors already caught in my imports?

There is very little that you can do about this ... except overhaul the imported codebase to improve its internal error reporting and logging.

The flip side is that if you are creating library code that might be reused elsewhere you should pay attention to getting the error reporting and logging right. In particular, clean out inappropriate use System.err, printStackTrace(), etcetera. It is also a good idea to use a logging abstraction layer so that you don't cause problems for people integrating your library.

Answer 5

You can, in your main class, change System.out and System.err to print streams which take what is printed and pass them on to the logger. It is a little more complicated than it sounds, but it has been done in open source projects (JBoss has an implementation, for example) so you can get how to do it from there.

Answer 6

OK, after more documentation, i came across this solution, to log everything, regardless if the source is in your code of elsewhere :

Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
 @Override
 public void uncaughtException(Thread t, Throwable exc) {
              //do something about it
              }
        });

That way, i was able to catch and report an abnormal state that occurs in an imported library, but was not handled or re-trowed. That is the case of something stupid like

   public double computeValue(int val){
      double a = 15/val;
     return a;
   }

and val was 0, generating an ArithmeticException, not throwed and not catched.