#include <Log_Msg.h>
Collaboration diagram for ACE_Log_Msg:
Public Types | |
enum | { STDERR = 1, LOGGER = 2, OSTREAM = 4, MSG_CALLBACK = 8, VERBOSE = 16, VERBOSE_LITE = 32, SILENT = 64, SYSLOG = 128 } |
enum | MASK_TYPE { PROCESS = 0, THREAD = 1 } |
Public Methods | |
ACE_Log_Msg (void) | |
Initialize logger. | |
~ACE_Log_Msg (void) | |
cleanup logger. | |
int | open (const ACE_TCHAR *prog_name, u_long options_flags = ACE_Log_Msg::STDERR, const ACE_TCHAR *logger_key = 0) |
Initialize the ACE logging facility. More... | |
void | set_flags (u_long f) |
void | clr_flags (u_long f) |
u_long | flags (void) |
void | sync (const ACE_TCHAR *program_name) |
Call after doing a <fork> to resynchronize the process id and <program_name> variables. | |
void | op_status (int status) |
Set the result of the operation status (by convention, -1 means error). | |
int | op_status (void) |
Get the result of the operation status (by convention, -1 means error). | |
void | errnum (int) |
Set the value of the errnum (by convention this corresponds to errno). | |
int | errnum (void) |
Get the value of the errnum (by convention this corresponds to errno). | |
void | linenum (int) |
Set the line number where an error occurred. | |
int | linenum (void) |
Get the line number where an error occurred. | |
void | file (const char *) |
Set the file name where an error occurred. | |
const char* | file (void) |
Get the file name where an error occurred. | |
void | msg (const ACE_TCHAR *) |
Set the message that describes what type of error occurred. | |
const ACE_TCHAR* | msg (void) |
Get the message that describes what type of error occurred. | |
void | restart (int) |
Set the field that indicates whether interrupted calls should be restarted. | |
int | restart (void) |
Get the field that indicates whether interrupted calls should be restarted. | |
void | msg_ostream (ACE_OSTREAM_TYPE *) |
Update the ostream without overwriting the delete_ostream_ flag. | |
void | msg_ostream (ACE_OSTREAM_TYPE *, int delete_ostream) |
ACE_OSTREAM_TYPE* | msg_ostream (void) const |
Get the ostream that is used to print error messages. | |
ACE_Log_Msg_Callback* | msg_callback (ACE_Log_Msg_Callback *c) |
ACE_Log_Msg_Callback* | msg_callback (void) const |
int | inc (void) |
int | dec (void) |
int | trace_depth (void) |
void | trace_depth (int) |
int | trace_active (void) |
void | trace_active (int value) |
ACE_Thread_Descriptor* | thr_desc (void) const |
Get the TSS thread descriptor. | |
void | thr_desc (ACE_Thread_Descriptor *td) |
void | stop_tracing (void) |
void | start_tracing (void) |
int | tracing_enabled (void) |
u_long | priority_mask (MASK_TYPE = THREAD) |
Get the current mask. Set the mask, returns original mask. | |
u_long | priority_mask (u_long, MASK_TYPE = THREAD) |
int | log_priority_enabled (ACE_Log_Priority log_priority) |
Return true if the requested priority is enabled. | |
int | log_priority_enabled (ACE_Log_Priority log_priority, const char *, ...) |
Return true if the requested priority is enabled. | |
pid_t | getpid (void) const |
Optimize reading of the pid (avoids a system call if the value is cached...). | |
const ACE_TCHAR* | local_host (void) const |
void | local_host (const ACE_TCHAR *) |
void | set (const char *file, int line, int op_status = -1, int errnum = 0, int restart = 1, ACE_OSTREAM_TYPE *os = 0, ACE_Log_Msg_Callback *c = 0) |
void | conditional_set (const char *file, int line, int op_status, int errnum) |
These values are only actually set if the requested priority is enabled. | |
ssize_t | log (ACE_Log_Priority priority, const ACE_TCHAR *format, ...) |
ssize_t | log (ACE_Log_Priority priority, const ACE_ANTI_TCHAR *format, ...) |
ssize_t | log (const ACE_TCHAR *format, ACE_Log_Priority priority, va_list argp) |
ssize_t | log (ACE_Log_Record &log_record, int suppress_stderr = 0) |
Log a custom built log record to the currently enabled logging sinks. | |
int | log_hexdump (ACE_Log_Priority log_priority, const char *buffer, int size, const ACE_TCHAR *text = 0) |
void | dump (void) const |
Dump the state of an object. | |
Allow apps to acquire and release internal synchronization | |
lock
This lock is used internally by the implementation. By exporting the lock, applications can hold the lock atomically over a number of calls to . | |
int | acquire (void) |
Acquire the internal lock. | |
int | release (void) |
Release the internal lock. | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. | |
Static Public Methods | |
ACE_Log_Msg* | instance (void) |
Returns a pointer to the Singleton. | |
int | exists (void) |
Returns non-null if an ACE_Log_Msg exists for the calling thread. | |
const ACE_TCHAR* | program_name (void) |
Returns the current program name used for logging. | |
void | disable_debug_messages (ACE_Log_Priority priority = LM_DEBUG) |
Clears the flag from the default priority mask used to initialize ACE_Log_Msg instances. | |
void | enable_debug_messages (ACE_Log_Priority priority = LM_DEBUG) |
Sets the flag in the default priority mask used to initialize ACE_Log_Msg instances. | |
void | init_hook (ACE_OS_Log_Msg_Attributes &attributes ) |
void | inherit_hook (ACE_OS_Thread_Descriptor *thr_desc, ACE_OS_Log_Msg_Attributes &attributes) |
Private Methods | |
ACE_Log_Msg& | operator= (const ACE_Log_Msg &) |
ACE_Log_Msg (const ACE_Log_Msg &) | |
Private Attributes | |
int | status_ |
Status of operation (-1 means failure, >= 0 means success). | |
int | errnum_ |
Type of error that occurred (see <sys/errno.h>). | |
int | linenum_ |
Line number where the error occurred. | |
char | file_ [MAXPATHLEN + 1] |
File where the error occurred. | |
ACE_TCHAR | msg_ [ACE_Log_Record::MAXLOGMSGLEN + 1] |
The log message, which resides in thread-specific storage. Note that only the current log message is stored here -- it will be overwritten by the subsequent call to <log>. | |
int | restart_ |
Indicates whether we should restart system calls that are interrupted. | |
ACE_OSTREAM_TYPE* | ostream_ |
The ostream where logging messages can be written. | |
ACE_Log_Msg_Callback* | msg_callback_ |
The callback object. | |
int | trace_depth_ |
Depth of the nesting for printing traces. | |
int | trace_active_ |
Are we already within an ACE_Trace constructor call? | |
int | tracing_enabled_ |
Are we allowing tracing in this thread? | |
int | delete_ostream_ |
Are we deleting this ostream? | |
ACE_Thread_Descriptor* | thr_desc_ |
u_long | priority_mask_ |
struct { | |
int is_set_ | |
const char* file_ | |
int line_ | |
int op_status_ | |
int errnum_ | |
} | conditional_values_ |
Static Private Methods | |
void | close (void) |
For cleanup, at program termination. | |
void | sync_hook (const ACE_TCHAR *prg_name) |
Decouple the OS layer from the Log_Msg layer. | |
ACE_OS_Thread_Descriptor* | thr_desc_hook (void) |
Return the TSS singleton thread descriptor. | |
Static Private Attributes | |
u_long | process_priority_mask_ |
const ACE_TCHAR* | program_name_ = 0 |
Records the program name. | |
const ACE_TCHAR* | local_host_ = 0 |
Name of the local host (used when printing messages). | |
pid_t | pid_ = -1 |
Process id of the current process. | |
u_long | flags_ = ACE_Log_Msg::STDERR |
Options flags. | |
int | msg_off_ = 0 |
Offset of msg_[]. | |
int | instance_count_ |
u_long | default_priority_mask_ = 0 |
Friends | |
void | ACE_OS::cleanup_tss (const u_int) |
This class is very flexible since it allows formatted error messages to be printed in a thread-safe manner to various locations, such as stdout, stderr, cerr, a distributed logger, etc. The current message is also kept in a thread-specific storage location (i.e., there is one ACE_Log_Msg object per-thread), which can be used to communicate errors between framework methods and callers. A message is logged by the log() method, only if the message priority is currently enabled. Moreover, only the current log message is stored here -- it will be overwritten by the subsequent call to <log>.
The ACE_Log_Msg class uses two priority masks to control its logging behavior. The <priority_mask_> object attribute is thread specific and specifies the priority levels logged by the thread. The <process_priority_mask_> class attribute is not thread-specific and specifies the priority levels that will be logged by all threads in the process. By default, all levels are disabled for <priority_mask_> and all levels are enabled for <process_priority_mask_> (i.e. the process-wide mask controls the settings, and each instance can expand on it if desired). Both priority masks can be modified using the priority_mask() method of this class.
|
|
|
|
Initialize logger.
|
|
cleanup logger.
|
|
|
|
Acquire the internal lock.
|
|
For cleanup, at program termination.
|
|
|
|
These values are only actually set if the requested priority is enabled.
|
|
|
|
Clears the flag from the default priority mask used to initialize ACE_Log_Msg instances.
|
|
Dump the state of an object.
|
|
Sets the flag in the default priority mask used to initialize ACE_Log_Msg instances.
|
|
Get the value of the errnum (by convention this corresponds to errno).
|
|
Set the value of the errnum (by convention this corresponds to errno).
|
|
Returns non-null if an ACE_Log_Msg exists for the calling thread.
|
|
Get the file name where an error occurred.
|
|
Set the file name where an error occurred.
|
|
|
|
Optimize reading of the pid (avoids a system call if the value is cached...).
|
|
|
|
Inherit hook, the field is a Log_Msg_Attribute object, invoke the <inherit_log_msg> method on it, then destroy it and set the argument to 0 |
|
|
|
Returns a pointer to the Singleton.
|
|
Get the line number where an error occurred.
|
|
Set the line number where an error occurred.
|
|
|
|
|
|
Log a custom built log record to the currently enabled logging sinks.
|
|
An alternative logging mechanism that makes it possible to integrate variable argument lists from other logging mechanisms into the ACE mechanism. |
|
Since this is the ANTI_TCHAR version, we need to convert the format string over. |
|
Format a message to the thread-safe ACE logging mechanism. Valid options (prefixed by '%', as in printf format strings) include: + 'A': print an ACE_timer_t value (which could be either double or ACE_UINT32.) + 'a': abort the program at this point abruptly. + 'c': print a character + 'C': print a character string + 'i', 'd': print a decimal number + 'I': indent according to nesting depth (obtained from ). + 'e', 'E', 'f', 'F', 'g', 'G': print a double + 'l': print line number where an error occurred. + 'm': return the message corresponding to errno value, e.g., as done by strerror() + 'N': print file name where the error occurred. + 'n': print the name of the program (or "<unknown>" if not set) + 'o': print as an octal number + 'P': print out the current process id + 'p': print out the appropriate errno message from sys_errlist, e.g., as done by perror() + 'Q': print out the uint64 number + 'r': call the function pointed to by the corresponding argument + 'R': print return status + 'S': print out the appropriate _sys_siglist entry corresponding to var-argument. + 's': print out a character string + 'T': print timestamp in hour:minute:sec:usec format. + 'D': print timestamp in month/day/year hour:minute:sec:usec format. + 't': print thread id (1 if single-threaded) + 'u': print as unsigned int + 'w': prints a wide character + 'W': print a wide character string + 'X', 'x': print as a hex number + '%': print out a single percent sign, '%' |
|
Method to log hex dump. This is useful for debugging. Calls <log> to do the actual print, but formats first to make the chars printable. |
|
Return true if the requested priority is enabled.
|
|
Return true if the requested priority is enabled.
|
|
Get the message that describes what type of error occurred.
|
|
Set the message that describes what type of error occurred.
|
|
|
|
Set a new callback object and return the existing callback to allow "chaining". Note that s are not inherited when spawning a new thread, so you'll need to reset them in each thread. |
|
Get the ostream that is used to print error messages.
|
|
delete_stream == 1, forces Log_Msg.h to delete the stream in its own ~dtor (assumes control of the stream) use only with proper ostream (eg: fstream), not (cout, cerr) |
|
Update the ostream without overwriting the delete_ostream_ flag.
|
|
Get the result of the operation status (by convention, -1 means error).
|
|
Set the result of the operation status (by convention, -1 means error).
|
|
Initialize the ACE logging facility. Initialize the ACE logging facility. Supplies the program name that is available to each logging message call. Default arguments set up logging to STDERR only.
|
|
|
|
|
|
Get the current mask. Set the mask, returns original mask.
|
|
Returns the current program name used for logging.
|
|
Release the internal lock.
|
|
Get the field that indicates whether interrupted calls should be restarted.
|
|
Set the field that indicates whether interrupted calls should be restarted.
|
|
Set the line number, file name, operational status, error number, restart flag, ostream, and the callback object. This combines all the other set methods into a single method. |
|
Enable the bits in the logger's options flags. Disable the bits in the logger's options flags. Return the bits in the logger's options flags. |
|
|
|
|
|
Call after doing a <fork> to resynchronize the process id and <program_name> variables.
|
|
Decouple the OS layer from the Log_Msg layer.
|
|
Set the TSS thread descriptor. This method will call td->acquire_release to block execution until this call return. |
|
Get the TSS thread descriptor.
|
|
Return the TSS singleton thread descriptor.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Declare the dynamic allocation hooks.
|
|
|
|
|
|
Are we deleting this ostream?
|
|
Type of error that occurred (see <sys/errno.h>).
|
|
File where the error occurred.
|
|
File where the error occurred.
|
|
Options flags.
|
|
Number of existing Log_Msg instances; when 0, delete program/host names Priority mask to use for each new instance |
|
|
|
|
|
Line number where the error occurred.
|
|
Name of the local host (used when printing messages).
|
|
The log message, which resides in thread-specific storage. Note that only the current log message is stored here -- it will be overwritten by the subsequent call to <log>.
|
|
The callback object.
|
|
Offset of msg_[].
|
|
|
|
The ostream where logging messages can be written.
|
|
Process id of the current process.
|
|
Keeps track of all the per-thread values that are currently enabled. Default is for all logging priorities to be _disabled_. |
|
Initializer: LM_SHUTDOWN | LM_TRACE | LM_DEBUG | LM_INFO | LM_NOTICE | LM_WARNING | LM_STARTUP | LM_ERROR | LM_CRITICAL | LM_ALERT | LM_EMERGENCY |
|
Records the program name.
|
|
Indicates whether we should restart system calls that are interrupted.
|
|
Status of operation (-1 means failure, >= 0 means success).
|
|
If we're running in the context of an this will point to the thread descriptor adapter which holds the thread descriptor of the thread. This can be used to repidly access all thread data kept in . |
|
Are we already within an ACE_Trace constructor call?
|
|
Depth of the nesting for printing traces.
|
|
Are we allowing tracing in this thread?
|