Page d'accueil>Lié à la programmation>Code source de Delphes
Télécharger

Datalogueur


| Portugais brésilien | Anglais |

Datalogueur

Datalogger est conçu pour être une simple bibliothèque de journaux prise en charge par plusieurs fournitures .

Support: dé[email protected]

Installation

Pour installer sur votre projet en utilisant le boss: 

$ boss install github.com/dliocode/datalogger

Installation manuelle

Ajoutez les dossiers suivants à votre projet, dans Project> Options> Compiler Delphi> Chemin de recherche 

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

? Indice

  • Comment utiliser
  • Proposer
  • Dépendances
  • Des informations supplémentaires
  • Exemples
    • Utilisation standard
    • Créer une nouvelle instance de Datalogueur
    • Datalogueur simple
    • Coutume
    • Spécial
      • Casse-noix
      • Décourager
    • Modèle (format de journal)
      • Modèle constant
    • Détroit
      • Comment définir un modèle en fournit des fournitures
    • SetFormattimstamp
    • Niveau
    • Nom de Setleveln
    • Devel
    • SetDisablevel
    • Sethonlylevel
    • Setlogexception
    • Setmaxreries
    • SetIgnoreTemplate
    • Nom de set
    • SetliveMode
    • Transaction

Comment utiliser

Il existe deux façons différentes d'utiliser Datalogger: directement par Logger ou instanciant votre propre TDataLogger .

Échantillons

Le premier est uniquement destiné à être un journal partagé pratique à utiliser dans votre application si vous choisissez.

  • Utilisations nécessaires : 
 uses DataLogger;

Proposer

Un fournisseur sert essentiellement pour stocker ses journaux. Chaque instance d'un tdatalogger peut avoir plusieurs fournitures configurées.

Ici, nous avons une liste de 60 fournitures disponibles:

Nom Usages Exemples
AWS CloudWatch Datalogger.provider.aws.cloudwatch AWS CloudWatch
Axiome Datalogger.provider.axiom Axiome
Callmebot Datalogger.provider.callmebot.whatsapp Callmebot
Console Datalogger.provider.console Console
Console simple
Coalogix Datalogger.provider.cragix Coalogix
CSV Datalogger.provider.csv CSV
Datadatog Datalogger.provider.date Datadatog
Datalust Datalogger.provider.datalust Datalust
Discorde Datalogger.provider.discord.webhook Discerner
Dynatrace Date Logger.Provider.Dynatrace Dynatrace
Elasticsearch Datalogger.provider.elasticsearch Elasticsearch
Lui apprendre Datalogger.provider.elmah Lui apprendre
E-mail Datalogger.provider.email E-mail
Journal des événements Datalogger.provider.eventlog Bloqueur
Événements Datalogger.provider.events Événements
Événements - avec ensemble de données
Événements - avec sqlite
Base de feu Date Logger.Provider.FireBase.Realtime Base de données Base de feu
Écart Datalogger.provider.grafana.loki
Datalogger.provider.grafana.concall.webhook		 Écart
Graphjson Datalogger.provider.graphjson Graphjson
Grislog Datalogger.provider.graylog Grislog
Html Datalogger.provider.html Html
Liste de listes Datalogger.provider.listbox Liste de listes
ListView Datalogger.provider.listview ListView
Logentries Datalogger.provider.logentries Logentries
Bûche Datalogger.provider.logflare Bûche
Déconnecter Datalogger.provider.loggly Déconnecter
Trottoir Datalogger.provider.logstash Trottoir
Logthal Datalogger.provider.logtail Logthal
Logz Datalogger.provider.logz Logz
Usine Datalogger.provider.mailgun.api Usine
Courrier Datalogger.provider.mailjet.api Courrier
Matemost Datalogger.provider.matemet
Datalogger.provider.mattemost.webhooks		 Matemost
Matemosthook
Note Datalogger.provider.memo Note
Mémo et fichier texte
Mémo - Seule Erreur / VCL
Mémoire Datalogger.provider.memory Mémoire
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
Nouveau Datalogger.provider.novu Nouveau
OutputdebugString Datalogger.provider.outputDebugString OutputdebugString
Papier Datalogger.provider.papertrail Papier
Cachet de la poste Datalogger.provider.postmark.api Cachet de la poste
Lapin Datalogger.provider.rabbitmq Lapin
Redis Datalogger.provider.redis Redis
Repos Datalogger.provider.rest.httpclient
Datalogger.provider.rest.indy
Datalogger.provider.rest.nethttpclient		 Repos
Riche Datalogger.provider.richedit Riche
Sematext Datalogger.provider.sematext.logs Sematext-logs
Sendchamp Datalogger.provider.sendchamp.sms
Datalogger.provider.sendchamp.whatsapp		 Senimemail
Senimemail Datalogger.provider.sendemail Senimemail
Sendgrid Datalogger.provider.sendgrid.webapi Sendgridwebapi
Mou Datalogger.provider.slack.webapi
Datalogger.provider.slack.webhook		 Mou
Sabot Datalogger.provider.splunk Sabot
Douille Datalogger.provider.socket Douille
Sumologique Datalogger.provider.sumologic Sumologique
Syslog Datalogger.provider.syslog
Datalogger.provider.syslog.indy		 Syslog
Syslog Indy
Télégramme Datalogger.provider.telegram Télégramme
Fichier de texte Datalogger.provider.textfile Fichier de texte
Ultramsg Datalogger.provider.ultramsg.whatsapp Ultramsg
Twilio Datalogger.provider.twilio.sms
Datalogger.provider.twilio.whatsapp		 Twilio
Z-api Datalogger.provider.zapi.whatsapp Z-api

