¿Cómo suele etiquetar las entradas del registro? (androide)

Supongo que la mayoría de ustedes conocen android.util.Log Todos los métodos de registro aceptan 'Etiqueta de cadena' como primer argumento.

Y mi pregunta es ¿Cómo suele etiquetar sus registros en sus aplicaciones? He visto un código duro como este:

public class MyActivity extends Activity {
    private static final String TAG = "MyActivity";
    //...
    public void method () {
        //...
        Log.d(TAG, "Some logging");
    }
}

Esto no se ve bien por muchas razones:

• Puede decirme que este código no tiene hardcode, pero lo tiene.
• Mi aplicación podría tener cualquier cantidad de clases en diferentes paquetes con el mismo nombre. Por lo que sería difícil leer el registro.
• No es flexible. Siempre ha puesto un TAG de campo privado en su clase.

¿Existe alguna forma sencilla de obtener un TAG para una clase?

Yo uso un TAG, pero lo inicializo así:

private static final String TAG = MyActivity.class.getName();

De esta manera, cuando refactorice mi código, la etiqueta también cambiará en consecuencia.

Normalmente creo una Appclase que se encuentra en un paquete diferente y contiene métodos estáticos útiles. Uno de los métodos es un getTag()método, de esta manera puedo obtener el TAG en todas partes.
Appla clase se ve así:

EDITAR : Mejorado por comentario br mob (Gracias :))

public class App {

    public static String getTag() {
        String tag = "";
        final StackTraceElement[] ste = Thread.currentThread().getStackTrace();
        for (int i = 0; i < ste.length; i++) {
            if (ste[i].getMethodName().equals("getTag")) {
                tag = "("+ste[i + 1].getFileName() + ":" + ste[i + 1].getLineNumber()+")";
            }
        }
        return tag;
    }

}

Y cuando quiero usarlo:

Log.i(App.getTag(), "Your message here");

La salida del getTagmétodo es el nombre de la clase que llama (con el nombre del paquete) y el número de línea desde donde getTagse llama, para facilitar la depuración.

Vaya a Android Studio -> preferencia -> Plantillas en vivo -> AndroidLog y luego seleccione Log.d (TAG, String) .

En texto de plantilla, reemplazar

android.util.Log.d(TAG, "$METHOD_NAME$: $content$");

con

android.util.Log.d("$className$", "$METHOD_NAME$: $content$");

Luego haga clic en Editar variables e ingrese className () en la columna Expresión junto a la columna className Name .

Ahora, cuando escriba el atajo logd, pondrá

Log.d("CurrentClassName", "currentMethodName: ");

Ya no es necesario definir un TAG.

Me gusta mejorar la respuesta de Yaniv si tiene el registro en este formato (nombre de archivo.java:XX) xx número de línea, puede vincular el acceso directo de la misma manera que se vincula cuando hay un error, de esta manera puedo ir directamente a la línea en cuestión con solo hacer clic en el logcat

Pongo esto dentro de mi aplicación extendida para poder usarlo en todos los demás archivos

public static String getTag() {
    String tag = "";
    final StackTraceElement[] ste = Thread.currentThread().getStackTrace();
    for (int i = 0; i < ste.length; i++) {
        if (ste[i].getMethodName().equals("getTag")) {
            tag = "("+ste[i + 1].getFileName() + ":" + ste[i + 1].getLineNumber()+")";
        }
    }
    return tag;
}

Captura de pantalla:

AndroidStudio tiene una logtplantilla por defecto (puede escribir logty presionar tabulador para que se expanda a un solo código). Recomiendo usar esto para evitar copiar y pegar la definición de TAG de otra clase y olvidar cambiar la clase a la que se refiere. La plantilla se expande de forma predeterminada a

private static final String TAG = "$CLASS_NAME$"

Para evitar usar el nombre de la clase anterior después de la refactorización, puede cambiarlo a

private static final String TAG = $CLASS_NAME$.class.getSimpleName();

Recuerde marcar el botón "Editar variables" y asegurarse de que la CLASS_NAMEvariable esté definida para usar la className()expresión y tenga marcada la opción "Omitir si está definida".

He creado una clase de variables, métodos y clases estáticas con el nombre S.

El siguiente es el método de registro:

public static void L(Context ctx, Object s) {
    Log.d("CCC " + ctx.getClass().getName().replace(ctx.getPackageName(), ""), s.toString());
}

Se llama de ninguna clase como S.L(this, whaterver_object);El getClass().getName()también añade el nombre del paquete, por lo tanto, yo estoy quitando a cabo para evitar que la etiqueta innecesariamente largo.

Ventajas:

