| Português Brasileiro | English |

DataLogger

DataLogger foi projetado para ser uma biblioteca simples de log com suporte a vários providers.

Suporte: developer.dlio@gmail.com

⚙️ Instalação

Para instalar em seu projeto usando boss:

$ boss install github.com/dliocode/datalogger

Instalação Manual

Adicione as seguintes pastas ao seu projeto, em Project > Options > Delphi Compiler > Search path

../src/Core
../src/Providers

📌 Índice

• Como usar
• Providers
• Dependências
• Informações Extras
• Exemplos
  • Uso Padrão
  • Criar uma nova instância do DataLogger
  • DataLogger Simple
  • Custom
  • Especiais
    • SlineBreak
    • UndoLast
  • Template (Formato do Log)
    • Template Constantes
  • SetTemplate
    • Como definir um template em providers específicos
  • SetFormatTimestamp
  • Level
  • SetLevelName
  • SetLevel
  • SetDisableLevel
  • SetOnlyLevel
  • SetLogException
  • SetMaxRetries
  • SetIgnoreTemplate
  • SetName
  • SetLiveMode
  • Transaction

Como usar

Existem duas maneiras diferentes de usar o DataLogger: Diretamente pelo Logger ou instanciando seu próprio TDataLogger.

Samples

O primeiro destina-se apenas a ser um log compartilhado conveniente para ser usado em todo o seu aplicativo, se você escolher.

• Uses necessária:

uses DataLogger;

Providers

Um provider serve essencialmente para armazenar seus logs. Cada instância de um TDataLogger pode ter vários providers configurados.

Aqui temos uma lista com 60 providers disponíveis:

Nome	Uses	Exemplos
AWS CloudWatch	DataLogger.Provider.AWS.CloudWatch	AWS CloudWatch
Axiom	DataLogger.Provider.Axiom	Axiom
CallMeBot	DataLogger.Provider.CallMeBot.WhatsApp	CallMeBot
Console	DataLogger.Provider.Console	Console Console Simple
Coralogix	DataLogger.Provider.Coralogix	Coralogix
CSV	DataLogger.Provider.CSV	CSV
Datadog	DataLogger.Provider.Datadog	Datadog
Datalust	DataLogger.Provider.Datalust	Datalust
Discord	DataLogger.Provider.Discord.WebHook	DiscordHook
Dynatrace	Data Logger.Provider.Dynatrace	Dynatrace
ElasticSearch	DataLogger.Provider.ElasticSearch	ElasticSearch
Teach him	DataLogger.Provider.Elmah	Teach him
Email	DataLogger.Provider.Email	Email
event log	DataLogger.Provider.EventLog	EventLog
Events	DataLogger.Provider.Events	Events Events - With DataSet Events - With SQLite
Firebase	Data Logger.Provider.Firebase.Realtime Database	Firebase
Grafana	DataLogger.Provider.Grafana.Loki DataLogger.Provider.Grafana.OnCall.WebHook	Grafana
GraphJSON	DataLogger.Provider.GraphJSON	GraphJSON
Graylog	DataLogger.Provider.Graylog	Graylog
HTML	DataLogger.Provider.HTML	HTML
ListBox	DataLogger.Provider.ListBox	ListBox
ListView	DataLogger.Provider.ListView	ListView
Logentries	DataLogger.Provider.Logentries	Logentries
Logflare	DataLogger.Provider.Logflare	Logflare
Loggly	DataLogger.Provider.Loggly	Loggly
Logstash	DataLogger.Provider.Logstash	Logstash
Logtail	DataLogger.Provider.Logtail	Logtail
Logz	DataLogger.Provider.Logz	Logz
Mailgun	DataLogger.Provider.Mailgun.Api	Mailgun
Mailjet	DataLogger.Provider.Mailjet.Api	Mailjet
Mattermost	DataLogger.Provider.Mattermost DataLogger.Provider.Mattermost.WebHooks	Mattermost MattermostHook
Memo	DataLogger.Provider.Memo	Memo Memo and Text File Memo - Only Error/VCL
Memory	DataLogger.Provider.Memory	Memory
Mezma	DataLogger.Provider.Mezmo	Mezma
MongoDB	DataLogger.Provider.MongoDB.Cloud	MongoDB
Ntfy	DataLogger.Provider.Ntfy	Ntfy
NewRelic	DataLogger.Provider.NewRelic	NewRelic
Notification	DataLogger.Provider.Notification	Notification
New	DataLogger.Provider.Novu	New
OutputDebugString	DataLogger.Provider.OutputDebugString	OutputDebugString
PaperTrail	DataLogger.Provider.PaperTrail	PaperTrail
Postmark	DataLogger.Provider.Postmark.Api	Postmark
RabbitMQ	DataLogger.Provider.RabbitMQ	RabbitMQ
Redis	DataLogger.Provider.Redis	Redis
Rest	DataLogger.Provider.REST.HTTPClient DataLogger.Provider.REST.Indy DataLogger.Provider.REST.NetHTTPClient	Rest
RichEdit	DataLogger.Provider.RichEdit	RichEdit
Sematext	DataLogger.Provider.Sematext.Logs	Sematext-Logs
SendChamp	DataLogger.Provider.SendChamp.SMS DataLogger.Provider.SendChamp.WhatsApp	SendEmail
SendEmail	DataLogger.Provider.SendEmail	SendEmail
SendGrid	DataLogger.Provider.SendGrid.WebApi	SendGridWebApi
Slack	DataLogger.Provider.Slack.WebApi DataLogger.Provider.Slack.WebHook	Slack
Splunk	DataLogger.Provider.Splunk	Splunk
Socket	DataLogger.Provider.Socket	Socket
SumoLogic	DataLogger.Provider.SumoLogic	SumoLogic
SysLog	DataLogger.Provider.SysLog DataLogger.Provider.SysLog.Indy	SysLog SysLog Indy
Telegram	DataLogger.Provider.Telegram	Telegram
TextFile	DataLogger.Provider.TextFile	TextFile
UltraMSG	DataLogger.Provider.UltraMSG.WhatsApp	UltraMSG
Twilio	DataLogger.Provider.Twilio.SMS DataLogger.Provider.Twilio.WhatsApp	Twilio
Z-API	DataLogger.Provider.ZAPI.WhatsApp	Z-API

