Input/Output System.err zusätzlich in Datei schreiben

[Gast2]

Hi, sitze gerade an meinem Error Logging.

Bin noch nicht sicher, ob ich log4j oder die einfache sun logger verwenden soll.

Unabhängig davon möchte ich jedoch die Möglichkeit haben alle System.err Ausgaben zusätzlich in eine Datei zu schreiben (Für alle Exceptions welche ich nicht abfangen konnte, wie z.B. NULL Pointer Exception ect.).

Wie die Umleitung funktioniert ist mir klar. Jedoch steh ich total auf dem Schlauch wie ich das ganze nicht umleite sondern duplizierend in eine Datei schreibe.

Hier mein Umbiege Code:

        PrintStream orgStream = null;
        PrintStream fileStream = null;
        try {
            // Saving the orginal stream
            orgStream = System.err;
            fileStream = new PrintStream(new FileOutputStream("./logfile.txt"));
            // Redirecting runtime exceptions to file
            System.setErr(fileStream);
        } catch (Exception ex) {
            //Restoring back to console
            System.setErr(orgStream);
            //Gets printed in the console
            System.out.println("Redirectiion of System.err failed!");
            ex.printStackTrace();
        }

Ich hoffe jemand kann mir den passenden Denkanstoß geben.

 

[RySa]

Wenn du keinen Logger benutzen willst, wie wärs einfach mal mit einem BufferedWriter die Meldungen in die Datei zu schreiben.

 

[Gast2]

Wenn du keinen Logger benutzen willst, wie wärs einfach mal mit einem BufferedWriter die Meldungen in die Datei zu schreiben.

Ich möchte doch einen Logger benutzen ???:L

Es geht darum nicht logbare Meldungen wie z.B. Null Pointer Exceptions AUCH in eine Datei schreiben zu können. Da die auf dem System.err landen ich diesen aber nicht umleiten will möchte ich den System.err ja eben als KOPIE in eine Datei schreiben.

Steht oben auch so geschrieben.

 

[SlaterB]

ein Trick ist einen eigenen Stream zu setzen, welcher alle Daten an zwei Streams weitersendet,
'java splitoutputstream' ist anscheinend ein gute Suche dazu

 

[DerEisteeTrinker]

Puh das über 2 Streams zu machen ist sicherlich erstmal ok. Aber denke bitte daran, wenn du das auf einmal nicht mehr auf der Console brauchst, dann musst erst wieder den Quellcode anfassen. Benutz doch einfach log4j. Da kannst das alles super easy in einer Property-Datei bzw. einem XML lösen und kannst das sogar dann für die QS einfach abändern, wo er hin loggen soll. Du kannst sogar das Format für die Datei anders machen, als für die Console oder kannst dir auch Error-Nachrichten per Mail schicken lassen. Also da würde ich das Rad an deiner Stelle nicht neu erfinden, sondern lass log4j für dich arbeiten.

 

[Gast2]

Puh das über 2 Streams zu machen ist sicherlich erstmal ok. Aber denke bitte daran, wenn du das auf einmal nicht mehr auf der Console brauchst, dann musst erst wieder den Quellcode anfassen. Benutz doch einfach log4j. Da kannst das alles super easy in einer Property-Datei bzw. einem XML lösen und kannst das sogar dann für die QS einfach abändern, wo er hin loggen soll. Du kannst sogar das Format für die Datei anders machen, als für die Console oder kannst dir auch Error-Nachrichten per Mail schicken lassen. Also da würde ich das Rad an deiner Stelle nicht neu erfinden, sondern lass log4j für dich arbeiten.

Ehm heisst ich kann über log4j auch den Console Output (System.out und System.err) loggen? War mir noch gar nicht bewusst?!

 

[Gast2]

ein Trick ist einen eigenen Stream zu setzen, welcher alle Daten an zwei Streams weitersendet,
'java splitoutputstream' ist anscheinend ein gute Suche dazu

Hab da nicht wirklich viel zu gefunden (was von freenet und was von apache). Hast du da noch nen heißen link zu dem Thema? Ist auf jeden Fall mal interessant, da ich so mehr über Streams lernen könnte (das ist echt eine Wissenslücke bei mir)

 

