System.out auf files umlenken in log4j.xml

[ruutaiokwu]

hallo zusammen,

wie mir bekannt ist, kann man system.out, nicht aber system.err, von der ausgabe in die konsole auf files "umlenken". wie man das in java realisiert, ist mir soweit bekannt.

jetzt stelle ich mir die frage, ob das bei log4j über die konfigurationsdatei log4j.xml möglich wäre? der inhalt dieser sieht so aus:

[XML]<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration>

<appender name="ConsoleAppender1" class="org.apache.log4j.ConsoleAppender">
<param name="Target" value="System.out" />
<layout class="org.apache.log4j.SimpleLayout" />
</appender>

<appender name="stdout" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%d{ABSOLUTE} %5p %c{1}:%L - %m%n" />
</layout>
</appender>

<appender name="WSAppender" class="org.apache.log4j.FileAppender">
<param name="File" value="log/sls-webservice.log"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss} %5p [%t] (%F:%L) - %m%n" />
</layout>
</appender>

<appender name="NullAppender1" class="org.apache.log4j.varia.NullAppender" />

<!-- LOGGER FOR SLS WEB SERVICES -->
<logger name="WS">
<level value="DEBUG" />
<appender-ref ref="WSAppender" />
</logger>

<!-- LOGGER FOR SLS ORDER BROWSER -->
<logger name="slsobLogger">
<level value="DEBUG" />
<appender-ref ref="ConsoleAppender1" />
</logger>

<!-- LOGGER FOR ALV BROWSER -->
<logger name="alvLogger">
<level value="DEBUG" />
<appender-ref ref="ConsoleAppender1" />
</logger>

<!-- LOGGER FOR ENTITLEMENT RECORD BROWSER -->
<logger name="erbLogger">
<level value="DEBUG" />
<appender-ref ref="ConsoleAppender1" />
</logger>

<!-- LOGGER FOR TEMPLATE MANAGER -->
<logger name="templateLogger">
<level value="DEBUG" />
<appender-ref ref="ConsoleAppender1" />
</logger>

<!-- ROOT LOGGER -->
<root>
<level value="OFF" />
<appender-ref ref="NullAppender1" />
</root>

</log4j:configuration>[/XML]


konkret würde es um dem appender "ConsoleAppender1" gehen.

...hätte evtl. jemand einen tipp dazu?


danke & grüsse,
jan

 

[XHelp]

ConsoleAppender ist ja dazu da um AUF die Konsole zu loggen und nicht VON der Konsole.
Ich weiß es zwar nicht 100%tig, aber ich bezweifle, dass du es einstellen kannst. Mal angenommen es ging: log4j fabriziert selber eine Ausgabe (z.B. Exception)... es erscheint auf der Konsole, sobald es auf der Konsole erscheint, versucht log4j zu schreiben, es gibt eine Exception, die auf der Konsole erscheint, sobald es auf der Konsole erscheint.... usw.

Also wird es vermutlich darauf hinauslaufen es mit System.setOut zu machen.

 

[ruutaiokwu]

...habe es jetzt mal so gelöst:

package commons.logging;

import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.Date;
import java.util.Enumeration;
import java.util.Properties;

import org.apache.log4j.ConsoleAppender;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import sls.commons.misc.DateFormatter;

public final class LoggerWrapper
{
    // @SuppressWarnings("unused")
    private static Properties mProperties = null;

    private LoggerWrapper()
    {
        // declared as "private" to prevent external instantiation...
    }

    public static void initProperties(final Properties caProperties)
    {
        mProperties = caProperties;
    }