Dependências

Essas dependências se dá quando utilizado alguns providers

Provider	Dependence
DataLogger.Provider.RabbitMQ	RabbitMQ
DataLogger.Provider.Redis	Redis
DataLogger.Provider.SendEmail	SendEmail

Informações Extras

Plataforma Android:

É necessário a permissão ACCESS_WIFI_STATE: Utilizado para capturar o MAC Address do dispositivo.

Exemplos

Uso Padrão

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  Logger
    .Trace('My Trace')
    .Debug('My Debug')
    .Info('My Info')
    .Warn('My Warn')
    .Error('My Error')
    .Success('My Success')
    .Fatal('My Fatal')
    .Custom('Custom Level', 'My Custom')
    ;

  // or

  Logger
    .T('My Trace')
    .D('My Debug')
    .I('My Info')
    .W('My Warn')
    .E('My Error')
    .S('My Success')
    .F('My Fatal')
    .C('Custom Level', 'My Custom')
    ;

  Readln;

end.

Criar uma nova instância do DataLogger

uses
  DataLogger,
  DataLogger.Provider.Console;

var
  LCustomLogger: TDataLogger;
begin
  LCustomLogger := TDataLogger.Builder;
  LCustomLogger.AddProvider(TProviderConsole.Create);

  LCustomLogger
    .Trace('My Trace')
    .Debug('My Debug')
    .Info('My Info')
    .Warn('My Warn')
    .Error('My Error')
    .Success('My Success')
    .Fatal('My Fatal')
    .Custom('Custom Level', 'My message with custom level');
  Readln;
end.

DataLogger Simple

uses
  DataLogger,
  DataLogger.Simple,
  DataLogger.Provider.Console;

begin
  // Defini o provider
  Logger.AddProvider(TProviderConsole.Create);

  //Defini no DataloggerSimple a instância do log a ser utilizado
  TDataLoggerSimple.SetDataLogger(Logger);

  // Só usar o modo simples;
  Trace('My message Trace');
  Debug('My message debug');
  Info('My message info');
  Success('My message success');
  Warn('My message warn');
  Error('My message error');
  Fatal('My message fatal');
  Custom('My Type', 'My message custom');

  Readln;
end.

Custom

O Custom é a forma de definir um nome para o seu próprio level.

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  Logger.Custom('Custom Level', 'My message with custom level!');

  // Output: 2022-12-01 09:00:05.500 [Custom Level] My message with custom level!

  Readln;
end.

Especiais