[turtle]

Einen Aufruf von StdOutErrLog.tieSystemOutAndErrToLog() beim Start

public class StdOutErrLog {

    private static final Logger logger = Logger.getLogger(StdOutErrLog.class);

    public static void tieSystemOutAndErrToLog() {
        System.setOut(createLoggingProxy(System.out));
        System.setErr(createLoggingProxy(System.err));
    }

    public static PrintStream createLoggingProxy(final PrintStream realPrintStream) {
        return new PrintStream(realPrintStream) {
            public void print(final String string) {
                realPrintStream.print(string);
                logger.info(string);
            }
        };
    }
}

 

[DerEisteeTrinker]

Es gibt den TeeOutputStream von Apache Commons IO, der sollte das genau machen.

 

[SlaterB]

ich dachte noch vor allem an
10.11. Splitting an OutputStream | Discursive
vormals der vierte Link, inzwischen ist dieses Thema hier ja vorbeigezogen, immer wieder unglaublich wie schnell das geht,
erst durch meine Nennung der Suchbegriffe

aber in dem Thema wird letzlich auch nur eine der beiden Library-Klassen verwendet, richtig, da steht leider nicht viel

tja, dann kann ich erstmal auch keine fertigen Beispiele nennen, müsste genauso suchen wie du,
überschreibe eine Klasse, überschreibe alle Methoden, schaue welche drankommen, welche vielleicht auch schon andere aufrufen, überschreibe die die nötig sind,
ist vielleicht bisschen kompliziert, aber fange wenigstens selber an, vorher mache ich nix

für FilterInput/OutputStream ist vielleicht eher was zu finden
http://www.java-forum.org/netzwerkprogrammierung/53630-filter-fuer-input-outputstream.html

 

[Gast2]

Super werd das mal testen die nächsten Tage! Mit den den Beispielen komm ich erst mal weiter. Melde mich dann wie und ob es läuft.

Nur noch mal meine andere Frage pushen:

Ehm heisst ich kann über log4j auch den Console Output (System.out und System.err) loggen? War mir noch gar nicht bewusst?!

 

[Pippl]

Du kannst z.B.: log4j verwenden und überall statt System.out.print oder System.err.print dann eben entsprechende Meldungen loggen. Mit einer Einstellungsdatei kannst du dann log4j sagen wo er diese geloggten Meldungen ausgeben soll ... das kann eine Datei aber auch die Console sein!

 

[Ariol]

Ich würde dir auch einen Logger empfehlen.

Ansonsten hab ich auch mal sowas gebastelt: MultipleOutputStream

 

[Gast2]

Du kannst z.B.: log4j verwenden und überall statt System.out.print oder System.err.print dann eben entsprechende Meldungen loggen. Mit einer Einstellungsdatei kannst du dann log4j sagen wo er diese geloggten Meldungen ausgeben soll ... das kann eine Datei aber auch die Console sein!

Es geht doch um Fehler die über den System.err gehen und NICHT von mir abgesetzt wurden. Hab ich doch jetzt schon 3 mal geschrieben.

Aber trotzdem nochmal: Ich benutze einen Logger. Der loggt nur halt nicht was ich nicht abfangen kann. das geht über System.err.

Meine Frage daher: Kann man log4j so konfigurieren, dass der System.err auch geloggt wird?

Die Beispiele mit den Double Streams teste ich gerade.

 

[Gast2]

Also der Code hier macht genau was ich wollte. Er spiegelt alle System.out und System.err zusätzlich in die von mir spezifizierte Datei.

Allerdings muss ich bei dem FileStream einen println machen sonst steht in der Datei nur eine Zeile. Ich hätte erwartet, dass auch hier ein print reicht ???:L.

public class StdOutAndErrLog {

    private static PrintStream fileStream = null;

    public static void tieSystemErrToLog() {
        try {
            fileStream = new PrintStream(new FileOutputStream("./std_out_err.log"));
        } catch (FileNotFoundException ex) {
        }
        
        System.setErr(createLoggingProxy(System.err));
        System.setOut(createLoggingProxy(System.out));
    }

