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 >= 0; 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    [main] INFO  demolog4j.Main  - iniciando aplicación
15 [main] DEBUG demolog4j.Main - el valor de n=10.0
15 [main] DEBUG demolog4j.Main - el valor de n=11.0
15 [main] DEBUG demolog4j.Main - el valor de n=12.0
15 [main] DEBUG demolog4j.Main - el valor de n=14.0
15 [main] DEBUG demolog4j.Main - el valor de n=16.0
15 [main] DEBUG demolog4j.Main - el valor de n=20.0
15 [main] DEBUG demolog4j.Main - el valor de n=25.0
15 [main] DEBUG demolog4j.Main - el valor de n=33.0
15 [main] DEBUG demolog4j.Main - el valor de n=50.0
15 [main] DEBUG demolog4j.Main - el valor de n=100.0
15 [main] ERROR demolog4j.Main - 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: loggers, appenders y layouts. Estos tres tipos de componentes trabajan juntos para permitir a los desarrolladores registrar mensajes según el tipo y nivel de estos, y controlarlos en tiempo de ejecución para mostrarlos de acuerdo a 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.

<script type=”text/javascript”>
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;
</script>

El código que acabamos de ver, lo pondremos entre <head> y </head>. Luego, para probarlo, utilizaremos este formulario entre <body> y </body>
<form name=”HolaMundo” action=””>
Nombre: <input type=”text” name=”nombre”>
Apellidos: <input type=”text” name=”apellidos”>
<input type=”button” name=”activo” value=”Enviar”>
</form>

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

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



Servicio de traducción automática en SharePoint 2013

Una nueva aplicación de servicio que trae consigo SharePoint 2013 es la de traducción automática. En este post vamos a ver un ejemplo de uso, partimos de la base de que ya la tenemos configurada y lista para usar.
¿Cómo funciona? 
Microsoft nos proporciona un servicio de traducción automática alojado en la nube, este servicio es el que realmente realizará la traducción. Por lo tanto la aplicación de servicio simplemente lo que hace es reenviar esta petición de traducción al servicio de traducciones de Microsoft.
NOTA: El servidor donde se ejecutan las traducciones automáticas debe ser capaz de conectarse a internet.
Tendremos 2 tipos de traducción automática:

  • Síncrona: Se procesan en cuanto se envían.
  • Asíncrona: El proceso es realizado por un Timer Job llamado “SharePoint Translation Services” que está puesto a 15 minutos por defecto.


¿Qué vamos a poder traducir?
Con esta aplicación de servicios vamos a ser capaces de traducir archivos y sitios.
¿Cómo lo vamos a utilizar?
Para hacer uso del servicio de traducción automática de SharePoint 2013 podremos utilizar Modelo de Objetos de Servidor, Modelo de Objetos de Cliente y API REST.
¿Un ejemplo?
Para comprobar que la traducción funciona, voy a poner todo el contenido de este mismo post en un archivo de Microsoft Word y haremos que el servicio traduzca este contenido al inglés.
Por lo tanto para realizar esta comprobación, crearemos una aplicación de consola y realizaremos la traducción de forma síncrona.
El código que aparece a continuación coge el documento llamado “Traducción.docx”, lo traduce y lo pone en otra biblioteca que he utilizado para guardar las traducciones realizadas. El archivo traducido se llamará  “TraduccionIngles.docx”
SPServiceContext spContext = SPServiceContext.GetContext(spSite);
SyncTranslator timerJobTranslate = new SyncTranslator(spContext, CultureInfo.GetCultureInfo(1033));
timerJobTranslate.OutputSaveBehavior = SaveBehavior.AlwaysOverwrite;
timerJobTranslate.Translate(“http://xxxxxxx/Documents/Traduccion.docx” , “http://xxxxxxx/DocumentsTranslate/TraduccionIngles.docx”);

Como podéis ver, la forma síncrona usa la clase SyncTranslator, pasándole el contexto y la cultura nos bastaría para realizar la traducción instantánea, en cambio la forma asíncrona utilizaría la clase TranslationJob.
Con este simple bloque de código ya podríamos realizar una traducción del documento de español a inglés.
Por último solo nos queda ver el resultado de la traducción.
Inicialmente el documento tenía este aspecto
traduccionEspañol
y el resultado final después de la traducción es este
traduccionIngles
fuente: solidq




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