/// <summary>
/// Registra un mensaje con un nivel de importancia en el flujo del método actual.
/// Requiere que el inicio y el retorno del método esté logeado.
/// </summary>
/// <example>
/// public class UsuarioBO
/// {
/// private UsuarioDAO dao = new UsuarioDAO();
///
/// public void Agregar(UsuarioTO usuario)
/// {
/// log.Mensaje("Antes de llamar al DAO", Nivel.INFO);
/// dao.Agregar(usuario);
/// log.Mensaje("Luego de llamar al DAO", Nivel.INFO);
/// }
/// }
/// </example>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="mensaje">Mensaje a registrar.</param>
/// <param name="nivel">Nivel de importancia o tipo del mensaje.</param>
public void Mensaje(string mensaje, Nivel nivel)
{
Llamada++;
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = Log4MeManager.ThreadGUID,
MethodGUID = InstanciaLog.MethodGUID,
Namespace = InstanciaLog.Metodo.DeclaringType.Namespace,
Clase = InstanciaLog.Metodo.DeclaringType.Name,
Metodo = InstanciaLog.Metodo.ToString(),
Mensaje = mensaje,
Nivel = nivel,
Correlativo = Llamada,
Tipo = Tipo.Mensaje
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteNivel(nivel))
{
writer.Guardar(registro);
}
}
}
/// <summary>
/// Registra el fin de la ejecución de un método, guardando la fecha de termino, el valor de retorno y su tipo.
/// Se debe logear antes de retornar. Requiere que se haya logeado el inicio del método.
/// </summary>
/// <example>
/// public int Sumar(int valor1, int valor2)
/// {
/// log.Inicio(valor1, valor2);
/// int resultado = valor1 + valor2;
/// log.Retorno(resultado);
/// return resultado;
/// }
/// </example>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="valor">Valor de retorno del método.</param>
public void Retorno(object valor)
{
Llamada++;
string valorJson = string.Empty;
try
{
valorJson = JsonConverterFactory.ObtenerJsonConverter().ToJson(valor, true);
}
catch (Exception e)
{
valorJson = "Error al transformar a Json - " + e.Message;
}
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = Log4MeManager.ThreadGUID,
MethodGUID = InstanciaLog.MethodGUID,
Namespace = InstanciaLog.Metodo.DeclaringType.Namespace,
Clase = InstanciaLog.Metodo.DeclaringType.Name,
Metodo = InstanciaLog.Metodo.ToString(),
ValorVariable = valorJson,
Correlativo = Llamada,
Tipo = Tipo.Retorno
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Retorno))
{
writer.Guardar(registro);
}
}
}
/// <summary>
/// Carga una colección de registros (fieles al txt) mediante un filtro, a una representación de cada parte del flujo.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="retorno">Representación completa del flujo, para cargar los datos leídos.</param>
/// <param name="x">Fila inicial a leer. Luego se continúa hasta el final.</param>
/// <param name="registros">Registros fieles el archivo plano (Origen de la información).</param>
/// <param name="filtro">Filtro para excluir elementos. <value>true</value> para incluir, <value>false</value> para excluir.</param>
/// <returns>Representación completa del flujo</returns>
private MetodoTO CargarArbol(MetodoTO retorno, ref int x, IList <RegistroInLineTO> registros, Func <RegistroInLineTO, bool> filtro = null)
{
while (x < registros.Count)
{
RegistroInLineTO registro = registros[x];
if (filtro == null || (filtro != null && filtro(registro)))
{
if (registro.Tipo == "Inicio")
{
if (retorno.Nombre != null)
{
retorno.Llamadas.Add(CargarArbol(new MetodoTO(), ref x, registros));
}
else
{
retorno.Nombre = registro.Metodo;
retorno.Clase = registro.Clase;
retorno.MethodGUID = registro.MethodGUID;
retorno.Fecha = registro.Fecha;
}
}
else if (registro.Tipo == "Retorno")
{
retorno.Retorno = new RetornoTO()
{
Fecha = registro.Fecha,
Tipo = registro.TipoVariable,
Valor = registro.ValorVariable
};
return(retorno);
}
else if (registro.Tipo == "Excepcion")
{
retorno.Excepcion = new ExcepcionTO()
{
Data = registro.Data,
Mensaje = registro.Mensaje,
StackTrace = registro.StackTrace,
Tipo = registro.NombreVariable,
};
}
else if (registro.Tipo == "Parametro")
{
retorno.Parametros.Add(new ParametroTO()
{
Nombre = registro.NombreVariable,
Tipo = registro.TipoVariable,
Valor = registro.ValorVariable
});
}
}
x++;
}
return(null);
}
protected override void Agregar(RegistroInLineTO registro)
{
if (Log == null)
{
Log = LogManager.GetLogger(Type.GetType(registro.Clase));
}
Log.Debug(Formatear(registro));
}
protected override void Agregar(RegistroInLineTO registro)
{
string salida = Formatear(registro);
NivelTrace nivel = null;
TraceTypeTag tipo = null;
if (NivelesSeguimiento != null)
{
if (registro.Tipo == Tipo.Mensaje)
{
tipo = NivelesSeguimiento.FirstOrDefault(c => c.Nombre == Tipo.Mensaje && c.Nivel != null && c.Nivel == registro.Nivel);
if (tipo == null)
{
tipo = NivelesSeguimiento.FirstOrDefault(c => c.Nombre == Tipo.Mensaje && c._Nivel == "*");
}
}
if (tipo == null)
{
tipo = NivelesSeguimiento.FirstOrDefault(c => c._Nombre.Equals("*", StringComparison.InvariantCultureIgnoreCase));
}
}
if (tipo != null)
{
nivel = tipo.NivelTrace;
}
if (nivel == NivelTrace.DEBUG)
{
Trace.WriteLine(salida);
}
if (nivel == NivelTrace.INFO)
{
Trace.TraceInformation(salida);
}
if (nivel == NivelTrace.ERROR)
{
Trace.TraceError(salida);
}
if (nivel == NivelTrace.WARN)
{
Trace.TraceWarning(salida);
}
if (nivel == NivelTrace.FAIL)
{
Trace.Fail(salida);
}
}
/// <summary>
/// Persiste el registro.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 27/06/2016 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="registro">Registro unificado a ser escrito.</param>
public void Guardar(RegistroInLineTO registro)
{
if (!inicializado)
{
Inicializar();
inicializado = true;
}
if (!SaltarGuardadoFormato && !parametrosAgregados)
{
AgregarParametros();
parametrosAgregados = true;
}
Agregar(registro);
}
protected override void Agregar(RegistroInLineTO registro)
{
if (Tipo == null)
{
Tipo = Tipo.Entity;
}
if (Tipo == Tipo.Entity)
{
Salida += Formatear(registro) + "\r\n";
}
else if (Tipo == Tipo.Entity)
{
Registros.Add(registro);
}
}
/// <summary>
/// Registra la información relevante de una excepción lanzada por un método. Se debe logear antes de ser lanzada.
/// Requiere que el inicio y el retorno del método esté logeado.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="excepcion">Excepción lanzada.</param>
/// <param name="permiteContinuar">Valor que indica si la excepción interrumpe el flujo (no permite continuar).
/// En caso de ser falso, se logea automáticamente el retorno del método como Excepción.</param>
public void Excepcion(Exception excepcion, bool permiteContinuar)
{
Llamada++;
string valorJson = string.Empty;
try
{
valorJson = JsonConverterFactory.ObtenerJsonConverter().ToJson(excepcion.Data, true);
}
catch (Exception ex)
{
valorJson = "Error al transformar a Json - " + ex.Message;
}
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = Log4MeManager.ThreadGUID,
MethodGUID = InstanciaLog.MethodGUID,
Namespace = InstanciaLog.Metodo.DeclaringType.Namespace,
Clase = InstanciaLog.Metodo.DeclaringType.Name,
Metodo = InstanciaLog.Metodo.ToString(),
StackTrace = excepcion.StackTrace,
Data = valorJson,
TipoExcepcion = excepcion.GetType().FullName,
Mensaje = excepcion.Message,
Correlativo = Llamada,
Tipo = Tipo.Excepcion
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Excepcion))
{
writer.Guardar(registro);
}
}
if (!permiteContinuar)
{
Retorno("<" + registro.Tipo + ">");
}
}
protected override void Agregar(RegistroInLineTO registro)
{
string salida = Formatear(registro);
ConsoleColor colorTexto = ConsoleColor.White;
ConsoleColor colorFondo = ConsoleColor.Black;
if (NivelesSeguimiento != null)
{
ConsoleTypeTag tipo = null;
if (registro.Tipo == Tipo.Mensaje)
{
tipo = NivelesSeguimiento.FirstOrDefault(c => c.Nombre == Tipo.Mensaje && c.Nivel != null && c.Nivel == registro.Nivel);
if (tipo == null)
{
tipo = NivelesSeguimiento.FirstOrDefault(c => c.Nombre == Tipo.Mensaje && c._Nivel == "*");
}
}
if (tipo == null)
{
tipo = NivelesSeguimiento.FirstOrDefault(c => c._Nombre.Equals("*", StringComparison.InvariantCultureIgnoreCase));
}
if (tipo != null)
{
if (!string.IsNullOrEmpty(tipo.ColorTexto))
{
colorTexto = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), tipo.ColorTexto);
}
if (!string.IsNullOrEmpty(tipo.ColorFondo))
{
colorFondo = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), tipo.ColorFondo);
}
}
}
Print(salida, colorFondo, colorTexto);
}
/// <summary>
/// Registra el fin de la ejecución de un método, guardando la fecha de termino, el valor de retorno y su tipo.
/// Se debe logear antes de retornar. Requiere que se haya logeado el inicio del método.
/// </summary>
/// <example>
/// public int Sumar(int valor1, int valor2)
/// {
/// log.Inicio(valor1, valor2);
/// int resultado = valor1 + valor2;
/// log.Retorno(resultado);
/// return resultado;
/// }
/// </example>
/// <remarks>
/// <para>
/// <h2 class="groupheader">Registro de versiones</h2>
/// <ul>
/// <li>1.0.0</li>
/// <table>
/// <tr style="font-weight: bold;">
/// <td>Autor</td>
/// <td>Fecha</td>
/// <td>Descripción</td>
/// </tr>
/// <tr>
/// <td>Marcos Abraham Hernández Bravo.</td>
/// <td>11/11/2016</td>
/// <td>Versión Inicial.</td>
/// </tr>
/// </table>
/// </ul>
/// </para>
/// </remarks>
/// <param name="valor">Valor de retorno del método.</param>
private void _Retorno(object valor = null)
{
Llamada++;
if (valor == null)
{
valor = "<Void>";
}
string valorJson = string.Empty;
try
{
valorJson = valor.ToJson(true);
}
catch (Exception e)
{
valorJson = "Error al transformar a Json - " + e.Message;
}
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = ThreadGUID,
MethodGUID = _MethodGUID,
Namespace = Metodo.DeclaringType.Namespace,
Clase = Metodo.DeclaringType.Name,
Metodo = Metodo.ToString(),
ValorVariable = valorJson,
Correlativo = Llamada,
Tipo = Tipo.Retorno
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Retorno))
{
writer.Guardar(registro);
}
}
}
/// <summary>
/// Logea el identifiador de ejecución del hilo actual. Es recomendable utilizar el RUN del usuario u otro valor que identifique la sesión actual.
/// </summary>
/// <remarks>
/// <para>
/// <h2 class="groupheader">Registro de versiones</h2>
/// <ul>
/// <li>1.0.0</li>
/// <table>
/// <tr style="font-weight: bold;">
/// <td>Autor</td>
/// <td>Fecha</td>
/// <td>Descripción</td>
/// </tr>
/// <tr>
/// <td>Marcos Abraham Hernández Bravo.</td>
/// <td>11/11/2016</td>
/// <td>Versión Inicial.</td>
/// </tr>
/// </table>
/// </ul>
/// </para>
/// </remarks>
/// <param name="identificador">Identificador del hilo.</param>
public static void Identificador(string identificador)
{
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = ThreadGUID,
MethodGUID = Instancia != null ? Instancia._MethodGUID : null,
Namespace = Instancia != null ? Instancia.Metodo.DeclaringType.Namespace : null,
Clase = Instancia != null ? Instancia.Metodo.DeclaringType.FullName : null,
Metodo = Instancia != null?Instancia.Metodo.ToString() : null,
Correlativo = 0,
Tipo = Tipo.Identificador,
ValorVariable = identificador
};
if (Configuration != null)
{
foreach (ALogWriter writer in Configuration.Writers)
{
writer.Guardar(registro);
}
}
}
/// <summary>
/// Carga una colección de registros (fieles al txt) mediante un filtro, a una representación de cada parte del flujo.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="retorno">Representación completa del flujo, para cargar los datos leídos.</param>
/// <param name="indiceInicio">Fila inicial a leer. Luego se continúa hasta el final.</param>
/// <param name="registros">Registros fieles el archivo plano (Origen de la información).</param>
/// <param name="filtro">Filtro para excluir elementos. <value>true</value> para incluir, <value>false</value> para excluir.</param>
/// <returns>Representación completa del flujo</returns>
private MetodoTO CargarArbol(MetodoTO retorno, ref int indiceInicio, IList <RegistroInLineTO> registros, Func <RegistroInLineTO, bool> filtro = null)
{
for (int indice = indiceInicio; indice < registros.Count; indice++)
{
RegistroInLineTO registro = registros[indice];
if (filtro == null || (filtro != null && filtro(registro)))
{
if (registro.Tipo == Tipo.Inicio)
{
if (retorno.Inicio != null)
{
retorno.Llamadas.Add(CargarArbol(new MetodoTO(), ref indiceInicio, registros));
}
else
{
retorno.Inicio = new InicioTO()
{
Namespace = registro.Namespace,
Clase = registro.Clase,
Llamada = registro.Correlativo,
Fecha = registro.Fecha,
MethodGUID = registro.MethodGUID,
Metodo = registro.Metodo,
ThreadGUID = registro.ThreadGUID
};
retorno.Namespace = retorno.Inicio.Namespace;
retorno.Clase = retorno.Inicio.Clase;
retorno.Llamada = retorno.Inicio.Llamada;
retorno.Fecha = retorno.Inicio.Fecha;
retorno.MethodGUID = retorno.Inicio.MethodGUID;
retorno.ThreadGUID = retorno.Inicio.ThreadGUID;
retorno.Metodo = retorno.Inicio.Metodo;
}
}
else if (registro.Tipo == Tipo.Variable)
{
retorno.Variables.Add(new VariableTO()
{
Namespace = retorno.Inicio.Namespace,
Clase = retorno.Inicio.Clase,
Llamada = retorno.Inicio.Llamada,
Fecha = registro.Fecha,
MethodGUID = retorno.Inicio.MethodGUID,
ThreadGUID = retorno.Inicio.ThreadGUID,
Nombre = registro.NombreVariable,
Valor = registro.ValorVariable
});
}
else if (registro.Tipo == Tipo.Retorno)
{
retorno.Retorno = new RetornoTO()
{
Namespace = retorno.Inicio.Namespace,
Clase = retorno.Inicio.Clase,
Llamada = retorno.Inicio.Llamada,
Fecha = registro.Fecha,
MethodGUID = retorno.Inicio.MethodGUID,
ThreadGUID = retorno.Inicio.ThreadGUID,
Valor = registro.ValorVariable
};
return(retorno);
}
else if (registro.Tipo == Tipo.Excepcion)
{
retorno.Excepciones.Add(new ExcepcionTO()
{
Namespace = retorno.Inicio.Namespace,
Clase = retorno.Inicio.Clase,
Llamada = retorno.Inicio.Llamada,
Fecha = registro.Fecha,
MethodGUID = retorno.Inicio.MethodGUID,
ThreadGUID = retorno.Inicio.ThreadGUID,
Data = registro.Data,
Mensaje = registro.Mensaje,
StackTrace = registro.StackTrace,
Tipo = registro.NombreVariable,
});
}
else if (registro.Tipo == Tipo.Mensaje)
{
retorno.Mensajes.Add(new MensajeTO()
{
Namespace = retorno.Inicio.Namespace,
Clase = retorno.Inicio.Clase,
Llamada = retorno.Inicio.Llamada,
Fecha = registro.Fecha,
Nivel = registro.Nivel,
MethodGUID = retorno.Inicio.MethodGUID,
ThreadGUID = retorno.Inicio.ThreadGUID,
Mensaje = registro.Mensaje
});
}
else if (registro.Tipo == Tipo.Parametro)
{
retorno.Parametros.Add(new ParametroTO()
{
Namespace = retorno.Inicio.Namespace,
Clase = retorno.Inicio.Clase,
Llamada = retorno.Inicio.Llamada,
Fecha = registro.Fecha,
MethodGUID = retorno.Inicio.MethodGUID,
ThreadGUID = retorno.Inicio.ThreadGUID,
Nombre = registro.NombreVariable,
Valor = registro.ValorVariable
});
}
}
}
return(null);
}
/// <summary>
/// Registra el inicio de un método, guarda la hora actual y cada parametro especificando
/// nombre, tipo y valor. Se recomienda que esta sea la primera instrucción de cada método.
/// Si se logea el inicio, es obligatorio logear el retorno aunque el método sea Void.
/// </summary>
/// <example>
/// public void Metodo1(int a, string b, bool c)
/// {
/// log.Inicio(a, b, c);
/// log.Retorno();
/// }
///
/// public void Metodo2()
/// {
/// log.Inicio();
/// log.Retorno();
/// }
/// </example>
/// <remarks>
/// <para>
/// <h2 class="groupheader">Registro de versiones</h2>
/// <ul>
/// <li>1.0.0</li>
/// <table>
/// <tr style="font-weight: bold;">
/// <td>Autor</td>
/// <td>Fecha</td>
/// <td>Descripción</td>
/// </tr>
/// <tr>
/// <td>Marcos Abraham Hernández Bravo.</td>
/// <td>11/11/2016</td>
/// <td>Versión Inicial.</td>
/// </tr>
/// </table>
/// </ul>
/// </para>
/// </remarks>
/// <param name="parametros">Lista de parametros del método actual.</param>
private void _Inicio(params object[] parametros)
{
Llamada++;
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = ThreadGUID,
MethodGUID = _MethodGUID,
Namespace = Metodo.DeclaringType.Namespace,
Clase = Metodo.DeclaringType.Name,
Metodo = Metodo.ToString(),
Correlativo = Llamada,
Tipo = Tipo.Inicio
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Inicio))
{
writer.Guardar(registro);
}
}
int numParametro = 0;
if (parametros != null && parametros.Length > 0)
{
foreach (ParameterInfo param in Metodo.GetParameters())
{
Llamada++;
string valor = string.Empty;
try
{
valor = parametros[numParametro].ToJson(true);
}
catch (Exception e)
{
valor = "Error al transformar a Json - " + e.Message.Replace("\n", "\t");
}
RegistroInLineTO parametro = new RegistroInLineTO()
{
ThreadGUID = ThreadGUID,
MethodGUID = _MethodGUID,
Namespace = Metodo.DeclaringType.Namespace,
Clase = Metodo.DeclaringType.Name,
Metodo = Metodo.ToString(),
NombreVariable = param.Name,
ValorVariable = valor,
Correlativo = Llamada,
Tipo = Tipo.Parametro
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Parametro))
{
writer.Guardar(parametro);
}
}
numParametro++;
}
}
}
/// <summary>
/// Formatea un registro en una cadena de texto.
/// </summary>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 10/04/2016 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="registro">Registro unificado.</param>
/// <returns>Cadena de texto formateada.</returns>
public virtual string Formatear(RegistroInLineTO registro)
{
if (FormatoSalida == null)
{
FormatoSalida = FormatoPredeterminado;
}
if (SeparadorSalida == 0)
{
SeparadorSalida = SeparadorPredeterminado;
}
if (!FormatoSalida.EndsWith(SeparadorSalida.ToString()) && !FormatoSalida.Equals(string.Empty))
{
FormatoSalida += SeparadorSalida;
}
if (FormatoSalida == FormatoPredeterminado + SeparadorSalida)
{
FormatoSalida = string.Format(FormatoPredeterminado, SeparadorSalida);
}
ExpresionFormato expresionFormato = new ExpresionFormato(FormatoSalida, SeparadorSalida);
if (ForzarTodosCampos)
{
if (!expresionFormato.TagFormato.ContainsKey("[ThreadGUID]"))
{
FormatoSalida += "[ThreadGUID]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[MethodGUID]"))
{
FormatoSalida += "[MethodGUID]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[Namespace]"))
{
FormatoSalida += "[Namespace]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[Class]"))
{
FormatoSalida += "[Class]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[Method]"))
{
FormatoSalida += "[Method]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[Type]"))
{
FormatoSalida += "[Type]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[Level]"))
{
FormatoSalida += "[Level]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[DateTime]"))
{
FormatoSalida += "[DateTime]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[VarName]"))
{
FormatoSalida += "[VarName]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[VarValue]"))
{
FormatoSalida += "[VarValue]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[StackTrace]"))
{
FormatoSalida += "[StackTrace]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[Data]"))
{
FormatoSalida += "[Data]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[ExceptionType]"))
{
FormatoSalida += "[ExceptionType]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[Message]"))
{
FormatoSalida += "[Message]" + SeparadorSalida;
}
if (!expresionFormato.TagFormato.ContainsKey("[Correlative]"))
{
FormatoSalida += "[Correlative]" + SeparadorSalida;
}
expresionFormato.Recargar(FormatoSalida, SeparadorSalida);
}
string fechaActual = DateTime.Now.ToString();
string formatoFecha = "";
if (expresionFormato.TagFormato.ContainsKey("[DateTime]"))
{
formatoFecha = expresionFormato.TagFormato["[DateTime]"];
fechaActual = DateTime.Now.ToString(formatoFecha);
}
string metodo = registro.Metodo.Substring(registro.Metodo.IndexOf(" ") + 1);
metodo = metodo.Substring(0, metodo.IndexOf("("));
string formatoMetodo = "Full";
if (expresionFormato.TagFormato.ContainsKey("[Method]"))
{
formatoMetodo = expresionFormato.TagFormato["[Method]"];
}
if (!string.IsNullOrEmpty(formatoMetodo))
{
if (formatoMetodo.Equals("Full", StringComparison.InvariantCultureIgnoreCase))
{
metodo = registro.Metodo;
}
}
if (!string.IsNullOrEmpty(registro.StackTrace))
{
registro.StackTrace = "\n\t\t<StackTrace>\n\t\t\t" + CambiarCaracteres(registro.StackTrace) + "\n\t\t</StackTrace>\n";
}
string salida = FormatoSalida
.Replace("[ThreadGUID]", registro.ThreadGUID)
.Replace("[MethodGUID]", registro.MethodGUID)
.Replace("[Namespace]", registro.Namespace)
.Replace("[Class]", CambiarCaracteres(registro.Clase))
.Replace("[Method]", CambiarCaracteres(metodo))
.Replace(string.Format("[Method:{0}]", formatoMetodo), CambiarCaracteres(metodo))
.Replace("[Type]", registro.Tipo.Codigo)
.Replace("[Level]", registro.Nivel != null ? registro.Nivel.Codigo : SeparadorSalida.ToString())
.Replace("[DateTime:" + formatoFecha + "]", fechaActual)
.Replace("[DateTime]", fechaActual)
.Replace("[VarName]", registro.NombreVariable)
.Replace("[VarValue]", CambiarCaracteres(registro.ValorVariable))
.Replace("[StackTrace]", registro.StackTrace)
.Replace("[Data]", CambiarCaracteres(registro.Data))
.Replace("[ExceptionType]", registro.TipoExcepcion)
.Replace("[Message]", CambiarCaracteres(registro.Mensaje))
.Replace("[Correlative]", registro.Correlativo.ToString());
return(salida);
}
/// <summary> /// Persiste el registro recibido. /// </summary> /// <remarks> /// Registro de versiones: /// /// 1.0 10/04/2016 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial. /// </remarks> /// <param name="registro">Registro unificado a ser escrito.</param> protected abstract void Agregar(RegistroInLineTO registro);
/// <summary>
/// Registra el inicio de un método, guarda la hora actual y cada parametro especificando
/// nombre, tipo y valor. Se recomienda que esta sea la primera instrucción de cada método.
/// Si se logea el inicio, es obligatorio logear el retorno aunque el método sea Void.
/// </summary>
/// <example>
/// public void Metodo1(int a, string b, bool c)
/// {
/// log.Inicio(a, b, c);
/// log.Retorno();
/// }
///
/// public void Metodo2()
/// {
/// log.Inicio();
/// log.Retorno();
/// }
/// </example>
/// <remarks>
/// Registro de versiones:
///
/// 1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
/// </remarks>
/// <param name="parametros">Lista de parametros del método actual.</param>
public void Inicio(params object[] parametros)
{
Writers = Log4MeBO.ObtenerWriters(InstanciaLog.Metodo);
Log4MeManager.CurrentInstance = InstanciaLog;
Llamada++;
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = Log4MeManager.ThreadGUID,
MethodGUID = InstanciaLog.MethodGUID,
Namespace = InstanciaLog.Metodo.DeclaringType.Namespace,
Clase = InstanciaLog.Metodo.DeclaringType.Name,
Metodo = InstanciaLog.Metodo.ToString(),
Correlativo = Llamada,
Tipo = Tipo.Inicio
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Inicio))
{
writer.Guardar(registro);
}
}
int numParametro = 0;
if (parametros != null && parametros.Length > 0)
{
foreach (ParameterInfo param in InstanciaLog.Metodo.GetParameters())
{
Llamada++;
string valor = string.Empty;
try
{
valor = JsonConverterFactory.ObtenerJsonConverter().ToJson(parametros[numParametro], true);
}
catch (Exception e)
{
valor = "Error al transformar a Json - " + e.Message.Replace("\n", "\t");
}
RegistroInLineTO parametro = new RegistroInLineTO()
{
ThreadGUID = Log4MeManager.ThreadGUID,
MethodGUID = InstanciaLog.MethodGUID,
Namespace = InstanciaLog.Metodo.DeclaringType.Namespace,
Clase = InstanciaLog.Metodo.DeclaringType.Name,
Metodo = InstanciaLog.Metodo.ToString(),
NombreVariable = param.Name,
ValorVariable = valor,
Correlativo = Llamada,
Tipo = Tipo.Parametro
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteTipo(Tipo.Parametro))
{
writer.Guardar(parametro);
}
}
numParametro++;
}
}
}
protected override void Agregar(RegistroInLineTO registro)
{
writer.WriteLine(Formatear(registro));
}
