Stacktrace loggen

[Gast]

Hallo!

Ich verwende die printStackTrace(PrintStream s) Methode, um den Stacktrace in eine Logdatei zu schreiben. Das Problem ist nun, dass bei jedem neuen Aufruf der Methode die Logdatei überschrieben wird und somit immer nur der letzte Stacktrace in der Logdatei steht.

Gibt es eine Möglichkeit einen neuen Stacktrace an die vorhandene Datei anzuhängen?

Danke!

 

[foobar]

Welchen Logger verwendest du?

 

[Gast]

Hab eine eigene Klasse geschrieben. Im wesentlichen wird einfach nur die printStackTrace-Methode aufgerufen, d.h. im Exceptionhandler wird dann meine eigene Methode handleException aufgerufen, die dann wiederum die printStackTrace-Methode aufruft:

try
{
    ....
} catch (Exception ex)
{
       // errorHandler ist eine Instanz meiner Logger-Klasse
      errorHandler.handleException(ex);
}

Die wesentlichen Methoden der Logger-Klasse:

private PrintStream errorLogger;

private void createErrorLogger()
{
        try
        {
            File logfileDir = new File(LOGFILE_DIR);
            if (!logfileDir.exists()) logfileDir.mkdir();

            File logfile = new File(LOGFILE_NAME);
            if (!logfile.exists()) logfile.createNewFile();

            errorLogger = new PrintStream(logfile);
        } catch (FileNotFoundException ex)
        {
            System.out.println(GlockServer.rbLabel.getString("CouldFindErrorLogFile"));
        } catch (IOException ex)
        {
            System.out.println(GlockServer.rbLabel.getString("CouldNotCreateErrorLogfile"));
        } catch (AccessControlException ex)
        {
            System.out.println(GlockServer.rbLabel.getString("IllegalOperation"));
            System.exit(-1);
        }

}


public void handleException(Exception ex)
{
	if (DEBUG)
        {
            if (errorLogger == null) createErrorLogger();

            ex.printStackTrace(errorLogger);
        }
}

 

[meez]

so kannst du es anhängen:

    OutputStream out = new FileOutputStream("<filename>", true);     
    StringWriter writer = new StringWriter();
    PrintWriter out = new PrintWriter(writer);
    t.printStackTrace(out);
    out.write(writer.getBuffer().toString().getBytes()): 
    out.close();

 

[bygones]

empfehle dir entweder den util.Logger von java oder log4j von apache typen...

 

[meez]

Ich Idiot...
So gehts noch einiges einfachher...
Das oben ist, wenn du einen String willst

PrintWriter writer = new PrintWriter(new OutputStream("<filename>", true));
t.printStackTrace(writer);

EDIT: dbac hat natürlich Recht...Ein Logger zu gebrauchen, wär eigentlich die schöne Art...

 

[Gast]

Hallo!

Danke für Eure Antworten. Ich hab es jetzt mal mit der java.util.Logger-Klasse probiert, habe damit aber noch ein paar Probleme:

(1) Zusätzlich zum Logfile, wird auch noch auf die Konsole geschrieben. Wie kann man das abstellen?
(2) Neben dem Logfile "logfile.txt" wird auch noch ein File "logfile.txt.lck" mit der Länge 0 erstellt. Wozu soll das gut sein und wie kann ich das verhindern?
(3) Ich würde gerne nach jedem Eintrag eine Leerzeile einfügen. Wie macht man sowas?

Beispielcode:

public class ExceptionLogger
{
    public static void main(String[] args)
    {
        Logger logger = Logger.getAnonymousLogger();

        try
        {
            FileHandler logfile = new FileHandler("./logs/logfile.txt", true);
            logfile.setFormatter(new SimpleFormatter());
            logger.addHandler(logfile);
        } catch (IOException ex)
        {
            System.out.println("IOException!!");
        }

        
        try
        {
            int x = Integer.parseInt("XXX");
        } catch (NumberFormatException ex)
        {
            logger.log(Level.SEVERE, ex.getMessage(), ex);
        }
    }
}

 

[bygones]

(1) logger.setUseParentHandlers(false); // damit wird nicht auf konsole geloogt
(2) weil du einen anonymouseLogger verwendest.. warum dann genau ein anderes file noch erstellt wird weiß ich nicht. hol dir einen bestimmten Logger über getLogger(String name)
(3) ich schreib mir meine LogHandlers immer selber damit kann ich das loggen steuern:

class LogFileHandler extends Handler {
    private static final SimpleFormatter LOG_FORMATTER = new SimpleFormatter();
    private static final String LOG_FILE = "files/error.log";

    private PrintWriter logWriter;

    public LogFileHandler() throws IOException {
        logWriter = new PrintWriter( new FileWriter( LOG_FILE, true ) );
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.util.logging.Handler#publish(java.util.logging.LogRecord)
     */
    public void publish( LogRecord record ) {
        if ( logWriter != null ) {
            logWriter.println( LOG_FORMATTER.format( record ) );
        }
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.util.logging.Handler#flush()
     */
    public void flush() {
        logWriter.flush();
    }

    /*
     * (non-Javadoc)
     * 
     * @see java.util.logging.Handler#close()
     */
    public void close() throws SecurityException {
        if ( logWriter != null ) {
            logWriter.close();
        }
    }
}

 

[Guest]

@ deathbyaclown

Vielen Dank, all meine Logging-Probleme sind damit gelöst!

 

[meez]

Obwohl du es ja jetzt nicht mehr brauchst...
Es gaht auch bedeutend einfacher:

	Logger logger = Logger.getLogger("key");
		String logfile = "...";
		String layout = "%d{MM.dd.yyyy\tHH:mm:ss}\t%p\t%m %n";
		logger.addAppender(new FileAppender(new PatternLayout(layout), logfile, true));
		logger.setLevel(Level.INFO);

Danach ganz normal mit logger.error usw. loggen...