---

ACE_Logging_Strategy Class Reference

This class provides the hooks to control the output produced by any of the network services. More...

#include <Logging_Strategy.h>

Inheritance diagram for ACE_Logging_Strategy:

[legend]Collaboration diagram for ACE_Logging_Strategy:

[legend]List of all members.

Public Methods
	ACE_Logging_Strategy (void)
	Constructor. More...
virtual int	init (int argc, ACE_TCHAR *argv[])
	Dynamic linking initialization hook. More...
virtual int	fini (void)
	Dynamic linking termination hook. More...
virtual int	handle_timeout (const ACE_Time_Value &tv, const void *arg)
int	parse_args (int argc, ACE_TCHAR *argv[])
void	log_msg (ACE_Log_Msg *log_msg)
Protected Methods
void	tokenize (ACE_TCHAR *flag_string)
	Tokenize to set all the flags. More...
void	priorities (ACE_TCHAR *priority_string, ACE_Log_Msg::MASK_TYPE mask)
	Tokenize to set priorities (either process or thread one). More...
Protected Attributes
u_long	thread_priority_mask_
	Current thread's priority mask set by <priorities>. More...
u_long	process_priority_mask_
	Process-wide priority mask set by <priorities>. More...
u_long	flags_
	Flags we keep track of. More...
ACE_TCHAR *	filename_
	File name we're logging to. More...
ACE_TCHAR *	logger_key_
	Logger key for distributed logging. More...
ACE_TCHAR *	program_name_
	Program name to be used for n format specifier. More...
int	wipeout_logfile_
	If non-0 then wipeout the logfile, otherwise append to it. Default value is 0. More...
int	count_
	This tells us in what file we last wrote. It will be increased to enable multiple log files. More...
int	fixed_number_
	If non-0 we have a maximum number of log files we can write. Default value is 0, i.e., no maximum number. More...
int	order_files_
	If non-0 we order the files as we rotate them. Default value is 0, i.e., we do not rotate files by default. More...
int	max_file_number_
	Tells us what is the maximum log file to write. We will write <max_file_number_> + 1 files (includes the current log file). Default value is 1, i.e., 2 files by default. More...
u_long	interval_
	If non-zero, sampling interval (in secs) at which maximum logfile size is checked, otherwise logfile size can grow indefinitely. Default value is 0. More...
u_long	max_size_
	Maximum logfile size (in KB). Default value is <ACE_DEFAULT_MAX_LOGFILE_SIZE>. More...
ACE_Log_Msg *	log_msg_
	ACE_Log_Msg instance to work with. More...

---

Detailed Description

This class provides the hooks to control the output produced by any of the network services.

Depending upon when this service is invoked and with what flags, the output of other network services can be controlled. The output can be streamed to stderr, to a file, to a logging daemon, or it can be set to be "silent". If logging records are output to a file, the file can be set to a maximum size and repeatedly split into new files. The log file size can be limited at any logging point (i.e., application, client logging daemon, or server logging daemon) by specifying the -i <sample_interval_in_secs> and -m <max_size_in_KB> options for the Logging_Strategy class in a svc.conf file.

By default, two logfiles are generated. It's possible, however, to generate as many logfiles as necessary to store all the information. To achieve this, it is only necessary to indicate the maximum size of the logfiles via the -m option and the process will generate automatically the logfiles. You can control the total number of logfiles created via the -n option.

