Android – Imposta la lunghezza massima dei messaggi di logcat

Per impostazione predefinita, sembra che il logcat tronca qualsiasi messaggio di log che considera "troppo lungo". Ciò accade sia all'interno di Eclipse che quando esegue il logcat sulla row di command usando adb -d logcat e tronca alcuni importnti messaggi di debug.

C'è un modo per aumentare la lunghezza massima della string supportta da logcat per farlo smettere di troncare le informazioni di debug? La documentazione ufficiale implica che non ci può essere, ma forse logcat support alcune opzioni aggiuntive non menzionate?

  • ClassCastException: java.lang.Object non può essere lanciato in java.lang.String android
  • Registri Android 'GC_EXTERNAL_ALLOC' 'GC_FOR_MALLOC'
  • Leak di memory di Android, sospetto di EMA: "byte " caricato da "<system class loader>"
  • Eccezione di cast di class quando si passa da Serializables da un'attività all'altra
  • CookieSyncManager è ora obsoleto, cosa posso usare invece?
  • i cambiamenti di progettazione predefiniti di selezione del android di numero nel fagiolo della gelatina e nel sandwich del gelato
  • 9 Solutions collect form web for “Android – Imposta la lunghezza massima dei messaggi di logcat”

    Esiste un buffer di size fisse in logcat per i log binari ( /dev/log/events ) e questo limite è di 1024 byte. Per i registri non binari esiste anche un limite:

     #define LOGGER_ENTRY_MAX_LEN (4*1024) #define LOGGER_ENTRY_MAX_PAYLOAD (LOGGER_ENTRY_MAX_LEN - sizeof(struct logger_entry)) 

    Quindi la dimensione reale del messaggio per i registri binari e non binari è ~ 4076 byte. L'interface logger del kernel impone questo limite LOGGER_ENTRY_MAX_PAYLOAD .

    Le fonti di liblog (usate da logcat) dicono anche:

    • Il messaggio potrebbe essere stato troncato dal driver del registro del kernel.

    Ti consiglio lo strumento nxlog che non utilizza il binario logcat, ma a causa delle limitazioni nel kernel dubito che risolverà il tuo problema. Tuttavia, potrebbe valere la pena di provare. (disclaimer: io sono l'autore.)

    Ok, interessante. Sono rimasto deluso di vedere che la risposta era "non si può davvero espandere". Il mio pensiero iniziale era quello di rompere in modo da poter vedere tutta la cosa, quindi qui condivido con te come faccio proprio questo (non che è qualcosa di elegante e non è vicino efficiente, ma ottiene il lavoro fatto in un pizzico):

     if (sb.length() > 4000) { Log.v(TAG, "sb.length = " + sb.length()); int chunkCount = sb.length() / 4000; // integer division for (int i = 0; i <= chunkCount; i++) { int max = 4000 * (i + 1); if (max >= sb.length()) { Log.v(TAG, "chunk " + i + " of " + chunkCount + ":" + sb.substring(4000 * i)); } else { Log.v(TAG, "chunk " + i + " of " + chunkCount + ":" + sb.substring(4000 * i, max)); } } } else { Log.v(TAG, sb.toString()); } 

    Modificato per mostrare l'ultima string!

    Ripartire in parecchi pezzi ricorsivamente.

     public static void largeLog(String tag, String content) { if (content.length() > 4000) { Log.d(tag, content.substring(0, 4000)); largeLog(tag, content.substring(4000)); } else { Log.d(tag, content); } } 
     for( String line : logMesg.split("\n") ) { Log.d( TAG, line ); } 

    Ecco il codice che uso – tronca le righe al limite 4000, mentre rompe la linea in nuove righe piuttosto che nei media della linea. Consente un file di registro più facile da leggere.

    Uso:

     Logger.debugEntire("...."); 

    Implementazione:

     package ...; import android.util.Log; import java.util.Arrays; public class Logger { private static final String LOG_TAG = "MyRockingApp"; /** @see <a href="http://stackoverflow.com/a/8899735" /> */ private static final int ENTRY_MAX_LEN = 4000; /** * @param args If the last argument is an exception than it prints out the stack trace, and there should be no {} * or %s placeholder for it. */ public static void d(String message, Object... args) { log(Log.DEBUG, false, message, args); } /** * Display the entire message, showing multiple lines if there are over 4000 characters rather than truncating it. */ public static void debugEntire(String message, Object... args) { log(Log.DEBUG, true, message, args); } public static void i(String message, Object... args) { log(Log.INFO, false, message, args); } public static void w(String message, Object... args) { log(Log.WARN, false, message, args); } public static void e(String message, Object... args) { log(Log.ERROR, false, message, args); } private static void log(int priority, boolean ignoreLimit, String message, Object... args) { String print; if (args != null && args.length > 0 && args[args.length-1] instanceof Throwable) { Object[] truncated = Arrays.copyOf(args, args.length -1); Throwable ex = (Throwable) args[args.length-1]; print = formatMessage(message, truncated) + '\n' + android.util.Log.getStackTraceString(ex); } else { print = formatMessage(message, args); } if (ignoreLimit) { while (!print.isEmpty()) { int lastNewLine = print.lastIndexOf('\n', ENTRY_MAX_LEN); int nextEnd = lastNewLine != -1 ? lastNewLine : Math.min(ENTRY_MAX_LEN, print.length()); String next = print.substring(0, nextEnd /*exclusive*/); android.util.Log.println(priority, LOG_TAG, next); if (lastNewLine != -1) { // Don't print out the \n twice. print = print.substring(nextEnd+1); } else { print = print.substring(nextEnd); } } } else { android.util.Log.println(priority, LOG_TAG, print); } } private static String formatMessage(String message, Object... args) { String formatted; try { /* * {} is used by SLF4J so keep it compatible with that as it's easy to forget to use %s when you are * switching back and forth between server and client code. */ formatted = String.format(message.replaceAll("\\{\\}", "%s"), args); } catch (Exception ex) { formatted = message + Arrays.toString(args); } return formatted; } } 

    noi questa logica di paging

      /* * StringBuffer sb - long text which want to show in multiple lines * int lenth - lenth of line need */ public static void showInPage(StringBuffer sb, int lenth) { System.out.println("sb.length = " + sb.length()); if (sb.length() > lenth) { int chunkCount = sb.length() / lenth; // integer division if ((chunkCount % lenth) > 1) chunkCount++; for (int i = 0; i < chunkCount; i++) { int max = lenth * (i + 1); if (max >= sb.length()) { System.out.println(""); System.out.println("chunk " + i + " of " + chunkCount + ":" + sb.substring(lenth * i)); } else { System.out.println(""); System.out.println("chunk " + i + " of " + chunkCount + ":" + sb.substring(lenth * i, max)); } } } } 

    fornendo la mia propria presa sulla soluzione di Travis,

     void d(String msg) { println(Log.DEBUG, msg); } private void println(int priority, String msg) { int l = msg.length(); int c = Log.println(priority, TAG, msg); if (c < l) { return c + println(priority, TAG, msg.substring(c+1)); } else { return c; } } 

    approfittare del fatto che Log.println() restituisce il numero di byte scritti per evitare il codificamento "4000". poi, ricorsivamente chiamatevi da parte del messaggio che non poteva essere registrato finché non c'è niente di più.

    Se il tuo registro è molto lungo (ad esempio, la logging di un integer dischetto del database per motivi di debug ecc.), Può accadere che il logcat impedisca la logging eccessiva. Per aggirare questo è ansible aggiungere un timeout evry x millisecondi.

     /** * Used for very long messages, splits it into equal chunks and logs each individual to * work around the logcat max message length. Will log with {@link Log#d(String, String)}. * * @param tag used in for logcat * @param message long message to log */ public static void longLogDebug(final String tag, @NonNull String message) { int i = 0; final int maxLogLength = 1000; while (message.length() > maxLogLength) { Log.d(tag, message.substring(0, maxLogLength)); message = message.substring(maxLogLength); i++; if (i % 100 == 0) { StrictMode.noteSlowCall("wait to flush logcat"); SystemClock.sleep(32); } } Log.d(tag, message); } 

    Attenzione, usa questo solo per scopi di debug come potrebbe bloccare i thread di blocchi principali.

    Non so alcuna opzione per aumentare la lunghezza di logcat, ma possiamo trovare i diversi log come il log principale, il registro degli events ecc. Il registro principale contiene di solito tutto ciò che la sua lunghezza va fino a 4Mb .. Quindi puoi get quello che hai perso nel terminal di log. Il path è: \ data \ logger.

    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.