    public static Logger getLoggerInstance(final String clLoggerName)
    {
        boolean logToFiles = false;

        if (mProperties != null)
        {
            try
            {
                logToFiles = Boolean.parseBoolean(mProperties.get("log_to_files").toString());
                System.out.println("logToFiles: " + logToFiles);
            }
            catch (final Exception caException)
            {
                System.out.println("Can't load properties file: use default value: " + logToFiles);
            }
        }

        if (logToFiles)
        {
            org.apache.log4j.Logger log4jLogger = org.apache.log4j.Logger.getLogger(clLoggerName);
            Enumeration<?> appenderEnumeration = log4jLogger.getAllAppenders();
            ConsoleAppender consoleAppender = null;

            if (appenderEnumeration.hasMoreElements())
            {
                consoleAppender = (ConsoleAppender) appenderEnumeration.nextElement();
            }
            else
            {
               throw new RuntimeException("No logger appenders found! -> PLEASE CHECK log4j.xml");
            }

            
            FileWriter fw = null;
            
            PrintWriter pw = null;
            
            try
            {
                String formattedDate = DateFormatter.FormatDate2String("yyyy-MM-dd", new Date());
                fw = new FileWriter("C:\\logfile_" + clLoggerName + "_" + formattedDate + ".txt", true);
                
                pw = new PrintWriter(fw,true);
                
                consoleAppender.setWriter(pw);
            }
            catch (final Exception ex)
            {
                ex.printStackTrace();
            }
            finally
            {
                try
                {
                    if(pw!=null)
                    {
                        /*
                        pw.flush();
                        pw.close();
                        */
                    }
                    
                if(fw != null)
                {
                    /*
                    fw.flush();
                    fw.close();
                    */
                }
                }
                catch(final Exception ex)
                {
                    final Runtime rt = Runtime.getRuntime();
                    rt.gc();
                }
            }
        }
        
        
        Logger myLogger = LoggerFactory.getLogger(clLoggerName);
        return myLogger;
    }
}

also wie bereits gesagt: der appender bleibt der GLEICHE, nur wird mit consoleAppender.setWriter(pw); auf eine andere ausgabe umgelenkt. das klappt soweit gut. nur habe ich das problem, dass die files gelockt werden.

wenn ich im finally-block den PrintWriter oder den FileWriter (oder beide) per .close() schliesse, habe ich das problem dass alles bereits geschlossen ist, bevor der rückgabewert zurückkommt. das geht also nicht.

weiss jemand eine möglichkeit? oder könnte dies am verwendeten application server liegen, müsste also dort eingestellt werden?


grüsse, jan

 

[ruutaiokwu]

hat sich gelöst...

 

[ruutaiokwu]

quelltexte hier:

(btw.: habe ich richtig synchronisiert??? Bei der klasse "LoggerWriter" wird als writer-klasse eine membervariable verwendet...)

package slstool.utils.logging;

import java.util.Enumeration;
import java.util.Properties;

import org.apache.log4j.Appender;
import org.apache.log4j.ConsoleAppender;
import org.slf4j.Logger;

public final class LoggerHandler
{
    private static Properties mProperties = null;

    private LoggerHandler()
    {
        // declared as "private" to prevent external instantiation...
    }

    public static void initProperties(final Properties caProperties)
    {
        LoggerHandler.mProperties = caProperties;
    }

    @SuppressWarnings("unchecked")
    public static Logger getLoggerInstance(final String clLoggerName)
    {
        boolean logToFiles = false;
        String lLogFilesPathValue = null;

        if (LoggerHandler.mProperties != null)
        {
            try
            {
                logToFiles = Boolean.parseBoolean(LoggerHandler.mProperties.getProperty("logToFiles", "" + false).toString());

                if (logToFiles)
                {
                    final String clLogFilesPathName = "logFilesPath";

                    lLogFilesPathValue = LoggerHandler.mProperties.getProperty(clLogFilesPathName);

                    if (lLogFilesPathValue == null)
                    {
                        throw new NullPointerException("Error parsing " + clLogFilesPathName + " in properties file...");
                    }
                }
            }
            catch (final Exception caException)
            {
                throw new RuntimeException(caException);
            }
        }

        ConsoleAppender consoleAppender = null;
        org.apache.log4j.Logger log4jLogger = org.apache.log4j.Logger.getLogger(clLoggerName);
        Enumeration<Appender> appenderEnumeration = log4jLogger.getAllAppenders();

        if (appenderEnumeration.hasMoreElements())
        {
            consoleAppender = (ConsoleAppender) appenderEnumeration.nextElement();
        }
        else
        {
            throw new RuntimeException("No logger appenders found! -> PLEASE CHECK log4j.xml");
        }

        LoggerWrapper myLogger = new LoggerWrapper(clLoggerName);

        if (logToFiles)
        {
            myLogger.setAppender(consoleAppender);
            myLogger.setLogToFiles(logToFiles);
            myLogger.setLogFilesPath(lLogFilesPathValue);
        }

        return myLogger;
    }
}

package slstool.utils.logging;

import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.log4j.Appender;
import org.apache.log4j.ConsoleAppender;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;

import slstool.utils.ResourceManager;

public final class LoggerWrapper implements Logger
{
    private final Logger myLogger;

    private volatile Writer writer = null;

    private static ConsoleAppender consoleAppender = null;

