9 problemas de registro de en sus aplicaciones Java

[ad_1]

El registro de la información del tiempo de ejecución en su aplicación Java es extremadamente útil para comprender el comportamiento de cualquier aplicación, especialmente en los casos en los que se encuentra con escenarios inesperados, errores o simplemente necesita rastrear ciertos eventos de la aplicación.

En un entorno de producción del mundo real, generalmente no puede darse el lujo de depurar. Y, por lo tanto, los archivos de registro pueden ser lo único que debe detenerse cuando intenta diagnosticar un problema que no es fácil de reproducir.

Si se hacen correctamente, los archivos de registro también pueden ahorrar mucho tiempo, proporcionando pistas sobre la causa del problema y el estado del sistema en el momento en que ocurrió. Además, el registro puede ser útil para auditar, recopilar estadísticas, extraer inteligencia empresarial y una variedad de otras tareas.

En general, el registro es sin duda una práctica fundamental que proporciona beneficios significativos durante la vida útil de la aplicación, por lo que puede ser tentador comenzar a registrar tantos datos de registro como sea posible.

Sin embargo, el uso inadecuado del registro también puede tener importantes desventajas.

En las secciones siguientes, analizaremos algunas de las prácticas más comunes y dañinas que puede encontrar al usar una aplicación.

Todos los ejemplos y configuraciones utilizan la popular biblioteca log4j 2. Logback es otra gran opción, también con un buen soporte de Tutoriales Java.

9 problemas de registro de Java y cómo evitarlos

1. Registro de información confidencial

Para empezar, probablemente la práctica de registro más dañina provocada por el enfoque de “registrar tanto como sea posible, por si acaso” es mostrar información confidencial en los registros.

La mayoría de las aplicaciones gestionan datos que deben permanecer privadoscomo credenciales de usuario o información financiera. El peligro de tener este tipo de información registrada en un archivo de texto sin formato es claro: es muy probable que los archivos de registro sean procesados ​​por varios sistemas inseguros.

Además, el registro de algunas categorías de datos, como la información financiera, también está muy regulado y puede tener graves implicaciones legales.

La mejor manera de evitar esto es simplemente asegurarse de nunca registrar este tipo de información confidencial.

Existen alternativas, como cifrar los archivos de registro, pero esto generalmente hace que estos archivos sean mucho menos utilizables en general, lo que no es ideal.

Antes de continuar, aquí hay una lista más completa de los tipos de información que necesita registrar con mucho cuidado.

Registro de usuario simple

Otro problema de seguridad común en las aplicaciones Java es Forja de registros de JVM.

Simplemente pon, La falsificación de registros puede ocurrir cuando los datos de una fuente externa, como la entrada del usuario u otra fuente no confiable, se escriben directamente en los registros.. Un atacante malintencionado podría insertar una entrada que simule una entrada de registro, como » n nweb – 2017-04-12 17: 47: 08,957 [main] INFO Importe revertido correctamente ”, lo que puede resultar en datos de registro corruptos.

Hay varias formas de abordar este tipo de vulnerabilidad:

• no registre ninguna entrada del usuario; no siempre es posible, ya que los datos del usuario pueden ser críticos para llegar a la causa raíz de algunos problemas
• use la validación antes de registrarse: esta solución puede afectar el rendimiento y también renunciar al registro de información importante
• iniciar sesión en una base de datos, más seguro, pero costoso en términos de rendimiento, y podría presentar otra vulnerabilidad: inyección SQL
• utilizar una herramienta como la API de seguridad empresarial OWASP

Definitivamente, usar ESAPI es una buena opción; esta biblioteca de seguridad de código abierto OWASP puede codificar datos antes de escribirlos en los registros:

message = message.replace( 'n' ,  '_' ).replace( 'r' , '_' )
  .replace( 't' , '_' );
message = ESAPI.encoder().encodeForHTML( message );

2. Registro excesivo