Funções que operam em alguns providers.

  // Pula uma linha
  Logger.SlineBreak;

  // Desfaz o último log registrado
  Logger.UndoLast;

SlineBreak

A função SlineBreak utilizando para fazer a quebra de linha.

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Gerando os logs
  Logger.Info('My message with level INFO');
  Logger.SlineBreak;
  Logger.Error('My message with level ERROR');

  // Output: 2022-12-01 09:00:05.500 [INFO] My message with level INFO
  // Output:
  // Output: 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

UndoLast

A função UndoLast utilizando para desfazer o último registro realizado.

• Alguns Providers não possuem algum recurso que permite desfazer o último registro enviado.

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Gerando os logs
  Logger.Info('My message with level INFO');

  // Output: 2022-12-01 09:00:05.500 [INFO] My message with level INFO

  Sleep(4000);
  Logger.UndoLast;
  Logger.Error('My message with level ERROR');

  // Output: 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

Template (Formato do Log)

O template é o formato que será gerado o log.

template padrão:

${timestamp} [TID ${thread_id}] [PID ${process_id}] [SEQ ${sequence}] [${level}] [${tag}] ${message}

Template Constantes

Existem algumas constantes que podem ser utilizadas para facilitar a criação do template.

• Comum

// Exibe o id que foi gerado o log, no formato GUID
TLoggerTemplate.LOG_ID = '${id}';

// Exibe o nome do log. ex: Logger.SetName('SERVICE_REMOTE')
TLoggerTemplate.LOG_NAME = '${name}';

// Exibe a sequencia que o log foi gerado.
TLoggerTemplate.LOG_SEQUENCE = '${sequence}';

// Exibe a data e hora que foi gerado, usado o SetFormatTimestamp
TLoggerTemplate.LOG_TIMESTAMP = '${timestamp}';

// Exibe a data e hora que foi gerado, no formato ISO8601.
TLoggerTemplate.LOG_TIMESTAMP_ISO8601 = '${timestamp_iso8601}';

// Exibe a data e hora que foi gerado, no formato UNIX.
TLoggerTemplate.LOG_TIMESTAMP_UNIX = '${timestamp_unix}';

// Exibe o Id da thread que foi gerado o log.
TLoggerTemplate.LOG_THREADID = '${thread_id}';

// Exibe o id do processo do app.
TLoggerTemplate.LOG_PROCESSID = '${process_id}';

// Exibe o level do log, sendo eles: TRACE / DEBUG / INFO / SUCCESS / WARN / ERROR / FATAL
TLoggerTemplate.LOG_LEVEL = '${level}';

// Exibe o level do log no formato numérico, sendo eles: 1=TRACE / 2=DEBUG / 3=INFO / 4=SUCCESS / 5=WARN / 6=ERROR / 7=FATAL / 8=CUSTOM
TLoggerTemplate.LOG_LEVEL_VALUE = '${level_value}';

// Exibe a tag do log, essa informação é preenchida a após a mensagem; Ex: Logger.Debug('Minha mensagem','Minha Tag');
TLoggerTemplate.LOG_TAG = '${tag}';

// Exibe a mensagem do log, sem essa tag a mensagem não é exibida. Ex: Logger.Debug('Minha mensagem');
TLoggerTemplate.LOG_MESSAGE = '${message}';

• Especiais:

// Exibe o nome do app.
TLoggerTemplate.LOG_APPNAME = '${app_name}';

// Exibe o diretório do app.
TLoggerTemplate.LOG_APPPATH = '${app_path}';

// Exibe a versão do app.
TLoggerTemplate.LOG_APPVERSION = '${app_version}';

// Exibe o tamanho do app em MB.
TLoggerTemplate.LOG_APPSIZE = '${app_size}';

// Exibe o nome do computador.
TLoggerTemplate.LOG_COMPUTERNAME = '${computer_name}';

// Exibe o nome do usuário do Sistema Operacional.
TLoggerTemplate.LOG_USERNAME = '${username}';

// Exibe as informações do Sistema Operacional.
TLoggerTemplate.LOG_OSVERSION = '${os_version}';

// Exibe o IP Local.
TLoggerTemplate.LOG_IP_LOCAL = '${ip_local}';

// Exibe o MAC Address.
TLoggerTemplate.LOG_MAC_ADDRESS = '${mac_address}';

SetTemplate

