Getting no output from java.util.logging.FileHandler

I am new to Java as is the company I work for, but we have just landed a contract that specifies J2EE as the platform, so here we are. :-) Please bear with me.
I have been charged with determining our logging architecture and it looks like what is available in java.util.logging will do well (though we may use log4j). However, at this point I am just trying to get anything to work and not having much luck.
We are using JSF on the front end and I have created a very simple JSF page to test logging. The relevant code is below and I hope will be self explanatory: This code is not meant to be efficient or anything. It is just a proof of concept.
    public String button1_action() {
        // User event code here...
        try {
            Logger l = java.util.logging.Logger.getLogger(Page1.class.getName());
            l.entering(Page1.class.getName(), "button1_action");
            l.info(this.textField1.getValue().toString());
            l.exiting(Page1.class.getName(), "button1_action");
            java.util.logging.Handler h = l.getHandlers()[0];
            h.flush();
        catch(Exception ex) {
            //I have tested this and we aren?t catching any errors.
            System.err.println(ex);
        return "";
    }My logger.properties files looks like this:
handlers= java.util.logging.FileHandler
.level= FINEST
java.util.logging.FileHandler.pattern = c:/sun/logs/test-%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatterI have developed and tested this in Sun Studio Creator 2004Q2 What is happening is that I am getting three log files in c:/sun/logs
test-0.log, test-1.log and test-2.log. The first two contain output from various sun components. (sun.rmi.transport for example). The third log remains empty. (zero length)
I have also deployed the test app to a tomcat 5.0.28 server and get similar results. The only difference is I get only one two log files and the second one remains empty.
Any assistance or suggestions as to what direction I should be taking would be appreciated.
--Ken

Do not use default logger as getLoggers[0] , but use your java.util.Logger.FileHandler and add filehandler object to log your fButtonActions and you do not need to mess with logger.properties too.

Similar Messages

Unable to capture messages from java.util.logging

I have a class called (Caller.java) which invokes a method called foo from another java class(Util.java) using reflection API.Now this method foo logs messages using Java's logger.My requirement is to call foo for 3 times from Caller and capture/redirect the log messages into 3 log files.
But only the first log file is capturing the log messages(from logger) and other two are not ?
Plz suggest if I am doing somethin wrong here ?
Caller.java
package project2;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.lang.reflect.Method;
public class Caller {
    public Caller() {
    public static void main(String[] args) throws Exception {
        Caller caller = new Caller();
        for (int i = 0 ;i<3 ;i++ ) {
            caller.createLogStream(i);
            System.setOut(caller.getPs());
            System.setErr(caller.getPs());
            /*****************Invoking Util.java*****************************/
            Class clas = Class.forName("project2.Util");
            Method m = clas.getMethod("foo",null);
            Object obj =clas.newInstance();
            m.invoke(obj,null);
    public void createLogStream(int i) throws FileNotFoundException {
        ps = new PrintStream(new File(System.getenv("HOME")+File.separator+"MyLog"+i+".log"));
    public void closeLogStream(){
        ps.close();
        ps = null;
    private PrintStream ps = null;
    public PrintStream getPs() {
        return ps;
} Util.java
package project2;
import java.util.logging.Logger;
public class Util {
    Logger logger = null;
    public Util() {
        logger = Logger.getLogger(this.getClass().getName());
    public void foo(){
        System.out.println("Hello out stream");
        System.err.println("Hello error stream");
        logger.info("This is an information");
        logger.warning("This is a warning message");
        logger.severe("This is fatal!! ");
}First Log file MyLog0.log:
Hello out stream
Hello error stream
Feb 16, 2009 7:55:55 PM project2.Util foo
INFO: This is an information
Feb 16, 2009 7:55:55 PM project2.Util foo
WARNING: This is a warning message
Feb 16, 2009 7:55:55 PM project2.Util foo
SEVERE: This is fatal!!
Feb 16, 2009 7:55:55 PM project2.Util foo
INFO: This is an information
Feb 16, 2009 7:55:55 PM project2.Util foo
WARNING: This is a warning message
Feb 16, 2009 7:55:55 PM project2.Util foo
SEVERE: This is fatal!!
Feb 16, 2009 7:55:55 PM project2.Util foo
INFO: This is an information
Feb 16, 2009 7:55:55 PM project2.Util foo
WARNING: This is a warning message
Feb 16, 2009 7:55:55 PM project2.Util foo
SEVERE: This is fatal!! Other 2 log files have only this much
Hello out stream
Hello error stream

A stale Connection Factory or Connection Handle may be used in SOA 11g
Regards,
Anuj

Get complete output from java.lang.Process

How do I get the complete output from java.lang.Process?
By the time I've started reading from Process.getInputStream() the process has already terminated...

I solved the problem:
private int exec(String pArguments[], OutputStream pOut, OutputStream pErr) throws IOException {
     class ProcessOutputPrinter implements Runnable {
          private InputStream ivIn;
          private OutputStream ivOut;
          public ProcessOutputPrinter(InputStream pIn, OutputStream pOut) {
               ivIn = pIn;
               ivOut = pOut;
          public void run() {
               try {
                    for(int tByte; (tByte = ivIn.read()) != -1; ) {
                         ivOut.write(tByte);
                    ivOut.flush();
               catch(IOException e) {
                    e.printStackTrace();
     // Start process
     Process tProcess = Runtime.getRuntime().exec(pArguments);
     // Create out printer
     Thread tOutPrinter = new Thread(new ProcessOutputPrinter(tProcess.getInputStream(), pOut), "NamingAdmin out-printer");
     tOutPrinter.start();
     // Create err printer
     Thread tErrPrinter = new Thread(new ProcessOutputPrinter(tProcess.getErrorStream(), pErr), "NamingAdmin err-printer");
     tErrPrinter.start();
     // Wait for process and printers to finish
     try {
          tProcess.waitFor();
          tOutPrinter.join();
          tErrPrinter.join();
     catch(InterruptedException e) {
     // return process exit value
     return tProcess.exitValue();

Enabling java.util.logging for Toplink

JDeveloper 10.1.3.0.4 Build 3673 running Embedded OC4J (jdk1.5.0_02).
I'm trying to get Toplink to log to a custom handler (a la java.util.logging) while running Embedded OC4J, but nothing I've tried works.
If I use the java.util.logging.LogManager to loop through and print out all of the existing loggers, none of the 145 listed in the Embedded OC4J environment mention anything about toplink. So presumably Toplink is not running in "java" logging mode. I'm not using toplink workbench which seems to have a UI checkbox to enable java logging, and I haven't found a way to turn it on using JDeveloper. I've tried using the system property -Dtoplink.log.destination=JAVA (no effect) and adding my handler to j2ee-logging.xml (couldn't find my custom logging handler class, and won't help anyway if toplink isn't using java.util.logging), and various attempts at hacking sessions.xml with using log-type and java-log elements (I couldn't get them right--xml parse errors).
What do I need to do to get Toplink to log to a custom handler?
TIA,
Clark

Hi Clark,
You can use either java or server log when running an application in OC4J.
1 When you run a CMP application, use system property (e.g. Dtoplink.log.destination=JAVA)
2 When you run a non CMP server application, use the logging tag in sessions.xml (e.g. <logging xsi:type="server-log"/>)
You have the following options to get TopLink to log to a custom handler
1 If you want to do the entire configuration from logging.properties, remove all handlers/loggers declarations from j2ee-logging.xml and in that case all configuration will be from logging.properties
2 Use a combination of j2ee-logging.xml and logging.properties. You can define certain attributes in j2ee-logging.xml. They are "name", "class", "level", "errorManager", "filter", "formatter" and "encoding", and they correspond to the attributes of java.util.logging.Handler. Attributes in subclasses of Handler are not supported. All other properties for the handler are defined in logging.properties. j2ee-logging.xml is processed on top of logging.properties, which means j2ee-logging.xml takes the precedence for certain attributes/properties. Take FileHandler for an example,
j2ee-logging.xml:
     <log_handlers>
     <log_handler name='my-handler' class='java.util.logging.FileHandler'
          formatter='java.util.logging.SimpleFormatter' level='INFO'/>
     </log_handlers>
logging.properties:
     java.util.logging.FileHandler.pattern = %h/java%u.log
     java.util.logging.FileHandler.limit = 10000
     java.util.logging.FileHandler.count = 2
If there are no properties defined in logging.properties, it will use its default values, which are documented in the FileHandler javadoc.
Shannon

Java.util.logging question

'Lo all -
I'm new to Java, so bear with me on this question - I'm sure it has a simple answer.
I am using the following code to create a new Logger object:
public class TAGLogging {
    private Logger oLog;
    private FileHandler oLogFile;
    private String sLoggingFolder = "AppLogs";
    private String sFormattedDateTime = String.format("%1$tY%1$tm%1$td_%1$tH%1$tM%1$tS",Calendar.getInstance());
    private String sCallingClass = new Throwable().fillInStackTrace().getStackTrace()[1].getClassName();
    private String sCallingMethod = new Throwable().fillInStackTrace().getStackTrace()[1].getMethodName();
    /** Constructors */
    public TAGLogging(String sLogFileName) throws IOException {
        this.initialSetup(sLogFileName);
    public TAGLogging() throws IOException {
        String sLogFileName = sLoggingFolder + File.separator + sFormattedDateTime + ".xml";
        this.initialSetup(sLogFileName);
    /** Methods */
    private void initialSetup(String logFileName) throws IOException {
        oLogFile = new FileHandler(logFileName);
        oLog = Logger.getLogger(sCallingClass);
        oLog.addHandler(oLogFile);
        oLog.setLevel(Level.ALL);
    }Everything is being logged correctly to the /AppLogs/yyyymmdd_HHMMSS.xml file. The problem is that there is another file that is being created in my home directory, which incidentally, is not where the program is located. The name, java01.log, matches the default logging.properties file set up, but I have removed all that and changed the file to the following (minus all the comments):
handlers= java.util.logging.FileHandler
.level= INFO
java.util.logging.FileHandler.level = ALL
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
The java01.log file contains the exact same contents as the file I am purposely logging to, the AppLogs/yyyymmd_HHMMSS.xml one.
Does anyone have any clue what is causing this file to get created, and if so, how do I stop it?
Message was edited by:
malakh

Man, I REALLY hate to do this, but it looks like I may be forced to work around it instead of fixing the issue. I'll have to add some code to manually remove the java01.log file when it's done writing to it.
Navy - Turns out that Log4j is pretty much the same thing as java.util.logging, except on steroids. It is almost identical syntactically, just has more options and more flexibility than JUL.

SLF4J instead of Java Util Logging?

Hi BDBJE team,
Is it included on the BDBJE roadmap a migration from "Java Util Logging" to a most flexible framework like SLF4J?
BR,
/César.

Hi Cesar,
No, definitely not on the road map, but we are aware of the shortcomings of standard Java logging (as documented on this forum) and we will think about what to do about it. It's a little disappointing, given that we just finished moving to standard Java logging (from our own custom logging) in the last release.
--mark

Java.util.logging.XMLFormatter - need advise

Hi all,
I have this class which suppose to write some message into the custom log file (in XML). Problem is, after the first time of writing it into the same file, it will append additional XML header :
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE log SYSTEM "logger.dtd">
Worse, it will always append below.
For example, the original XML file contains:
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE log SYSTEM "logger.dtd">
<log>
<record>
<date>2010-10-20T18:18:33</date>
<millis>1287569913671</millis>
<sequence>0</sequence>
<logger>atm.controller.Log_Controller</logger>
<level>INFO</level>
<class>atm.controller.Log_Controller</class>
<method>writeInfoLog</method>
<thread>10</thread>
<message>message inside thia standard data</message>
</record>
</log>when I write additional message into the same file using logger.info("some message"); on the second rounds, it will append additional XML header* info and become like this:
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE log SYSTEM "logger.dtd">
<log>
<record>
<date>2010-10-20T18:18:33</date>
<millis>1287569913671</millis>
<sequence>0</sequence>
<logger>atm.controller.Log_Controller</logger>
<level>INFO</level>
<class>atm.controller.Log_Controller</class>
<method>writeInfoLog</method>
<thread>10</thread>
<message>message inside thia standard data</message>
</record>
</log>
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE log SYSTEM "logger.dtd">
<log>
<record>
<date>2010-10-20T18:21:25</date>
<millis>1287570085050</millis>
<sequence>0</sequence>
<logger>atm.controller.Log_Controller</logger>
<level>INFO</level>
<class>atm.controller.Log_Controller</class>
<method>writeInfoLog</method>
<thread>10</thread>
<message>message inside thia standard data</message>
</record>
</log>--------------------------------------------------
Below is the code.
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Logger;
import java.util.logging.XMLFormatter;
public class Log_Controller
    private static Logger logger = Logger.getLogger( Log_Controller.class.getName() );
    private boolean allowAppend = true;
    public Log_Controller()
        try
            XMLFormatter formatterTxt = new XMLFormatter();
            FileHandler fileTxt = new FileHandler( "test.xml", allowAppend );
            fileTxt.setFormatter( formatterTxt );
            logger.addHandler( fileTxt );
        catch ( IOException ioe )
            ioe.printStackTrace();
    public void writeInfoLog( String message )
        logger.info("message inside thia standard data"); //THIS IS THE PART WHERE IT WRITE SOME MESSAGE INTO THE FILE
//        logger.info( message );
}This is something new to me, appreciate if someone can point me what the mistake that I have done.
Thanks thanks.
Edited by: 803699 on 20-Oct-2010 04:15
Edited by: 803699 on 20-Oct-2010 08:45

you cannot append to an xml file using the standard formatter because it makes the log file a "complete xml document" (header and root wrapper tags). if you want to be able to append to an existing xml log file, you will need to roll your own formatter.

Can't create log file with java.util.logging

Hi,
I have created a class to create a log file with java.util.logging
This class works correctly as standalone (without jdev/weblogic)
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.*;
public class LogDemo
     private static final Logger logger = Logger.getLogger( "Logging" );
     public static void main( String[] args ) throws IOException
         Date date = new Date();
         DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
         String dateStr = dateFormat.format(date);
         String logFileName = dateStr + "SEC" + ".log";
         Handler fh;
         try
           fh = new FileHandler(logFileName);
           //fh.setFormatter(new XMLFormatter());
           fh.setFormatter(new SimpleFormatter());
           logger.addHandler(fh);
           logger.setLevel(Level.ALL);
           logger.log(Level.INFO, "Initialization log");
           // force a bug
           ((Object)null).toString();
         catch (IOException e)
              logger.log( Level.WARNING, e.getMessage(), e );
         catch (Exception e)
              logger.log( Level.WARNING, "Exception", e);
}But when I use this class...
import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.XMLFormatter;
public class TraceUtils
public static Logger logger = Logger.getLogger("log");
public static void initLogger(String ApplicationName) {
    Date date = new Date();
    DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
    String dateStr = dateFormat.format(date);
    String logFileName = dateStr + ApplicationName + ".log";
    Handler fh;
    try
      fh = new FileHandler(logFileName);
      fh.setFormatter(new XMLFormatter());
      logger.addHandler(fh);
      logger.setLevel(Level.ALL);
      logger.log(Level.INFO, "Initialization log");
    catch (IOException e)
      System.out.println(e.getMessage());
}and I call it in a backingBean, I have the message in console but the log file is not created.
TraceUtils.initLogger("SEC");why?
Thanks for your help.

I have uncommented this line in logging.properties and it works.
# To also add the FileHandler, use the following line instead.
handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandlerBut I have another problem:
jdev ignore the parameters of the FileHandler method .
And it creates a general log file with anothers log files created each time I call the method logp.
So I play with these parameters
fh = new FileHandler(logFileName,true);
fh = new FileHandler(logFileName,0,1,true);
fh = new FileHandler(logFileName,10000000,1,true);without succes.
I want only one log file, how to do that?

Java.util.logging - different log files for different loggers

I'm having trouble configuring Java logging to use different log files for different loggers.
In log4j, I would do this by configuring multiple loggers each with a different appender. But how can I do this with Java (java.util.logging) logging?
This is the basic idea of what I'd like to do:
com.mycompany.app1.level = FINEST
com.mycompany.app1.<log file> = logfile1.log
com.mycompany.app2.level = ALL
com.mycompany.app2.<log file> = logfile2.log
Any suggestions?

This kind of thing?
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
public class LogTest {
    private Logger app1;
    private Logger app2;
    public LogTest() {
        // setup loggers
        try {
            // first logger
            app1 = Logger.getLogger("com.mycompany.app1");
            FileHandler filehandler = new FileHandler( "logfile1.log" );
            filehandler.setFormatter(new SimpleFormatter());
            app1.addHandler(filehandler);
            // second logger
            app2 = Logger.getLogger("com.mycompany.app2");
            filehandler = new FileHandler( "logfile2.log" );
            filehandler.setFormatter(new SimpleFormatter());
            app2.addHandler(filehandler);
        } catch(IOException ioex) {
            ioex.printStackTrace();
    private void logStuff() {
        app1.log(Level.SEVERE, "a message for log 1");
        app2.log(Level.SEVERE, "a message for log 2");
        app2.log(Level.WARNING, "another message for log 2");
     * @param args
    public static void main(String[] args) {
        new LogTest().logStuff();
}

Can java.util.logging.SimpleFormatter log stack trace?

can java.util.logging.SimpleFormatter log stack trace? I hope I don't have to write a custom formatter.
-yc

right, it does, the code I am modifying prints regular log msg at LEVEL.SEVERE, that's why it doesn't have any stack trace.
By the way, I am using file name pattern, aName.log%g, why it the most current log is aName.log.0, rather than just aName.log. In the conf file, I have,
mypackage.myclass.logfile.name=/.../aName.log.%g
java.util.logging.FileHandler.limit=60000
java.util.logging.FileHandler.count=3
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter
Thanks.
Message was edited by:
javalatte1

Java.util.logging: write to one log file from many application (classes)

I have a menuapp to launch many applications, all running in same JVM and i want to add logging information to them, using java.util.logging.
Intention is to redirect the logginginfo to a specific file within the menuapp. Then i want all logging from all applications written in same file. Finally, if needed (but i don't think it is), i will include code to write logging to specific file per app (class). The latter is probably not neccessary because there are tools to analyse the logging-files and allow to select filters on specific classes only.
The applications are in their own packages/jars and contain following logging-code:
        // Redirect error output
        try {
            myHandler = new FileHandler("myLogging.xml",1000000,2);
        } catch (IOException e) {
          System.out.println("Could not create file. Using the console handler");
        myLogger.addHandler(myHandler);
        myLogger.info("Our first logging message");
        myLogger.severe("Something terrible happened");
        ...When i launch the menuapplication, it writes info to "myLogging.xml.0"
but when i launch an application, the app writes info to "myLogging.xml.0.1"
I already tried to leave out the creation of a new Filehandler (try/catch block in code above) but it doesn't help.
Is it possible to write loginfo to same specific file?

You should open/close it somehow at every write from different processes.
But I personally prefer different file names to your forced merging, though.

How to prevent java.util.logging from displaying pop-up dialog on SEVERE?

Hi,
I'm new to using java.util.logging. I notice that whenever I try to make a call to logger.SEVERE(msg) or logger.WARNING(msg), not only does it write the output to file (which I want), but it also pops up a dialog box displaying the exception. I don't want this pop up to appear. How do I prevent the logger from doing this?

What are you talking about?
Hello,
In order to better assist you with your issue please provide us with a screenshot. If you need help to create a screenshot, please see [[How do I create a screenshot of my problem?]]
Once you've done this, attach the saved screenshot file to your forum post by clicking the '''Browse...''' button below the ''Post your reply'' box. This will help us to visualize the problem.
Thank you!

Preventing java.util.logging.Logger from writing to STD ERR.

Hi!
I'm currently writing a program which uses the java.util.logging package for logging. For some reason it writes ALL logging to std err (as well as to the designated (file) handlers). From what I gather, this is probably done via a ConsoleHandler, but I certainly haven't added any ConsoleHandler. I've also tried printing all registered handlers, which only returns one FileHandler (i.e. the one I added :)).
The following is a simplification of the code I use:
private static Logger log = Logger.getLogger("my.package");
    static{
         String logfile = "log.txt";
          try{
               FileHandler fh = new FileHandler(logfile);
               fh.setFormatter(new Formatter() {
                    public String format( LogRecord record){
                         return record.getLevel()+ " " +new Date(record.getMillis()).toString() + ": " +record.getMessage()+ "\n";
               System.out.println(log.getHandlers().length);
               log.addHandler(fh);
               log.setLevel(Level.ALL);
          }catch(IOException e){
               Frontend.getInstance().displayWarning("Unable to write to log file at "+logfile);
    }Any help on this would be greatly appreciated!

The speed and on-the-spotness of that reply totally blew me away. Thanks alot, buddy :).

Can't load runtime properties in java.util.logging.LogManager

This should be so easy, what am I doing wrong?
I have the following logging.properties located on my classpath:
handlers=java.util.logging.ConsoleHandler
.level=INFO
java.util.logging.ConsoleHandler.level=INFO
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
Test.level=FINE
Test.handlers=java.util.logging.ConsoleHandlerI have a very simple Test.java file that should load the new properties file and print out the known logger names (ie Test).
I've also tried putting Test.java in a package, it didn't seem to matter.
public class Test {
public Test() {
    String name = this.getClass().getName();
    //this properties file is should be sitting in same dir as Test class
    java.io.InputStream is = this.getClass().getResourceAsStream("logging.properties");
    try {
      //get log manager instance
      java.util.logging.LogManager lm = java.util.logging.LogManager.getLogManager();
      //read the new configuration
      lm.readConfiguration(is);
      //print out list of logger names
      java.util.Enumeration e = lm.getLoggerNames();
      while (e.hasMoreElements()) {
        System.out.println(e.nextElement());
      //print logger for this class!
      System.out.println("getLogger("+name+"): "+lm.getLogger(name));
    } catch (Exception e) {
    } finally {
      try {
        is.close();
        is = null;
      } catch (Exception e) {}
public static void main(String[] args) {
    Test test1 = new Test();
}The output I get from this is a single logger name, and then null for my desired Test logger.
global
getLogger(Test): null

It seems a logger instance HAS been created for my Test class, I've added the lines below. Though it didn't appear in the logger names enumeration.
java.util.logging.Logger logger = java.util.logging.Logger.getLogger(name);
System.out.println(logger.getName()+"="+logger.getLevel().getName());
logger.severe("severe");
logger.warning("warning");
logger.info("info");
logger.config("config");
logger.fine("fine");
logger.finer("finer");
logger.finest("finest");Output:Test=FINEST
6/10/2003 16:00:01 Test <init>
SEVERE: severe
6/10/2003 16:00:01 Test <init>
WARNING: warning
6/10/2003 16:00:01 Test <init>
INFO: infoObservations:
1) Despite my Test class having the FINEST log level, the default ConsoleHandler had log level of INFO, and hence only up to INFO logged.

Creating a new Handler (java.util.logging API)

Hi,
I'm developping a new Handler (extending the java.util.logging.StreamHandler) and I need to get some initialisation properties from the LogManager. I was taking example from the existing Handlers (SocketHandler, FileHandler...) and wanted to use the LogManager.getLevelProperty, getFilterProperty and so on). Unfortunately these methods are not public.
Is there any good reason for that ? As we are still dealing with a beta version, can't we have them public (same old Open Source problem).
Antonio

I am in a similar situation and agree completely with the above comments. Using the LogManager getProperty() is incredibly cumbersome.
Ciao Ric

Getting no output from java.util.logging.FileHandler

Similar Messages

Maybe you are looking for