118 votes

Android - Définir la longueur maximale des messages logcat

Par défaut, il semble que logcat tronque toute message de journal qu'il juge "trop long". Ce qui se passe à l'intérieur de l'Éclipse et lors de l'exécution de logcat sur la ligne de commande à l'aide de adb -d logcat, et est de tronquer certains des plus importants messages de débogage.

Est-il possible d'augmenter la longueur maximale de la chaîne pris en charge par le logcat pour obtenir l'arrêt de tronquer les informations de débogage? La documentation officielle implique qu'il y a peut-être pas, mais peut-être logcat prend en charge des options supplémentaires non mentionnés-il?

95voto

Travis Points 1664

Ok, c'est intéressant. J'ai été déçu de voir que la réponse a été "on ne peut pas vraiment le développer". Ma première pensée était pour casser vers le haut de sorte que je pouvais voir toute chose, donc ici je partage avec vous comment je le faire (non pas que c'est quelque chose de compliqué, ni est-il près efficace, mais il fait le travail dans un pincement):

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());
}

Modifiée pour afficher la dernière chaîne!

53voto

b0ti Points 897

Il y a une taille fixe de la mémoire tampon dans le logcat pour les journaux (/dev/log/events), et cette limite est de 1024 octets. Pour les non-binaire journaux il y a aussi une limite:

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

Donc le vrai message de la taille à la fois binaire et non-binaire journaux ~4076 octets. Le noyau enregistreur interface impose cette LOGGER_ENTRY_MAX_PAYLOAD limite.

Le liblog sources (utilisé par le logcat) dit aussi:

  • Le message peut avoir été tronqué par le noyau du journal pilote.

Je vous recommande la nxlog outil qui n'utilise pas le logcat binaire, mais en raison des limitations dans le noyau, je doute qu'il permettra de résoudre votre problème. Néanmoins, il peut être vaut la peine d'essayer. (disclaimer: je suis l'auteur.)

12voto

user2085092 Points 61
for( String line : logMesg.split("\n") ) {
    Log.d( TAG, line );
}

5voto

enl8enmentnow Points 243

Voici le code que j'utilise-il tronque les lignes à la limite de 4000 tout en brisant la ligne à de nouvelles lignes plutôt que dans le milieu de la ligne. Rend plus facile à lire fichier journal.

Utilisation:

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

Mise en œuvre:

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;
    }
}

2voto

neeraj t Points 1309

nous cette logique de pagination

    /*
     * 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));
            }
        }
    }

}

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X