Define o formato que será registrado o log

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Definindo o template com constante
  Logger.SetTemplate(Format('%s [%s] %s', [TLoggerTemplate.LOG_TIMESTAMP, TLoggerTemplate.LOG_LEVEL, LoggerTemplate.LOG_MESSAGE]));

  // Gerando os logs
  Logger.Info('My message with level INFO');
  Logger.Error('My message with level ERROR');

  // Output: 2022-12-01 09:00:05.500 [INFO] My message with level INFO
  // Output: 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

Como definir um template em providers específicos

• É possível definir várias configurações específicas em cada provider separado.

uses
  DataLogger,
  DataLogger.Provider.Console,
  DataLogger.Provider.TextFile;

begin
  // Formato do console '${timestamp} [${level}] ${message}'
  Logger.AddProvider(
    TProviderConsole.Create
    .SetTemplate('${timestamp} [${level}] ${message}')
  );

  // Formato do text file '${timestamp} - ${message}'
  Logger.AddProvider(
    TProviderTextFile.Create
    .SetTemplate('${timestamp} - ${message}')
  );

  // Gerando os logs
  Logger.Info('My message with level INFO');
  Logger.Error('My message with level ERROR');

  // Output Console:
  // 2022-12-01 09:00:05.500 [INFO] My message with level INFO
  // 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  // Output TextFile:
  // 2022-12-01 09:00:05.500 - My message with level INFO
  // 2022-12-01 09:00:05.600 - My message with level ERROR

  Readln;
end.

SetFormatTimestamp

Muda o formato do TimeStamp.

• Formato de TimeStamp padrão: yyyy-mm-dd hh:mm:ss.zzz

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o formato do Timestamp
  Logger.SetFormatTimestamp('dd/mm/yyyy hh:mm:ss')

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Definindo o template com constante
  Logger.SetTemplate(Format('%s [%s] %s', [TLoggerTemplate.LOG_TIMESTAMP, TLoggerTemplate.LOG_LEVEL, LoggerTemplate.LOG_MESSAGE]));

  // Gerando os logs
  Logger.Info('My message with level INFO');
  Logger.Error('My message with level ERROR');

  // Output: 01/12/2022 09:00:05 [INFO] My message with level INFO
  // Output: 01/12/2022 09:00:05 [ERROR] My message with level ERROR

  Readln;
end.

Level

O DataLogger possui estes levels para gerar os logs:

  Logger.Trace('');
  Logger.Debug('');
  Logger.Info('');
  Logger.Success('');
  Logger.Warn('');
  Logger.Error('');
  Logger.Fatal('');
  Logger.Custom('');

  // Modo simplificado
  Logger.T(''); // TRACE
  Logger.D(''); // DEBUG
  Logger.I(''); // INFO
  Logger.S(''); // SUCCESS
  Logger.W(''); // WARN
  Logger.E(''); // ERROR
  Logger.F(''); // FATAL
  Logger.C(''); // CUSTOM

SetLevelName

É possível mudar a descrição do level para outra descrição.

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Definindo o Level
  Logger.SetLevelName(TLoggerLevel.Info, 'INFORMATION');
  Logger.SetLevelName(TLoggerLevel.Warn, '  WARNING  ');

  // Gerando os logs
  Logger.Info('My message with level INFO');
  Logger.Warn('My message with level WARN');

  // Output: 2022-12-01 09:00:05.600 [INFORMATION] My message with level INFO
  // Output: 2022-12-01 09:00:05.600 [  WARNING  ] My message with level WARN

  Readln;
end.

SetLevel

É possível mostrar somente os logs a partir de um level definido, com base no TLoggerLevel.

SetLevel valor padrão = TLoggerLevel.All

TLoggerLevel

• Quando definido um level, será exibido somente a opção escolhida e seus tipos superiores.
• Ex: Logger.SetLevel(TLoggerLevel.Warn); - Será registrado somente os logs com o tipo Warn / Error / Fatal / Custom.

  TLoggerLevel.All = 'Utilizado para operações internas'
  TLoggerLevel.Trace = 'Level 1'
  TLoggerLevel.Debug = 'Level 2'
  TLoggerLevel.Info = 'Level 3'
  TLoggerLevel.Success = 'Level 4'
  TLoggerLevel.Warn = 'Level 5'
  TLoggerLevel.Error = 'Level 6'
  TLoggerLevel.Fatal = 'Level 7'
  TLoggerLevel.Custom = 'Level 8'

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Definindo o Level
  Logger.SetLevel(TLoggerLevel.Warn);

  // Gerando os logs
  Logger.Info('My message with level INFO');
  Logger.Error('My message with level ERROR');

  // Output: 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