1. Más corto que Log.d(TAG,
2. No es necesario convertir valores int a su cadena. De hecho, no es necesario escribirtoString
3. No me olvidaré de eliminarlo, Log.dya que solo tengo que eliminar el método y las ubicaciones de todos los registros se marcan en rojo.
4. No es necesario definir TAG en la parte superior de la actividad, ya que toma el nombre de la clase.
5. La ETIQUETA tiene un prefijo de CCC(una cadena corta y fácil de escribir) para que sea fácil enumerar solo sus registros en el monitor de Android en Android Studio. A veces está ejecutando servicios u otras clases simultáneamente. Si tiene que buscar solo por el nombre de la actividad, entonces no puede ver exactamente cuándo se obtuvo una respuesta de servicio y luego se produjo una acción de su actividad. Un prefijo como CCC ayuda, ya que le brinda registros cronológicamente con la actividad en la que ocurrió.

Puede utilizar this.toString()para obtener un identificador único para la clase específica en la que imprime en el registro.

A expensas de actualizar estas cadenas cuando muevo código entre métodos o renombro métodos, me gusta hacer lo siguiente. Filosóficamente, también parece ser mejor mantener "ubicación" o "contexto" en la etiqueta, no en el mensaje.

public class MyClass {

    // note this is ALWAYS private...subclasses should define their own
    private static final LOG_TAG = MyClass.class.getName();

    public void f() {
        Log.i(LOG_TAG + ".f", "Merry Christmas!");
    }

}

El beneficio aquí es que puede filtrar un solo método incluso si el contenido no es estático, por ejemplo

Log.i(LOG_TAG + ".f", String.valueOf(new Random().nextInt()));

El único inconveniente es que cuando cambio el nombre f()ag() necesito tener en cuenta esa cadena. Además, la refactorización automática de IDE no los detectará.

Durante un tiempo fui fanático de usar el nombre corto de la clase, quiero decir LOG_TAG = MyClass.class.getSimpleName(). Los encontré más difíciles de filtrar en los registros porque había menos para continuar.

Es una pregunta muy antigua, pero incluso pensando en una respuesta actualizada para julio de 2018, es más preferible usar Timber. Para registrar el registro correcto, se pueden enviar errores y advertencias a bibliotecas de fallas de terceros, como Firebase o Crashlytics.

En la clase que implementa Application debes agregar esto:

@Override
public void onCreate() {
    super.onCreate();
    if (BuildConfig.DEBUG) {
        Timber.plant(new Timber.DebugTree());
    } else {
        Timber.plant(new CrashReportingTree());
    }
}

/** A tree which logs important information for crash reporting. */
private static class CrashReportingTree extends Timber.Tree {
    @Override protected void log(int priority, String tag, String message, Throwable t) {
        if (priority == Log.VERBOSE || priority == Log.DEBUG) {
            return;
        }

        FakeCrashLibrary.log(priority, tag, message);

        if (t != null) {
            if (priority == Log.ERROR) {
                FakeCrashLibrary.logError(t);
            } else if (priority == Log.WARN) {
                FakeCrashLibrary.logWarning(t);
            }
        }
    }
}

No olvide la dependencia de la madera.

implementation 'com.jakewharton.timber:timber:4.7.1'

Para aquellos usuarios que visitan esta pregunta:

private val TAG:String = this.javaClass.simpleName;

utilizan Timber para la aplicación IOsched 2019 para mostrar información de depuración:

implementation 'com.jakewharton.timber:timber:4.7.1'

class ApplicationController: Application() {

override fun onCreate() {  
    super.onCreate()
    if(BuildConfig.DEBUG){
        Timber.plant(Timber.DebugTree())
    }
}   
// enables logs for every activity and service of the application
// needs to be registered in manifest like:  
 <application
    android:label="@string/app_name"
    android:name=".ApplicationController"
    ... >

uso

  Timber.e("Error Message") 
  // will print ->  D/MainActivity: Error Message

  Timber.d("Debug Message");
  Timber.tag("new tag").e("error message");

tenga en cuenta que esto hace que los registros estén disponibles solo durante el estado DEBUG y le facilita la tarea de eliminarlos manualmente para el lanzamiento en Google Play -

cuando lancemos la aplicación en Play Store, debemos eliminar todas las declaraciones de registro de la aplicación, de modo que ninguno de los datos de la aplicación, como la información del usuario, los datos ocultos de la aplicación, los tokens de autenticación estén disponibles para el usuario en logcat como texto sin formato

consulte este artículo https://medium.com/mindorks/better-logging-in-android-using-timber-72e40cc2293d

Normalmente uso el nombre del método como etiqueta pero de Thread

String TAG = Thread.currentThread().getStackTrace()[1].getMethodName();

Esto evita la nueva excepción.

private static final String TAG = new RuntimeException().getStackTrace()[0].getClassName();