android - hacer - logcat ionic

Android: establece la duración máxima de los mensajes de Logcat

Question

De forma predeterminada, parece que Logcat truncará cualquier mensaje de registro que considere "demasiado largo". Esto sucede tanto dentro de Eclipse como cuando se ejecuta logcat en la línea de comandos usando adb -d logcat , y está truncando algunos mensajes de depuración importantes.

¿Hay alguna manera de aumentar la longitud máxima de cadena soportada por logcat para que deje de truncar la información de depuración? La documentación oficial implica que puede que no exista, pero tal vez logcat soporte algunas opciones adicionales que no se mencionan allí.

Answer 1

Aquí está el código que uso: trunca las líneas en el límite de 4000 mientras también divide la línea en nuevas líneas en lugar de en los medios de la línea. Hace un archivo de registro más fácil de leer.

Uso:

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

Implementación:

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

Answer 2

Divídelo en varios pedazos recursivamente.

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

Answer 3

El siguiente código es un refinamiento de lo publicado por Mark Buikema. Rompe la cuerda en nuevas líneas. Útil para el registro de cadenas largas 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);
}
}

Answer 4

Hay un búfer de tamaño fijo en Logcat para registros binarios ( /dev/log/events ) y este límite es de 1024 bytes. Para los registros no binarios también hay un límite:

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

Entonces, el tamaño del mensaje real para los registros binarios y no binarios es ~ 4076 bytes. La interfaz del registrador kernel impone este límite LOGGER_ENTRY_MAX_PAYLOAD .

Las fuentes de liblog (utilizadas por logcat) también dicen:

• El mensaje puede haber sido truncado por el controlador de registro del kernel.

Le recomendaría la herramienta nxlog que no utiliza el binario de logcat, pero debido a las limitaciones del kernel, dudo que resuelva su problema. Sin embargo, podría valer la pena intentarlo. (descargo de responsabilidad: soy el autor)

Answer 5

No conozco ninguna opción para aumentar la longitud del logcat, pero podemos encontrar los diferentes registros como el registro principal, el registro de eventos, etc. El registro principal generalmente contiene todo lo que su longitud puede llegar a 4Mb. Así que es posible que pueda obtener lo que perdió en la terminal de registro. La ruta es: / data / logger.

Answer 6

Ok, interesante. Me decepcionó ver que la respuesta era "realmente no se puede expandir". Lo primero que pensé fue dividirlo para poder verlo todo, así que aquí les comparto cómo lo hago (no es que sea nada sofisticado ni eficiente, pero hace el trabajo en un apuro):

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

¡Editado para mostrar la última cadena!

Answer 7

Si su registro es muy largo (por ejemplo, registrando el volcado completo de su base de datos por razones de depuración, etc.), es posible que logcat evite el registro excesivo. Para solucionar esto, puede agregar un tiempo de espera evry x milisegundos.

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

Tenga cuidado, solo use esto para eliminar fallas, ya que puede detener el hilo principal de los bloques.

Answer 8

nosotros esta lógica de paginación

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

Answer 9

proporcionando mi propia opinión sobre la solución de 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;
}
}

aproveche el hecho de que Log.println() devuelve el número de bytes escritos para evitar la codificación rígida "4000". luego, de forma recursiva, invoca la parte del mensaje que no se pudo registrar hasta que no quede nada.

Answer 10

for( String line : logMesg.split("/n") ) {
Log.d( TAG, line );
}