By using the -o option we can also choose the mode of organization of the files, e.g., the first one is the normal used in Unix systems (when cron rotates the logs it keeps the lowest number the most recent one), the second is for increasing speed (we only create a new log file, and don't rotate the others (fewer accesses to disk)).

Definition at line 59 of file Logging_Strategy.h.

---

Constructor & Destructor Documentation

ACE_Logging_Strategy::ACE_Logging_Strategy (  void    )

Constructor. Definition at line 218 of file Logging_Strategy.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_NEW, ACE_TCHAR, filename_, ACE_Lib_Find::get_temp_dir, LM_ERROR, logger_key_, MAXPATHLEN, program_name_, ACE_OS_String::strcat, and ACE::strnew. : log_msg_ (ACE_Log_Msg::instance ()) { #if defined (ACE_DEFAULT_LOGFILE) this->filename_ = ACE::strnew (ACE_DEFAULT_LOGFILE); #else /* ACE_DEFAULT_LOGFILE */ ACE_NEW (this->filename_, ACE_TCHAR[MAXPATHLEN + 1]); // Get the temporary directory if (ACE_Lib_Find::get_temp_dir (this->filename_, MAXPATHLEN - 7) == -1) // 7 for "logfile" { ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("Temporary path too long, ") ACE_LIB_TEXT ("defaulting to current directory\n"))); this->filename_[0] = 0; } // Add the filename to the end ACE_OS::strcat (this->filename_, ACE_LIB_TEXT ("logfile")); #endif /* ACE_DEFAULT_LOGFILE */ this->logger_key_ = 0; this->program_name_ = 0; }

---

Member Function Documentation

int ACE_Logging_Strategy::fini (  void    )  [virtual]

Dynamic linking termination hook. Reimplemented from ACE_Shared_Object. Definition at line 247 of file Logging_Strategy.cpp. References ACE_Reactor::cancel_timer, filename_, interval_, logger_key_, max_size_, program_name_, and ACE_Event_Handler::reactor. { delete [] this->filename_; delete [] this->logger_key_; delete [] this->program_name_; if (this->interval_ > 0 && this->max_size_ > 0) this->reactor ()->cancel_timer (this); return 0; }

int ACE_Logging_Strategy::handle_timeout (  const ACE_Time_Value &    tv, const void *    arg )  [virtual]

Timeout handler which tests logfile size. If the current logfile size exceeds <max_size_>, the current logfile is closed, saved to logfile.old, and a new logfile is reopened. Reimplemented from ACE_Event_Handler. Definition at line 355 of file Logging_Strategy.cpp. References ACE_ERROR, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, ACE_Log_Msg::acquire, count_, ACE_OS::fclose, fixed_number_, ACE_OS::fopen, ACE_OS::fseek, LM_ERROR, log_msg_, max_file_number_, max_size_, MAXPATHLEN, ACE_Log_Msg::msg_ostream, ACE_Log_Msg::release, ACE_OS::rename, ACE_OS::sprintf, ACE_OS_String::strlen, and ACE_OS::unlink. { #if defined (ACE_LACKS_IOSTREAM_TOTALLY) if ((size_t) ACE_OS::fseek (this->log_msg_->msg_ostream (), 0, SEEK_CUR) > this->max_size_) #else if ((size_t) this->log_msg_->msg_ostream ()->tellp () > this->max_size_) #endif /* ACE_LACKS_IOSTREAM_TOTALLY */ { // Lock out any other logging. if (this->log_msg_->acquire ()) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("Cannot acquire lock!\n")), -1); // Close the current ostream. #if defined (ACE_LACKS_IOSTREAM_TOTALLY) FILE *output_file = (FILE *) this->log_msg_->msg_ostream (); ACE_OS::fclose (output_file); // We'll call msg_ostream() modifier later. #else ofstream *output_file = (ofstream *) this->log_msg_->msg_ostream (); output_file->close (); #endif /* ACE_LACKS_IOSTREAM_TOTALLY */ // Save current logfile to logfile.old analyze if it was set any // fixed number for the log_files. if (fixed_number_) { if (max_file_number_ < 1) //we only want one file { // Just unlink the file. ACE_OS::unlink (this->filename_); // Open a new log file with the same name. #if defined (ACE_LACKS_IOSTREAM_TOTALLY) output_file = ACE_OS::fopen (this->filename_, ACE_LIB_TEXT ("wt")); if (output_file == 0) return -1; this->log_msg_->msg_ostream (output_file); #else output_file->open (ACE_TEXT_ALWAYS_CHAR (this->filename_), ios::out); #endif /* ACE_LACKS_IOSTREAM_TOTALLY */ // Release the lock previously acquired. this->log_msg_->release (); return 0; } } count_++; // Set the number of digits of the log_files labels. int digits = 1, res = count_; while((res = (res / 10))>0) digits++; if (ACE_OS::strlen (this->filename_) + digits <= MAXPATHLEN) { ACE_TCHAR backup[MAXPATHLEN+1]; // analyse if it was chosen the mode which will order the // log_files if (order_files_) { ACE_TCHAR to_backup[MAXPATHLEN+1]; // reorder the logs starting at the oldest (the biggest // number) watch if we reached max_file_number_. int max_num; if (fixed_number_ && count_ > max_file_number_) // count_ will always be bigger than max_file_number_, // so do nothing so to always reorder files from // max_file_number_. max_num = max_file_number_; else max_num = count_; for (int i = max_num ; i > 1 ;i--) { ACE_OS::sprintf (backup, ACE_LIB_TEXT ("%s.%d"), this->filename_, i); ACE_OS::sprintf (to_backup, ACE_LIB_TEXT ("%s.%d"), this->filename_, i - 1); // Remove any existing old file; ignore error as // file may not exist. ACE_OS::unlink (backup); // Rename the current log file to the name of the // backup log file. ACE_OS::rename (to_backup, backup); } ACE_OS::sprintf (backup, ACE_LIB_TEXT ("%s.1"), this->filename_); } else { if (fixed_number_ && count_>max_file_number_) count_ = 1; // start over from 1 ACE_OS::sprintf (backup, ACE_LIB_TEXT ("%s.%d"), this->filename_, count_); } // Remove any existing old file; ignore error as file may // not exist. ACE_OS::unlink (backup); // Rename the current log file to the name of the backup log // file. ACE_OS::rename (this->filename_, backup); } else ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("Backup file name too long; ") ACE_LIB_TEXT ("backup logfile not saved.\n"))); // Open a new log file by the same name #if defined (ACE_LACKS_IOSTREAM_TOTALLY) output_file = ACE_OS::fopen (this->filename_, ACE_LIB_TEXT ("wt")); if (output_file == 0) return -1; this->log_msg_->msg_ostream (output_file); #else output_file->open (ACE_TEXT_ALWAYS_CHAR (this->filename_), ios::out); #endif /* ACE_LACKS_IOSTREAM_TOTALLY */ // Release the lock previously acquired. this->log_msg_->release (); } return 0; }

int ACE_Logging_Strategy::init (  int    argc, ACE_TCHAR *    argv[] )  [virtual]

Dynamic linking initialization hook. Reimplemented from ACE_Shared_Object. Definition at line 260 of file Logging_Strategy.cpp. References ACE_BIT_ENABLED, ACE_LIB_TEXT, ACE_NEW_RETURN, ACE_TCHAR, ACE_TEXT_ALWAYS_CHAR, ACE_TRACE, ACE_Log_Msg::clr_flags, flags_, ACE_OS::fopen, ACE_Reactor::instance, interval_, log_msg_, ACE_Log_Msg::LOGGER, logger_key_, max_size_, ACE_Log_Msg::msg_ostream, ACE_Log_Msg::open, ACE_Log_Msg::OSTREAM, parse_args, ACE_Log_Msg::priority_mask, ACE_Log_Msg::PROCESS, process_priority_mask_, ACE_Event_Handler::reactor, ACE_Reactor::schedule_timer, ACE_Log_Msg::set_flags, ACE_Log_Msg::SILENT, ACE_Log_Msg::STDERR, ACE_Log_Msg::SYSLOG, ACE_Log_Msg::THREAD, thread_priority_mask_, ACE_Log_Msg::VERBOSE, and ACE_Log_Msg::VERBOSE_LITE. { ACE_TRACE ("ACE_Logging_Strategy::init"); // Store current priority masks for changes in <parse_args>. this->process_priority_mask_ = this->log_msg_->priority_mask (ACE_Log_Msg::PROCESS); this->thread_priority_mask_ = this->log_msg_->priority_mask (ACE_Log_Msg::THREAD); // Use the options hook to parse the command line arguments. this->parse_args (argc, argv); // Setup priorities (to original if not specified on command line) this->log_msg_->priority_mask (thread_priority_mask_, ACE_Log_Msg::THREAD); this->log_msg_->priority_mask (process_priority_mask_, ACE_Log_Msg::PROCESS); // Check if any flags were specified. If none were specified, let // the default behavior take effect. if (this->flags_ != 0) { // Clear all flags this->log_msg_->clr_flags (ACE_Log_Msg::STDERR | ACE_Log_Msg::LOGGER | ACE_Log_Msg::OSTREAM | ACE_Log_Msg::VERBOSE | ACE_Log_Msg::VERBOSE_LITE | ACE_Log_Msg::SILENT | ACE_Log_Msg::SYSLOG); // Check if OSTREAM bit is set if (ACE_BIT_ENABLED (this->flags_, ACE_Log_Msg::OSTREAM)) { #if defined (ACE_LACKS_IOSTREAM_TOTALLY) FILE *output_file = 0; if (wipeout_logfile_) output_file = ACE_OS::fopen (this->filename_, ACE_LIB_TEXT ("wt")); else output_file = ACE_OS::fopen (this->filename_, ACE_LIB_TEXT ("at")); if (output_file == 0) return -1; #else ofstream *output_file = 0; // Create a new ofstream to direct output to the file. if (wipeout_logfile_) ACE_NEW_RETURN (output_file, ofstream (ACE_TEXT_ALWAYS_CHAR (this->filename_)), -1); else ACE_NEW_RETURN (output_file, ofstream (ACE_TEXT_ALWAYS_CHAR (this->filename_), ios::app | ios::out), -1); if (output_file->rdstate () != ios::goodbit) { delete output_file; return -1; } #endif /* ACE_LACKS_IOSTREAM_TOTALLY */ // Set the <output_file> that'll be used by the rest of the // code. this->log_msg_->msg_ostream (output_file); // Setup a timeout handler to perform the maximum file size // check (if required). if (this->interval_ > 0 && this->max_size_ > 0) { if (this->reactor () == 0) // Use singleton. this->reactor (ACE_Reactor::instance ()); this->reactor ()->schedule_timer (this, 0, ACE_Time_Value (this->interval_), ACE_Time_Value (this->interval_)); } } // Now set the flags for Log_Msg this->log_msg_->set_flags (this->flags_); } return this->log_msg_->open (this->program_name_, this->log_msg_->flags (), this->logger_key_); }

void ACE_Logging_Strategy::log_msg (  ACE_Log_Msg *    log_msg )

Definition at line 507 of file Logging_Strategy.cpp. References log_msg_. { this->log_msg_ = log_msg; }

int ACE_Logging_Strategy::parse_args (  int    argc, ACE_TCHAR *    argv[] )

Parse arguments provided in svc.conf file. '-f' Pass in the flags (such as OSTREAM, STDERR, LOGGER, VERBOSE, SILENT, VERBOSE_LITE) used to control logging. '-i' The interval (in seconds) at which the logfile size is sampled (default is 0, i.e., do not sample by default). '-k' Set the logging key. '-m' Maximum logfile size in Kbytes. '-n' Set the program name for the n format specifier. '-N' The maximum number of logfiles that we want created. '-o' Specifies that we want the no standard logfiles ordering (fastest processing in <handle_timeout>). Default is not to order logfiles. '-p' Pass in the process-wide priorities to either enable (e.g., DEBUG, INFO, WARNING, NOTICE, ERROR, CRITICAL, ALERT, EMERGENCY) or to disable (e.g., ~DEBUG, ~INFO, ~WARNING, ~NOTICE, ~ERROR, ~CRITICAL, ~ALERT, ~EMERGENCY). '-s' Ensure that the OSTREAM flag is set. '-t' Pass in the thread-wide priorities to either enable (e.g., DEBUG, INFO, WARNING, NOTICE, ERROR, CRITICAL, ALERT, EMERGENCY) or to disable (e.g., ~DEBUG, ~INFO, ~WARNING, ~NOTICE, ~ERROR, ~CRITICAL, ~ALERT, ~EMERGENCY). '-w' Cause the logfile to be wiped out, both on startup and on reconfiguration. Definition at line 126 of file Logging_Strategy.cpp. References ACE_BIT_ENABLED, ACE_DEFAULT_LOGFILE_POLL_INTERVAL, ACE_DEFAULT_LOGGER_KEY, ACE_LIB_TEXT, ACE_SET_BITS, ACE_TCHAR, ACE_TRACE, ACE_OS::atoi, count_, filename_, fixed_number_, flags_, interval_, ACE_Log_Msg::LOGGER, logger_key_, max_file_number_, max_size_, ACE_Get_Opt::opt_arg, order_files_, ACE_Log_Msg::OSTREAM, priorities, ACE_Log_Msg::PROCESS, program_name_, ACE::strnew, ACE_OS_String::strtoul, ACE_Log_Msg::THREAD, tokenize, and wipeout_logfile_. Referenced by init. { ACE_TRACE ("ACE_Logging_Strategy::parse_args"); ACE_TCHAR *temp; // Perform data member initializations. BTW, do *not* initialize // <thread_priority_mask_> or <process_priority_mask_> here to avoid // unduing the behavior in <init>, where these are set by // <ACE_Log_Msg::instance>. this->flags_ = 0; this->wipeout_logfile_ = 0; this->count_ = 0; this->fixed_number_ = 0; this->order_files_ = 0; this->max_file_number_ = 1; this->interval_ = ACE_DEFAULT_LOGFILE_POLL_INTERVAL; this->max_size_ = 0; ACE_Get_Opt get_opt (argc, argv, ACE_LIB_TEXT ("f:i:k:m:n:N:op:s:t:w"), 0); for (int c; (c = get_opt ()) != -1; ) { switch (c) { case 'f': temp = get_opt.opt_arg (); // Now tokenize the string to get all the flags this->tokenize (temp); // If LOGGER was specified, set up the default logger key. // The key can be changed by the -k option also, so if it's // been set already, don't set it. if (ACE_BIT_ENABLED (this->flags_, ACE_Log_Msg::LOGGER) && this->logger_key_ == 0) this->logger_key_ = ACE::strnew (ACE_DEFAULT_LOGGER_KEY); break; case 'i': // Interval (in secs) at which logfile size is sampled. this->interval_ = ACE_OS::strtoul (get_opt.opt_arg (), 0, 10); break; case 'k': // Ensure that the LOGGER flag is set ACE_SET_BITS (this->flags_, ACE_Log_Msg::LOGGER); delete [] this->logger_key_; this->logger_key_ = ACE::strnew (get_opt.opt_arg ()); break; case 'm': // Maximum logfile size (in KB). Must be a non-zero value. this->max_size_ = ACE_OS::strtoul (get_opt.opt_arg (), 0, 10); this->max_size_ <<= 10; // convert to KB break; case 'n': delete [] this->program_name_; this->program_name_ = ACE::strnew (get_opt.opt_arg ()); break; case 'N': // The max number for the log_file being created this->max_file_number_ = ACE_OS::atoi (get_opt.opt_arg ()) - 1; this->fixed_number_ = 1; break; case 'o': // Log_files generation order this->order_files_ = 1; break; case 'p': temp = get_opt.opt_arg (); // Now tokenize the string to setup process log priority this->priorities (temp, ACE_Log_Msg::PROCESS); break; case 's': // Ensure that the OSTREAM flag is set ACE_SET_BITS (this->flags_, ACE_Log_Msg::OSTREAM); delete [] this->filename_; this->filename_ = ACE::strnew (get_opt.opt_arg ()); break; case 't': temp = get_opt.opt_arg (); // Now tokenize the string to setup thread log priority this->priorities (temp, ACE_Log_Msg::THREAD); break; case 'w': // Cause the logfile to be wiped out, both on startup and on // reconfigure. this->wipeout_logfile_ = 1; break; default: break; } } return 0; }

void ACE_Logging_Strategy::priorities (  ACE_TCHAR *    priority_string, ACE_Log_Msg::MASK_TYPE    mask )  [protected]

Tokenize to set priorities (either process or thread one). Definition at line 16 of file Logging_Strategy.cpp. References ACE_CLR_BITS, ACE_LIB_TEXT, ACE_SET_BITS, ACE_TCHAR, LM_ALERT, LM_CRITICAL, LM_DEBUG, LM_EMERGENCY, LM_ERROR, LM_INFO, LM_NOTICE, LM_SHUTDOWN, LM_STARTUP, LM_TRACE, LM_WARNING, ACE_Log_Msg::MASK_TYPE, ACE_Event_Handler::priority, ACE_Log_Msg::PROCESS, process_priority_mask_, ACE_OS_String::strcmp, ACE_OS_String::strtok_r, and thread_priority_mask_. Referenced by parse_args. { u_long priority_mask = 0; // Choose priority mask to change. if (mask == ACE_Log_Msg::PROCESS) priority_mask = process_priority_mask_; else priority_mask = thread_priority_mask_; ACE_TCHAR *strtokp; // Parse string and alternate priority mask. for (ACE_TCHAR *priority = ACE_OS_String::strtok_r (priority_string, ACE_LIB_TEXT ("|"), &strtokp); priority != 0; priority = ACE_OS_String::strtok_r (0, ACE_LIB_TEXT ("|"), &strtokp)) { if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("SHUTDOWN")) == 0) ACE_SET_BITS (priority_mask, LM_SHUTDOWN); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~SHUTDOWN")) == 0) ACE_CLR_BITS (priority_mask, LM_SHUTDOWN); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("TRACE")) == 0) ACE_SET_BITS (priority_mask, LM_TRACE); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~TRACE")) == 0) ACE_CLR_BITS (priority_mask, LM_TRACE); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("DEBUG")) == 0) ACE_SET_BITS (priority_mask, LM_DEBUG); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~DEBUG")) == 0) ACE_CLR_BITS (priority_mask, LM_DEBUG); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("INFO")) == 0) ACE_SET_BITS (priority_mask, LM_INFO); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~INFO")) == 0) ACE_CLR_BITS (priority_mask, LM_INFO); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("NOTICE")) == 0) ACE_SET_BITS (priority_mask, LM_NOTICE); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~NOTICE")) == 0) ACE_CLR_BITS (priority_mask, LM_NOTICE); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("WARNING")) == 0) ACE_SET_BITS (priority_mask, LM_WARNING); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~WARNING")) == 0) ACE_CLR_BITS (priority_mask, LM_WARNING); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("STARTUP")) == 0) ACE_SET_BITS (priority_mask, LM_STARTUP); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~STARTUP")) == 0) ACE_CLR_BITS (priority_mask, LM_STARTUP); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("ERROR")) == 0) ACE_SET_BITS (priority_mask, LM_ERROR); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~ERROR")) == 0) ACE_CLR_BITS (priority_mask, LM_ERROR); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("CRITICAL")) == 0) ACE_SET_BITS (priority_mask, LM_CRITICAL); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~CRITICAL")) == 0) ACE_CLR_BITS (priority_mask, LM_CRITICAL); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("ALERT")) == 0) ACE_SET_BITS (priority_mask, LM_ALERT); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~ALERT")) == 0) ACE_CLR_BITS (priority_mask, LM_ALERT); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("EMERGENCY")) == 0) ACE_SET_BITS (priority_mask, LM_EMERGENCY); else if (ACE_OS::strcmp (priority, ACE_LIB_TEXT ("~EMERGENCY")) == 0) ACE_CLR_BITS (priority_mask, LM_EMERGENCY); } // Affect right priority mask. if (mask == ACE_Log_Msg::PROCESS) process_priority_mask_ = priority_mask; else thread_priority_mask_ = priority_mask; }

void ACE_Logging_Strategy::tokenize (  ACE_TCHAR *    flag_string )  [protected]

Tokenize to set all the flags. Definition at line 98 of file Logging_Strategy.cpp. References ACE_LIB_TEXT, ACE_SET_BITS, ACE_TCHAR, ACE_Log_Msg::LOGGER, ACE_Log_Msg::OSTREAM, ACE_Log_Msg::SILENT, ACE_Log_Msg::STDERR, ACE_OS_String::strcmp, ACE_OS_String::strtok_r, ACE_Log_Msg::SYSLOG, ACE_Log_Msg::VERBOSE, and ACE_Log_Msg::VERBOSE_LITE. Referenced by parse_args. { ACE_TCHAR *strtokp; for (ACE_TCHAR *flag = ACE_OS::strtok_r (flag_string, ACE_LIB_TEXT ("|"), &strtokp); flag != 0; flag = ACE_OS::strtok_r (0, ACE_LIB_TEXT ("|"), &strtokp)) { if (ACE_OS::strcmp (flag, ACE_LIB_TEXT ("STDERR")) == 0) ACE_SET_BITS (this->flags_, ACE_Log_Msg::STDERR); else if (ACE_OS::strcmp (flag, ACE_LIB_TEXT ("LOGGER")) == 0) ACE_SET_BITS (this->flags_, ACE_Log_Msg::LOGGER); else if (ACE_OS::strcmp (flag, ACE_LIB_TEXT ("OSTREAM")) == 0) ACE_SET_BITS (this->flags_, ACE_Log_Msg::OSTREAM); else if (ACE_OS::strcmp (flag, ACE_LIB_TEXT ("VERBOSE")) == 0) ACE_SET_BITS (this->flags_, ACE_Log_Msg::VERBOSE); else if (ACE_OS::strcmp (flag, ACE_LIB_TEXT ("VERBOSE_LITE")) == 0) ACE_SET_BITS (this->flags_, ACE_Log_Msg::VERBOSE_LITE); else if (ACE_OS::strcmp (flag, ACE_LIB_TEXT ("SILENT")) == 0) ACE_SET_BITS (this->flags_, ACE_Log_Msg::SILENT); else if (ACE_OS::strcmp (flag, ACE_LIB_TEXT ("SYSLOG")) == 0) ACE_SET_BITS (this->flags_, ACE_Log_Msg::SYSLOG); } }

---

Member Data Documentation

int ACE_Logging_Strategy::count_ [protected]

This tells us in what file we last wrote. It will be increased to enable multiple log files. Definition at line 140 of file Logging_Strategy.h. Referenced by handle_timeout, and parse_args.

ACE_TCHAR* ACE_Logging_Strategy::filename_ [protected]

File name we're logging to. Definition at line 126 of file Logging_Strategy.h. Referenced by ACE_Logging_Strategy, fini, and parse_args.

int ACE_Logging_Strategy::fixed_number_ [protected]

If non-0 we have a maximum number of log files we can write. Default value is 0, i.e., no maximum number. Definition at line 144 of file Logging_Strategy.h. Referenced by handle_timeout, and parse_args.

u_long ACE_Logging_Strategy::flags_ [protected]

Flags we keep track of. Definition at line 123 of file Logging_Strategy.h. Referenced by init, and parse_args.

u_long ACE_Logging_Strategy::interval_ [protected]

If non-zero, sampling interval (in secs) at which maximum logfile size is checked, otherwise logfile size can grow indefinitely. Default value is 0. Definition at line 158 of file Logging_Strategy.h. Referenced by fini, init, and parse_args.

ACE_Log_Msg* ACE_Logging_Strategy::log_msg_ [protected]

ACE_Log_Msg instance to work with. Definition at line 165 of file Logging_Strategy.h. Referenced by handle_timeout, init, and log_msg.

ACE_TCHAR* ACE_Logging_Strategy::logger_key_ [protected]

Logger key for distributed logging. Definition at line 129 of file Logging_Strategy.h. Referenced by ACE_Logging_Strategy, fini, init, and parse_args.

int ACE_Logging_Strategy::max_file_number_ [protected]

Tells us what is the maximum log file to write. We will write <max_file_number_> + 1 files (includes the current log file). Default value is 1, i.e., 2 files by default. Definition at line 153 of file Logging_Strategy.h. Referenced by handle_timeout, and parse_args.

u_long ACE_Logging_Strategy::max_size_ [protected]

Maximum logfile size (in KB). Default value is <ACE_DEFAULT_MAX_LOGFILE_SIZE>. Definition at line 162 of file Logging_Strategy.h. Referenced by fini, handle_timeout, init, and parse_args.

int ACE_Logging_Strategy::order_files_ [protected]

If non-0 we order the files as we rotate them. Default value is 0, i.e., we do not rotate files by default. Definition at line 148 of file Logging_Strategy.h. Referenced by parse_args.

u_long ACE_Logging_Strategy::process_priority_mask_ [protected]

Process-wide priority mask set by <priorities>. Definition at line 120 of file Logging_Strategy.h. Referenced by init, and priorities.

ACE_TCHAR* ACE_Logging_Strategy::program_name_ [protected]

Program name to be used for n format specifier. Definition at line 132 of file Logging_Strategy.h. Referenced by ACE_Logging_Strategy, fini, and parse_args.

u_long ACE_Logging_Strategy::thread_priority_mask_ [protected]

Current thread's priority mask set by <priorities>. Definition at line 117 of file Logging_Strategy.h. Referenced by init, and priorities.

int ACE_Logging_Strategy::wipeout_logfile_ [protected]

If non-0 then wipeout the logfile, otherwise append to it. Default value is 0. Definition at line 136 of file Logging_Strategy.h. Referenced by parse_args.

---

The documentation for this class was generated from the following files:

• Logging_Strategy.h
• Logging_Strategy.cpp

---