Android - установите максимальную длину сообщений logcat

По умолчанию создается впечатление, что logcat обрезает любое сообщение журнала, которое считает «слишком длинным». Это происходит как внутри Eclipse, так и при запуске logcat в командной строке с помощью adb -d logcatи усечения некоторых важных отладочных сообщений.

Есть ли способ увеличить максимальную длину строки, поддерживаемую logcat, чтобы он прекратил усекать отладочную информацию? Официальная документация подразумевает , что не может быть, но , возможно , LogCat поддерживают некоторые дополнительные опции там не упоминаются?

В logcat есть буфер фиксированного размера для двоичных журналов ( /dev/log/events), и этот предел составляет 1024 байта. Для недвоичных журналов также существует ограничение:

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

Таким образом, реальный размер сообщения для двоичных и недвоичных журналов составляет ~ 4076 байт. Этот LOGGER_ENTRY_MAX_PAYLOADпредел накладывает интерфейс регистратора ядра .

Источники liblog (используемые logcat) также говорят:

• Сообщение могло быть усечено драйвером журнала ядра.

Я бы порекомендовал вам инструмент nxlog , который не использует двоичный файл logcat, но из-за ограничений ядра я сомневаюсь, что он решит вашу проблему. Тем не менее, попробовать стоит. (отказ от ответственности: я автор.)

Хорошо, интересно. Я был разочарован, увидев, что ответ был «вы не можете его расширить». Моя первоначальная мысль заключалась в том, чтобы разбить его, чтобы я мог видеть все это, поэтому здесь я поделюсь с вами, как я это делаю (не то чтобы это было что-то необычное и почти неэффективное, но оно выполняет свою работу в крайнем случае):

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

Отредактировано, чтобы показать последнюю строку!

Рекурсивно разбейте его на несколько частей.

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

Вот код, который я использую - он обрезает строки на пределе 4000, а также разбивает строку на новых строках, а не в середине строки. Облегчает чтение файла журнала.

Использование:

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

Реализация:

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

Приведенный ниже код является уточнением того, что было опубликовано Марком Буйкема. Он разбивает строку на новые строки. Полезно для записи длинных строк JSON.

  public static void dLong(String theMsg)
  {
    final int MAX_INDEX = 4000;
    final int MIN_INDEX = 3000;

    // String to be logged is longer than the max...
    if (theMsg.length() > MAX_INDEX)
    {
      String theSubstring = theMsg.substring(0, MAX_INDEX);
      int    theIndex = MAX_INDEX;

      // Try to find a substring break at a line end.
      theIndex = theSubstring.lastIndexOf('\n');
      if (theIndex >= MIN_INDEX)
      {
        theSubstring = theSubstring.substring(0, theIndex);
      }
      else
      {
        theIndex = MAX_INDEX;
      }

      // Log the substring.
      Log.d(APP_LOG_TAG, theSubstring);

      // Recursively log the remainder.
      dLong(theMsg.substring(theIndex));
    }

    // String to be logged is shorter than the max...
    else
    {
      Log.d(APP_LOG_TAG, theMsg);
    }
  }

int i = 3000;
while (sb.length() > i) {
    Log.e(TAG, "Substring: "+ sb.substring(0, i));
    sb = sb.substring(i);
}
Log.e(TAG, "Substring: "+ sb);

нам эта логика пейджинга

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

}

предлагая свой собственный взгляд на решение Трэвиса,

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

Воспользуйтесь тем, что Log.println()возвращает количество записанных байтов, чтобы избежать жесткого кодирования «4000». затем рекурсивно назовите себя частью сообщения, которое невозможно зарегистрировать, пока ничего не останется.

Если ваш журнал очень длинный (например, ведется полный дамп вашей базы данных для отладки и т. Д.), Может случиться так, что logcat предотвратит чрезмерное ведение журнала. Чтобы обойти это, вы можете добавить таймаут каждые x миллисекунд.

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

