datalogger Download - datalogger -Quellcode herunterladen

Datalogger

| Brasilianische Portugiesisch | Englisch |

Datalogger

Datalogger wurde als einfache Protokollbibliothek entwickelt, die von mehreren Bereitstellungen unterstützt wird.

Installation

So installieren Sie Ihr Projekt mit Chef:

$ boss install github.com/dliocode/datalogger

Manuelle Installation

Fügen Sie Ihrem Projekt die folgenden Ordner hinzu, in Projekt> Optionen> Delphi Compiler> Suchpfad

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

? Index

Wie man benutzt
Bietet
Abhängigkeiten
Zusätzliche Informationen
Beispiele
- Standardeinsatz
- Erstellen Sie eine neue Instanz von Datalogger
- Datalogger einfach
- Brauch
- Besonders
  - Slinebreak
  - Unvermeuert
- Vorlage (Protokollformat)
  - Konstante Vorlage
- SETMATE
  - So definieren Sie eine Vorlage in bestimmten Bereichen
- SetFormattimstamp
- Ebene
- SetlevelName
- Setlevel
- Setdisablevel
- Sethonlylevel
- Setlogexception
- SetMaxreries
- SetIgnoretemplate
- SetName
- SetLivemode
- Transaktion

Wie man benutzt

Es gibt zwei verschiedene Möglichkeiten, Datalogger zu verwenden: direkt durch Logger oder instanziieren Sie Ihren eigenen TDataLogger .

Proben

Das erste ist nur als bequemes gemeinsam genutztes Protokoll gedacht, das Sie in Ihrer App verwenden können, wenn Sie dies wünschen.

Notwendige Verwendungen :

 uses DataLogger;

Bietet

Ein Anbieter dient im Wesentlichen, um seine Protokolle zu speichern. Jede Instanz eines Tdatalogger kann mehrere konfigurierte Bereitstellungen haben.

Hier haben wir eine Liste von 60 bereitgestellt :

Name	Verwendung	Beispiele
AWS CloudWatch	Datalogger.provider.aws.cloudwatch	AWS CloudWatch
Axiom	Datalogger.provider.axiom	Axiom
Callmebot	Datalogger.provider.callmebot.whatsApp	Callmebot
Konsole	Datalogger.provider.Console	Konsole Einfache Konsole
Koalogix	Datalogger.Provider.Calogix	Koalogix
CSV	Datalogger.provider.csv	CSV
Datadatog	Datalogger.provider.dateg	Datadatog
Datalust	Datalogger.Provider.Datalust	Datalust
Zwietracht	Datalogger.Provider.Discord.Webhook	Discordhook
Dynatrace	Datum logger.provider.dynatrace	Dynatrace
Elasticsarch	Datalogger.Provider.ElasticSearch	Elasticsarch
Lehre ihn	Datalogger.provider.elmah	Lehre ihn
E-Mail	Datalogger.Provider.Email	E-Mail
Ereignisprotokoll	Datalogger.provider.EventLog	EventLog
Ereignisse	Datalogger.provider.Events	Ereignisse Ereignisse - mit Datensatz Ereignisse - mit SQLite
Firebase	Datum logger.provider.firebase.realtime Datenbank	Firebase
Lücke	Datalogger.provider.grafana.loki Datalogger.provider.grafana.oncall.Webhook	Lücke
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
Logentien	Datalogger.Provider.Logentriies	Logentien
Logflare	Datalogger.provider.logflare	Logflare
Protokolliert	Datalogger.Provider.Loggly	Protokolliert
Logstash	Datalogger.provider.logstash	Logstash
Logthal	Datalogger.provider.logtail	Logthal
Logz	Datalogger.provider.logz	Logz
Mailgun	Datalogger.provider.mailgun.api	Mailgun
MailJet	Datalogger.provider.mailjet.api	MailJet
Mattemost	Datalogger.provider.Mattemet Datalogger.provider.Mattemost.Webhooks	Mattemost Mattemosthook
Memo	Datalogger.provider.Memo	Memo Memo- und Textdatei Memo - Nur Fehler/VCL
Erinnerung	Datalogger.provider.Memory	Erinnerung
Mezma	Datalogger.provider.mezmo	Mezma
MongoDb	Datalogger.provider.Mongodb.cloud	MongoDb
Ntfy	Datalogger.provider.ntfy	Ntfy
Newrelic	Datalogger.Provider.Newrelic	Newrelic
Benachrichtigung	Datalogger.provider.notification	Benachrichtigung
Neu	Datalogger.provider.novu	Neu
Outputdebugstring	Datalogger.provider.OutputDebugstring	Outputdebugstring
Papertrail	Datalogger.Provider.PaperTrail	Papertrail
Stempel	Datalogger.provider.postmark.api	Stempel
Rabbitmq	Datalogger.provider.rabbitmq	Rabbitmq
Redis	Datalogger.provider.redis	Redis
Ausruhen	Datalogger.provider.rest.httpclient Datalogger.provider.rest.indy Datalogger.provider.rest.Nethttpclient	Ausruhen
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
Locker	Datalogger.provider.slack.webapi Datalogger.provider.slack.webhook	Locker
Splunk	Datalogger.provider.splunk	Splunk
Buchse	Datalogger.Provider.Socket	Buchse
Sumologisch	Datalogger.provider.sumologic	Sumologisch
Syslog	Datalogger.provider.syslog Datalogger.provider.syslog.indy	Syslog Syslog Indy
Telegramm	Datalogger.provider.telegram	Telegramm
Textdatei	Datalogger.provider.textfile	Textdatei
Ultramsg	Datalogger.provider.ultramsg.whatsapp	Ultramsg
Dämmerung	Datalogger.provider.twilio.sms Datalogger.provider.twilio.whatsapp	Dämmerung
Z-API	Datalogger.provider.zapi.whatsapp	Z-API