    private static PrintStream createLoggingProxy(final PrintStream realPrintStream) {
        return new PrintStream(realPrintStream) {

            @Override
            public void print(final String string) {
                realPrintStream.print(string);
                fileStream.println(string);
            }
        };
    }
}

Wie löst ihr das denn? Fangt ihr die Meldungen welche automatisch auf dem System.err landen gar nicht ab oder gibt es noch andere Möglichkeiten die ich einfach nicht kenne?

 

[SlaterB]

wie gesagt musst du evtl. mehrere Methoden überschreiben, println sieht intern so aus:

    public void println(String x) {
	synchronized (this) {
	    print(x);
	    newLine();
	}
    }

du solltest also auch newLine() überschreiben
dann gibts auch noch

    public void print(int i) {
	write(String.valueOf(i));
    }

und ähnliches, was ja vielleicht irgendwer aufruft, statt nun alle print-Methoden zu überschreiben reicht vielleicht write(String)
dann evtl die anderen nicht mehr nötig, da z.B. newLine() zu

    public void newLine() throws IOException {
	write(lineSeparator);
    }

führt, also auch bei write(String) vorbeikommt,
in diesen Dimensionen muss man untersuchen was alles passiert und dann getan werden muss,

falls keine zentrale Methode zu finden ist sondern mehrere überschrieben werden,
dann aufpassen dass ein String nicht zweimal weitergeleitet wird

-------

was stellst du dir denn unter 'automatisch auf dem System.err landen' vor? typisch ist das ja nicht gerade,
nur beim AWT-Eventthread ist mir das bisher begegnet, da wäre das in der Tat hilfreich,

es gibt auch Thread.UncaughtExceptionHandler, aber ich schätze nur für Threads die dann wirklich zu Ende gehen,
der AWT-Eventthread läuft ja weiter

für allen eigenen Code gibts try/catch

 

[Ariol]

Nochmal:

package numberguess;

import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;

public class MultipleOutputStream extends OutputStream
{
	private static final long serialVersionUID = -4883712704959553981L;
	private ArrayList<OutputStream> outputStreams = new ArrayList<OutputStream>();

	/**
	 * Create an MultipleOutputStream
	 * 
	 * 	@param out 
	 * 		the OutputStream can be null
	 */
	public MultipleOutputStream(OutputStream out)
	{
		if (out != null)
		{
			outputStreams.add(out);
		}
	}

	/**
	 * Add an OutputStream
	 *
	 * @param out
	 * 		the OutputStream 
	 **/
	public synchronized void add(OutputStream out)
	{
		if (out != null)
		{
			outputStreams.add(out);
		}
	}

	/** 
	 * 
	 * Removes an OutputStream 
	 * 
	 * @param out 
	 * 		the OutputStream 
	 **/
	public synchronized void remove(OutputStream out)
	{
		for (OutputStream outputStream : outputStreams)
		{
			if (out != null && out.equals(outputStream))
			{
				outputStreams.remove(out);
			}
		}
	}

	@Override
	public void write(int b) throws IOException
	{
		synchronized (outputStreams)
		{
			for (OutputStream outputStream : outputStreams)
			{
				outputStream.write(b);
			}
		}
	}
}

Beispiel für Verwendung:

		MultipleOutputStream multipleOutputStream = new MultipleOutputStream(System.out);
		multipleOutputStream.add(System.err);
		
		try 
		{
			multipleOutputStream.add(new FileOutputStream("log.log",true));
		} catch (FileNotFoundException e) {}
		multipleOutputStream.println("Hallo");

EDIT: Formatierung

 

[SlaterB]

@Ariol
mal abgesehen von der Unterscheidung Stream zu Writer noch ne Anmerkung:
für einfache Log-Ausgaben mag es nicht ins Gewicht fallen, aber allgemein ist es ja ziemlich ungünstig in eine Datei byte für byte zu schreiben,
deswegen liest man doch überall den Vorschlag BufferedOutputStream bzw. byte[],
deine Implementierung macht das zunichte, jedes Array wird hier in einzelne bytes zerlegt

und ganz nebenbei:
Code posten mit Leerzeilen zwischen jeder Zeile ist doch nicht schön, ist das nötig?

 

[Ariol]