    private boolean mLogToFiles = false;

    private static String mLogFilesPath = null;

    public LoggerWrapper(final String caLoggerName)
    {
        synchronized (this)
        {
            this.myLogger = LoggerFactory.getLogger(caLoggerName);
        }
    }

    public void setLogFilesPath(final String caLogFilesPath)
    {
        LoggerWrapper.mLogFilesPath = caLogFilesPath;
    }

    public void setAppender(final Appender consoleAppender)
    {
        LoggerWrapper.consoleAppender = (ConsoleAppender) consoleAppender;
    }

    public void setLogToFiles(final boolean caLogToFiles)
    {
        this.mLogToFiles = caLogToFiles;
    }

    private void initWriter()
    {
        if (this.mLogToFiles)
        {
            try
            {
                synchronized (this)
                {
                    DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
                    String formattedDate = df.format(new Date());

                    final String logFile = LoggerWrapper.mLogFilesPath + "logfile_" + this.myLogger.getName() + "_" + formattedDate + ".txt";

                    FileWriter fw = new FileWriter(logFile, true);
                    this.writer = new PrintWriter(fw, true);
                    LoggerWrapper.consoleAppender.setWriter(this.writer);
                }
            }
            catch (final Exception ex)
            {
                ex.printStackTrace();
            }
        }
    }

    @Override
    public void debug(final String arg0)
    {
        this.initWriter();
        this.myLogger.debug(arg0);
        this.close(this.writer);
    }

