easyloggingpp
Chore release
﷽
→ Última versión
→ Registro de cambios
→ Muestras
Descripción general
¿Por qué otra biblioteca más?
Funciones de un vistazo
Empezando
Descargar
Inicio rápido
Instalar (opcional)
Configuración de argumentos de aplicación
Configuración
Nivel
Configurar
Usando el archivo de configuración
Usando la clase el::Configurations
Uso de configuraciones en línea
Configuraciones predeterminadas
Configuraciones globales
Especificadores de formato de registro
Especificadores de formato de fecha/hora
Especificadores de formato personalizados
Banderas de registro
Argumentos de aplicación
Macros de configuración
Configuraciones de lectura
Explotación florestal
Básico
Registro condicional
Registro ocasional
printf Me gusta iniciar sesión
Registro de red
Registro detallado
Básico
Condicional y ocasional
Nivel detallado
Compruebe si el registro detallado está activado
Módulo V
Registro de nuevos registradores
Dar de baja registradores
Completar ID de registrador existentes
Compartir repositorio de registros
Funciones adicionales
Seguimiento del rendimiento
Seguimiento de rendimiento condicional
Utilice datos de seguimiento del rendimiento
Rotación de archivos de registro
Manejo de accidentes
Instalación de controladores de fallos personalizados
seguimiento de pila
subprocesos múltiples
VERIFICAR Macros
Registro de registro()
Usando Syslog
Registro STL
Plantillas compatibles
Registro Qt
Impulsar el registro
Registro de wxWidgets
Biblioteca ampliada
Registrar su propia clase
Registro de clase de terceros
Vaciar y transferir archivos de registro manualmente
Registrar devolución de llamada de envío
Devolución de llamada de registro del registrador
Registro asincrónico
Clases de ayuda
Contribución
Envío de parches
Informar un error
Compatibilidad
Construir matriz
Licencia
Descargo de responsabilidad
Easylogging++ es una biblioteca de registro eficiente de encabezado único para aplicaciones C++. Es extremadamente potente, altamente extensible y configurable según los requisitos del usuario. Proporciona la posibilidad de escribir sus propios receptores (a través de funciones destacadas denominadas LogDispatchCallback ). Esta biblioteca es utilizada actualmente por cientos de proyectos de código abierto en github y otros sitios de administración de control de código abierto.
Este manual es para Easylogging++ v9.97.1. Para otras versiones, consulte la versión correspondiente en github.
Quizás también le interese el servidor de registro de residuos.
Ir arriba
Si está trabajando en una utilidad pequeña o en un proyecto grande en C++, esta biblioteca puede resultarle útil. Se basa en un encabezado único y solo requiere vincularlo a un único archivo fuente. (Originalmente era solo encabezado y se cambió para usar el archivo fuente en el número 445. Aún puede usar solo encabezado en v9.89).
Esta biblioteca ha sido diseñada teniendo en cuenta varias ideas (es decir, portabilidad, rendimiento, usabilidad, funciones y facilidad de configuración).
¿Por qué otra biblioteca más? Bueno, la respuesta es bastante sencilla, úsala tal como la escribiste para poder solucionar problemas (si los hay) sobre la marcha o plantearlos en github. Además de eso, personalmente no he visto ninguna biblioteca de registro basada en un solo encabezado con un diseño de este tipo que pueda configurar sobre la marcha, ampliarla según sus necesidades y obtener un rendimiento rápido. He visto otras bibliotecas de registro de encabezado único para C++, pero usan bibliotecas externas, por ejemplo, boost o Qt para admitir ciertas funciones como subprocesos, expresiones regulares o fechas, etc. Esta biblioteca tiene todo integrado para evitar el uso de bibliotecas externas. No es que no me gusten esas bibliotecas, de hecho las amo, pero como no todos los proyectos usan estas bibliotecas, no podía correr el riesgo de depender de ellas.
Ir arriba
Easylogging++ tiene muchas funciones que tanto los desarrolladores típicos como los avanzados necesitarán al escribir un software;
Ir arriba
Descargue la última versión de la última versión
Para otros lanzamientos, visite la página de lanzamientos. Si su aplicación no es compatible con C++ 11, considere usar v8.91. Esta es una versión estable para C++98 y C++03, solo le faltan algunas características.
Ir arriba
Para comenzar con Easylogging++, puede seguir tres sencillos pasos:
easylogging++.h y easylogging++.cc )# include " easylogging++.h "
INITIALIZE_EASYLOGGINGPP
int main ( int argc, char * argv[]) {
LOG (INFO) << " My first info log using default logger " ;
return 0 ;
}Ahora compila usando
g++ main.cc easylogging++.cc -o prog -std=c++11
¡Así de sencillo! Tenga en cuenta que INITIALIZE_EASYLOGGINGPP debe usarse una sola vez, de lo contrario terminará obteniendo errores de compilación. Esta es la definición de varias variables extern . Esto significa que solo se puede definir una vez por aplicación. El mejor lugar para colocar esta declaración de inicialización es en el archivo donde se define la función int main(int, char**) , justo después de la última declaración de inclusión.
Si desea instalar este encabezado en todo el sistema, puede hacerlo a través de:
mkdir build
cd build
cmake -Dtest=ON ../
make
make test
make install
Las siguientes opciones son compatibles con Easylogging++ cmake y puede activarlas usando -D<option>=ON
lib_utc_datetime : define ELPP_UTC_DATETIMEbuild_static_lib : crea una biblioteca estática para Easylogging++ Dicho esto, aún necesitarás el archivo easylogging++.cc para poder compilar. Solo para el encabezado, verifique v9.89 y versiones anteriores.
Alternativamente, puedes descargar e instalar easyloggingpp usando el administrador de dependencias vcpkg:
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
./vcpkg install easyloggingpp
Los miembros del equipo de Microsoft y los contribuyentes de la comunidad mantienen actualizado el puerto easyloggingpp en vcpkg. Si la versión no está actualizada, cree un problema o una solicitud de extracción en el repositorio de vcpkg.
Ir arriba
Siempre se recomienda pasar los argumentos de la aplicación a Easylogging++. Algunas características de Easylogging++ requieren que usted establezca argumentos de la aplicación, por ejemplo, registro detallado para establecer el nivel detallado o vmodules (se explica más adelante). Para hacer eso, puede usar una macro auxiliar o una clase auxiliar;
int main ( int argc, char * argv[]) {
START_EASYLOGGINGPP (argc, argv);
...
} Ir arriba
Para comenzar a configurar su biblioteca de registros, debe comprender los niveles de gravedad. Easylogging++ deliberadamente no utiliza el registro jerárquico para controlar completamente lo que está habilitado y lo que no. Dicho esto, todavía existe la opción de utilizar el registro jerárquico mediante LoggingFlag::HierarchicalLogging . Easylogging++ tiene los siguientes niveles (ordenados por niveles jerárquicos)
| Nivel | Descripción |
|---|---|
| Global | Nivel genérico que representa todos los niveles. Útil al establecer la configuración global para todos los niveles. |
| Rastro | Información que puede ser útil para rastrear ciertos eventos, más útil que los registros de depuración. |
| Depurar | Eventos informativos más útiles para que los desarrolladores depuren aplicaciones. Solo se aplica si NDEBUG no está definido (para no VC++) o _DEBUG está definido (para VC++). |
| Fatal | Evento de error muy grave que presumiblemente provocará la cancelación de la aplicación. |
| Error | Información de error pero continuará la aplicación para seguir ejecutándose. |
| Advertencia | Información que representa errores en la aplicación, pero la aplicación seguirá ejecutándose. |
| Información | Principalmente útil para representar el progreso actual de la aplicación. |
| Verboso | Información que puede ser muy útil y variar según el nivel de registro detallado. El registro detallado no se aplica al registro jerárquico. |
| Desconocido | Solo se aplica al registro jerárquico y se utiliza para desactivar el registro por completo. |
Ir arriba
Easylogging++ es fácil de configurar. Hay tres formas posibles de hacerlo,
La configuración se puede realizar mediante un archivo que se carga en tiempo de ejecución mediante la clase Configurations . Este archivo tiene el siguiente formato;
* LEVEL:
CONFIGURATION NAME = "VALUE" ## Comment
ANOTHER CONFIG NAME = "VALUE"
El nombre del nivel comienza con un asterisco (*) y termina con dos puntos (:). Se recomienda encarecidamente iniciar su archivo de configuración con el nivel Global para que cualquier configuración no especificada en el archivo utilice automáticamente la configuración de Global . Por ejemplo, si configura Filename en Global y desea que todos los niveles usen el mismo nombre de archivo, no lo configure explícitamente para cada nivel, la biblioteca usará el valor de configuración de Global automáticamente. La siguiente tabla contiene configuraciones admitidas por el archivo de configuración.
| Nombre de configuración | Tipo | Descripción |
|---|---|---|
Enabled | booleano | Determina si el nivel correspondiente para el registrador está habilitado o no. Puede desactivar todos los registros utilizando el::Level::Global |
To_File | booleano | Si escribir o no el registro correspondiente en el archivo de registro |
To_Standard_Output | booleano | Si escribir o no registros en la salida estándar, por ejemplo, terminal o símbolo del sistema |
Format | carbonizarse* | Determina el formato/patrón de registro para el nivel y registrador correspondiente. |
Filename | carbonizarse* | Determina el archivo de registro (ruta completa) en el que escribir registros para el nivel y registrador correspondientes |
Subsecond_Precision | uint | Especifica una precisión de subsegundos (anteriormente denominada "ancho de milisegundos"). El ancho puede estar dentro del rango (1-6) |
Performance_Tracking | booleano | Determina si el seguimiento del rendimiento está habilitado o no. Esto no depende del registrador ni del nivel. El seguimiento del rendimiento siempre utiliza el registrador de "rendimiento" a menos que se especifique |
Max_Log_File_Size | tamaño_t | Si el tamaño del archivo de registro del nivel correspondiente es >= tamaño especificado, el archivo de registro se truncará. |
Log_Flush_Threshold | tamaño_t | Especifica el número de entradas de registro que se conservarán hasta que eliminemos los datos de registro pendientes. |
No utilice comillas dobles en ningún comentario, podría terminar teniendo un comportamiento inesperado.
Archivo de configuración de muestra
* 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"
El contenido del archivo de configuración en el ejemplo anterior es sencillo. Comenzamos con el nivel GLOBAL para anular todos los niveles. Cualquier nivel posterior definido explícitamente anulará la configuración de GLOBAL . Por ejemplo, todos los niveles excepto DEBUG tienen el mismo formato, es decir, fecha y hora y mensaje de registro. Para el nivel DEBUG , solo tenemos fecha (con día y mes), función fuente y mensaje de registro. El resto de configuraciones para DEBUG se utilizan desde GLOBAL . Además, observe {%d/%M} en el formato DEBUG anterior; si no especifica el formato de fecha, se utiliza el formato predeterminado. Los valores predeterminados de fecha/hora son %d/%M/%Y %h:%m:%s,%g Para obtener más información sobre estos especificadores de formato, consulte la sección Especificador de formato de fecha/hora a continuación.
# 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
}Su archivo de configuración se puede convertir en el objeto
el::Configurations(usando el constructor) que se puede usar donde sea necesario (como en el ejemplo anterior).
Ir arriba
Puede establecer configuraciones o restablecer configuraciones;
# 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 ;
}La configuración solo debe establecerse una vez. Si está satisfecho con la configuración predeterminada, también puede usarla.
Ir arriba
La configuración en línea significa que puede establecer configuraciones en std::string pero asegúrese de agregar todos los caracteres de nueva línea, etc. Esto no se recomienda porque siempre es complicado.
el::Configurations c;
c.setToDefault();
c.parseFromText( " *GLOBAL: n FORMAT = %level %msg " );El código anterior solo establece el objeto Configuraciones, aún necesita reconfigurar los registradores usando estas configuraciones.
Ir arriba
Si desea tener una configuración para registradores existentes y futuros, puede usar el::Loggers::setDefaultConfigurations(el::Configurations& configurations, bool configureExistingLoggers = false) . Esto es útil cuando trabaja a una escala bastante grande o cuando utiliza una biblioteca de terceros que ya usa Easylogging++. Cualquier registrador recién creado utilizará configuraciones predeterminadas. Si también desea configurar los registradores existentes, puede establecer el segundo argumento en true (el valor predeterminado es false ).
Ir arriba
Level::Global no tiene nada que ver con configuraciones globales, es un concepto en el que puede registrar configuraciones para todos o algunos registradores e incluso registrar nuevos registradores utilizando el archivo de configuración. La sintaxis del archivo de configuración es:
-- LOGGER ID ## Case sensitive
## Everything else is same as configuration file
-- ANOTHER LOGGER ID
## Configuration for this logger
La identificación del registrador comienza con dos guiones. Una vez que haya escrito su archivo de configuración global, puede configurar todos sus registradores (y registrar nuevos) usando una sola función;
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 ;
}Tenga en cuenta que no es posible registrar un nuevo registrador utilizando la configuración global sin definir su configuración. Debe definir al menos una configuración única. Otras formas de registrar registradores se analizan en la sección Registro a continuación.
Ir arriba
Puede personalizar el formato de registro utilizando los siguientes especificadores:
| Especificador | Reemplazado por |
|---|---|
%logger | ID del registrador |
%thread | ID de subproceso: utiliza std::thread si está disponible; de lo contrario, GetCurrentThreadId() en Windows |
%thread_name | Utilice Helpers::setThreadName para establecer el nombre del hilo actual (desde donde ejecuta setThreadName ). Ver ejemplo de nombres de hilos |
%level | Nivel de gravedad (información, depuración, error, advertencia, grave, detallado, seguimiento) |
%levshort | Nivel de gravedad (versión corta, es decir, I para Información y respectivamente D, E, W, F, V, T) |
%vlevel | Nivel de detalle (aplicable al registro detallado) |
%datetime | Fecha y/u hora: el patrón se puede personalizar; consulte los especificadores de formato de fecha/hora a continuación |
%user | Usuario que actualmente ejecuta la aplicación |
%host | La aplicación de nombre de computadora se está ejecutando |
%file * | Nombre del archivo fuente (ruta completa): esta función está sujeta a la disponibilidad de la macro __FILE__ del compilador. |
%fbase * | Nombre de archivo del archivo fuente (solo nombre base) |
%line * | Número de línea de origen: esta función está sujeta a la disponibilidad de la macro __LINE__ de compilación |
%func * | Función de registro |
%loc * | Nombre del archivo de origen y número de línea del registro (separados por dos puntos) |
%msg | Mensaje de registro real |
% | Carácter de escape (por ejemplo, %%level escribirá %level) |
__LINE__ , __FILE__ , etc. Ir arriba
Puede personalizar el formato de fecha/hora utilizando los siguientes especificadores
| Especificador | Reemplazado por |
|---|---|
%d | Día del mes (rellenado con ceros) |
%a | Día de la semana: breve (lunes, martes, miércoles, jueves, viernes, sábado, domingo) |
%A | Día de la semana largo (lunes, martes, miércoles, jueves, viernes, sábado, domingo) |
%M | Mes (rellenado con ceros) |
%b | Mes: corto (enero, febrero, marzo, abril, mayo, junio, julio, agosto, septiembre, octubre, noviembre, diciembre) |
%B | Mes largo (enero, febrero, marzo, abril, mayo, junio, julio, agosto, septiembre, octubre, noviembre, diciembre) |
%y | Año: dos dígitos (13, 14, etc.) |
%Y | Año: cuatro dígitos (2013, 2014, etc.) |
%h | Hora (formato de 12 horas) |
%H | Hora (formato de 24 horas) |
%m | Minuto (con relleno de ceros) |
%s | Segundo (relleno con ceros) |
%g | Parte de subsegundo (la precisión se configura mediante ConfigurationType::Sub secondPrecision) |
%F | Designación AM/PM |
% | personaje de escape |
Tenga en cuenta que la fecha/hora está limitada a 30 caracteres como máximo.
Ir arriba
También puede especificar sus propios especificadores de formato. Para hacer eso, puede usar el::Helpers::installCustomFormatSpecifier . Un ejemplo perfecto es %ip_addr para la aplicación 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 arriba
En algunas partes del registro, puede configurar indicadores de registro; Aquí se admiten banderas:
| Bandera | Descripción |
|---|---|
NewLineForContainer (1) | Se asegura de que tengamos una nueva línea para cada entrada del registro del contenedor. |
AllowVerboseIfModuleNotSpecified (2) | Se asegura de que si se usa -vmodule y no especifica un módulo, entonces se permite el registro detallado a través de ese módulo. Digamos que el parámetro era -vmodule=main*=3 y se está escribiendo un registro detallado desde un archivo llamado algo.cpp; luego, si este indicador está habilitado, se escribirá el registro; de lo contrario, no se permitirá. Nota: tener esto anula el propósito de -vmodule |
LogDetailedCrashReason (4) | Al gestionar fallos de forma predeterminada, también se registrará el motivo detallado del fallo (deshabilitado de forma predeterminada) (problema n.º 90) |
DisableApplicationAbortOnFatalLog (8) | Permite deshabilitar el aborto de la aplicación cuando se inicia sesión usando el nivel FATAL. Tenga en cuenta que esto no se aplica a los controladores de fallas predeterminados, ya que la aplicación debe cancelarse después de que se maneja la señal de falla. (No agregado de forma predeterminada) (problema n.° 119) |
ImmediateFlush (16) | Vacía el registro con cada entrada de registro (sensible al rendimiento): deshabilitado de forma predeterminada |
StrictLogFileSizeCheck (32) | Se asegura de que el tamaño del archivo de registro se verifique con cada registro. |
ColoredTerminalOutput (64) | La salida del terminal será colorida si es compatible con el terminal. |
MultiLoggerSupport (128) | Habilita la compatibilidad con el uso de varios registradores para registrar un solo mensaje. (Por ejemplo, CLOG(INFO, "default", "network") << This will be logged using default and network loggers; ) |
DisablePerformanceTrackingCheckpointComparison (256) | Desactiva la comparación de puntos de control |
DisableVModules (512) | Deshabilita el uso de vmodules |
DisableVModulesExtensions (1024) | Deshabilita la extensión vmodules. Esto significa que si tiene un vmodule -vmodule=main*=4, cubrirá todo comenzando con main, mientras que si no tiene esto definido, estará cubierto para cualquier archivo que comience con main y termine con una de las siguientes extensiones; .h .c .cpp .cc .cxx .-inl-.h .hxx .hpp. Tenga en cuenta que el siguiente vmodule no es correcto -vmodule=main.=4 con esta macro no definida porque esto verificará main..c, observe los puntos dobles. Si desea que esto sea válido, eche un vistazo al indicador de registro de arriba: AllowVerboseIfModuleNotSpecified '?' y '' se admiten comodines |
HierarchicalLogging (2048) | Habilita el registro jerárquico. Esto no se aplica al registro detallado. |
CreateLoggerAutomatically (4096) | Crea un registrador automáticamente cuando no está disponible. |
AutoSpacing (8192) | Agrega espacios automáticamente. Por ejemplo, LOG(INFO) << "DODGE" << "THIS!"; mostrará "¡ESQUIVA ESTO!" |
FixedTimeFormat (16384) | Aplicable únicamente al seguimiento del rendimiento; esto evita el tiempo de formateo. Por ejemplo, 1001 ms se registrarán tal cual, en lugar de formatearlos como 1.01 sec |
IgnoreSigInt (32768) | Cuando la aplicación falla, ignore la señal de interrupción |
Puede configurar/desarmar estos indicadores usando static el::Loggers::addFlag y el::Loggers::removeFlag . Puede verificar si cierta bandera está disponible usando el::Loggers::hasFlag , todas estas funciones toman una enumeración fuertemente tipada el::LoggingFlag
Puede configurar estos indicadores utilizando la línea de comando
--logging-flagsarg. Debe habilitar esta funcionalidad definiendo la macroELPP_LOGGING_FLAGS_FROM_ARG(deberá asegurarse de usarSTART_EASYLOGGINGPP(argc, argv)para configurar los argumentos).
También puede configurar indicadores predeterminados (iniciales) usando
ELPP_DEFAULT_LOGGING_FLAGSy establecer valores numéricos para los indicadores iniciales.
Ir arriba
La siguiente tabla explicará todos los argumentos de la línea de comando que puede usar para definir cierto comportamiento; Necesitará inicializar los argumentos de la aplicación usando START_EASYLOGGINGPP(argc, argv) en su función main(int, char**) .
| Argumento | Descripción |
|---|---|
-v | Activa la máxima verbosidad |
--v=2 | Activa la detalle hasta el nivel detallado 2 (rango válido: 0-9) |
--verbose | Activa la máxima verbosidad |
-vmodule=MODULE_NAME | Activa la detalle para archivos que comienzan con main hasta el nivel 1, el resto de los archivos dependen del indicador de registro AllowVerboseIfModuleNotSpecified Consulte la sección Indicadores de registro anterior. Dos módulos se pueden separar por coma. Tenga en cuenta que los vmodules están al final en el orden de prioridad de verificación de argumentos para el registro detallado; por ejemplo, si tenemos -v en los argumentos de la aplicación antes de vmodules, se ignorarán los vmodules. |
--logging-flags=3 | Establece el indicador de registro. En el ejemplo ie, 3 , establece el indicador de registro en NewLineForContainer y AllowVerboseIfModuleNotSpecified . Consulte la sección de indicadores de registro anterior para obtener más detalles y valores. Consulte la sección de macros para desactivar esta función. |
--default-log-file=FILE | Establece el archivo de registro predeterminado para registradores existentes y futuros. Es posible que desee considerar definir ELPP_NO_DEFAULT_LOG_FILE para evitar la creación de un archivo de registro vacío predeterminado durante el preprocesamiento. Consulte la sección de macros para desactivar esta función. |
Ir arriba
Algunas de las opciones de registro se pueden configurar mediante macros, esta es una decisión bien pensada, por ejemplo, si tenemos ELPP_THREAD_SAFE definido, todas las funcionalidades seguras para subprocesos están habilitadas, de lo contrario están deshabilitadas (asegurándose de que los gastos generales de seguridad de subprocesos vayan con ello). Para que sea fácil de recordar y evitar posibles conflictos, todas las macros comienzan con ELPP_
NOTA: Todas las macros se pueden definir de una de las siguientes maneras:
Defina macros usando la opción -D del compilador, por ejemplo, en el caso de g++ hará g++ source.cpp ... -DELPP_SYSLOG -DELPP_THREAD_SAFE ... ( forma recomendada )
Defina macros dentro de "easylogging++.h" (definir macros en otros archivos no funcionará)
| Nombre de la macro | Descripción |
|---|---|
ELPP_DEBUG_ASSERT_FAILURE | Aborta la aplicación cuando falla la primera afirmación. Esta afirmación se debe a una entrada no válida, por ejemplo, un archivo de configuración no válido, etc. |
ELPP_UNICODE | Habilita la compatibilidad con Unicode al iniciar sesión. Requiere START_EASYLOGGINGPP |
ELPP_THREAD_SAFE | Habilita la seguridad de subprocesos; asegúrese de vincular -lpthread para Linux. |
ELPP_FORCE_USE_STD_THREAD | Obliga a usar la biblioteca estándar de C++ para subprocesos (solo es útil cuando se usa ELPP_THREAD_SAFE |
ELPP_FEATURE_CRASH_LOG | Aplicable únicamente al CCG. Habilita el seguimiento de pila en caso de fallo de la aplicación |
ELPP_DISABLE_DEFAULT_CRASH_HANDLING | Deshabilita el manejo de fallas predeterminado. Puede utilizar el::Helpers::setCrashHandler para utilizar su propio controlador. |
ELPP_DISABLE_LOGS | Deshabilita todos los registros - (preprocesamiento) |
ELPP_DISABLE_DEBUG_LOGS | Deshabilita los registros de depuración - (preprocesamiento) |
ELPP_DISABLE_INFO_LOGS | Deshabilita los registros de información - (preprocesamiento) |
ELPP_DISABLE_WARNING_LOGS | Deshabilita los registros de advertencia - (preprocesamiento) |
ELPP_DISABLE_ERROR_LOGS | Deshabilita los registros de errores - (preprocesamiento) |
ELPP_DISABLE_FATAL_LOGS | Deshabilita los registros fatales - (preprocesamiento) |
ELPP_DISABLE_VERBOSE_LOGS | Deshabilita los registros detallados - (preprocesamiento) |
ELPP_DISABLE_TRACE_LOGS | Deshabilita los registros de seguimiento - (preprocesamiento) |
ELPP_FORCE_ENV_VAR_FROM_BASH | Si no se puede encontrar la variable de entorno, fuerce el uso del comando bash alternativo para encontrar el valor, por ejemplo, whoami para el nombre de usuario. (NO USE ESTA MACRO CON LD_PRELOAD PARA BIBLIOTECAS QUE YA ESTÁN UTILIZANDO Easylogging++ O TERMINARÁS EN EL DESBORDAMIENTO DE LA PILA PARA LOS PROCESOS ( popen ) (consulte el número 87 para obtener más detalles)) |
ELPP_DEFAULT_LOG_FILE | Nombre de archivo completo donde desea que se creen los archivos iniciales. Debe incrustar el valor de esta macro entre comillas, por ejemplo, -DELPP_DEFAULT_LOG_FILE='"logs/el.gtest.log"' Tenga en cuenta las comillas dobles dentro de las comillas simples, las comillas dobles son los valores de const char* y las comillas simples especifican el valor de macro |
ELPP_NO_LOG_TO_FILE | Deshabilitar el registro en el archivo inicialmente |
ELPP_NO_DEFAULT_LOG_FILE | Si no desea inicializar la biblioteca con el archivo de registro predeterminado, defina esta macro. Esto se registrará en un dispositivo nulo para Unix y Windows. En otras plataformas es posible que obtenga un error y deberá utilizar ELPP_DEFAULT_LOG_FILE . (Las relaciones públicas para dispositivos nulos de otras plataformas son bienvenidas) |
ELPP_FRESH_LOG_FILE | Nunca agrega un archivo de registro cada vez que se crea un archivo de registro (úselo con cuidado, ya que puede causar algún resultado inesperado para algunos usuarios) |
ELPP_DEBUG_ERRORS | Si desea descubrir errores internos generados por Easylogging++ que pueden deberse a la configuración u otra cosa, puede habilitarlos definiendo esta macro. Obtendrá sus errores en la salida estándar, es decir, terminal o símbolo del sistema. |
ELPP_DISABLE_CUSTOM_FORMAT_SPECIFIERS | Desactiva por la fuerza los especificadores de formato personalizados |
ELPP_DISABLE_LOGGING_FLAGS_FROM_ARG | Desactiva por la fuerza la capacidad de establecer indicadores de registro mediante argumentos de línea de comandos |
ELPP_DISABLE_LOG_FILE_FROM_ARG | Desactiva por la fuerza la capacidad de configurar el archivo de registro predeterminado a partir de argumentos de línea de comandos |
ELPP_WINSOCK2 | En el sistema Windows, fuerce el uso winsock2.h en lugar de winsock.h cuando se define WIN32_LEAN_AND_MEAN |
ELPP_CUSTOM_COUT (avanzado) | Se resuelve en un valor, por ejemplo, #define ELPP_CUSTOM_COUT qDebug() o #define ELPP_CUSTOM_COUT std::cerr . Esto usará el valor para la salida estándar (en lugar de usar std::cout |
ELPP_CUSTOM_COUT_LINE (avanzado) | Se utiliza con ELPP_CUSTOM_COUT para definir cómo escribir una línea de registro con cout personalizado. por ejemplo, #define ELPP_CUSTOM_COUT_LINE(msg) QString::fromStdString(msg).trimmed() |
ELPP_NO_CHECK_MACROS | No defina las macros CHECK |
ELPP_NO_DEBUG_MACROS | No defina las macros DEBUG |
ELPP_UTC_DATETIME | Utiliza la hora UTC en lugar de la hora local (esencialmente utiliza gmtime en lugar de localtime y funciones familiares) |
ELPP_NO_GLOBAL_LOCK | No cierre con llave todo el almacenamiento en el momento del envío. Esto debe usarse con cuidado. Ver número 580 |
Ir arriba
Si desea leer las configuraciones de determinado registrador, puede hacerlo utilizando la función typedConfigurations() en la clase 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 arriba
El inicio de sesión en easylogging++ se realiza mediante una colección de macros. Esto es para hacerlo más fácil para el usuario y evitar que conozca mayores detalles innecesarios de cómo se hacen las cosas.
Se le proporcionan dos macros básicas que puede utilizar para escribir registros:
LOG(LEVEL)CLOG(LEVEL, logger ID) LOG utiliza el registrador 'predeterminado' mientras que en CLOG (LOGO personalizado) usted especifica el ID del registrador. Para NIVEL, consulte la sección Configuraciones - Niveles anterior. Diferentes registradores pueden tener diferentes configuraciones según sus necesidades; también puede escribir una macro personalizada para acceder al registrador personalizado. También tiene diferentes macros para el registro detallado que se explica en la sección siguiente. A continuación se muestra un ejemplo muy sencillo del uso de estas macros después de haber inicializado easylogging++.
LOG (INFO) << "This is info log";
CLOG (ERROR, " performance " ) << "This is info log using performance logger"; Hay otra forma de utilizar la misma macro, es decir, LOG (y las macros asociadas). Esto significa que usted define las macros ELPP_DEFAULT_LOGGER y ELPP_DEFAULT_PERFORMANCE_LOGGER con un ID de registrador que ya está registrado, y ahora, cuando use la macro LOG , automáticamente usará el registrador especificado en lugar del registrador default . Tenga en cuenta que esto debe definirse en el archivo fuente en lugar del archivo de encabezado. Esto es para que cuando incluyamos el encabezado no utilicemos accidentalmente un registrador no válido.
Un ejemplo rápido está aquí.
# 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
}También puede escribir registros utilizando la clase
Loggerdirectamente. Esta característica está disponible en compiladores que admiten plantillas variadas. Puede explorar más consultandosamples/STL/logger-log-functions.cpp.
Ir arriba
Easylogging++ proporciona ciertos aspectos del registro, uno de estos aspectos es el registro condicional, es decir, el registro se escribirá sólo si se cumple cierta condición. Esto resulta muy útil en algunas situaciones. Las macros auxiliares terminan en _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)" Las mismas macros están disponibles para el registro detallado con V al principio, es decir, VLOG_IF y CVLOG_IF . consulte la sección de registro detallada a continuación para obtener más información. Es posible que tenga condiciones tan complicadas como desee según sus necesidades.
Ir arriba
El registro ocasional es otro aspecto útil del registro con Easylogging++. Esto significa que se escribirá un registro si se produce ciertas veces o parte de ciertas veces, por ejemplo, cada 10.º, 100.º o 2.º impacto. Las macros auxiliares terminan en _EVERY_N ;
LOG_EVERY_N(n, LEVEL)CLOG_EVERY_N(n, LEVEL, logger ID)También existen otras formas de iniciar sesión según el recuento de visitas. Estas útiles macros son
LOG_AFTER_N(n, LEVEL) ; Solo se registra cuando hemos alcanzado un recuento de visitas de nLOG_N_TIMES(n, LEVEL) ; Registra n veces 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, 3Las mismas versiones de macros están disponibles para el modo
DEBUGsolamente, estas macros comienzan conD(para depuración) seguida del mismo nombre. por ejemplo,DLOGpara iniciar sesión solo en modo de depuración (es decir, cuando_DEBUGestá definido oNDEBUGno está definido)
Ir arriba
printf Me gusta iniciar sesión Para los compiladores que admiten las plantillas variadas de C++ 11, está disponible la capacidad de iniciar sesión como "printf". Esto se hace utilizando la clase Logger . Esta característica es segura para subprocesos y tipos (ya que no utilizamos macros como LOG(INFO) etc.)
Esto se hace en dos pasos:
el::Loggers::getLogger(<logger_id>); La única diferencia con printf es que el registro utilizando estas funciones requiere %v para cada argumento (esto es por seguridad de tipos); en lugar de especificadores de formato personalizados. Puedes escapar de esto por %%v
A continuación se muestran varias firmas de funciones:
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 );
Los especificadores de formato
%file,%func%liney%locno funcionarán conprintfcomo el registro.
Ir arriba
Puedes enviar tus mensajes a la red. Pero tendrá que implementar su propia manera utilizando la API del despachador de registros. Hemos escrito una muestra completamente funcional para este propósito. Consulte el ejemplo de Enviar a la red.
Ir arriba
El registro detallado es útil en todos los programas para registrar más información de lo habitual. Muy útil para solucionar problemas. A continuación se muestran macros específicas de registro detalladas;
VLOG(verbose-level)CVLOG(verbose-level, logger ID) Ir arriba
El registro detallado también tiene aspectos de registro condicional y ocasional, es decir,
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 arriba
El nivel detallado es un nivel de detalle que puede tener un rango de 1 a 9. El nivel detallado no estará activo a menos que establezca argumentos de aplicación para él. Lea la sección Argumentos de la aplicación para comprender más sobre el registro detallado.
Para cambiar el nivel detallado sobre la marcha, utilice Loggers::setVerboseLevel(base::type::VerboseLevel) , también conocida como función Loggers::setVerboseLevel(int) . (Puede verificar el nivel detallado actual mediante Loggers::verboseLevel()
Ir arriba
Puede usar una macro VLOG_IS_ON(verbose-level) para verificar si cierto registro está activado para el archivo fuente para el nivel detallado especificado. Esto devuelve un valor booleano que puede incrustar en la condición if.
if (VLOG_IS_ON( 2 )) {
// Verbosity level 2 is on for this file
} Ir arriba
VModule es una funcionalidad para el registro detallado (como se menciona en la tabla anterior) donde puede especificar la detalle por módulos/archivo fuente. A continuación se muestran algunos ejemplos con explicación; Cualquiera de los vmodule siguientes comienza con -vmodule= y el indicador LoggingFlag::DisableVModulesExtensions no está configurado. Vmodule se puede desactivar completamente agregando el indicador LoggingFlag::DisableVModules
Ejemplo con el indicador 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}
