Mini curso de Log4j - Segunda parte Paso 3: Personalizando los mensajes
Veremos un ejemplo más avanzado para ilustrar estos conceptos. Modifiquemos el archivo .properties para que tenga el siguiente contenido:
log4j.rootLogger=debug, stdout, R
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log
log4j.appender.R.Append=false
log4j.appender.R.MaxFileSize=100KB
log4j.appender.R.MaxBackupIndex=1
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n
Destallaremos cada línea de esta configuración:
log4j.rootLogger=debug, stdout, R Aquí estamos definiendo que nuestro Logger serán stdout y R. Ambos serán para atender el nivel debug.
log4j.appender.stdout=org.apache.log4j.ConsoleAppender En esta línea el appender stdout será de tipo ConsoleAppender. Esta clase se encargará de mostrar los mensajes a la pantalla.
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout La clase “PatternLayout” nos permite configurar nuestro appender por una cadena. En el API del framework podemos ver más detalle de estas clases.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n Aquí ya estamos definiendo nuestro formato el cual consiste en mostrar en un espacio de 5 caracteres (%5) el nivel del mensaje (p). Luego sigue de un espacio. Entre llaves mostrará el hilo que generó el mensaje (%t). Luego de un espacio, entre paréntesis el nombre del archivo fuente (%F) y después de dos puntos muestra la línea dentro del código fuente (%L). Después sigue un guión y luego muestra el mensaje que se ha mandado desde el programa. Finaliza con un salto de línea. Tenemos otro appender que es el R. Este es de clase RollingFileAppender. Esta clase permite agregar a un archivo y si este llega a un límite especificado es renombrado y el registro seguirá en un archivo nuevo. Esto es muy útil si queremos mantener todos los registros de eventos partidos en archivos de un tamaño manejable.
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log
log4j.appender.R.Append=false
Aquí estamos diciendo que el archivo que creará será “example.log”y que sobreescriba los mensajes cada vez que se ejecute la aplicación.
log4j.appender.R.MaxFileSize=100KB Que tendrá un tamaño máximo de 100KB
log4j.appender.R.MaxBackupIndex=2 Y cuantos backups deberá crear antes de que el más antiguo deba borrarse.
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n
Aquí estamos definiendo el formato de salida que tendrá: la prioridad del evento (%p) seguido del nombre del thread que generó el evento (%t), el nombre completo de la clase incluyendo el paquete (%c) seguido de un guión y luego mensaje. Termina con una línea nueva. Por último, agregaremos estas líneas a la configuración para enviar un email cuando suceda un error.
log4j.rootLogger=debug, stdout, R,email
....
log4j.appender.email.Threshold=error
log4j.appender.email=org.apache.log4j.net.SMTPAppender
log4j.appender.email.SMTPHost=smtp.provider.com
[email protected]
[email protected]
log4j.appender.email.Subject=Mensaje de Log4j!
log4j.appender.email.layout=org.apache.log4j.PatternLayout
log4j.appender.email.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n
Para que este funcione deberemos de agregar la biblioteca de JavaMail.
Conclusiones
Cómo hemos visto, el cambio de la manera de registrar los eventos fue solo en el archivo .properties y no en nuestro programa. Muchas aplicaciones hechas en java que utilizamos – como el Tomcat – utilizan este framework de registro de mensajes. Puedes personalizar sus mensajes de acuerdo a tus exigencias.
www.asociacionaepi.es
Mini curso de Log4j - Primera parte Quién no ha utilizado System.out.println() para saber qué está haciendo en ese momento el programa, a veces ponemos mensajes mostrando el valor que tiene una variable, un array, etc. El problema sucede cuando el programa tiene que estar en producción y estos mensajes pueden resultar incómodos. Se torna una tarea tediosa buscar estas instrucciones para “comentarlas”. Y si hay error después ¿dónde está? ¡voy a tener que editar y recompilar el código para ver lo que pasa!. Afortunadamente programadores como nosotros han tenido el mismo problema y han desarrollado un framework que permite administrar estos mensajes – en inglés el término utilizado es logging – de tal manera que nuestros programas no tengan que pasar por el quirófano cada vez que esté “enfermo”. Este framework es Log4j. Log4j permite registrar eventos de nuestro programa sin necesidad de modificar el código a cada instante. Estos eventos (o logs) pueden ser mostrados en pantalla, guardados en un archivo, enviados por correo electrónico, etc. Por ejemplo, cuando nuestra aplicación web se levantó correctamente deseamos que se guarde en un log la hora y fecha con un mensaje “SUCCESS”, pero cuando nuestra misma aplicación que atiende a más quinientos mil usuarios al día tenga un error crítico queremos que nos avise por correo electrónico a nuestro celular. Todo esto puede ser posible gracias a Log4j.
Desarrollaremos un ejemplo y a medida que lo hagamos iremos explicando cada parte del Log4j. Paso 1: Obteniendo, instalando y configurando
Naturalmente para poder utilizar Log4j debemos obtenerlo de algún lado. Este framework se encuentra enhttp://logging.apache.org/. Descomprimimos su contenido en un directorio. Al descomprimir se habrá creado un subdirectorio con un nombre como logging-log4j-1.2.12. Este subdirectorio tiene otros subdirectorios que incluye la documentación, ejemplos, el código fuente y las bibliotecas necesarias. Dentro del subdirectorio “dist/lib” hay un archivo .jar que no pesa más de 400KB. Este es un nuestro framework que usaremos en nuestros programas. Para usarlo recomiendo crear una biblioteca en nuestro IDE para así poderlo reutilizar en otros proyectos. Solo bastaría con agregar a nuestra biblioteca el archivo .jar del framework. Recordemos que al crear un proyecto con nuestro IDE favorito, este crea una estructura de directorios especial. Generalmente crea el directorio src donde estarán todos los .java, un directorio class para nuestras .class, y un directorio build donde está la aplicación lista para ejecutar. Esto varía dependiendo de nuestro IDE. Paso 2: Construyendo nuestro ejemplo.
Crearemos la clase demolog4j.Main (es decir, la clase Main dentro del paquete demolog4j) package demolog4j; import org.apache.log4j.Logger;
public class Main { static final Logger log = Logger.getLogger(Main.class); public static void main(String[] args) { log.info("iniciando aplicación"); for (int i = 10; i >= ; i--) { try { double n = 100 / i * 1.0; log.debug("el valor de n=" + n); } catch (Exception ex) { log.error(ex); } } } }
Es un ejemplo bastante forzado para mostrar tres de los cinco niveles de mensajes: info, debug y error. El nivel más detallado es el debug, que nos será de mucha utilidad al momento de depuración. Esto sirve, por ejemplo, para mostrar el nuevo valor de una variable. No debería estar activado cuando se encuentre el producción.
El siguiente nivel es info. Este nivel es para informarnos de cosas que ya se hizo algo concreto, tal como haberse conectado a la base de datos, el inicio satisfactorio de un servlet o un thread, etc. Es similar al modo “verbose” de las aplicaciones. El siguiente nivel es el warn. Este es para advertir de eventos que no necesariamente pueda ser un error. Por ejemplo el que no haya definido un archivo de configuración pero se puede cargar valores por omisión, El nivel error está relacionado para informar errores. Y un nivel mucho más crítico es el fatal. Este es para informar de eventos que no tienen solución. Por ejemplo cuando una aplicación está a punto de cerrarse a causa de un error. Para que nuestro ejemplo funcione crearemos un archivo llamado log4j.properties que debe estar en la raíz de los código fuente. Es decir, en el directorio src de nuestro proyecto. Debe encontrarse aquí ya que cada vez que el IDE construya el proyecto se copiará al directorio junto con las .classes. El archivo log4j.properties deberá tener el siguiente contenido: log4j.rootLogger=DEBUG, A1 log4j.appender.A1=org.apache.log4j.ConsoleAppender log4j.appender.A1.layout=org.apache.log4j.PatternLayout log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
Y ejecutamos el programa. Lo que mostrará es algo similar a esto: 0 15 15 15 15 15 15 15 15 15 15 15
[main] [main] [main] [main] [main] [main] [main] [main] [main] [main] [main] [main]
INFO DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG ERROR
demolog4j.Main demolog4j.Main demolog4j.Main demolog4j.Main demolog4j.Main demolog4j.Main demolog4j.Main demolog4j.Main demolog4j.Main demolog4j.Main demolog4j.Main demolog4j.Main
-
iniciando aplicación el valor de n=10.0 el valor de n=11.0 el valor de n=12.0 el valor de n=14.0 el valor de n=16.0 el valor de n=20.0 el valor de n=25.0 el valor de n=33.0 el valor de n=50.0 el valor de n=100.0 java.lang.ArithmeticException:
Puedes editar la primera línea del log4.properties cambiando el texto “debug” por alguno de los demás niveles: info, warn, error o fatal para ver los resultados.
Estructura de Log4j.
Log4j tiene tres componentes principales: tres tipos de componentes trabajan juntos registrar mensajes según el tipo y nivel de ejecución para mostrarlos de acuerdo a
loggers, appenders y layouts. Estos para permitir a los desarrolladores de estos, y controlarlos en tiempo un formato que le especifiquemos.
Loggers
La principal ventaja del Log4j comparado con el tradicional System.out.println() es su capacidad para habilitar o deshabilitar los registradores de mensajes sin afectar a los demás. Un registrador de mensajes (Logger) son entidades autónomas con configuración independiente, de tal manera que uno tenga cierta funcionalidad que otro no lo tenga. Los nombres de los loggers son sensibles a mayúsculas. Appenders
La habilidad para activar o desactivar cualquier logger es solo una parte de Log4j. El framework permite registrar los eventos en varios destinos. Para Log4j una salida (pantalla, archivo, etc) es un appender. Actualmente, existe appenders para consola (como hemos visto), archivos, componentes visuales, servidores de sockets, JMS, Registro de Eventos de NT, y demonios de registro Unix. Layouts
El layout es el responsable de formatear los mensajes de acuerdo a criterio del programador. Existen dos tipos de Layout: SimpleLayout, que básicamente muestra el nivel del mensaje y el mensaje en sí, y el PatternLayout que consiste en formatear la salida. Muchas gracias a los que nos habéis leído y a los que no también, en breve continuaremos con la siguiente parte. www.asociacionaepi.es
Cómo obtener el elemento activo de un formulario con JavaScript
Para obtener el elemento activo de un formulario en Internet Explorer lo podemos hacer fácilmente con la propiedad activeElement, pero en navegadores Mozilla, como Firefox, no existe esta propiedad, aunque eso no quiere decir que no podamos hacerlo. Podemos averiguar qué elemento está activo recorriendo los elementos del formulario y asignándoles una función en el evento onfocus y onblur que nos permitirá averiguar qué elemento está activo.
var activeElement; function blurFunc() { activeElement = null; /* Cuando el elemento deja de estar activo el elemento activo pasa a ser nulo (null) */ } function focusFunc(evento) { if(!evento) { // Para IE evento = window.event; activeElement = evento.srcElement; /* Cuando un elemento se activa (focus) lo indicamos */ } else { // Para otros navegadores
activeElement = evento.target; } alert(activeElement.name); // Lo utilizaremos para hacer la prueba } function init() { for (var i = 0; i < document.forms.length; i++) { for(var j = 0; j < document.forms[i].elements.length; j++) { document.forms[i].elements[j].onfocus = focusFunc; document.forms[i].elements[j].onblur = blurFunc; } } } window.onload = init;
El código que acabamos de ver, lo pondremos entre y . Luego, para probarlo, utilizaremos este formulario entre y Nombre: Apellidos:
Cuando probemos este formulario, tanto con IE como con Firefox, al pulsar sobre un campo del formulario nos aparecerá una ventana con el nombre del elemento activo.
Cómo usar adecuadamente el Log de Android en tus aplicaciones
Buenos días desde la Asociación Española de Programadores Informáticos os traemos un nuevo post sobre Android. Es posible que durante el desarrollo de una aplicación Android, surja la duda de qué nivel de Log se debe usar, qué cosas se deben loggear y cuales no. En la documentación de Android se trata este tema, el cual traduzco para ponerlo a disposición de todos. Aunque el logging es necesario, tiene un impacto negativo significante en el rendimiento y pierde rápidamente su utilidad si no se mantiene razonablemente breve. La herramienta de logging de Android proporciona cinco niveles distintos para el log. A continuación se describe cada uno y se explica brevemente cómo y cuando deberían usarse: ERROR: Este nivel de logging debe usarse cuando haya ocurrido algo fatal, por ejemplo, algo que tendrá consecuencias visibles para el usuario y que no se podrá recuperar sin eliminar explícitamente algunos datos, desinstalar aplicaciones, borrando las particiones de datos o reseteando el dispositivo por completo. Este nivel se loggea siempre. Los problemas que jusifiquen mostrar un log con este nivel son típicamente buenos candidatos para ser recolectados por un servidor de recopilación de estadísticas (statistics-gathering server). WARNING: Este nivel de logging debe usarse cuando haya pasado algo serio e inesperado, por ejemplo, algo que tendrá consecuencias visibles para el usuario pero es probable que pueda recuperarse sin implicar la pérdida de datos realizando alguna acción explícita, oscilando entre esperar o reiniciar la aplicación por completo descargándola para reinstalarla, o reiniciar el dispositivo. Este nivel se loggea siempre. Igual que el nivel anterior, los problemas que impliquen registrar un WARNING son candidatos a ser reportados a un statistics-gathering server. INFORMATIVE:Este nivel de logging debe usarse para indicar que ha pasado algo que puede resultar interesante a la mayoría de la gente, por ejemplo, cuando se detecta una situación que probablemente tenga un amplio impacto, aunque no es necesariamente un error. Esta condición debe ser loggeada sólo por un módulo que sea el considerado más apropiado en ese dominio (Para evitar registrar más de una vez el evento por componentes no autoritativos). Este nivel se loggea siempre. DEBUG: Este nivel de log debe usarse para dar a conocer qué eventos están ocurriendo en el dispositivo que puedan ser relevantes para investigar y depurar comportamientos de la aplicación inesperados. Se debe loggear únicamente lo necesario para obtener la información suficiente sobre qué está pasando. Si los mensajes de log de en este nivel inundan el log, es
probable que deban usarse en el nivel VERBOSE. Este nivel será loggeado, incluso en las versiones definitivas de la aplicación. Es necesario que estén en un bloque condicional del tipo if(LOCAL_LOG) o if(LOCAL_LOGD). Donde LOCAL_LOG[D] se define en una clase o sub-componente, para que exista la posibilidad de desactivar todos los mensajes de log en este nivel, por tanto, dentro de éstos bloques no puede haber ninguna lógica del programa, solo los mensajes de log. VERBOSE: Este nivel de logging debe usarse para cualquier otra cosa. Solo se mostrará en las aplicaciones destinadas a depuración y debe estar dentro de un bloque if(LOCAL_LOGV) para permitir su desactivación.
www.asociacionaepi.es
Instalación del entorno de desarrollo y primer proyecto en Android
En Internet encontraremos muchos tutoriales dedicados a este tema, pero la mayoría tiene un problema: se han quedado obsoletos. Con el paso del tiempo, Google ha ido haciendo cambios en las herramientas para desarrollar Android. No siempre han sido del agrado de los usuarios porque se veían obligados a cambiar su forma de trabajar, o incluso se encontraban con que los manuales y las guías que usaban dejaban de estar al día. Afortunadamente, el proceso de instalación del entorno de desarrollo de Android es más fácil que nunca, y aquí lo vamos a ver en detalle. Partiremos del supuesto de no tener nada instalado, y nuestro objetivo es desarrollar nuestra
primera aplicación en Android, el famoso Hola Mundo. Descarga del SDK En este enlace descargaremos en un solo paso todo el entorno de desarrollo. El paquete incluye casi todo lo que necesitaremos: Eclipse + plugin ADT Las tools del Android SDK Las herramientas de plataforma Android La plataforma Android más reciente Emuladores más recientes Si estás más familiarizado con Android, puedes descargarte solamente el SDK. La web te mostrará un único enlace en función de tu sistema operativo, pero también puedes descargar las otras versiones. Existen para Windows de 32 y 64 bits, Linux de 32 y 64 bits, y Mac. En caso de duda, ve directamente a la descarga sugerida, Mac para este ejemplo: Instalación Para las 3 plataformas tendremos que tomar nota del directorio donde se instala el SDK, lo necesitaremos más adelante. Mac Descargaremos un zip que se descomprimirá en una carpeta con un nombre del tipo adt-bundle-mac-x86_64-xxxx . La moveremos a un directorio que conozcamos, típicamente ~/Development. Linux Funcionará de forma muy parecida a Mac, seguiremos los mismos pasos. Windows Descargaremos un .exe que nos guiará durante todo el proceso, descargando el Java JDK si es necesario. Por último arrancaremos Eclipse, y nos iremos a Preferences → Android, y pondremos la ruta al SDK que nos corresponda. Con estos sencillos pasos, ya estamos preparados para hacer nuestro primer proyecto y arrancarlo. Primer proyecto Haremos File → New → Android Application Project, y pondremos “Hola Mundo” como nombre de la aplicación. Pondremos el tema a “none”. Aceptamos todo, y cuando lleguemos a la pantalla de crear actividad, la dejaremos vacía, y continuamos hasta finalizar el asistente. Pulsaremos sobre la flecha verde en la barra de herramientas superior, y ejecutaremos nuestro proyecto como una aplicación de Android: Como aún no tenemos ningún emulador virtual (AVD) creado, tendremos un mensaje de error al que contestaremos que sí. Cuando tengamos abierto el Android Virtual Device Manager, crearemos uno nuevo de este modo: Aceptamos, continuamos, y si todo ha salido bien, tras unos instantes de carga, tendremos nuestro primer proyecto andando. www.asociacionaepi.es