SetDisableLevel

É possível desabilitar alguns levels do log, com base no TLoggerLevel.

SetDisableLevel valor padrão = []

• Quando desabilitado será exibido somente as opções que não estão desabilitadas.
• Ex: Logger.SetDisableLevel([TLoggerLevel.Info, TLoggerLevel.Warn]); - Será registrado somente os logs com o tipo Tracer / Debug / Success / Error / Fatal / Custom.

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Definindo o DisableLevel
  Logger.SetDisableLevel([TLoggerLevel.Info, TLoggerLevel.Warn]);

  // Gerando os logs
  Logger.Debug('My message with level DEBUG');
  Logger.Info('My message with level INFO');
  Logger.Warn('My message with level WARN');
  Logger.Error('My message with level ERROR');

  // Output:
  // 2022-12-01 09:00:05.500 [DEBUG] My message with level DEBUG
  // 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

SetOnlyLevel

É possível mostrar somente alguns levels do log, com base no TLoggerLevel.

SetOnlyLevel valor padrão = [TLoggerLevel.All]

• Quando definido será exibido somente as opções registradas.
• Ex: Logger.SetOnlyLevel([TLoggerLevel.Error]); - Será registrado somente os logs com o tipo Error.

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Definindo o OnlyLevel
  Logger.SetOnlyLevel([TLoggerLevel.Error]);

  // Gerando os logs
  Logger.Debug('My message with level DEBUG');
  Logger.Info('My message with level INFO');
  Logger.Warn('My message with level WARN');
  Logger.Error('My message with level ERROR');

  // Output:
  // 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

SetLogException

É possível capturar exceções geradas pelos providers

SetLogException valor padrão = nil

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Definindo o LogException
  Logger.SetLogException(
    procedure(const Sender: TObject; const LogItem: TLoggerItem; const E: Exception; var RetriesCount: Integer)
    begin
      // Sender - Provider que gerou a exceção, para visualizar - Sender.ClassName

      // LogItem - Contém todas as informações do log

      // E - Contém as informações da exceção

      // RetriesCount - Contém o número da tentativa realizada
      // Caso seja alterado o valor para -1, o processo é interrompido
    end
  );

  // Gerando o log
  Logger.Error('My message with level ERROR');

  // Output:
  // 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

SetMaxRetries

É possível definir o número de tentativas que o Provider deve tentar ao salvar o log.

SetMaxRetries valor padrão = 5

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Definindo o máximo de tentativas
  Logger.SetMaxRetries(5);

  // Gerando o log
  Logger.Error('My message with level ERROR');

  // Output:
  // 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

SetIgnoreTemplate

É possível ignorar o Template e salvar todos os dados gerados pelo DataLogger;

  SetIgnoreTemplate({1}, {2}, {3}, {4});

  Parâmetros:
    {1} = (Boolean) = Defini se deve ignorar o Template.
    {2} = (string) = Defini qual texto vai fazer a separação das informações, semelhante ao CSV.
    {3} = (Boolean) = Defini se deve mostrar as palavras chaves de cada valor.
    {4} = (string) = Defini qual texto deve separar a palavra chave do valor.

  Logger.SetIgnoreTemplate(True, '|', True, ' -> ');

  {palavra_chave}           = "timestamp"
  {palavra_chave_separador} = " -> "
  {valor}                   = "2022-09-15T14:39:38.896-03:00"
  {separator}               = " | "

  // output timestamp -> 2022-09-15T14:39:38.896-03:00 | timestamp_format -> 2022-09-15 14:39:38.896

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Ignorando o log format
  Logger.SetIgnoreTemplate(True, '|', True, ' -> ');

  // Gerando o log
  Logger.Error('My message with level ERROR');

  // Output:
  // timestamp -> 2022-09-15T14:39:38.896-03:00 | timestamp_format -> 2022-09-15 14:39:38.896 | name -> | sequence -> 1 | thread_id -> 3804 | level -> Trace | level_value -> 1 | tag -> | message -> My Trace | app_name -> ProviderTextFile | app_version -> 1.0.0.0 | app_path -> C:\Github\DataLogger\Samples\TextFile\Win32\Debug | app_size -> 13,24 MB | computer_name -> DESKTOP-7RP1H3K | username -> danil | os_version -> Windows 10 (Version 21H2, OS Build 19044.1889, 64-bit Edition) | process_id -> 13608 | ip_local -> 192.168.56.1

  Readln;
