Use Custom logging Formatter/Handler in Eclipse RCP

In my latest Eclipse RCP project, we use java.util.logging and want to add a custom Formatter in logging properties.

It works on IBM JDK 6.0, but doesn't work on Sun JDK, or any IBM previous JDK releases.Compared the source code of LogManager and Handler classes in Sun JDK or IBM old JDK releases, I figured out that this is because in IBM JDK 6.0, when to new a Formatter (Hanlder etc) instance, it use context ClassLoader (the ClassLoader of the method that called the caller) to load Formatter class:

Thread.currentThread().getContextClassLoader() But in old releases, it just use system classloader to load formatter class: ClassLoader.getSystemClassLoader().loadClass(val)

Of course, it can't find our custom Formatter class in system classloader, so it throws ClassNotFoundException.

The simple (not elegant way) is that when the application starts, configure jdk logging in AbstractUIPlugin subclass:

public class Activator extends AbstractUIPlugin  
{  
  public static final String PLUGIN_ID = "org.codeexample.myrcp"; //$NON-NLS-1$  
  public Activator(){}  
  public void start(BundleContext context) throws Exception  
  {  
   LogConfigurer.configureLogging();  
   final Logger logger = Logger.getLogger(Activator.class.getName());  
   // test logger  
   logger.warning("hello logger: " + new Date());  
   logger.throwing(Activator.class.getName(), "start", new RuntimeException("thrown exception"));  
   super.start(context);  
  }  
  public void stop(BundleContext context) throws Exception  
  {  
   super.stop(context);  
  }  
 }  
public class LogConfigurer { 
     public static String DATE_FOMAT = "yyyy-MM-dd hh:mm:ss.SSS"; 
     public static String LOG_DIRECTORY = Platform.getLocation() 
               .toPortableString() + IConstants.FILE_SEPARATOR + "logs"; 
     public static String LOG_PREFIX = "main"; 
     public static boolean configured = false; 
     public synchronized static void configureLogging() { 
          if (!configured) { 
               configured = true; 
               try { 
                    LogManager.getLogManager().readConfiguration( 
                              LogConfigurer.class 
                                        .getResourceAsStream("logging.properties")); 
                    File file = new File(LOG_DIRECTORY); 
                    if (!file.exists()) { 
                         file.mkdir(); 
                    } 
                    FileHandler fileHandler = new FileHandler(LOG_DIRECTORY 
                              + IConstants.FILE_SEPARATOR + LOG_PREFIX + ".log", true); 
                    fileHandler.setFormatter(new MySimpleFormatter()); 
                    fileHandler.setEncoding("UTF-8"); 
                    fileHandler.setLevel(Level.FINER); 
                    ConsoleHandler consoleHandler = new ConsoleHandler(); 
                    consoleHandler.setFormatter(new MySimpleFormatter()); 
                    consoleHandler.setEncoding("UTF-8"); 
                    consoleHandler.setLevel(Level.ALL); 
                    Logger parentLogger = Logger 
                              .getLogger("com.ibm.storage.ess.cli.wrapper"); 
                    parentLogger.addHandler(fileHandler); 
                    parentLogger.addHandler(consoleHandler); 
                    parentLogger.setLevel(Level.ALL); 
               } catch (Exception e) { 
                    Activator.logException(e); 
               } 
          } 
     } 
} 
/** 
 * The code is similar as JDK SimpleFormatter, just made a little change to 
 * record all message(including exception stack) in one line. 
 */ 
public class MySimpleFormatter extends Formatter { 
     Date dat = new Date(); 
     private final static String format = "{0,date," + LogConfigurer.DATE_FOMAT 
               + "}"; 
     private MessageFormat formatter; 
     private Object args[] = new Object[1]; 
     public static final String LINE_SEPARATOR = System 
               .getProperty("line.separator"); 
     private String separator = " ------ "; 
     public synchronized String format(LogRecord record) { 
          StringBuffer sb = new StringBuffer(); 
          // Minimize memory allocations here. 
          dat.setTime(record.getMillis()); 
          args[0] = dat; 
          StringBuffer text = new StringBuffer(); 
          if (formatter == null) { 
               formatter = new MessageFormat(format); 
          } 
          formatter.format(args, text, null); 
          sb.append(text); 
          sb.append(" "); 
          if (record.getSourceClassName() != null) { 
               sb.append(record.getSourceClassName()); 
          } else { 
               sb.append(record.getLoggerName()); 
          } 
          if (record.getSourceMethodName() != null) { 
               sb.append(" "); 
               sb.append(record.getSourceMethodName()); 
          } 
          sb.append(separator); 
          String message = formatMessage(record); 
          sb.append(record.getLevel().getLocalizedName()); 
          sb.append(": "); 
          sb.append(message); 
          if (record.getThrown() != null) { 
               sb.append(separator); 
               try { 
                    StringWriter sw = new StringWriter(); 
                    PrintWriter pw = new PrintWriter(sw); 
                    record.getThrown().printStackTrace(pw); 
                    pw.close(); 
                    String str = sw.toString(); 
                    String[] strs = str.split(IConstants.LINE_SEPARATOR); 
                    for (int i = 0; i < strs.length; i++) { 
                         sb.append(strs[i]); 
                         if (i != strs.length - 1) { 
                              sb.append(separator); 
                         } 
                    } 
               } catch (Exception ex) { 
               } 
          } 
          sb.append("\n"); 
          return sb.toString(); 
     } 
}