@Ariol
mal abgesehen von der Unterscheidung Stream zu Writer noch ne Anmerkung:
für einfache Log-Ausgaben mag es nicht ins Gewicht fallen, aber allgemein ist es ja ziemlich ungünstig in eine Datei byte für byte zu schreiben,
deswegen liest man doch überall den Vorschlag BufferedOutputStream bzw. byte[],
deine Implementierung macht das zunichte, jedes Array wird hier in einzelne bytes zerlegt

Ich will ja keine Illusionen zerstören, aber z.B.: die Methode

BufferedOutputStream#write(byte b[], int off, int len)

ruft

OutputStream#write(byte b[], int off, int len);

auf (vorher natürlich gepuffert).
Diese wiederum sieht so aus:

  public void write(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if ((off < 0) || (off > b.length) || (len < 0) ||
                   ((off + len) > b.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        }
        for (int i = 0 ; i < len ; i++) {
            write(b[off + i]);
        }
    }

Sie ruft also die Methode

OutputStream#write(byte b)

auf, die in meinem Code überschreiben wurde.

Weiterhin ist es ja kein Problem zu Puffern:

MultipleOutputStream mos = new MultipleOutputStream(System.in);
mos.add(System.err);
BufferedOutputStream bos = new BufferedOutputStream(mos);

und ganz nebenbei:
Code posten mit Leerzeilen zwischen jeder Zeile ist doch nicht schön, ist das nötig?

Das war keine Absicht (Copy&Paste)


EDIT: Gerade gesehen, dass FileOutputStream native write-Methoden für arrays hat...
Angepasste Klasse:

package numberguess;

import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;

public class MultipleOutputStream extends OutputStream
{
	private static final long serialVersionUID = -4883712704959553981L;
	private ArrayList<OutputStream> outputStreams = new ArrayList<OutputStream>();

	/**
	 * Create an MultipleOutputStream
	 * 
	 * 	@param out 
	 * 		the OutputStream can be null
	 */
	public MultipleOutputStream(OutputStream out)
	{
		if (out != null)
		{
			outputStreams.add(out);
		}
	}

	/**
	 * Add an OutputStream
	 *
	 * @param out
	 * 		the OutputStream 
	 **/
	public synchronized void add(OutputStream out)
	{
		if (out != null)
		{
			outputStreams.add(out);
		}
	}

	/** 
	 * 
	 * Removes an OutputStream 
	 * 
	 * @param out 
	 * 		the OutputStream 
	 **/
	public synchronized void remove(OutputStream out)
	{
		for (OutputStream outputStream : outputStreams)
		{
			if (out != null && out.equals(outputStream))
			{
				outputStreams.remove(out);
			}
		}
	}
	
	@Override
	public void write(byte[] b) throws IOException
	{
		synchronized (outputStreams)
		{
			for (OutputStream outputStream : outputStreams)
			{
				outputStream.write(b);
			}
		}
	}
	
	@Override
	public void write(byte[] b, int off, int len) throws IOException
	{
		synchronized (outputStreams)
		{
			for (OutputStream outputStream : outputStreams)
			{
				outputStream.write(b, off, len);
			}
		}
	}

	@Override
	public void write(int b) throws IOException
	{
		synchronized (outputStreams)
		{
			for (OutputStream outputStream : outputStreams)
			{
				outputStream.write(b);
			}
		}
	}
}

Das sollte performanter sein

 

[SlaterB]

> Weiterhin ist es ja kein Problem zu Puffern:
genau das meinte ich, Buffer außen rum suggeriert die Performance, aber wird dann intern wieder aufgelöst,
nun finde ich es besser, ja

um immer noch was anzumerken: die Methode write(byte[] b, int off, int len) reicht sicherlich,
write(byte[] b) kann ruhig in der Default-Implementierung an write(byte[] b, int off, int len) weiterreichen

 

[Gast2]

Der Thread triftet total weg von meinem Thema.

Hier nochmal die Fakten:

1) Ich benutze überall in meinem Code Logger.
2) Meine Logger können keine Runtime Exceptions abfangen (Wie NULL Pointer Exceptions oder Class not Found ect.)
3) Ich kann den mir bekannten UncaughtExceptionHandler nicht verwenden, da ich nicht auf alle Threads direkten Zugang habe.
4) Alles das was ich nicht abfangen kann in eigenem Code landet im System.err
5) Wie bereits im ersten Post beschrieben ist mir auch bekannt wie man den umleiten kann. Das möchte ich aber nicht, da dann keine Ausgaben mehr in der Konsole ankommen.

