CHSAM_LogServicesToolkit 2.0.0

LogServicesToolkit 2.0.0

Entre los cambios que trae esta nueva version se encuentran los siguientes:

1. Versiones normalizadas de escritura "AdAsJson", como su nombre lo indica permiten escribir en formato JSON la informacion de la excepcion. Estas contienen mayor detalle como fragmentos parciales del stacktrace y el numero de linea.
2. Tamaño maximo por archivo, se permite configurar un tamaño en mb, al sobrepasar dicho tamaño se comenzara la escritura en un nuevo archivo.
3. Se permite clasificar los mensajes escritos a log dependiendo su nivel de criticidad.
4. Nueva funcionalidad de escritura al log con reintentos (LogAsync) para evitar perdida de informacion de errores en situaciones asincronas .

Uso sugerido

Se sugiere para proyectos tipo NetFramework utilizar una clase estatica que configure y proporcione acceso a los metodos de la libreria.

A continuacion se muestra un ejemplo de codigo para dicha clase que lista todos los metodos disponibles:

LogManager.cs

    /// <summary>
    /// Clase estatica para exponer metodos de logeo.
    /// </summary>
    public static class LogManager
    {

        /// <summary>
        /// Clase auxiliar para accesar a los metodos del servicio de logs
        /// </summary>
        /// <returns></returns>
        private static LogServiceBase LogServiceInstance()
        {
            LogServiceBase _logService = new LogServiceBase()
            {
                Path = Properties.Settings.Default.LogManager_FolderPath,
                Level = Properties.Settings.Default.LogManager_Level,
                LogAllLevels = Properties.Settings.Default.LogManager_LogAllLevels,
                MaxFileSizeMB = Properties.Settings.Default.LogManager_MaxFileSizeMB,
                MaxRetries = Properties.Settings.Default.LogManager_MaxFileSizeMB,
                DelayBetweenRetries = Properties.Settings.Default.LogManager_MaxFileSizeMB,
            };
            return _logService;
        }

        /// <summary>
        /// Crea una entrada de log con el mensaje proporcionado
        /// </summary>
        /// <param name="sLog"></param>
        public static void Add(string sLog) => LogServiceInstance().Add(sLog);

        /// <summary>
        /// Crea una entrada de log con informacion relevante sobre la excepcion proporcionada
        /// </summary>
        /// <param name="ex"></param>
        public static void Add(Exception ex) => LogServiceInstance().Add(ex);

        /// <summary>
        /// Crea una entrada de log con informacion relevante sobre la excepcion proporcionada
        /// </summary>
        /// <param name="ex"></param>
        public static void AddAsJson(string sLog, LogLevel logLevel = LogLevel.Information) => LogServiceInstance().AddAsJson(sLog, logLevel);

        /// <summary>
        /// Crea una entrada de log con informacion relevante sobre la excepcion proporcionada
        /// </summary>
        /// <param name="ex"></param>
        public static void AddAsJson(Exception ex) => LogServiceInstance().AddAsJson(ex);

        /// <summary>
        /// Expone el metodo con el mismo nombre de LogServicesToolkit
        /// Crea una entrada totalmente personalizada de log
        /// </summary>
        /// <param name="ex"></param>
        public static void AddAsJson(LogEntry logEntry) => LogServiceInstance().AddAsJson(logEntry);

        /// <summary>
        /// Escribe una cadena al log al igual que la version no asincrona pero incluye logica de reintentos.
        /// </summary>
        /// <param name="sLog"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public static async Task AddAsync(string sLog) => await LogServiceInstance().AddAsync(sLog);

        /// <summary>
        /// Escribe una excepcion al log al igual que la version no asincrona pero incluye logica de reintentos.
        /// </summary>
        /// <param name="sLog"></param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public static async Task AddAsync(Exception ex) => await LogServiceInstance().AddAsync(ex);

        /// <summary>
        /// Crea una entrada de log con informacion relevante sobre la excepcion proporcionada
        /// </summary>
        /// <param name="ex"></param>
        public static async Task AddAsJsonAsync(string sLog, LogLevel logLevel = LogLevel.Information) => await LogServiceInstance().AddJsonAsync(sLog, logLevel);

        /// <summary>
        /// Crea una entrada de log con informacion relevante sobre la excepcion proporcionada
        /// </summary>
        /// <param name="ex"></param>
        public static async Task AddAsJsonAsync(Exception ex) => await LogServiceInstance().AddJsonAsync(ex);

        /// <summary>
        /// Expone el metodo con el mismo nombre de LogServicesToolkit
        /// Crea una entrada totalmente personalizada de log
        /// </summary>
        /// <param name="ex"></param>
        public static async Task AddAsJsonAsync(LogEntry logEntry) => await LogServiceInstance().AddJsonAsync(logEntry);

        /// <summary>
        /// Expone el metodo con el mismo nombre de LogServicesToolkit
        /// Permite obtener la entrada de log en formato resumido
        /// </summary>
        /// <param name="ex"></param>
        /// <returns></returns>
        public static string SimplifiedLogString(Exception ex) => LogServiceInstance().SimplifiedLogString(ex);

        /// <summary>
        /// Expone el metodo con el mismo nombre de LogServicesToolkit
        /// Valida que el modulo de logs funcione correctamente con la configuracion de directorio y permisos actuales
        /// </summary>
        /// <param name="ex"></param>
        public static void Test() => LogServiceInstance().TestLogs();
    }

