Como registrar ações em sistema (Logs) em C#

Em qualquer aplicação robusta, seja ela pequena ou de grande porte, registrar logs é essencial para o monitoramento, depuração, e auditoria. Os logs ajudam a rastrear o comportamento da aplicação, facilitando a identificação de problemas e permitindo a análise de eventos ocorridos ao longo do tempo. Neste post, aprenda como registrar ações em sistema (Logs) em C#.

O que é um Log?

Um log é um registro de eventos que ocorrem no sistema, podendo incluir informações sobre:

• Erros: Exceções ou falhas que ocorrem durante a execução;
  
• Informações: Ações normais executadas pela aplicação (inicializações, processamentos, etc.);
  
• Avisos: Situações que não são erros, mas podem representar potenciais problemas;
  
• Depuração (Debug): Detalhes úteis durante o desenvolvimento para monitorar o fluxo da aplicação.

Por que utilizar Logs?

Os logs são essenciais para:

1. Monitorar o comportamento da aplicação em ambientes de produção;
   
2. Depurar erros sem a necessidade de interromper o sistema;
   
3. Auditar ações do sistema e de usuários para fins de segurança;
   
4. Analisar o desempenho e identificar gargalos.

Implementação básica de Logs em C#

O C# fornece mecanismos simples para registrar logs usando classes padrão, como System.IO, que permite escrever arquivos de texto diretamente no disco. Vamos ver um exemplo básico:

using System;
using System.IO;

public class Logger
{
    private static readonly string caminhoDoArquivo = "logs.txt";

    public static void Log(string mensagem)
    {
        using (StreamWriter sw = new StreamWriter(caminhoDoArquivo, true))
        {
            string logFormatado = $"{DateTime.Now} - {mensagem}";
            sw.WriteLine(logFormatado);
        }
    }
}

public class Program
{
    public static void Main()
    {
        Logger.Log("Aplicação Iniciada");
        try
        {
            // Simulando uma ação
            throw new Exception("Ocorreu um erro");
        }
        catch (Exception ex)
        {
            Logger.Log($"Erro: {ex.Message}");
        }
        Logger.Log("Aplicação Finalizada");
    }
}

Neste exemplo:

• O log é salvo em um arquivo logs.txt.
• Cada linha do log contém a data e hora seguida da mensagem.
• O método Log() é chamado para registrar eventos no sistema.

Utilizando bibliotecas de logging: NLog e Serilog

Escrever logs manualmente com StreamWriter funciona bem em casos simples, mas para sistemas maiores e mais complexos, é altamente recomendável o uso de bibliotecas especializadas de logging, como o NLog e o Serilog.

1. NLog

O NLog é uma das bibliotecas de log mais populares no ecossistema .NET. Ele permite configurar diferentes destinos de log (arquivos, console, banco de dados, etc.) e níveis de log.

Instalando o NLog

No NuGet Package Manager, instale o pacote:

Install-Package NLog

Configurando e usando NLog

Veja um exemplo de configuração e uso:

using NLog;

public class Program
{
    private static readonly Logger logger = LogManager.GetCurrentClassLogger();

    public static void Main()
    {
        logger.Info("Aplicação Iniciada");
        
        try
        {
            // Simulando uma exceção
            throw new Exception("Erro inesperado");
        }
        catch (Exception ex)
        {
            logger.Error(ex, "Ocorreu uma exceção");
        }

        logger.Info("Aplicação Finalizada");
    }
}

No arquivo de configuração (NLog.config), você pode definir para onde os logs serão enviados:

<nlog>
  <targets>
    <target name="logfile" xsi:type="File" fileName="file.txt" />
    <target name="logconsole" xsi:type="Console" />
  </targets>
  <rules>
    <logger name="*" minlevel="Info" writeTo="logconsole,logfile" />
  </rules>
</nlog>

2. Serilog

Outra excelente opção é o Serilog, conhecido por sua flexibilidade e saída estruturada (JSON, por exemplo).

Instalando o Serilog

No NuGet, instale:

Install-Package Serilog
Install-Package Serilog.Sinks.File

Configurando e usando Serilog

using Serilog;

public class Program
{
    public static void Main()
    {
        Log.Logger = new LoggerConfiguration()
            .WriteTo.Console()
            .WriteTo.File("logs.txt")
            .CreateLogger();

        Log.Information("Aplicação Iniciada");

        try
        {
            // Simulando uma exceção
            throw new Exception("Erro inesperado");
        }
        catch (Exception ex)
        {
            Log.Error(ex, "Ocorreu uma exceção");
        }

        Log.Information("Aplicação Finalizada");
        Log.CloseAndFlush();
    }
}

Com o Serilog, você pode personalizar facilmente os destinos e o formato dos logs.

Dicas para um Logging eficiente

• Escolha o nível correto de Log: Use níveis adequados como Error, Warning, Info e Debug para categorizar a importância dos eventos;
  
  
• Evite registrar informações sensíveis: Nunca logue senhas, informações pessoais ou dados sensíveis;
  
  
• Mantenha a configuração flexível: Use arquivos de configuração para alterar os destinos e níveis de logs sem modificar o código;
  
  
• Armazene Logs em local seguro: Para sistemas em produção, considere armazenar logs em bancos de dados ou serviços de log centralizados (ex: Elasticsearch, Loggly).

Implementar logs de forma eficiente é um passo crucial para garantir a manutenção, estabilidade e segurança de uma aplicação. Seja utilizando uma solução personalizada ou uma biblioteca robusta como NLog ou Serilog, os logs irão facilitar muito a vida de desenvolvedores e administradores de sistemas.

kkkk

Exemplo mais simples de log

Abaixo está um código mais simplificado para sistemas menos complexos:

//Método para criar logs - recebe três parâmetros
public void log(string modulo, string acao, string detalhes) {

  string caminhoArquivo = @"D:\log-controles-ti.txt"; //Caminho do arquivo
        
   if (!File.Exists(caminhoArquivo)) //Se arquivo de log não existir...
        File.Create(caminhoArquivo).Close(); //É criado o arquivo de log
            
        //Escreve uma linha no arquivo de log com as informações da ação    
        File.AppendAllText(caminhoArquivo, "Usuário " + Usuario + " " + acao + " (" + detalhes + ") no módulo " + modulo + " em (" + DateTime.Now.ToShortDateString() + ")\r\n");
    }

O código acima cria um método que recebe três parâmetros (módulo, ação e detalhes da ação) e escreve no arquivo de log a ação praticada no sistema.

Para chamar o método que cria o log:

log("Equipamentos", "inseriu", "N/S: " + num_serie);

Acima é chamado o método e as informações da ação no sistema são passados como parâmetro.

Para melhor compreensão dos códigos, assista a videoaula que ensina, passo a passo, como implementar os códigos acima:

Dúvidas ou sugestões sobre como registrar ações em sistema (Logs) em C#? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
 https://youtube.com/criandobits

Tags: logs