==> Meine Frage war daher: Wie kann ich den kompletten Inhalt des System.err Stream sowohl in der Konsole anzeigen lassen und diesen zusätzlich in eine Datei speichern.

Der StreamProxy Vorschlag funktioniert soweit. Ist aber problemtisch wegen der nur teilweise überschrieben Funktionen.

@Ariol: Dein Vorschlag löst mein Problem nicht, da er etwas in System.err reinschreibt. Ist ja nicht mein Ziel.

PS: Vielen Dank für die Rege Beteiligung schonmal!

 

[SlaterB]

> Der StreamProxy Vorschlag funktioniert soweit.
was ist 'Der StreamProxy Vorschlag'? StreamProxy ist auf Seite 1 per Suche nicht zu finden, turtle schreibt was von Proxy, meinst du das?
na das ist dem Vorschlag von Ariol doch recht ähnlich, überschriebene Stream oder Writer-Klassen,
wo ist das Abdriften? Stream mit bytes sind was anderes als Writer mit Strings und chars, dennoch strukturell schon wichtige Infos für diese Art der Vererbung

damit bekommst du System.err komplett oder welche konkreten Probleme hast du?

-------

du musst damit leben dass gar nicht oft genug erwähnt werden kann, dass dein Problem eher ungewöhlich ist,
Legionen von Java-Programmiern kamen bisher auch mit normalen Loggern und try/catch aus, was bei dir das Problem ist ist nicht ganz klar

einerseits schreibst du
> Meine Logger können keine Runtime Exceptions abfangen
ohne Begründung,
wenn der Grund ist dass die Exception in ganz anderen Threads stattfinden, dann ist es ja klar, dann können die das sowenig wie die Logger von meinem Rechner aus,
aber dann ist der ganze Punkt etwas fraglich, wie sollten sie auch die fernen Exceptions abfangen, oder kommen die Exceptions doch durch deinen Code?
andererseits schreibst du
> da ich nicht auf alle Threads direkten Zugang habe.
ok, das ist natürlich ein Punkt der schlimmstenfalls nicht zu umgehen ist, wenn es da andere Threads oder auch nur Aufrufe von anderen Klassen gibt die direkt in System.err schreiben,
dann kann das nur mit neuem System.err erhalten werden

 

[Ariol]

....
@Ariol: Dein Vorschlag löst mein Problem nicht, da er etwas in System.err reinschreibt. Ist ja nicht mein Ziel.
...

In was der reinschreibt hängt davon ab, welche OutputStreams du reinsteckst.
System.err ist nur ein Beispiel

 

[Gast2]

In was der reinschreibt hängt davon ab, welche OutputStreams du reinsteckst.
System.err ist nur ein Beispiel

Das schon aber einen OutputStream kann ich nicht als neuen System.err setzen. Das muss ein PrintStream sein.

Das Vorgehen wäre demnach deinem MultipleStream den Original System.err zu übergeben. Meinen FileStream und den Multiple dann dem System.err zu setzen.

Ist ja im Prinzip das selbe wie die Proxy Geschichte.

 

[Gast2]

Der StreamProxy Vorschlag funktioniert soweit.
was ist 'Der StreamProxy Vorschlag'? StreamProxy ist auf Seite 1 per Suche nicht zu finden, turtle schreibt was von Proxy, meinst du das?

Genau

du musst damit leben dass gar nicht oft genug erwähnt werden kann, dass dein Problem eher ungewöhlich ist,
Legionen von Java-Programmiern kamen bisher auch mit normalen Loggern und try/catch aus, was bei dir das Problem ist ist nicht ganz klar

Wieso nicht? Ich muss halt alle Fehler loggen. Auch die an die ich nicht per try catch oder UncaughtException dran komme. Hab ich genau so ein paar mal erklärt.