    @Override
    public void debug(final String arg0, final Object arg1)
    {
        this.initWriter();
        this.myLogger.debug(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void debug(final String arg0, final Object[] arg1)
    {
        this.initWriter();
        this.myLogger.debug(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void debug(final String arg0, final Throwable arg1)
    {
        this.initWriter();
        this.myLogger.debug(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void debug(final Marker arg0, final String arg1)
    {
        this.initWriter();
        this.myLogger.debug(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void debug(final String arg0, final Object arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.debug(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void debug(final Marker arg0, final String arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.debug(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void debug(final Marker arg0, final String arg1, final Object[] arg2)
    {
        this.initWriter();
        this.myLogger.debug(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void debug(final Marker arg0, final String arg1, final Throwable arg2)
    {
        this.initWriter();
        this.myLogger.debug(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void debug(final Marker arg0, final String arg1, final Object arg2, final Object arg3)
    {
        this.initWriter();
        this.myLogger.debug(arg0, arg1, arg2, arg3);
        this.close(this.writer);
    }

    @Override
    public void error(final String arg0)
    {
        this.initWriter();
        this.myLogger.error(arg0);
        this.close(this.writer);
    }

    @Override
    public void error(final String arg0, final Object arg1)
    {
        this.initWriter();
        this.myLogger.error(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void error(final String arg0, final Object[] arg1)
    {
        this.initWriter();
        this.myLogger.error(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void error(final String arg0, final Throwable arg1)
    {
        this.initWriter();
        this.myLogger.error(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void error(final Marker arg0, final String arg1)
    {
        this.initWriter();
        this.myLogger.error(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void error(final String arg0, final Object arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.error(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void error(final Marker arg0, final String arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.error(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void error(final Marker arg0, final String arg1, final Object[] arg2)
    {
        this.initWriter();
        this.myLogger.error(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void error(final Marker arg0, final String arg1, final Throwable arg2)
    {
        this.initWriter();
        this.myLogger.error(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void error(final Marker arg0, final String arg1, final Object arg2, final Object arg3)
    {
        this.initWriter();
        this.myLogger.error(arg0, arg1, arg2, arg3);
        this.close(this.writer);
    }

    @Override
    public String getName()
    {
        return this.myLogger.getName();
    }

    @Override
    public void info(final String arg0)
    {
        this.initWriter();
        this.myLogger.info(arg0);
        this.close(this.writer);
    }

    @Override
    public void info(final String arg0, final Object arg1)
    {
        this.initWriter();
        this.myLogger.info(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void info(final String arg0, final Object[] arg1)
    {
        this.initWriter();
        this.myLogger.info(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void info(final String arg0, final Throwable arg1)
    {
        this.initWriter();
        this.myLogger.info(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void info(final Marker arg0, final String arg1)
    {
        this.initWriter();
        this.myLogger.info(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void info(final String arg0, final Object arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.info(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void info(final Marker arg0, final String arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.info(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void info(final Marker arg0, final String arg1, final Object[] arg2)
    {
        this.initWriter();
        this.myLogger.info(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void info(final Marker arg0, final String arg1, final Throwable arg2)
    {
        this.initWriter();
        this.myLogger.info(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void info(final Marker arg0, final String arg1, final Object arg2, final Object arg3)
    {
        this.initWriter();
        this.myLogger.info(arg0, arg1, arg2, arg3);
        this.close(this.writer);
    }

    @Override
    public boolean isDebugEnabled()
    {
        return this.myLogger.isDebugEnabled();
    }

    @Override
    public boolean isDebugEnabled(final Marker arg0)
    {
        return this.myLogger.isDebugEnabled(arg0);
    }

    @Override
    public boolean isErrorEnabled()
    {
        return this.myLogger.isErrorEnabled();
    }

    @Override
    public boolean isErrorEnabled(final Marker arg0)
    {
        return this.myLogger.isErrorEnabled(arg0);
    }

    @Override
    public boolean isInfoEnabled()
    {
        return this.myLogger.isInfoEnabled();
    }

    @Override
    public boolean isInfoEnabled(final Marker arg0)
    {
        return this.myLogger.isInfoEnabled(arg0);
    }

    @Override
    public boolean isTraceEnabled()
    {
        return this.myLogger.isTraceEnabled();
    }

    @Override
    public boolean isTraceEnabled(final Marker arg0)
    {
        return this.myLogger.isTraceEnabled();
    }

    @Override
    public boolean isWarnEnabled()
    {
        return this.myLogger.isWarnEnabled();
    }

    @Override
    public boolean isWarnEnabled(final Marker arg0)
    {
        return this.myLogger.isWarnEnabled(arg0);
    }

    @Override
    public void trace(final String arg0)
    {
        this.initWriter();
        this.myLogger.trace(arg0);
        this.close(this.writer);
    }

    @Override
    public void trace(final String arg0, final Object arg1)
    {
        this.initWriter();
        this.myLogger.trace(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void trace(final String arg0, final Object[] arg1)
    {
        this.initWriter();
        this.myLogger.trace(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void trace(final String arg0, final Throwable arg1)
    {
        this.initWriter();
        this.myLogger.trace(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void trace(final Marker arg0, final String arg1)
    {
        this.initWriter();
        this.myLogger.trace(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void trace(final String arg0, final Object arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.trace(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void trace(final Marker arg0, final String arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.trace(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void trace(final Marker arg0, final String arg1, final Object[] arg2)
    {
        this.initWriter();
        this.myLogger.trace(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void trace(final Marker arg0, final String arg1, final Throwable arg2)
    {
        this.initWriter();
        this.myLogger.trace(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void trace(final Marker arg0, final String arg1, final Object arg2, final Object arg3)
    {
        this.initWriter();
        this.myLogger.trace(arg0, arg1, arg2, arg3);
        this.close(this.writer);
    }

    @Override
    public void warn(final String arg0)
    {
        this.initWriter();
        this.myLogger.warn(arg0);
        this.close(this.writer);
    }

    @Override
    public void warn(final String arg0, final Object arg1)
    {
        this.initWriter();
        this.myLogger.warn(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void warn(final String arg0, final Object[] arg1)
    {
        this.initWriter();
        this.myLogger.warn(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void warn(final String arg0, final Throwable arg1)
    {
        this.initWriter();
        this.myLogger.warn(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void warn(final Marker arg0, final String arg1)
    {
        this.initWriter();
        this.myLogger.warn(arg0, arg1);
        this.close(this.writer);
    }

    @Override
    public void warn(final String arg0, final Object arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.warn(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void warn(final Marker arg0, final String arg1, final Object arg2)
    {
        this.initWriter();
        this.myLogger.warn(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void warn(final Marker arg0, final String arg1, final Object[] arg2)
    {
        this.initWriter();
        this.myLogger.warn(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void warn(final Marker arg0, final String arg1, final Throwable arg2)
    {
        this.initWriter();
        this.myLogger.warn(arg0, arg1, arg2);
        this.close(this.writer);
    }

    @Override
    public void warn(final Marker arg0, final String arg1, final Object arg2, final Object arg3)
    {
        this.initWriter();
        this.myLogger.warn(arg0, arg1, arg2, arg3);
        this.close(this.writer);
    }

    public void close(final Writer writer)
    {
        if (this.mLogToFiles)
        {
            synchronized (this)
            {
                ResourceManager.close(writer);
            }
        }
    }
}

grüsse, jan