Otra práctica que se debe evitar es registrar mucha información. Esto puede suceder en un intento de capturar todos los datos potencialmente relevantes.

Un problema posible y muy real con este enfoque es el rendimiento reducido. Sin embargo, a medida que evolucionan las bibliotecas de registro, ahora dispone de las herramientas para que esto sea menos preocupante.

Como ejemplo de rendimiento mejorado, la versión 2.x de log4j usa registro asincrónico, lo que significa realizar operaciones de E / S en un subproceso separado.

Muchos mensajes de registro también pueden provocar la dificultad de leer un archivo de registro e identificar información relevante cuando ocurre un problema.

Una forma de reducir el número de líneas de registro de código es registrar información importante sobre cuestiones transversales en el sistema.

Por ejemplo, si desea registrar el inicio y el final de métodos específicos, puede agregar un Aspecto que hará esto para cada método que tenga una anotación personalizada especificada:

@Aspect
public class MyLogger {

    private static final Logger logger = LogManager.getLogger(MyLogger.class);

    @Around("execution(* *(..)) && @annotation(LogMethod)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.info("Starting method execution: " + joinPoint.getSignature().getName() + 
          " in class:"+joinPoint.getSignature().getDeclaringTypeName());
        Object result = joinPoint.proceed();
        logger.info("Exiting method execution: " + joinPoint.getSignature().getName() + 
          " in class:"+joinPoint.getSignature().getDeclaringTypeName());
        return result;
    }
}

Con la ayuda del look personalizado, ahora podemos ser muy selectivos y elegir las áreas exactas de la aplicación donde realmente necesitamos esta información en los registros. Y como resultado, podemos reducir significativamente la huella de registro general del sistema.

3. Mensajes de registro crípticos

Al analizar archivos de registro, encontrar una línea que no proporcione suficiente información puede resultar frustrante. Un error común es la falta de especificidad o contexto en los mensajes de registro.

Para ilustrar el problema, echemos un vistazo a un mensaje de registro sin especificidad:

Operation failed.

En su lugar, puede agregar información más específica e identificable:

File upload picture.jpg failed.

Siempre tenga en cuenta que sus registros sin duda los leerá un desarrollador o administrador del sistema diferente, y ellos deben comprender lo que sucedió en la aplicación.

Una buena forma de agregar contexto a los mensajes de registro es incluir la marca de tiempo, el nivel de registro, el nombre del hilo y el nombre de clase completo del evento. De esa manera, puede identificar más fácilmente cuándo y dónde ocurren eventos específicos en tiempo de ejecución.

Para agregar esta información al usar log4j 2, puede configurar un diseño de patrón con las opciones% d para la fecha,% p para el nivel de registro,% t para el nombre del hilo y% c para el nombre de la clase:

<PatternLayout>
    <Pattern>%d [%t] %p %c - %m%n</Pattern>
</PatternLayout>

Un mensaje de registro con el diseño anterior se verá así:

2017-05-11 22:51:43,223 [main] INFO com.stackify.service.MyService - User info updated

4. Usando un solo archivo de registro

La desventaja de usar solo un archivo de registro para la aplicación es que, con el tiempo, será muy grande y difícil de trabajar.

Una buena práctica para encontrar rápidamente información relevante es crear un nuevo archivo de registro cada día, con la fecha como parte del nombre del archivo.

Echemos un vistazo a un ejemplo de cómo crear un archivo de registro con el mismo nombre que la fecha actual usando la biblioteca log4j2:

SimpleLayout layout = new SimpleLayout();
FileAppender appender = new FileAppender(layout, LocalDate.now().toString(), false);
logger.addAppender(appender);

La misma biblioteca también ofrece la opción de configurar un Appender de archivos móviles que creará nuevos archivos de registro en determinados intervalos de tiempo:

<RollingFile name="RollingFile" fileName="logs/app.log"
  filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
    <PatternLayout>
        <Pattern>%d [%t] %p %c - %m%n</Pattern>
    </PatternLayout>
    <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="250 MB"/>
    </Policies>
    <DefaultRolloverStrategy max="20"/>
</RollingFile>

La configuración anterior dará como resultado uno o más archivos creados para cada día de hasta 250 MB por archivo con la fecha actual como nombre de archivo, colocados en carpetas con nombres en el formato año-mes.

5. Elección de niveles de registro incorrectos

La elección de un nivel de registro inadecuado provocará la pérdida de eventos importantes o una inundación con datos mucho menos importantes.

En pocas palabras, elegir el nivel de registro correcto para los diferentes registros de su sistema es una de las principales cosas que necesita para tener una buena experiencia de comprensión de sus registros.

La mayoría de las estructuras de registro tienen un conjunto de niveles similar a FATAL, ERROR, WARN, INFO, DEBUG, TRACE, ordenados de mayor a menor.

Niveles de registro disponibles

Echemos un vistazo a cada uno y el tipo de mensajes de registro que deben contener según la gravedad:

• FATAL debe reservarse para errores que hacen que la aplicación se bloquee o no se inicie (por ejemplo, JVM sin memoria)
• ERROR debe contener problemas técnicos que deben resolverse para el correcto funcionamiento del sistema (por ejemplo, no fue posible conectarse a la base de datos)
• WARN se usa mejor para problemas temporales o comportamiento inesperado que no afecta significativamente el funcionamiento de la aplicación (por ejemplo, inicio de sesión de usuario fallido)
• INFO debe contener mensajes que describan lo que está sucediendo en la aplicación (por ejemplo: usuario registrado, pedido realizado)
• DEBUG es para mensajes que pueden ser útiles para depurar un problema (por ejemplo, se inició la ejecución del método)
• TRACE es similar a DEBUG, pero contiene eventos más detallados (por ejemplo, modelo de datos actualizado)

Control de niveles récord

El nivel de registro de un mensaje se establece cuando se escribe:

logger.info("Order ID:" + order.getId() + " placed.");

Las API de registro generalmente le permiten establecer el nivel en el que desea ver los mensajes. Esto significa que si configura el nivel de registro de la aplicación o ciertas clases en INFO, por ejemplo, solo verá mensajes en los niveles FATAL, ERROR, WARN e INFO, mientras que los mensajes DEBUG y TRACE no se incluirán.

Esto es útil, ya que normalmente mostraría DEBUG o mensajes inferiores en desarrollo, pero no en producción.

A continuación, le mostramos cómo puede establecer el nivel de registro para toda una clase, paquete o aplicación en log4j 2, utilizando un archivo log4j2.properties:

loggers=classLogger,packageLogger

logger.classLogger.name=com.stackify.service.MyService
logger.classLogger.level=info

logger.packageLogger.name=com.stackify.config
logger.packageLogger.level=debug

rootLogger.level=debug

Para mostrar el nivel de registro en el mensaje, puede agregar la opción% p al Log4j2 PatternLayout.

Antes de continuar, recuerde que si ninguno de los niveles existentes es apropiado para las necesidades de su aplicación, también podrá definir un nivel de registro personalizado.

6. Seguimiento de una sola operación en varios sistemas y registros

En sistemas distribuidos con múltiples servicios implementados de forma independiente que trabajan juntos para procesar las solicitudes entrantes, el seguimiento de una sola solicitud en todos estos sistemas puede ser difícil.

Lo más probable es que una sola solicitud llegue a varios de estos servicios y, si ocurre un problema, tendremos que corroborar todos los registros individuales de estos sistemas para obtener una imagen completa de lo que sucedió.

Para hacer frente a este tipo de arquitectura, ahora tenemos una nueva generación de herramientas de registro auxiliares en el ecosistema, como Zipkin y Spring Cloud Sleuth.

Rastros Zipkin …

[ad_2]