einerseits schreibst du: Meine Logger können keine Runtime Exceptions abfangen, ohne Begründung,

Ich habe begründet, dass ich an die Threads nicht dran komme um eine UncaughtException abzufangen. Das ist doch eine Begründung.
Falls es da noch andere Wege gibt wäre ich für den Hinweis dankbar. (Irgendein "globales" UncaughtException Framework oder sowas?!)

wenn der Grund ist dass die Exception in ganz anderen Threads stattfinden, dann ist es ja klar, dann können die das sowenig wie die Logger von meinem Rechner aus,
aber dann ist der ganze Punkt etwas fraglich, wie sollten sie auch die fernen Exceptions abfangen, oder kommen die Exceptions doch durch deinen Code?
andererseits schreibst du
> da ich nicht auf alle Threads direkten Zugang habe.
ok, das ist natürlich ein Punkt der schlimmstenfalls nicht zu umgehen ist, wenn es da andere Threads oder auch nur Aufrufe von anderen Klassen gibt die direkt in System.err schreiben,
dann kann das nur mit neuem System.err erhalten werden

Genau so siehts aus. Und diese Errors welche über den System.err gehen muss ich mitloggen. Und zwar ohne den System.err umzuleiten (Dann kommt auf dem ursprünglichen System.err (Konsole ect) ja nichts mehr an.

Jetzt haben wirs ^^

Mit den Vorschlägen geht es ja grundsätzlich. Ich frage mich halt ob es nicht wirklich eine Standard Lösung gibt alle UncaughtExceptions aller Threads an einer Stelle abzufangen.

 

[SlaterB]

> Ich frage mich halt ob es nicht wirklich eine Standard Lösung gibt alle UncaughtExceptions aller Threads an einer Stelle abzufangen.
doch das geht vielleicgt,
an alle Threads kommst du mit Thread.getAllStackTraces() ran, hatte bisher nicht korrekt gelesen dass du die Threads nicht findest,
es gibt auch Thread.setDefaultUncaughtExceptionHandler(), welcher aber wohl nicht gilt wenn in einzelnen Threads anderer Handler schon gesetzt ist?,
ob du in dem Fall überhaupt deinen eigenen Handler noch hinzufügen oder ersetzen kannst (und solltest) ist dann eine Folgefrage..

aber nur auf diese Art weitere Exceptions zu fangen ist eher knapp, wieviele andere Threads gibt es denn schon, dass nichtmal deren Ende auffällt bzw. extra ein Log-Eintrag lohnt, oder werden die immer neu gestartet?
als Begründung wäre hilfreich mehr über diese komischen anderen Klassen und Threads zu erzählen, alle bekannten Libraries der Welt sollten eigentlich ohne sowas auskommen oder sind ansonsten ziemlich buggy,

wenn man schon so komische Klassen hat, dann können die auch ziemlich leicht try/catch verwenden und selber in System.err schreiben,
dann kommst du nur mit UncaughtExceptionHandler nicht weit und solltest doch auch System.err kontrollieren

 

[Gast2]

Ich benutze einige Bibliotheken welche potentiell Runtime Errors über die System.err ausgeben. Diese wollte ich eben mitloggen.

Hast natürlich recht den Default Handler der Threads zu ändern kann Probleme machen. Werde dann die Proxy Variante noch etwas aufpolieren. Funktioniert ja. Dachte nur es gibts was fertiges.

Problem damit gelöst.

 

[Gast2]

Für die Suchmaschine hier noch das endgültige Resultat:

Dank SlaterB's Tipp habe ich dann noch die Klasse TeePrintStream gefunden welche genau das leistet was ich brauche (TeeOutputStream kann ich zwar nicht nutzen, es gab mir aber die richtige Richtung vor )

Hier der Link zu den Sourcen: TeePrintStream tees all PrintStream operations into a file, rather like the UNIX tee(1) command : File CommandsFile Input OutputJava

Dank auch an alle die Vorschläge zu eigenen Implementierungen gemacht haben. Das gipfelt letztlich in den Tee* Klassen. Benutze dann die bereits fertige

*Jetzt nur noch dran denk überall den Danke Button anzuklicken*