Остерегайтесь, используйте это только для целей отладки, так как это может остановить основной поток.

Как упоминал @mhsmith, LOGGER_ENTRY_MAX_PAYLOADв последних версиях Android это 4068. Однако, если вы используете 4068 в качестве максимальной длины сообщения во фрагментах кода, предлагаемых в других ответах, сообщения будут усечены. Это связано с тем, что Android добавляет больше символов в начало и конец сообщения, что также учитывается. В других ответах в качестве обходного пути используется предел 4000. Однако с помощью этого кода можно действительно использовать весь лимит (код генерирует тег из трассировки стека, чтобы показать имя класса и номер строки, которая вызвала журнал, не стесняйтесь изменять это):

private static final int MAX_MESSAGE_LENGTH = 4068;

private enum LogType {
    debug,
    info,
    warning,
    error
}

private static void logMessage(LogType logType, @Nullable String message, @Nullable String tag) {
    logMessage(logType, message, tag, Thread.currentThread().getStackTrace()[4]);
}

private static void logMessage(LogType logType, @Nullable String message, @Nullable String customTag, StackTraceElement stackTraceElement) {
    // don't use expensive String.format
    String tag = "DASHBOARDS(" + stackTraceElement.getFileName() + "." + (!TextUtils.isEmpty(customTag) ? customTag : stackTraceElement.getMethodName()) + ":" + stackTraceElement.getLineNumber() + ")";
    int maxMessageLength = MAX_MESSAGE_LENGTH - (tag.length()) - 4; // minus four because android adds a letter showing the log type before the tag, e. g. "D/" for debug, and a colon and space are added behind it, i. e. ": "
    if (message == null || message.length() <= maxMessageLength) {
        logMessageInternal(logType, message, tag);
    } else {
        maxMessageLength -= 8; // we will add counter to the beginning of the message, e. g. "(12/15) "
        int totalChunks = (int) Math.ceil((float) message.length() / maxMessageLength);
        for (int i = 1; i <= totalChunks; i++) {
            int start = (i - 1) * maxMessageLength;
            logMessageInternal(logType, "(" + i + "/" + totalChunks + ") " + message.substring(start, Math.min(start + maxMessageLength, message.length())), tag);
        }
    }
}

private static void logMessageInternal(LogType logType, String message, String tag) {
    if (message == null) {
        message = "message is null";
    }
    switch (logType) {
        case debug:
            Log.d(tag, message);
            break;
        case info:
            Log.i(tag, message);
            break;
        case warning:
            Log.w(tag, message);
            break;
        case error:
            Log.e(tag, message);
    }
}

public static void d(String debug, String tag) {
    logMessage(LogType.debug, debug, tag);
}

Я не знаю какой-либо опции для увеличения длины logcat, но мы можем найти различные журналы, такие как основной журнал, журнал событий и т. Д. Основной журнал обычно содержит все, что его длина достигает 4 Мб .. Так что вы можете получить то, что потеряли в терминале журнала. Путь: \ data \ logger.

Хотя другие предоставленные решения были полезны, они меня не удовлетворили, потому что они не охватывали случаи, когда журнал длиннее, чем в два раза длиннее, чем LOGGER_ENTRY_MAX_LEN, упомянутый @ b0ti. Более того, даже мое следующее решение не идеально, поскольку LOGGER_ENTRY_MAX_LEN не извлекается динамически. Если кто-то знает, как это сделать, я хотел бы услышать об этом в комментариях! Во всяком случае, это решение, которое я использую в своем коде прямо сейчас:

final int loggerEntryMaxLength = 4000;
int logLength = loggerEntryMaxLength - 2 - TAG.length();
int i = 0;
while (output.length() / logLength > i) {
    int startIndex = i++ * logLength;
    int endIndex = i * logLength;
    Log.d(TAG, output.substring(startIndex, endIndex));
}
int startIndex = i * logLength;
Log.d(
        TAG,
        output.substring(
                startIndex,
                startIndex + (output.length() % logLength)
        )
);