/// <summary>
/// Eventod de log, disparado para registrar o log no EventView.
/// </summary>
/// <param name="e"></param>
/// <exception cref="Exception"></exception>
public void Log(EventosLogEventArgs e)
{
EventLogEntryType tipo;
switch (e.Registro.LogTipo)
{
case GrauCritico.Sucesso: tipo = EventLogEntryType.SuccessAudit;
break;
case GrauCritico.Informacao: tipo = EventLogEntryType.Information;
break;
case GrauCritico.Alerta: tipo = EventLogEntryType.Warning;
break;
case GrauCritico.Falha: tipo = EventLogEntryType.FailureAudit;
break;
case GrauCritico.Erro: tipo = EventLogEntryType.Error;
break;
case GrauCritico.ErroCritico: tipo = EventLogEntryType.Error;
break;
case GrauCritico.Debug: tipo = EventLogEntryType.Information;
break;
default: tipo = EventLogEntryType.Information;
break;
}
var excecao = e.Exception.Message + Environment.NewLine + e.Exception.Source + Environment.NewLine + e.Exception.StackTrace + Environment.NewLine + e.Exception.TargetSite;
byte[] bytes = Encoding.ASCII.GetBytes(excecao);
if (_logView == null) RegistrarLog();
if (_logView == null) throw new Exception("Não foi possível criar o objeto de log para o Visualizador de Eventos do Windows");
var descricao = e.Descricao ?? e.Exception.Message;
_logView.WriteEntry(descricao, tipo, 0, (short) e.Registro.LogTipo, bytes);
}
/// <summary>
/// Evento do log, disparado para efetuar o registro.
/// </summary>
/// <param name="evento">Evento de log que será registrado</param>
internal void Log(EventosLogEventArgs evento)
{
ISessionFactory factory = NhibernateRegistry.ObterSessionFactory();
_session = factory.OpenSession();
var model = ConvertEventoToModel(evento);
Gravar(model);
_session.Connection.Close();
}
/// <summary>
/// Conversão dos dados de um objeto Evento para seus respectivos num novo objeto LogModel.
/// </summary>
/// <param name="evento"></param>
/// <returns></returns>
private LogModel ConvertEventoToModel(EventosLogEventArgs evento)
{
if (evento == null)
throw new ArgumentEmptyException("evento");
var model = new LogModel();
model.DataHora = evento.DataHora;
model.Description = evento.Descricao;
model.LogTipo = evento.Registro.LogTipo.ToString();
model.Message = evento.Exception.Message;
if (evento.Exception.InnerException != null)
{
model.Message += "\n" + evento.Exception.InnerException.Message;
}
model.Origem = evento.Registro.Origem;
model.Source = evento.Exception.Source;
model.StackTrace = evento.Exception.StackTrace;
model.TargetSite = evento.Exception.TargetSite.ToString();
return model;
}
/// <summary>
/// Criar um novo arquivo json ou substitui o existente.
/// </summary>
/// <param name="objEvento">Objeto dos dados do evento do log.</param>
protected override void GravarArquivo(EventosLogEventArgs objEvento)
{
base.GravarArquivo(objEvento);
var arquivo = CaminhoArquivo + NomeArquivo;
var logConteudo = JsonConvert.SerializeObject(objEvento);
if (File.Exists(arquivo))
{
if (SubstituirArquivo)
{
var swrite = new StreamWriter(arquivo, false, Encoding.UTF8);
swrite.Write(logConteudo);
swrite.Close();
}
else
{
var sread = new StreamReader(arquivo);
var conteudo = sread.ReadToEnd();
if (conteudo.StartsWith("["))
conteudo.Remove(0);
if (conteudo.EndsWith("]"))
conteudo.Remove(conteudo.Length - 1);
logConteudo = string.Format("[{0},{1}]", conteudo, logConteudo);
sread.Close();
var swrite = new StreamWriter(arquivo, false, Encoding.UTF8);
swrite.Write(logConteudo);
swrite.Close();
}
}
else
{
var swrite = new StreamWriter(logConteudo, false, Encoding.UTF8);
swrite.Write(logConteudo);
swrite.Close();
}
}
/// <summary>
/// Grava os dados do log no arquivo de repositório como uma linha de texto.
/// <para>Uma linha será escrita no arquivo com o formato: [DataHora]\t[Tipo do Log]\t[Descrição]\t\t[Message]\t[Source]\t[StackTrace]\t[TargetSite]\t[Origem]</para>
/// </summary>
/// <param name="objEvento">Objeto dos dados do evento do log.</param>
protected override void GravarArquivo(EventosLogEventArgs objEvento)
{
base.GravarArquivo(objEvento);
var arquivo = CaminhoArquivo + NomeArquivo;
var logConteudo = string.Empty;
var linha1 = string.Empty;
var conteudo = string.Empty;
#region Verifica a existência do arquivo
if (File.Exists(arquivo) && !SubstituirArquivo)
{
var sread = new StreamReader(arquivo);
conteudo = sread.ReadToEnd();
logConteudo = (conteudo.LastIndexOf("\n", StringComparison.CurrentCulture) + 1) == conteudo.Length ? string.Empty : Environment.NewLine;
if (conteudo.Length > 0)
{
sread.BaseStream.Seek(0, SeekOrigin.Begin);
linha1 = sread.ReadLine();
}
sread.Close();
}
#endregion
#region Formata o conteúdo de acordo com o tipo de repositório
switch (objEvento.Registro.Repositorio)
{
case RepositorioLog.Texto:
{
logConteudo += string.Format("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}",
objEvento.DataHora, objEvento.Registro.LogTipo.ToString("G"), objEvento.Registro.Origem, objEvento.Descricao, objEvento.Exception.Message,
objEvento.Exception.Source, objEvento.Exception.StackTrace, objEvento.Exception.TargetSite);
break;
}
case RepositorioLog.CSV:
{
if (!string.IsNullOrWhiteSpace(objEvento.Registro.Origem))
objEvento.Registro.Origem = objEvento.Registro.Origem.Replace(objEvento.Registro.SeparadorCSV, '|');
var descricao = !string.IsNullOrWhiteSpace(objEvento.Descricao)
? objEvento.Descricao.Replace(objEvento.Registro.SeparadorCSV, '|')
: objEvento.Descricao;
var exMessage = !string.IsNullOrWhiteSpace(objEvento.Exception.Message)
? objEvento.Exception.Message.Replace(objEvento.Registro.SeparadorCSV, '|')
: objEvento.Exception.Message;
var exSource = !string.IsNullOrWhiteSpace(objEvento.Exception.Source)
? objEvento.Exception.Source.Replace(objEvento.Registro.SeparadorCSV, '|')
: objEvento.Exception.Source;
var exStackTrace = !string.IsNullOrWhiteSpace(objEvento.Exception.StackTrace)
? objEvento.Exception.StackTrace.Replace(objEvento.Registro.SeparadorCSV, '|')
: objEvento.Exception.StackTrace;
var exTargetSite = !string.IsNullOrWhiteSpace(objEvento.Exception.TargetSite.ToString())
? objEvento.Exception.TargetSite.ToString().Replace(objEvento.Registro.SeparadorCSV, '|')
: objEvento.Exception.TargetSite.ToString();
logConteudo += string.Format("{0}{8}{1}{8}{2}{8}{3}{8}{4}{8}{5}{8}{6}{8}{7}",
objEvento.DataHora, objEvento.Registro.LogTipo.ToString("G"),
objEvento.Registro.Origem, descricao, exMessage,
exSource, exStackTrace, exTargetSite,
objEvento.Registro.SeparadorCSV);
break;
}
}
#endregion
StreamWriter escrita;
#region Se o repositório for um CSV, verifica se há a linha de título. Do contrário ela será criada
if (objEvento.Registro.LinhaTituloCSV && objEvento.Registro.Repositorio == RepositorioLog.CSV)
{
const string linhaTitulo = "DataHora,LogTipo,Origem,Descricao,Exception.Message,Exception.Source,Exception.StackTrace,Exception.TargetSite";
if (string.IsNullOrWhiteSpace(linha1) || !linha1.Equals(linhaTitulo))
{
escrita = new StreamWriter(arquivo, false);
escrita.BaseStream.Seek(0, SeekOrigin.Begin);
escrita.WriteLine(linhaTitulo);
escrita.Write(conteudo);
escrita.Close();
}
}
#endregion
escrita = !SubstituirArquivo ? new StreamWriter(arquivo, true) : new StreamWriter(arquivo, false) ;
escrita.WriteLine(logConteudo);
escrita.Close();
}
/// <summary>
/// Inicia o evento de registro do log em arquivo texto
/// </summary>
/// <param name="evento">Conteúdo do log para o LogEventos</param>
public override void Log(EventosLogEventArgs evento)
{
GravarArquivo(evento);
}
/// <summary>
/// Grava os dados do log no arquivo de repositório.
/// </summary>
/// <param name="objEvento">Objeto dos dados do evento do log.</param>
protected virtual void GravarArquivo(EventosLogEventArgs objEvento)
{
ValidarRepositorio(objEvento.Registro.CaminhoArquivo, objEvento.Registro.NomeArquivo, objEvento.Registro.SubstituirArquivo, objEvento.Registro.Repositorio);
}
/// <summary>
/// Evento de registro do log em arquivo texto
/// </summary>
/// <param name="evento">Conteúdo do log para o LogEventos</param>
public virtual void Log(EventosLogEventArgs evento)
{
}
/// <summary>
/// Grava os dados do evento no xml
/// </summary>
/// <param name="objEvento">Evento de log ocorrido</param>
protected override void GravarArquivo(EventosLogEventArgs objEvento)
{
base.GravarArquivo(objEvento);
var logXml = new XmlDocument();
try
{
logXml.Load(CaminhoArquivo + NomeArquivo);
}
catch (XmlException)
{
if (!logXml.HasChildNodes)
{
var arquivoXml = new XmlTextWriter(CaminhoArquivo + NomeArquivo, Encoding.UTF8)
{
Formatting = Formatting.Indented
};
arquivoXml.WriteStartDocument();
arquivoXml.WriteDocType("RegistroLog", null, "", "<!ELEMENT RegistroLog ANY>");
arquivoXml.WriteStartElement("RegistroLog");
arquivoXml.WriteEndElement();
arquivoXml.WriteEndDocument();
arquivoXml.Flush();
arquivoXml.Close();
}
logXml.Load(CaminhoArquivo + NomeArquivo);
}
var root = logXml.DocumentElement;
XmlNode evento = logXml.CreateElement("evento");
var dataHora = logXml.CreateAttribute("datahora");
dataHora.Value = objEvento.DataHora.ToString(CultureInfo.CurrentCulture);
if (evento.Attributes != null) evento.Attributes.Append(dataHora);
XmlNode tipo = logXml.CreateElement("tipolog");
tipo.InnerText = objEvento.Registro.LogTipo.ToString("G");
XmlNode origem = logXml.CreateElement("origem");
origem.InnerText = objEvento.Registro.Origem;
XmlNode descricao = logXml.CreateElement("descricao");
if (string.IsNullOrWhiteSpace(objEvento.Descricao))
descricao.InnerText = objEvento.Descricao;
#region Dados da Exceção
XmlNode excecao = logXml.CreateElement("dadosexcecao");
XmlNode mensagem = logXml.CreateElement("mensagem");
mensagem.InnerText = objEvento.Exception.Message;
XmlNode source = logXml.CreateElement("source");
source.InnerText = objEvento.Exception.Source;
XmlNode stackTrace = logXml.CreateElement("stacktrace");
stackTrace.InnerText = objEvento.Exception.StackTrace;
XmlNode targetSite = logXml.CreateElement("targetsite");
targetSite.InnerText = objEvento.Exception.TargetSite.ToString();
excecao.AppendChild(mensagem);
excecao.AppendChild(source);
excecao.AppendChild(stackTrace);
excecao.AppendChild(targetSite);
#endregion
evento.AppendChild(tipo);
evento.AppendChild(descricao);
evento.AppendChild(excecao);
if (root != null) root.AppendChild(evento);
logXml.Save(CaminhoArquivo + NomeArquivo);
}
