Was ist eine gute Logging-Bibliothek für Echtzeitsysteme (schnell ohne Objekterstellung)?

Question

Ich versuchte Logback, aber es schuf eine Tonne Müll. Hat jemand von einem guten für Java in Echtzeit gehört?

---

@Bernie: Ich habe eine Schleife hat 1M Cache gespeicherten Nachrichten Protokollierung und der GC wurde verrückt.

Answer 1

Sie können einen Blick auf CoralLog von Coral Blocks entworfen (mit denen ich angegliedert), die Null Müll produziert und hat eine durchschnittliche Latenz von 53 Nanosekunden beim Protokollieren einer 64-Byte-Nachricht. In Bezug auf den Durchsatz kann es protokollieren 2,6 Millionen 64-Byte-Nachrichten pro Sekunde mit Zeitstempeln und 3,5 Millionen 64-Byte-Nachrichten pro Sekunde ohne Zeitstempel. Die vollständigen Benchmark-Ergebnisse sind zu sehen here.

Wenn Sie die Nachrichtengröße auf 16 Byte reduzieren, können Sie 5,2 Millionen Nachrichten pro Sekunde ohne Zeitstempel protokollieren.

Es folgt ein einfaches Durchsatztest:

package com.coralblocks.corallog.bench; 

import java.io.File; 
import java.nio.ByteBuffer; 

import com.coralblocks.corallog.AsyncThread; 
import com.coralblocks.corallog.Log; 
import com.coralblocks.corallog.Logger; 

public class PerformanceTest4 { 

    public static void main(String[] args) throws Exception { 

     int batchSize = Integer.parseInt(args[0]); 
     int passes = Integer.parseInt(args[1]); 
     int msgSize = Integer.parseInt(args[2]); 

     byte[] msgBytes = new byte[msgSize]; 

     // build a dummy message: 
     for(int i = 0; i < msgBytes.length; i++) { 
      msgBytes[i] = (byte) String.valueOf(i % 10).charAt(0); 
     } 

     ByteBuffer bb = ByteBuffer.wrap(msgBytes); 

     Log.setIncludeTopHeader(false); 

     String dir = "."; 
     String filename = "throughput.log"; 

     Logger logger; 
     boolean isMmap = System.getProperty("logMemoryMappedFile", "true").equals("true"); 

     if (isMmap) { 
      logger = Log.createMemoryMappedLogger(dir, filename, null /* no timestamps */, false /* not synchronized */, true /* asynchronous */); 
     } else { 
      logger = Log.createLogger(dir, filename, null, false, true); 
     } 

     int count = 0; 

     while(count < passes) { 

      long start = System.nanoTime(); 

      for(int i = 0; i < batchSize; i++) { 
      bb.position(0); 
      logger.log(bb); 
      } 

      long time = System.nanoTime() - start; 

      double seconds = (((double) time)/1000000000L); 

      System.out.println("Batch " + (count + 1) + " took: " + seconds + " s"); 

      count++; 
     } 

     logger.drainCloseAndWait(); 

     boolean deleteFile = System.getProperty("deleteFile", "true").equals("true"); 

     if (deleteFile) { 
      File f = new File(dir, filename); 
      f.delete(); 
     } 

     AsyncThread.drainAndDie(); // just so the vm will exit... (async thread is not daemon) 
    } 
} 

Answer 2

Ich habe eine Bibliothek, die Text oder Binärdaten in weniger als einer Mikrosekunde protokollieren kann, ohne Müll oder sogar einen Systemaufruf zu erzeugen.

https://github.com/peter-lawrey/Java-Chronicle

Das Protokoll kann auch durch eine beliebige Anzahl von Leseprozessen in Echtzeit gelesen werden, können Sie eine persistente Warteschlange geben, die mehr als 5 Millionen Nachrichten pro Sekunde verarbeiten kann.

Answer 3

Versuchen Sie, die log4j-Systeme: http://logging.apache.org/log4j/1.2/

Answer 4

Javolution Protokollierungsfunktionen zur Verfügung stellt.

Vom LogContext javadoc:

Der gleiche Code kann unter Verwendung des Systems aus/err, Standardprotokollierung (java.util.logging), Log4J oder sogar OSGI Log-Dienste ausführen. Die Auswahl kann zur Laufzeit über configuration erfolgen.

('configuration' bezieht sich auf eine Javolution-Klasse).