Dépendances

Ces dépendances se produisent lorsque certains fournissent une utilisation

Fournisseur Dépend
Datalogger.provider.rabbitmq Lapin
Datalogger.provider.redis Redis
Datalogger.provider.sendemail Senimemail

Des informations supplémentaires

Plateforme Android:

L'autorisation Access_wifi_state est requise: Utilisé pour capturer l'adresse MAC du périphérique.

Exemples

Utilisation standard 

 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 .

Créer une nouvelle instance de Datalogueur 

 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 .

Datalogueur 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 .

Coutume

La coutume est le moyen de définir un nom pour votre propre niveau . 

 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 .

Spécial

Fonctions qui fonctionnent dans certains fournitures. 

  // Pula uma linha
  Logger.SlineBreak;

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

Casse-noix

La fonction SlineBreak utilisant pour briser la ligne. 

 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 .

Décourager

La fonction UndoLast utilisant pour annuler le dernier enregistrement effectué.

  • Certains prévoient n'ont aucun appel qui vous permet d'annuler la dernière inscription envoyée. 
 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 .

Modèle (format de journal)

Le modèle est le format qui sera généré le journal.

Modèle standard: 

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

Modèle constant

Certaines constantes peuvent être utilisées pour faciliter la création du modèle.

  • Commun 
 // 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} ' ;
  • Spécial: 
 // 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} ' ;

Détroit

Définit le format qui sera enregistré le journal 

 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 .

Comment définir un modèle en fournit des fournitures

  • Vous pouvez définir plusieurs paramètres spécifiques dans chaque fournisseur séparé. 
 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

Il modifie la forme d'horodatage.

  • Format d'horodatage standard: 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 .

Niveau

Datalogger a ces niveaux pour générer les journaux : 

  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

Nom de Setleveln

Il est possible de modifier la description du niveau en une autre description. 

 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 .

Devel

Il est possible de montrer uniquement les journaux à partir d'un niveau défini, basé sur TLoggerLevel .

Valeur par défaut de SetLevel = TLoggerLevel.All

Tloggerlevel

  • Lorsqu'un niveau est défini, seule l'option choisie et ses types supérieurs seront affichés.
  • Ex: Logger.SetLevel(TLoggerLevel.Warn); - Seuls les journaux seront enregistrés avec 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 .

SetDisablevel

Il est possible de désactiver certains journaux à partir du journal, basé sur TLoggerLevel .

SetDisablevel Noral Value = []

  • Lorsque les désactivés seront affichés, seules les options qui ne sont pas désactivées.
  • Ex: Logger.SetDisableLevel([TLoggerLevel.Info, TLoggerLevel.Warn]); - Seuls les journaux seront enregistrés auprès de 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 .

Sethonlylevel

Il est possible de montrer que quelques journaux du journal, basés sur le TLoggerLevel .

SetOnlyLevel Value par défaut = [TLoggerLevel.All]

  • Lorsqu'il est défini, seules les options enregistrées seront affichées.
  • Ex: Logger.SetOnlyLevel([TLoggerLevel.Error]); - Seuls les journaux seront enregistrés avec le type 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

Il est possible de capturer des exceptions générées par fournit

SetLoGException Valeur par défaut = 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

Il est possible de définir le nombre de tentatives que le fournisseur devrait essayer d'enregistrer le journal.

SetMaxReries Valeur standard = 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

Il est possible d'ignorer le modèle et d'enregistrer toutes les données générées par 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: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 .

Nom de set

Il est possible de définir un nom pour le données de données qui peut être affiché dans l'enregistrement du journal. Ce nom peut être utilisé pour différencier Datalogueur lorsque plusieurs instances.

SetName Value par défaut = 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

Il est possible d'enregistrer les journaux en temps réel, afin que la prochaine instruction de votre code ne se poursuive qu'après que le journal soit enregistré!

Les journaux sont actuellement enregistrés en mémoire, puis il est enregistré sans verrouiller l'application.

SetLiveMode Standard Value = 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

Il est possible de travailler avec la transaction , tout comme il est utilisé dans d'autres composants avec une connexion de base de données.

L'utilisation de cette procédure peut être appliquée à la situation suivante;

Disons une petite histoire:

Nous avons une procédure qui effectue, à chaque étape, plusieurs informations de journal sont générées, donc nous enregistrons toujours ces informations, ce qui rend notre fichier texte par exemple trop grand.
Imaginez maintenant pouvoir enregistrer les données uniquement s'il y avait des erreurs pendant l'exécution ou si nécessaire pour vraiment enregistrer les données.

Comment activer

L'activation de l'utilisation de la transaction doit être effectuée par le fournisseur avec la fonction UseTransaction(True) .

Ex: 

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

Starttrasation

Il commence une nouvelle transaction.

Commissance

Confirme l'enregistrement de tous les journaux de la transaction.

Rollbacktransation

Annule tous les journaux générés dans la transaction.

Exemple avec une transaction simple

Échantillon avec 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 .

Exemple avec Anninha

Échantillon avec transaction nichée

Les transactions nichistes donnent la possibilité d'une plus grande gestion lors de l'enregistrement des informations.

  • Une seule observation doit être rappelée, seule l'enregistrement final sera enregistré s'il y avait un engagement de la transaction père, c'est-à-dire la transaction qui a commencé l'ensemble du processus;
    Si la transaction du père est en retour, les transactions de filles qui ont été effectuées seront ignorées! 
 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 .
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout