java - tutorial - Cómo pasar manualmente el archivo de registro con JDK Logging

para que se usa elastic search

Question

Tengo una aplicación que usa JDK Logging con un archivo logging.properties que configura una cantidad de archivos de registro antiguos a través de java.util.logging.FileHandler.count.

En ciertos puntos de la aplicación me gustaría activar una transferencia manual del archivo de registro para iniciar un nuevo archivo de registro, por ejemplo, antes de que comience una actividad programada.

¿Es esto posible con JDK Logging?

En Log4j estoy usando lo siguiente, sin embargo, en este caso, me gustaría utilizar JDK Logging.

Logger logger = Logger.getRootLogger();
Enumeration<Object> appenders = logger.getAllAppenders();
while(appenders.hasMoreElements()) {
    Object obj = appenders.nextElement();
    if(obj instanceof RollingFileAppender) {
        ((RollingFileAppender)obj).rollOver();
    }
}

Answer 1

Tendría que escribir su propio controlador para que funcione una rotación. Algo como JBoss Log Manager funciona con el registro de JDK y simplemente reemplaza las partes del logmanger. Ya tiene algunos manejadores giratorios diferentes.

Answer 2

Puede activar una rotación creando un FileHandler desechable con un límite cero y sin agregar.

new FileHandler(pattern, 0, count, false).close();

1. Elimine y cierre su FileHandler existente
2. Crea y cierra la rotación FileHandler.
3. Crea y agrega tu FileHandler usando tu configuración predeterminada.

De lo contrario, puede recurrir al uso de la reflexión:

        Method m = FileHandler.class.getDeclaredMethod("rotate");
        m.setAccessible(true);
        if (!Level.OFF.equals(f.getLevel())) { //Assume not closed.
            m.invoke(f);
        }

Answer 3

RollingFileHandler fileHandler = new RollingFileHandler(path);
fileHandler.setFormatter( newFormatter );
fileHandler.setLevel(level);
logger.addHandler(fileHandler);



import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.logging.ErrorManager;
import java.util.logging.LogRecord;
import java.util.logging.StreamHandler;


public class RollingFileHandler extends StreamHandler {

    private static String dateFormat = "yyyy-MM-dd"; //default

    private String path = null;

 // Standard-Log-Puffer (vergrößert sich on Demand)
    static ByteArrayOutputStream bas = new ByteArrayOutputStream(1024*200*25);  

    /**
     * Constructor.
     */
    public RollingFileHandler() {
        super();
        setOutputStream(bas);
        // Write old data in Multithread-Environment
        flush();
    }

    public RollingFileHandler(String path) {
        this.path = path;
    }

    /**
     * Overwrites super.
     */
    public synchronized void publish(LogRecord record) {
        if (!isLoggable(record)) {
            return;
        }
        super.publish(record);
    }


    @Override
    public synchronized void flush() {

        // Puffer ist leer
        if (bas.size() == 0) {
            return;
        }

        super.flush();

        File file = null;

        try {

            String dateString = null;

            SimpleDateFormat sdf = new SimpleDateFormat(dateFormat, Locale.getDefault());
            dateString = sdf.format(new Date());
            String fileName = "dummyFile_" + dateString + ".log";

            try {

                // Auf den Servern mapping, bei lokalem Test am Arbeitsplatz brauche ich kein Logfile-Mapping

                boolean windows = System.getProperty("os.name").toLowerCase().indexOf("win") >= 0 ;

                if (!windows 
                        && path != null) {

                    File unixLogDir = new File(path);

                    if (unixLogDir.exists()) {

                        // Versuchen in das neue Directory zu speichern
                        File logfile = new File (path + "/" + fileName);
                        if (!logfile.exists()) {
                            logfile.createNewFile();
                        }
                        file = logfile;
                    }
                } 

            } catch(Exception e) {
                e.printStackTrace();
            }


            if (file == null) {

                // Fallback - Umzug hat nicht geklappt
                file = new File(fileName);
                if (!file.exists()) {
                    file.createNewFile();
                }
            }

            FileOutputStream fos = new FileOutputStream(file,true);
                bas.flush();    
                bas.writeTo(fos);
                bas.reset();
            fos.close();


    } catch (Exception fnfe) {
        reportError(null, fnfe, ErrorManager.GENERIC_FAILURE);
        fnfe.printStackTrace(System.err);
        setOutputStream(System.out); //fallback stream
        try {
            bas.writeTo(System.out);
        } catch (IOException e) {
            // Da kann man nichts machen
        }

    }

}

}