end.

SetName

É possível definir um nome para o DataLogger que pode ser exibido no registro do log. Esse nome pode ser utilizado para diferenciar o DataLogger quando a mais de uma instância.

SetName valor padrão = EmptyStr

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${name} ${timestamp} [${level}] ${message}');

  // Definindo o name
  Logger.SetName('MyLogger');

  // Gerando o log
  Logger.Error('My message with level ERROR');

  // Output:
  // MyLogger 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

SetLiveMode

É possível salvar os logs em tempo real, de forma que a próxima instrução do seu código só vai continuar depois que o log for salvo!

Atualmente os logs são registrados em memória e depois ele é salvo sem travar a aplicação.

SetLiveMode valor padrão = false

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create);

  // Definindo o template
  Logger.SetTemplate('${name} ${timestamp} [${level}] ${message}');

  // Definindo o LiveMode
  Logger.SetLiveMode(True);

  // Gerando o log
  Logger.Error('My message with level ERROR');

  // Output:
  // MyLogger 2022-12-01 09:00:05.600 [ERROR] My message with level ERROR

  Readln;
end.

Transaction

É possível trabalhar com Transaction, da mesma forma que é usado em outros componentes com conexão de banco de dados.

A utilização deste procedimento pode ser aplicado a seguinte situação;

Vamos contar uma pequena história:

Temos uma procedure que está fazendo uma execução, em cada etapa é gerado várias informações de log, por costume sempre salvamos essas informações, isso faz com que o nosso arquivo de texto por exemplo fique muito grande demais.
Agora imagina poder salvar os dados somente se houve algum erro durante a execução ou quando necessário realmente salvar os dados.

Como habilitar

A ativação do uso da Transaction deve ser feita por Provider com a função UseTransaction(True).

Ex:

Logger.AddProvider(
  TProviderConsole.Create
  .UseTransaction(True) // Enable transaction only on this provider
);

StartTransaction

Inicia uma nova transação.

CommitTransaction

Confirma o registra de todos os logs na transação.

RollbackTransaction

Cancela todos os logs gerados na transação.

Exemplo com Transação Simples

Sample com Transaction

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create.UseTransaction(True));

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Iniciando a transaction
  Logger.StartTransaction;

  Writeln('Iniciou a transaction');

  // Gerando o log
  Logger.Info('My message with level INFO 1 ');
  Logger.Info('My message with level INFO 2');
  Logger.Info('My message with level INFO 3');
  Logger.Info('My message with level INFO 4');
  Logger.Info('My message with level INFO 5');
  Logger.Info('My message with level INFO 6');
  Logger.Info('My message with level INFO 7');
  Logger.Info('My message with level INFO 8');
  Logger.Info('My message with level INFO 9');

  Writeln('Terminou os Logs');

  // Fazendo o commit
  Logger.CommitTransaction;
  Writeln('Fez os commits');

  Readln;
end.

Exemplo com Transation Aninhada

Sample com Transaction Aninhada

As transactions aninhadas dá a possibilidade de um gerenciamento maior na hora de salvar as informações.

• Apenas uma observação deve ser lembrada, só será salvo o registro final se houve commit da transação pai, ou seja, da transação que iniciou todo processo;
  Caso a transação pai, tenha feito rollback, as transações filhas que foram feitas commit serão ignoradas!

uses
  DataLogger,
  DataLogger.Provider.Console;

begin
  Logger.AddProvider(TProviderConsole.Create.UseTransaction(True));

  // Definindo o template
  Logger.SetTemplate('${timestamp} [${level}] ${message}');

  // Iniciando a transaction
  Logger.StartTransaction;
  try
    // Gerando o log
    Logger.Info('My message with level INFO 1 ');
    Logger.Info('My message with level INFO 2');
    Logger.Info('My message with level INFO 3');
    Logger.Info('My message with level INFO 4');

    // Iniciando 2 transaction
    Logger.StartTransaction;
    try
      Logger.Info('My message with level INFO 5');
      Logger.Info('My message with level INFO 6');
    finally
      // fazendo Rollback da segunda transaction
      Logger.RollbackTransaction;
    end;

    Logger.Info('My message with level INFO 7');
    Logger.Info('My message with level INFO 8');
    Logger.Info('My message with level INFO 9');
  finally
    // Fazendo o commit
    Logger.CommitTransaction;
  end;

  Readln;
end.