Abhängigkeiten

Diese Abhängigkeiten treten auf, wenn einige verwendet werden

Anbieter	Kommt darauf an
Datalogger.provider.rabbitmq	Rabbitmq
Datalogger.provider.redis	Redis
Datalogger.provider.sendemail	Sendemail

Zusätzliche Informationen

Android -Plattform:

Access_wifi_State -Berechtigung ist erforderlich: Wird verwendet, um die MAC -Adresse der Geräte zu erfassen.

Beispiele

Standardeinsatz

 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 .

Erstellen Sie eine neue Instanz von 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 einfach

 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 .

Brauch

Custom ist der Weg, um einen Namen für Ihre eigene Ebene zu definieren.

 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 .

Besonders

Funktionen, die in einigen arbeiten, bietet.

  // Pula uma linha
  Logger.SlineBreak;

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

Slinebreak

Die SlineBreak -Funktion verwendet, um die Linie zu brechen.

 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 .

Unvermeuert

Die UndoLast Funktion, die den letzten aufgeführten Datensatz rückgängig macht.

Einige Angebote haben keine Berufung, die es Ihnen ermöglicht, die letzte gesendete Registrierung rückgängig zu machen.

 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 .

Vorlage (Protokollformat)

Die Vorlage ist das Format, das das Protokoll erzeugt wird.

Standardvorlage:

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

Konstante Vorlage

Es gibt einige Konstanten, mit denen die Schaffung der Vorlage erleichtert werden kann.

Gemeinsam

 // 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} ' ;

Besonders:

 // 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} ' ;

SETMATE

Definiert das Format, das das Protokoll erfasst wird

 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 .

So definieren Sie eine Vorlage in bestimmten Bereichen

Sie können mehrere spezifische Einstellungen in jedem separaten Anbieter definieren.

 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 .

SetFormattimstamp

Es verändert die Zeitstempelform.

Standard-Zeitstempelformat: 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 .

Ebene

Datalogger hat diese Ebenen, um die Protokolle zu generieren:

  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

Es ist möglich, die Beschreibung der Ebene in eine andere Beschreibung zu ändern.

 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

Es ist möglich, nur die Protokolle aus einer definierten Ebene zu zeigen, basierend auf TLoggerLevel .

SETLEVEL -Standardwert = TLoggerLevel.All

Tloggerlevel

