easyloggingpp
Chore release
﷽
→ Último lançamento
→ Registro de alterações
→ Amostras
Visão geral
Por que mais uma biblioteca
Visão geral dos recursos
Começando
Download
Início rápido
Instalar (opcional)
Configurando argumentos do aplicativo
Configuração
Nível
Configurar
Usando arquivo de configuração
Usando a classe el::Configurations
Usando configurações em linha
Configurações padrão
Configurações globais
Especificadores de formato de registro
Especificadores de formato de data/hora
Especificadores de formato personalizado
Sinalizadores de registro
Argumentos de aplicação
Macros de configuração
Configurações de leitura
Registro
Básico
Registro Condicional
Registro ocasional
printf como registro
Registro de rede
Registro detalhado
Básico
Condicional e Ocasional
Nível detalhado
Verifique se o registro detalhado está ativado
Módulo VM
Registrando novos registradores
Cancelar registro de registradores
Preenchendo IDs de Logger Existentes
Compartilhando repositório de registros
Recursos extras
Acompanhamento de desempenho
Acompanhamento de desempenho condicional
Faça uso de dados de monitoramento de desempenho
Rotação do arquivo de log
Tratamento de falhas
Instalando manipuladores de falhas personalizados
Stacktrace
Multi-threading
VERIFICAR Macros
Erros de registro()
Usando Syslog
Registro STL
Modelos Suportados
Registro Qt
Aumente o registro
Registro wxWidgets
Estendendo Biblioteca
Registrando sua própria aula
Registrando aula de terceiros
Liberando e rolando arquivos de log manualmente
Retorno de chamada de envio de registro
Retorno de chamada de registro do registrador
Registro assíncrono
Aulas auxiliares
Contribuição
Enviando correções
Relatando um bug
Compatibilidade
Matriz de construção
Licença
Isenção de responsabilidade
Easylogging++ é uma biblioteca de registro eficiente de cabeçalho único para aplicativos C++. É extremamente poderoso, altamente extensível e configurável de acordo com as necessidades do usuário. Ele fornece a capacidade de escrever seus próprios coletores (por meio do recurso conhecido como LogDispatchCallback ). Esta biblioteca é atualmente usada por centenas de projetos de código aberto no GitHub e outros sites de gerenciamento de controle de código aberto.
Este manual é para Easylogging++ v9.97.1. Para outras versões, consulte a versão correspondente no github.
Você também pode estar interessado no servidor de registro de resíduos.
Ir para o topo
Se você estiver trabalhando em um utilitário pequeno ou em um projeto grande em C++, esta biblioteca pode ser útil. É baseado em um único cabeçalho e requer apenas o link para um único arquivo de origem. (Originalmente era apenas cabeçalho e foi alterado para usar o arquivo de origem na edição nº 445. Você ainda pode usar apenas cabeçalho na v9.89).
Esta biblioteca foi projetada com vários pensamentos em mente (ou seja, portabilidade, desempenho, usabilidade, recursos e facilidade de configuração).
Por que mais uma biblioteca? Bem, a resposta é bastante direta, use-a como você a escreveu para que possa corrigir problemas (se houver) à medida que avança ou abordá-los no github. Além disso, eu pessoalmente não vi nenhuma biblioteca de log baseada em cabeçalho único com um design onde você possa configurar em qualquer lugar, estendê-la de acordo com suas necessidades e obter desempenho rápido. Já vi outras bibliotecas de log de cabeçalho único para C++, mas elas usam bibliotecas externas, por exemplo, boost ou Qt para oferecer suporte a certos recursos como threading, expressão regular ou data, etc. não que eu não goste dessas bibliotecas, na verdade adoro elas, mas como nem todos os projetos utilizam essas bibliotecas, não poderia correr o risco de depender delas.
Ir para o topo
Easylogging++ é rico em recursos, contendo muitos recursos que desenvolvedores típicos e avançados exigirão ao escrever um software;
Ir para o topo
Baixe a versão mais recente do último lançamento
Para outros lançamentos, visite a página de lançamentos. Se seu aplicativo não oferece suporte a C++ 11, considere usar a versão 8.91. Esta é uma versão estável para C++98 e C++03, faltando apenas alguns recursos.
Ir para o topo
Para começar a usar o Easylogging++, você pode seguir três etapas fáceis:
easylogging++.h e easylogging++.cc )# include " easylogging++.h "
INITIALIZE_EASYLOGGINGPP
int main ( int argc, char * argv[]) {
LOG (INFO) << " My first info log using default logger " ;
return 0 ;
}Agora compile usando
g++ main.cc easylogging++.cc -o prog -std=c++11
Tão simples! Observe que INITIALIZE_EASYLOGGINGPP deve ser usado uma vez e somente uma vez, caso contrário você acabará recebendo erros de compilação. Esta é a definição de diversas variáveis extern . Isso significa que ele pode ser definido apenas uma vez por aplicativo. O melhor lugar para colocar esta instrução de inicialização é no arquivo onde a função int main(int, char**) está definida, logo após a última instrução de inclusão.
Se quiser instalar este cabeçalho em todo o sistema, você pode fazer isso por meio de:
mkdir build
cd build
cmake -Dtest=ON ../
make
make test
make install
As opções a seguir são suportadas pelo Easylogging++ cmake e você pode ativar essas opções usando -D<option>=ON
lib_utc_datetime - Define ELPP_UTC_DATETIMEbuild_static_lib - Constrói biblioteca estática para Easylogging++ Dito isso, você ainda precisará do arquivo easylogging++.cc para compilar. Apenas para cabeçalho, verifique v9.89 e inferior.
Alternativamente, você pode baixar e instalar o easyloggingpp usando o gerenciador de dependência vcpkg:
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
./vcpkg install easyloggingpp
A porta easyloggingpp no vcpkg é mantida atualizada pelos membros da equipe da Microsoft e colaboradores da comunidade. Se a versão estiver desatualizada, crie um problema ou solicitação pull no repositório vcpkg.
Ir para o topo
É sempre recomendado passar os argumentos da aplicação para o Easylogging++. Alguns recursos do Easylogging++ exigem que você defina argumentos de aplicação, por exemplo, registro detalhado para definir níveis detalhados ou vmodules (explicados posteriormente). Para fazer isso você pode usar macro auxiliar ou classe auxiliar;
int main ( int argc, char * argv[]) {
START_EASYLOGGINGPP (argc, argv);
...
} Ir para o topo
Para começar a configurar sua biblioteca de criação de log, você deve compreender os níveis de gravidade. Easylogging++ deliberadamente não usa registro hierárquico para controlar totalmente o que está habilitado e o que não está. Dito isto, ainda há a opção de usar o log hierárquico usando LoggingFlag::HierarchicalLogging . Easylogging++ possui os seguintes níveis (ordenados para níveis hierárquicos)
| Nível | Descrição |
|---|---|
| Global | Nível genérico que representa todos os níveis. Útil ao definir a configuração global para todos os níveis. |
| Rastreamento | Informações que podem ser úteis para rastrear determinados eventos - mais úteis do que logs de depuração. |
| Depurar | Eventos informativos mais úteis para desenvolvedores depurarem aplicativos. Aplicável apenas se NDEBUG não estiver definido (para não VC++) ou _DEBUG estiver definido (para VC++). |
| Fatal | Evento de erro muito grave que provavelmente levará o aplicativo a ser abortado. |
| Erro | Informações de erro, mas continuarão o aplicativo em execução. |
| Aviso | Informações que representam erros no aplicativo, mas o aplicativo continuará em execução. |
| Informações | Útil principalmente para representar o progresso atual da aplicação. |
| Verboso | Informações que podem ser altamente úteis e variam de acordo com o nível de registro detalhado. A criação de log detalhada não é aplicável à criação de log hierárquica. |
| Desconhecido | Aplicável apenas à criação de log hierárquico e é usado para desativar completamente a criação de log. |
Ir para o topo
Easylogging++ é fácil de configurar. Existem três maneiras possíveis de fazer isso,
A configuração pode ser feita por arquivo que é carregado em tempo de execução pela classe Configurations . Este arquivo possui o seguinte formato;
* LEVEL:
CONFIGURATION NAME = "VALUE" ## Comment
ANOTHER CONFIG NAME = "VALUE"
O nome do nível começa com uma estrela (*) e termina com dois pontos (:). É altamente recomendável iniciar seu arquivo de configuração com nível Global para que qualquer configuração não especificada no arquivo use automaticamente a configuração de Global . Por exemplo, se você definir Filename como Global e desejar que todos os níveis usem o mesmo nome de arquivo, não o defina explicitamente para cada nível, a biblioteca usará o valor de configuração do Global automaticamente. A tabela a seguir contém configurações suportadas pelo arquivo de configuração.
| Nome da configuração | Tipo | Descrição |
|---|---|---|
Enabled | bool | Determina se o nível correspondente do criador de logs está habilitado ou não. Você pode desabilitar todos os logs usando el::Level::Global |
To_File | bool | Gravar ou não o log correspondente no arquivo de log |
To_Standard_Output | bool | Se deve ou não gravar logs na saída padrão, por exemplo, terminal ou prompt de comando |
Format | caractere* | Determina o formato/padrão de registro para o nível e registrador correspondente. |
Filename | caractere* | Determina o arquivo de log (caminho completo) para gravar logs para o nível e logger correspondentes |
Subsecond_Precision | unint | Especifica a precisão de subsegundos (anteriormente chamada de 'largura em milissegundos'). A largura pode estar dentro do intervalo (1-6) |
Performance_Tracking | bool | Determina se o rastreamento de desempenho está habilitado ou não. Isso não depende do logger ou do nível. O acompanhamento de desempenho sempre usa o registrador de 'desempenho', a menos que especificado |
Max_Log_File_Size | tamanho_t | Se o tamanho do arquivo de log do nível correspondente for >= tamanho especificado, o arquivo de log será truncado. |
Log_Flush_Threshold | tamanho_t | Especifica o número de entradas de log a serem retidas até liberarmos os dados de log pendentes |
Por favor, não use aspas duplas em nenhum comentário, pois você pode acabar tendo um comportamento inesperado.
Exemplo de arquivo de configuração
* GLOBAL:
FORMAT = "%datetime %msg"
FILENAME = "/tmp/logs/my.log"
ENABLED = true
TO_FILE = true
TO_STANDARD_OUTPUT = true
SUBSECOND_PRECISION = 6
PERFORMANCE_TRACKING = true
MAX_LOG_FILE_SIZE = 2097152 ## 2MB - Comment starts with two hashes (##)
LOG_FLUSH_THRESHOLD = 100 ## Flush after every 100 logs
* DEBUG:
FORMAT = "%datetime{%d/%M} %func %msg"
O conteúdo do arquivo de configuração no exemplo acima é simples. Começamos com o nível GLOBAL para substituir todos os níveis. Qualquer nível subsequente definido explicitamente substituirá a configuração de GLOBAL . Por exemplo, todos os níveis, exceto DEBUG têm o mesmo formato, ou seja, data e hora e mensagem de log. Para o nível DEBUG , temos apenas data (com dia e mês), função de origem e mensagem de log. O resto das configurações para DEBUG são usadas em GLOBAL . Além disso, observe {%d/%M} no formato DEBUG acima, se você não especificar o formato de data, o formato padrão será usado. Os valores padrão de data/hora são %d/%M/%Y %h:%m:%s,%g Para obter mais informações sobre esses especificadores de formato, consulte a seção Especificador de formato de data/hora abaixo
# include " easylogging++.h "
INITIALIZE_EASYLOGGINGPP
int main ( int argc, const char ** argv) {
// Load configuration from file
el::Configurations conf ( " /path/to/my-conf.conf " );
// Reconfigure single logger
el::Loggers::reconfigureLogger ( " default " , conf);
// Actually reconfigure all loggers instead
el::Loggers::reconfigureAllLoggers (conf);
// Now all the loggers will use configuration from file
}Seu arquivo de configuração pode ser convertido para o objeto
el::Configurations(usando o construtor) que pode ser usado onde for necessário (como no exemplo acima).
Ir para o topo
Você pode definir configurações ou redefinir configurações;
# include " easylogging++.h "
INITIALIZE_EASYLOGGINGPP
int main ( int argc, const char ** argv) {
el::Configurations defaultConf;
defaultConf. setToDefault ();
// Values are always std::string
defaultConf. set (el::Level::Info,
el::ConfigurationType::Format, " %datetime %level %msg " );
// default logger uses default configurations
el::Loggers::reconfigureLogger ( " default " , defaultConf);
LOG (INFO) << " Log using default file " ;
// To set GLOBAL configurations you may use
defaultConf. setGlobally (
el::ConfigurationType::Format, " %date %msg " );
el::Loggers::reconfigureLogger ( " default " , defaultConf);
return 0 ;
}A configuração só precisa ser definida uma vez. Se estiver satisfeito com a configuração padrão, você também poderá usá-la.
Ir para o topo
Configuração embutida significa que você pode definir configurações em std::string mas certifique-se de adicionar todos os novos caracteres de linha, etc. Isso não é recomendado porque é sempre confuso.
el::Configurations c;
c.setToDefault();
c.parseFromText( " *GLOBAL: n FORMAT = %level %msg " );O código acima define apenas o objeto Configurações, você ainda precisa reconfigurar os registradores usando essas configurações.
Ir para o topo
Se você deseja ter uma configuração para criadores de log existentes e futuros, você pode usar el::Loggers::setDefaultConfigurations(el::Configurations& configurations, bool configureExistingLoggers = false) . Isso é útil quando você está trabalhando em grande escala ou usando uma biblioteca de terceiros que já usa o Easylogging++. Qualquer criador de logs recém-criado usará configurações padrão. Se você também deseja configurar os criadores de log existentes, você pode definir o segundo argumento como true (o padrão é false ).
Ir para o topo
Level::Global não tem nada a ver com configurações globais, é um conceito onde você pode registrar configurações para todos/ou alguns loggers e até mesmo registrar novos loggers usando o arquivo de configuração. A sintaxe do arquivo de configuração é:
-- LOGGER ID ## Case sensitive
## Everything else is same as configuration file
-- ANOTHER LOGGER ID
## Configuration for this logger
O ID do registrador começa com dois travessões. Depois de escrever seu arquivo de configuração global, você poderá configurar todos os seus registradores (e registrar novos) usando uma única função;
int main ( void ) {
// Registers new and configures it or
// configures existing logger - everything in global.conf
el::Loggers::configureFromGlobal ( " global.conf " );
// .. Your prog
return 0 ;
}Observe que não é possível registrar um novo registrador usando configuração global sem definir sua configuração. Você deve definir pelo menos uma configuração única. Outras maneiras de registrar registradores são discutidas na seção Registro abaixo.
Ir para o topo
Você pode personalizar o formato do log usando os seguintes especificadores:
| Especificador | Substituído por |
|---|---|
%logger | ID do registrador |
%thread | Thread ID - Usa std::thread se disponível, caso contrário GetCurrentThreadId() no Windows |
%thread_name | Use Helpers::setThreadName para definir o nome do thread atual (de onde você executa setThreadName ). Veja exemplo de nomes de thread |
%level | Nível de gravidade (Informações, Depuração, Erro, Aviso, Fatal, Verbose, Rastreamento) |
%levshort | Nível de gravidade (versão resumida, ou seja, I para informações e respectivamente D, E, W, F, V, T) |
%vlevel | Nível de verbosidade (aplicável ao registro detalhado) |
%datetime | Data e/ou hora - O padrão é personalizável - consulte os especificadores de formato de data/hora abaixo |
%user | Usuário atualmente executando o aplicativo |
%host | O aplicativo de nome do computador está em execução |
%file * | Nome do arquivo de origem (caminho completo) - Este recurso está sujeito à disponibilidade da macro __FILE__ do compilador |
%fbase * | Nome do arquivo de origem (somente nome base) |
%line * | Número da linha de origem - Este recurso está sujeito à disponibilidade da macro __LINE__ de compilação |
%func * | Função de registro |
%loc * | Nome do arquivo de origem e número da linha de registro (separados por dois pontos) |
%msg | Mensagem de registro real |
% | Caractere de escape (por exemplo, %%level escreverá %level) |
__LINE__ , __FILE__ etc. Ir para o topo
Você pode personalizar o formato de data/hora usando os seguintes especificadores
| Especificador | Substituído por |
|---|---|
%d | Dia do mês (preenchido com zeros) |
%a | Dia da semana - curto (segunda, terça, quarta, quinta, sexta, sábado, domingo) |
%A | Dia da semana - longo (segunda, terça, quarta, quinta, sexta, sábado, domingo) |
%M | Mês (preenchido com zeros) |
%b | Mês - curto (janeiro, fevereiro, março, abril, maio, junho, julho, agosto, setembro, outubro, novembro, dezembro) |
%B | Mês - Longo (janeiro, fevereiro, março, abril, maio, junho, julho, agosto, setembro, outubro, novembro, dezembro) |
%y | Ano - Dois dígitos (13, 14 etc) |
%Y | Ano - Quatro dígitos (2013, 2014 etc) |
%h | Hora (formato de 12 horas) |
%H | Hora (formato de 24 horas) |
%m | Minuto (preenchido com zeros) |
%s | Segundo (preenchido com zeros) |
%g | Parte do subsegundo (a precisão é configurada por ConfigurationType::SubsecondPrecision) |
%F | Designação AM/PM |
% | Personagem de fuga |
Observe que a data/hora está limitada a no máximo 30 caracteres.
Ir para o topo
Você também pode especificar seus próprios especificadores de formato. Para fazer isso você pode usar el::Helpers::installCustomFormatSpecifier . Um exemplo perfeito é %ip_addr para aplicação de servidor TCP;
const char * getIp ( const el::LogMessage*) {
return " 192.168.1.1 " ;
}
int main ( void ) {
el::Helpers::installCustomFormatSpecifier ( el::CustomFormatSpecifier ( " %ip_addr " , getIp));
el::Loggers::reconfigureAllLoggers (el::ConfigurationType::Format, " %datetime %level %ip_addr : %msg " );
LOG (INFO) << " This is request from client " ;
return 0 ;
} Ir para o topo
Em algumas partes do registro, você pode definir sinalizadores de registro; aqui estão os sinalizadores suportados:
| Bandeira | Descrição |
|---|---|
NewLineForContainer (1) | Garante que tenhamos uma nova linha para cada entrada de log do contêiner |
AllowVerboseIfModuleNotSpecified (2) | Garante que se -vmodule for usado e não especificar um módulo, então o registro detalhado será permitido por meio desse módulo. Digamos que o parâmetro era -vmodule=main*=3 e um log detalhado está sendo gravado a partir de um arquivo chamado Something.cpp, então, se este sinalizador estiver habilitado, o log será gravado, caso contrário, não será permitido. Nota: ter este propósito de derrota de -vmodule |
LogDetailedCrashReason (4) | Ao lidar com falhas por padrão, o motivo detalhado da falha também será registrado (desativado por padrão) (problema nº 90) |
DisableApplicationAbortOnFatalLog (8) | Permite desativar o aborto do aplicativo quando logado no nível FATAL. Observe que isso não se aplica aos manipuladores de travamento padrão, pois o aplicativo deve ser abortado após o sinal de travamento ser tratado. (Não adicionado por padrão) (edição nº 119) |
ImmediateFlush (16) | Libera o log com cada entrada de log (sensível ao desempenho) - Desabilitado por padrão |
StrictLogFileSizeCheck (32) | Garante que o tamanho do arquivo de log seja verificado em cada log |
ColoredTerminalOutput (64) | A saída do terminal será colorida se for suportada pelo terminal. |
MultiLoggerSupport (128) | Ativa o suporte para o uso de vários criadores de logs para registrar uma única mensagem. (Por exemplo, CLOG(INFO, "default", "network") << This will be logged using default and network loggers; ) |
DisablePerformanceTrackingCheckpointComparison (256) | Desativa a comparação de pontos de verificação |
DisableVModules (512) | Desativa o uso de vmodules |
DisableVModulesExtensions (1024) | Desativa a extensão vmodules. Isso significa que se você tiver um vmodule -vmodule=main*=4 ele cobrirá tudo começando com main, onde como se você não tivesse isso definido você será coberto para qualquer arquivo começando com main e terminando com uma das seguintes extensões; .h .c .cpp .cc .cxx .-inl-.h .hxx .hpp. Observe que o seguinte vmodule não está correto -vmodule=main.=4 com esta macro não definida porque isso verificará main..c, observe os pontos duplos. Se você deseja que isso seja válido, dê uma olhada no sinalizador de log acima: AllowVerboseIfModuleNotSpecified '?' e '' curingas são suportados |
HierarchicalLogging (2048) | Ativa o registro hierárquico. Isso não se aplica ao registro detalhado. |
CreateLoggerAutomatically (4096) | Cria o registrador automaticamente quando não está disponível. |
AutoSpacing (8192) | Adiciona espaços automaticamente. Por exemplo, LOG(INFO) << "DODGE" << "THIS!"; irá gerar "DODGE THIS!" |
FixedTimeFormat (16384) | Aplicável apenas ao acompanhamento de desempenho - isso evita o tempo de formatação. Por exemplo, 1001 ms serão registrados como estão, em vez de formatá-los como 1.01 sec |
IgnoreSigInt (32768) | Quando o aplicativo trava, ignore o sinal de interrupção |
Você pode definir/desativar esses sinalizadores usando static el::Loggers::addFlag e el::Loggers::removeFlag . Você pode verificar se determinado sinalizador está disponível usando el::Loggers::hasFlag , todas essas funções usam enum fortemente digitado el::LoggingFlag
Você pode definir esses sinalizadores usando o argumento de linha de comando
--logging-flags. Você precisa habilitar esta funcionalidade definindo a macroELPP_LOGGING_FLAGS_FROM_ARG(você precisará usarSTART_EASYLOGGINGPP(argc, argv)para configurar argumentos).
Você também pode definir sinalizadores padrão (iniciais) usando
ELPP_DEFAULT_LOGGING_FLAGSe definir valores numéricos para sinalizadores iniciais
Ir para o topo
A tabela a seguir explicará todos os argumentos de linha de comando que você pode usar para definir determinado comportamento; Você precisará inicializar os argumentos do aplicativo usando START_EASYLOGGINGPP(argc, argv) em sua função main(int, char**) .
| Argumento | Descrição |
|---|---|
-v | Ativa verbosidade máxima |
--v=2 | Ativa verbosidade até nível detalhado 2 (intervalo válido: 0-9) |
--verbose | Ativa verbosidade máxima |
-vmodule=MODULE_NAME | Ativa o detalhamento para arquivos começando com main até o nível 1, o restante dos arquivos depende do sinalizador de registro AllowVerboseIfModuleNotSpecified Consulte a seção Sinalizadores de registro acima. Dois módulos podem ser separados por vírgula. Observe que os vmodules são os últimos em ordem de precedência de verificação de argumentos para registro detalhado, por exemplo, se tivermos -v nos argumentos do aplicativo antes dos vmodules, os vmodules serão ignorados. |
--logging-flags=3 | Define o sinalizador de registro. No exemplo ie, 3 , ele define o sinalizador de log como NewLineForContainer e AllowVerboseIfModuleNotSpecified . Consulte a seção de sinalizadores de registro acima para obter mais detalhes e valores. Consulte a seção de macros para desativar esta função. |
--default-log-file=FILE | Define o arquivo de log padrão para criadores de log existentes e futuros. Você pode considerar a definição de ELPP_NO_DEFAULT_LOG_FILE para evitar a criação de um arquivo de log vazio padrão durante o pré-processamento. Consulte a seção de macros para desativar esta função. |
Ir para o topo
Algumas das opções de log podem ser definidas por macros, esta é uma decisão cuidadosa, por exemplo, se tivermos ELPP_THREAD_SAFE definido, todas as funcionalidades thread-safe serão habilitadas, caso contrário desabilitadas (certificando-se de que a sobrecarga da segurança do thread esteja junto). Para facilitar a memorização e evitar possíveis conflitos, todas as macros começam com ELPP_
NOTA: Todas as macros podem ser definidas de uma das seguintes maneiras:
Defina macros usando a opção -D do compilador, por exemplo no caso de g++ você fará g++ source.cpp ... -DELPP_SYSLOG -DELPP_THREAD_SAFE ... ( maneira recomendada )
Defina macros dentro de "easylogging++.h" (definir macros em outros arquivos não funcionará)
| Nome da macro | Descrição |
|---|---|
ELPP_DEBUG_ASSERT_FAILURE | Anula o aplicativo na primeira falha de asserção. Esta afirmação é devido a entrada inválida, por exemplo, arquivo de configuração inválido, etc. |
ELPP_UNICODE | Ativa o suporte Unicode durante o registro. Requer START_EASYLOGGINGPP |
ELPP_THREAD_SAFE | Ativa a segurança de thread - certifique-se de vincular -lpthread para Linux. |
ELPP_FORCE_USE_STD_THREAD | Força a usar a biblioteca padrão C++ para threading (Útil apenas ao usar ELPP_THREAD_SAFE |
ELPP_FEATURE_CRASH_LOG | Aplicável apenas ao GCC. Ativa o stacktrace em caso de falha do aplicativo |
ELPP_DISABLE_DEFAULT_CRASH_HANDLING | Desativa o tratamento de falhas padrão. Você pode usar el::Helpers::setCrashHandler para usar seu próprio manipulador. |
ELPP_DISABLE_LOGS | Desativa todos os logs - (pré-processamento) |
ELPP_DISABLE_DEBUG_LOGS | Desativa logs de depuração - (pré-processamento) |
ELPP_DISABLE_INFO_LOGS | Desativa registros de informações - (pré-processamento) |
ELPP_DISABLE_WARNING_LOGS | Desativa logs de aviso - (pré-processamento) |
ELPP_DISABLE_ERROR_LOGS | Desativa logs de erros - (pré-processamento) |
ELPP_DISABLE_FATAL_LOGS | Desativa logs fatais - (pré-processamento) |
ELPP_DISABLE_VERBOSE_LOGS | Desativa logs detalhados - (pré-processamento) |
ELPP_DISABLE_TRACE_LOGS | Desativa logs de rastreamento - (pré-processamento) |
ELPP_FORCE_ENV_VAR_FROM_BASH | Se a variável de ambiente não puder ser encontrada, force o uso do comando bash alternativo para encontrar o valor, por exemplo, whoami para nome de usuário. (NÃO USE ESTA MACRO COM LD_PRELOAD PARA BIBLIOTECAS QUE JÁ ESTÃO USANDO Easylogging++ OU VOCÊ ACABARÁ EM STACK OVERFLOW PARA PROCESSOS ( popen ) (veja a edição #87 para detalhes)) |
ELPP_DEFAULT_LOG_FILE | Nome completo do arquivo onde você deseja que os arquivos iniciais sejam criados. Você precisa incorporar o valor desta macro entre aspas, por exemplo, -DELPP_DEFAULT_LOG_FILE='"logs/el.gtest.log"' Observe as aspas duplas dentro das aspas simples, as aspas duplas são os valores para const char* e aspas simples especificam o valor de macro |
ELPP_NO_LOG_TO_FILE | Desative o registro no arquivo inicialmente |
ELPP_NO_DEFAULT_LOG_FILE | Se você não quiser inicializar a biblioteca com o arquivo de log padrão, defina esta macro. Isso registrará no dispositivo nulo para Unix e Windows. Em outras plataformas você pode receber erros e precisará usar ELPP_DEFAULT_LOG_FILE . (PR para dispositivos nulos de outras plataformas são muito bem-vindos) |
ELPP_FRESH_LOG_FILE | Nunca anexa o arquivo de log sempre que o arquivo de log for criado (use com cuidado, pois pode causar algum resultado inesperado para alguns usuários) |
ELPP_DEBUG_ERRORS | Se você deseja descobrir erros internos gerados pelo Easylogging++ que podem ser devido à configuração ou qualquer outra coisa, você pode habilitá-los definindo esta macro. Você receberá seus erros na saída padrão, ou seja, terminal ou prompt de comando. |
ELPP_DISABLE_CUSTOM_FORMAT_SPECIFIERS | Desativa à força especificadores de formato personalizado |
ELPP_DISABLE_LOGGING_FLAGS_FROM_ARG | Desativa à força a capacidade de definir sinalizadores de registro usando argumentos de linha de comando |
ELPP_DISABLE_LOG_FILE_FROM_ARG | Desativa à força a capacidade de definir o arquivo de log padrão a partir de argumentos de linha de comando |
ELPP_WINSOCK2 | No sistema Windows, force o uso de winsock2.h em vez de winsock.h quando WIN32_LEAN_AND_MEAN estiver definido |
ELPP_CUSTOM_COUT (avançado) | Resolve um valor, por exemplo, #define ELPP_CUSTOM_COUT qDebug() ou #define ELPP_CUSTOM_COUT std::cerr . Isso usará o valor da saída padrão (em vez de usar std::cout |
ELPP_CUSTOM_COUT_LINE (avançado) | Usado com ELPP_CUSTOM_COUT para definir como escrever uma linha de log com cout customizado. por exemplo, #define ELPP_CUSTOM_COUT_LINE(msg) QString::fromStdString(msg).trimmed() |
ELPP_NO_CHECK_MACROS | Não defina as macros CHECK |
ELPP_NO_DEBUG_MACROS | Não defina as macros DEBUG |
ELPP_UTC_DATETIME | Usa a hora UTC em vez da hora local (essencialmente usa gmtime em vez de localtime e funções familiares) |
ELPP_NO_GLOBAL_LOCK | Não bloqueie todo o armazenamento no envio. Isto deve ser usado com cuidado. Veja a edição nº 580 |
Ir para o topo
Se você deseja ler as configurações de determinado logger, você pode fazê-lo usando a função typedConfigurations() na classe Logger.
el::Logger* l = el::Loggers::getLogger( " default " );
bool enabled = l-> typedConfigurations ()->enabled(el::Level::Info);
// Or to read log format/pattern
std::string format =
l-> typedConfigurations ()->logFormat(el::Level::Info).format(); Ir para o topo
O login no easylogging++ é feito usando uma coleção de macros. Isso torna mais fácil para o usuário e evita que ele conheça maiores detalhes desnecessários de como as coisas são feitas.
Você recebe duas macros básicas que podem ser usadas para gravar logs:
LOG(LEVEL)CLOG(LEVEL, logger ID) LOG usa o criador de logs 'padrão' enquanto em CLOG (Custom LOG) você especifica o ID do criador de logs. Para NÍVEIS, consulte a seção Configurações - Níveis acima. Registradores diferentes podem ter configurações diferentes dependendo da sua necessidade. Você também pode escrever uma macro personalizada para acessar o registrador personalizado. Você também tem macros diferentes para registro detalhado, explicadas na seção abaixo. Aqui está um exemplo muito simples de uso dessas macros depois de inicializar o easylogging++.
LOG (INFO) << "This is info log";
CLOG (ERROR, " performance " ) << "This is info log using performance logger"; Existe outra maneira de usar a mesma macro, ou seja, LOG (e macros associadas). Isto é que você define a macro ELPP_DEFAULT_LOGGER e ELPP_DEFAULT_PERFORMANCE_LOGGER com o ID do criador de logs que já está registrado, e agora quando você usa a macro LOG , ele automaticamente usará o criador de logs especificado em vez do criador de logs default . Observe que isso deve ser definido no arquivo de origem em vez do arquivo de cabeçalho. Isso ocorre para que, quando incluímos o cabeçalho, não usemos acidentalmente um registrador inválido.
Um exemplo rápido está aqui
# ifndef ELPP_DEFAULT_LOGGER
# define ELPP_DEFAULT_LOGGER " update_manager "
# endif
# ifndef ELPP_DEFAULT_PERFORMANCE_LOGGER
# define ELPP_DEFAULT_PERFORMANCE_LOGGER ELPP_DEFAULT_LOGGER
# endif
# include " easylogging++.h "
UpdateManager::UpdateManager {
_TRACE; // Logs using LOG(TRACE) provided logger is already registered - i.e, update_manager
LOG (INFO) << " This will log using update_manager logger as well " ;
}# include " easylogging++.h "
UpdateManager::UpdateManager {
_TRACE; // Logs using LOG(TRACE) using default logger because no `ELPP_DEFAULT_LOGGER` is defined unless you have it in makefile
}Você também pode escrever logs usando a classe
Loggerdiretamente. Este recurso está disponível em compiladores que suportam modelos variados. Você pode explorar mais examinandosamples/STL/logger-log-functions.cpp.
Ir para o topo
Easylogging++ fornece certos aspectos de registro, um desses aspectos é o registro condicional, ou seja, o registro será gravado somente se determinadas condições forem atendidas. Isso é muito útil em algumas situações. As macros auxiliares terminam com _IF;
LOG_IF(condition, LEVEL)CLOG_IF(condition, LEVEL, logger ID) LOG_IF (condition, INFO) << "Logged if condition is true";
LOG_IF ( false , WARNING) << "Never logged";
CLOG_IF ( true , INFO, " performance " ) << "Always logged (performance logger)" As mesmas macros estão disponíveis para registro detalhado com V no início, ou seja, VLOG_IF e CVLOG_IF . consulte a seção de registro detalhado abaixo para obter mais informações. Você pode ter condições tão complicadas quanto desejar, dependendo da sua necessidade.
Ir para o topo
O registro ocasional é outro aspecto útil do registro com Easylogging++. Isso significa que um log será gravado se for atingido em determinados momentos ou parte de determinados momentos, por exemplo, a cada 10º acerto ou 100º acerto ou 2º acerto. As macros auxiliares terminam com _EVERY_N ;
LOG_EVERY_N(n, LEVEL)CLOG_EVERY_N(n, LEVEL, logger ID)Existem algumas outras maneiras de registrar também com base nas contagens de ocorrências. Essas macros úteis são
LOG_AFTER_N(n, LEVEL) ; Somente registra quando atingimos contagens de acertos de nLOG_N_TIMES(n, LEVEL) ; Registra n vezes for ( int i = 1 ; i <= 10 ; ++i) {
LOG_EVERY_N ( 2 , INFO) << " Logged every second iter " ;
}
// 5 logs written; 2, 4, 6, 7, 10
for ( int i = 1 ; i <= 10 ; ++i) {
LOG_AFTER_N ( 2 , INFO) << " Log after 2 hits; " << i;
}
// 8 logs written; 3, 4, 5, 6, 7, 8, 9, 10
for ( int i = 1 ; i <= 100 ; ++i) {
LOG_N_TIMES ( 3 , INFO) << " Log only 3 times; " << i;
}
// 3 logs writter; 1, 2, 3As mesmas versões de macros estão disponíveis apenas para o modo
DEBUG, essas macros começam comD(para depuração) seguido do mesmo nome. por exemplo,DLOGpara registrar apenas no modo de depuração (ou seja, quando_DEBUGé definido ouNDEBUGé indefinido)
Ir para o topo
printf como registro Para compiladores que suportam modelos variados do C++ 11, a capacidade de registrar como "printf" está disponível. Isso é feito usando a classe Logger . Este recurso é seguro para thread e tipo (já que não usamos nenhuma macro como LOG(INFO) etc)
Isso é feito em duas etapas:
el::Loggers::getLogger(<logger_id>); A única diferença do printf é que o log usando essas funções requer %v para cada argumento (isso é para segurança de tipo); em vez de especificadores de formato personalizados. Você pode escapar disso por %%v
A seguir estão várias assinaturas de função:
info(const char*, const T&, const Args&...)warn(const char*, const T&, const Args&...)error(const char*, const T&, const Args&...)debug(const char*, const T&, const Args&...)fatal(const char*, const T&, const Args&...)trace(const char*, const T&, const Args&...)verbose(int vlevel, const char*, const T&, const Args&...) // Use default logger
el::Logger* defaultLogger = el::Loggers::getLogger( " default " );
// STL logging (`ELPP_STL_LOGGING` should be defined)
std::vector< int > i;
i.push_back( 1 );
defaultLogger-> warn ( " My first ultimate log message %v %v %v " , 123 , 222 , i);
// Escaping
defaultLogger-> info ( " My first ultimate log message %% %%v %v %v " , 123 , 222 );
Os especificadores de formato
%file,%func%linee%locnão funcionarão comprintfcomo registro.
Ir para o topo
Você pode enviar suas mensagens para a rede. Mas você terá que implementar sua própria maneira usando a API do log dispatcher. Escrevemos uma amostra totalmente funcional para esse propósito. Consulte o exemplo Enviar para rede
Ir para o topo
O registro detalhado é útil em todos os softwares para registrar mais informações do que o normal. Muito útil para solução de problemas. A seguir estão macros específicas de registro detalhado;
VLOG(verbose-level)CVLOG(verbose-level, logger ID) Ir para o topo
O registro detalhado também possui aspectos de registro condicional e ocasional, ou seja,
VLOG_IF(condition, verbose-level)CVLOG_IF(condition, verbose-level, loggerID)VLOG_EVERY_N(n, verbose-level)CVLOG_EVERY_N(n, verbose-level, loggerID)VLOG_AFTER_N(n, verbose-level)CVLOG_AFTER_N(n, verbose-level, loggerID)VLOG_N_TIMES(n, verbose-level)CVLOG_N_TIMES(n, verbose-level, loggerID) Ir para o topo
O nível detalhado é o nível de verbosidade que pode variar de 1 a 9. O nível detalhado não estará ativo a menos que você defina argumentos de aplicativo para ele. Leia a seção Argumentos do aplicativo para entender mais sobre o registro detalhado.
Para alterar o nível detalhado rapidamente, use a função Loggers::setVerboseLevel(base::type::VerboseLevel) também conhecida como Loggers::setVerboseLevel(int) . (Você pode verificar o nível detalhado atual por Loggers::verboseLevel()
Ir para o topo
Você pode usar uma macro VLOG_IS_ON(verbose-level) para verificar se determinado log está ativado para o arquivo de origem para o nível detalhado especificado. Isso retorna um booleano que você pode incorporar à condição if.
if (VLOG_IS_ON( 2 )) {
// Verbosity level 2 is on for this file
} Ir para o topo
VModule é uma funcionalidade para registro detalhado (conforme mencionado na tabela acima), onde você pode especificar o detalhamento por módulos/arquivo de origem. A seguir estão alguns exemplos com explicação; Qualquer um dos vmodules abaixo começa com -vmodule= e o sinalizador LoggingFlag::DisableVModulesExtensions não está definido. Vmodule pode ser completamente desativado adicionando o sinalizador LoggingFlag::DisableVModules
Exemplo com sinalizador LoggingFlag::AllowVerboseIfModuleNotSpecified ;
main=3,parser*=4 :
main{.h, .c, .cpp, .cc, .cxx, -inl.h, .hxx, .hpp} parser{.h, .c, .cpp, .cc, .cxx, -inl.h, .hxx, .hpp}