Si tomamos como base la clase de arriba podemos utilizar la funcionalidad de log de esta manera:

MiClase.cs

    public class MiClase{
      public void MiMetodo(){
        LogManager.Add();
      }
    }

Ejemplos de implementacion global:

A continuacion se muestran algunos ejemplos para implementar la escritura de logs a nivel global segun el subframework .Net utilizado

- WinForms

Para el caso de WindowsForms nos apoyamos del manejador global de errores encontrado dentro del archivo program:

Program.cs

    internal static class Program
    {
        /// <summary>
        /// Punto de entrada principal para la aplicación.
        /// </summary>
        [STAThread]
        static void Main()
        {
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(ErrorHandler);
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.ThrowException);
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new MainForm());
        }

        static void ErrorHandler(object sender, UnhandledExceptionEventArgs args)
        {
            Exception e = (Exception)args.ExceptionObject;
            LogManager.AddAsJson(e);
            MessageBox.Show("Ocurrio un problema con la aplicacion. Contacte a su administrador.", "Error inesperado",MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

- WebApi

Para el caso de WebApi la opcion mas sencilla es escribir un filtro de excepcion y registrarlo en el WebApiConfig.cs

HandleExceptionFilter.cs

/// <summary>
/// Filtro de captura de excepciones no manejadas para escritura
/// en log y retorno de mensaje personalizado.
/// </summary>
public class HandleExceptionFilter : ExceptionFilterAttribute
{
    /// <summary>
    /// Metodo principal del filtro, aqui se capturan todas las excepciones no controladas.
    /// </summary>
    /// <param name="context"></param>
    public override void OnException(HttpActionExecutedContext context)
    {
        Exception exception = context.Exception;
        LogManager.AddAsJson(exception);

        string jsonResponse = JsonConvert.SerializeObject(new ResponseOutputModel<string>() { Message = "Error interno en el servidor, inténtelo nuevamente. Consulte Log.", Success = false });
        context.Response = new HttpResponseMessage(HttpStatusCode.InternalServerError)
        {
            StatusCode = HttpStatusCode.InternalServerError,
            Content = new StringContent(jsonResponse, System.Text.Encoding.UTF8, "application/json"),
            ReasonPhrase = "Internal Server Error"
        };
    }
}

WebApiConfig.cs

    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            config.Filters.Add(new HandleExceptionFilter());
            ...
        }
    }

- MVC

Si se desea implementar con el subframework MVC se utiliza el Application_Error encontrado dentro de Global.asax.cs

Global.asax.cs

    protected void Application_Error(object sender, EventArgs e)
    {
        Exception exception = Server.GetLastError();
        HttpContext context = HttpContext.Current;
        
        LogManager.AddAsJson(exception);

        Response.Clear();
        Server.ClearError();

        Response.Redirect("/Home/Error");
    }

Notas:

En caso de no proporcionar valores a los parametros de configuracion se utilizaran los siguientes valores default:

    MaxFileSizeMB  = 1;
    LogAllLevels = true;
    Path = "C:\\Log\\LogServiceBase";
    Level = "Information";
    MaxRetries = 3;
    DelayBetweenRetries = 1000;

El parametro "Level" permite configurar el nivel de criticidad de los mensajes de log, todos los mensajes que tengan la criticidad igual a la configurada o mayor seran escritos al log y el resto ignorados. A continuacion se muestran en orden los posibles valores de criticidad configurables:

• Trace
• Debug
• Information
• Warning
• Error
• Critical
• None