Wenn ein Level definiert ist, werden nur die ausgewählte Option und ihre überlegenen Typen angezeigt.
Ex: Logger.SetLevel(TLoggerLevel.Warn); - Es werden nur Protokolle mit Warn / Error / Fatal / Custom aufgezeichnet.

  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 .

Setdisablevel

Es ist möglich, einige Protokolle aus dem Protokoll zu deaktivieren, basierend auf TLoggerLevel .

SetDisablevel Standardwert = []

Wenn deaktiviert wird, werden nur Optionen angezeigt, die nicht deaktiviert sind.
Ex: Logger.SetDisableLevel([TLoggerLevel.Info, TLoggerLevel.Warn]); - Nur Protokolle werden mit Tracer / Debug / Success / Error / Fatal / Custom registriert.

 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 .

Sethonlylevel

Es ist möglich, nur wenige Protokolle des Protokolls anzuzeigen, basierend auf der TLoggerLevel .

SetonlyLevel Standardwert = [TLoggerLevel.All]

Wenn nur die registrierten Optionen definiert werden, werden angezeigt.
Ex: Logger.SetOnlyLevel([TLoggerLevel.Error]); - Es werden nur Protokolle mit Error aufgezeichnet.

 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

Es ist möglich, Ausnahmen zu erfassen, die von bereitgestellt wurden

Setlogexception Standardwert = 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 .

SetMaxreries

Es ist möglich, die Anzahl der Versuche zu definieren, die der Anbieter versuchen sollte, das Protokoll zu speichern.

SetMaxReries Standardwert = 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

Es ist möglich, die Vorlage zu ignorieren und alle von Datalogger generierten Daten zu speichern.

  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:GithubDataLoggerSamplesTextFileWin32Debug | 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

Es ist möglich, einen Namen für den Datalogger zu definieren, der im Protokolldatensatz angezeigt werden kann. Dieser Name kann verwendet werden, um Datalogger bei mehr als einer Instanz zu unterscheiden.

SetName Standardwert = 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

Es ist möglich, die Protokolle in Echtzeit zu speichern, damit die nächste Anweisung Ihres Codes erst nach dem Speichern des Protokolls fortgesetzt wird!

Derzeit werden Protokolle im Speicher aufgezeichnet und dann gespeichert, ohne die Anwendung zu sperren.

SetLivemode Standard Wert = 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 .

Transaktion

Es ist möglich, mit Transaktionen zu arbeiten, genau wie in anderen Komponenten mit Datenbankverbindung verwendet wird.

Die Verwendung dieses Verfahrens kann auf die folgende Situation angewendet werden.

Lassen Sie uns eine kleine Geschichte erzählen:

Wir haben eine Prozedur , die in jedem Schritt durchgeführt wird, und es werden mehrere Protokollinformationen generiert. Daher speichern wir diese Informationen immer. Dadurch wird unsere Textdatei beispielsweise zu groß.
Stellen Sie sich nun vor, Sie könnten die Daten nur dann speichern, wenn während der Ausführung Fehler oder bei Bedarf, um die Daten wirklich zu speichern.

Wie man aktiviert

Die Aktivierung der Transaktionsanwendung muss vom Anbieter mit der UseTransaction(True) -Funktion durchgeführt werden.

Ex:

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

Starttrasation

Es startet eine neue Transaktion.

CommitTransaction

Bestätigt den Aufzeichnung aller Protokolle in der Transaktion.

Rollbacktranation

Storniert alle in der Transaktion generierten Protokolle.

Beispiel mit einfacher Transaktion

Probe mit Transaktion

 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 .

Beispiel mit Anninha

Probe mit eingespannter Transaktion

Nestile -Transaktionen bieten die Möglichkeit eines größeren Managements beim Speichern der Informationen.

Es sollte nur eine Beobachtung in Erinnerung bleiben, nur die endgültige Registrierung wird gespeichert, wenn es sich für die Vatertransaktion befasst , dh der Transaktion, die den gesamten Prozess begann.
Wenn die Vater -Transaktion Rollback hat, werden die durchgeführten Töchtertransaktionen ignoriert!

 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 .

Expandieren