コード例 #1
0
        /// <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);
        }
コード例 #2
0
ファイル: LogDb.cs プロジェクト: GustavoAdolfo/RegistroLog
 /// <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();
 }
コード例 #3
0
ファイル: LogDb.cs プロジェクト: GustavoAdolfo/RegistroLog
 /// <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;
 }
コード例 #4
0
ファイル: LogJSON.cs プロジェクト: GustavoAdolfo/RegistroLog
        /// <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();
            }
        }
コード例 #5
0
ファイル: LogTexto.cs プロジェクト: GustavoAdolfo/RegistroLog
        /// <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();
        }
コード例 #6
0
ファイル: LogTexto.cs プロジェクト: GustavoAdolfo/RegistroLog
 /// <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);
 }
コード例 #7
0
 /// <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);
 }
コード例 #8
0
 /// <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)
 {
 }
コード例 #9
0
ファイル: LogXML.cs プロジェクト: GustavoAdolfo/RegistroLog
        /// <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);
        }