ASSA::FileLogger Class Reference

#include <FileLogger.h>

Inheritance diagram for ASSA::FileLogger:

ASSA::Logger_Impl List of all members.

Public Member Functions

 FileLogger ()
virtual int log_open (const char *logfname_, u_long groups_, u_long maxsize_=10485760)
 Open File Logger.
virtual int log_close (void)
virtual void log_resync (void)
virtual int log_msg (Group g_, size_t indent_level_, const string &func_name_, size_t expected_sz_, const char *fmt_, va_list)
 If output string is longer then LOGGER_MAXLINE-1, it is truncated to that size.
virtual int log_func (Group g_, size_t indent_level_, const string &func_name_, marker_t type_)
int log_raw_msg (const string &msg_)
 Log message as it is (raw) without indentation or timestamping, but still perform byte counting and the logic associated with it.
void dump (void)

Private Types

enum  state_t { opened, closed }

Private Member Functions

 FileLogger (const FileLogger &)
FileLoggeroperator= (const FileLogger &)
int handle_rollover ()

Private Attributes

std::ofstream m_sink
u_long m_maxsize
state_t m_state
u_long m_bytecount

Detailed Description

Definition at line 30 of file FileLogger.h.


Member Enumeration Documentation

enum ASSA::FileLogger::state_t [private]
 

Enumerator:
opened 
closed 

Definition at line 60 of file FileLogger.h.

00060 { opened, closed };


Constructor & Destructor Documentation

ASSA::FileLogger::FileLogger  )  [inline]
 

Definition at line 75 of file FileLogger.h.

00076     : m_maxsize   (1048576), 
00077       m_state     (closed),
00078       m_bytecount (0)
00079 {
00080     /*--- empty ---*/
00081 }

ASSA::FileLogger::FileLogger const FileLogger  )  [private]
 


Member Function Documentation

void FileLogger::dump void   ) 
 

Definition at line 211 of file FileLogger.cpp.

References ASSA::endl(), m_bytecount, ASSA::Logger_Impl::m_groups, ASSA::Logger_Impl::m_indent_step, ASSA::Logger_Impl::m_logfname, m_maxsize, m_sink, m_state, ASSA::Logger_Impl::m_tmflg, and opened.

00212 {
00213 #ifdef BUG_HUNTING
00214     if (m_state == opened) {
00215         m_sink << "m_logfname    = \"" << m_logfname      << "\"\n"
00216                << "m_groups      = 0x";
00217         char oldfill = m_sink.fill ('0');
00218         m_sink << std::setw(8) << std::hex << m_groups << '\n' << std::dec;
00219         m_sink.fill (oldfill);
00220         m_sink << "m_indent_step = "   << m_indent_step   << '\n'
00221                << "m_tmflg       = "   << m_tmflg         << '\n'
00222                << "m_maxsize     = "   << m_maxsize       << '\n'
00223                << "m_state       = opened\n"
00224                << "m_bytecount   = "   << m_bytecount     << std::endl;
00225     }
00226 #endif
00227 }

int FileLogger::handle_rollover  )  [private]
 

Definition at line 175 of file FileLogger.cpp.

References Assure_exit, closed, ASSA::endl(), m_bytecount, ASSA::Logger_Impl::m_logfname, m_maxsize, m_sink, m_state, and opened.

Referenced by log_func(), log_msg(), and log_raw_msg().

00176 {
00177     if (m_bytecount >= m_maxsize) {
00178         struct stat fst;
00179         if (::stat (m_logfname.c_str(), &fst) == 0) {
00180             if (S_ISREG (fst.st_mode)) {
00181                 m_sink << "\nReached maximum allowable size\n"
00182                        << "m_bytecount = " << m_bytecount
00183                        << ", m_maxsize = " << m_maxsize << std::endl;
00184                 m_sink.close ();
00185                 m_state = closed;
00186                 m_bytecount = 0;
00187 
00188                 string newname = m_logfname + ".0";
00189                 unlink (newname.c_str ());
00190                 rename (m_logfname.c_str (), newname.c_str ());
00191                 m_sink.open (m_logfname.c_str (), 
00192                              std::ios::app | std::ios::out);
00193                 if (!m_sink) {
00194                     return -1;
00195                 }
00196                 m_state = opened;
00197             }
00198             else if (S_ISCHR (fst.st_mode)) { // It is /dev/null
00199                 m_bytecount = 0;
00200             }
00201             else {
00202                 Assure_exit (1);
00203             }
00204         }
00205     }
00206     return 0;
00207 }

int FileLogger::log_close void   )  [virtual]
 

Implements ASSA::Logger_Impl.

Definition at line 60 of file FileLogger.cpp.

References closed, ASSA::flush(), m_bytecount, ASSA::Logger_Impl::m_groups, ASSA::Logger_Impl::m_logfname, m_maxsize, m_sink, and m_state.

00061 {
00062     if (m_state != closed) {
00063         m_sink << std::flush;
00064         m_sink.close ();
00065         m_state = closed;
00066 
00067         if (m_groups == 0) {
00068             ::unlink (m_logfname.c_str ());
00069         }
00070         m_logfname.empty ();
00071         m_maxsize = 0;
00072         m_bytecount = 0;
00073     }
00074     return 0;
00075 }

int FileLogger::log_func Group  g_,
size_t  indent_level_,
const string &  func_name_,
marker_t  type_
[virtual]
 

Implements ASSA::Logger_Impl.

Definition at line 143 of file FileLogger.cpp.

References ASSA::Logger_Impl::add_timestamp(), closed, ASSA::flush(), ASSA::FUNC_ENTRY, ASSA::Logger_Impl::group_enabled(), handle_rollover(), ASSA::Logger_Impl::indent_func_name(), m_bytecount, m_sink, and m_state.

00145 {
00146     if (m_state == closed) {
00147         errno = EPERM;
00148         return -1;
00149     }
00150     if (! group_enabled (g_)) {
00151         return 0;
00152     }
00153     m_bytecount += add_timestamp (m_sink);
00154     m_bytecount += indent_func_name (m_sink, func_name_, indent_level_, type_);
00155     m_sink << ((type_ == FUNC_ENTRY) ? "---v---\n" : "---^---\n") << std::flush;
00156     m_bytecount += ::strlen ("---v---\n");
00157     return handle_rollover ();
00158 }

int FileLogger::log_msg Group  g_,
size_t  indent_level_,
const string &  func_name_,
size_t  expected_sz_,
const char *  fmt_,
va_list  msg_list_
[virtual]
 

If output string is longer then LOGGER_MAXLINE-1, it is truncated to that size.

From printf(3) manpage:

"Upon successful return, these functions return the number of characters printed (not including the trailing '\0' used to end output to strings).

If the output was truncated due to this limit then the return value is the number of characters (not including the trailing '\0') which would have been written to the final string if enough space had been available.

Thus, a return value of size or more means that the output was truncated.

If an output error is encountered, a negative value is returned."

In other words, if you have attempted to write more then buffer can hold, the output is truncated by buffer size - 1, and the return value would be the number of bytes you have tried to write to the buffer.

If buffer size is 256, and you tried to write 340 bytes to it, the first 255 bytes are written to the buffer, and 340 is returns as the return value.

Implements ASSA::Logger_Impl.

Definition at line 107 of file FileLogger.cpp.

References ASSA::Logger_Impl::add_timestamp(), closed, ASSA::flush(), ASSA::Logger_Impl::format_msg(), ASSA::FUNC_MSG, ASSA::Logger_Impl::group_enabled(), handle_rollover(), ASSA::Logger_Impl::indent_func_name(), m_bytecount, m_sink, and m_state.

00113 {
00114     if (m_state == closed) {
00115         errno = EPERM;
00116         return -1;
00117     }
00118 
00119     if (! group_enabled (g_)) {
00120         return 0;
00121     }
00122 
00123     m_bytecount += add_timestamp (m_sink);
00124     m_bytecount += indent_func_name (m_sink, func_name_,indent_level_,FUNC_MSG);
00125 
00126     bool release = false;
00127     char* msgbuf_ptr = format_msg (expected_sz_, fmt_, msg_list_, release);
00128     if (msgbuf_ptr == NULL) {
00129         return -1;              // failed to format
00130     }
00131     m_sink << msgbuf_ptr << std::flush;
00132     m_bytecount += strlen (msgbuf_ptr);
00133 
00134     if (release) {
00135         delete [] msgbuf_ptr;
00136     }
00137 
00138     return handle_rollover ();
00139 }

int FileLogger::log_open const char *  logfname_,
u_long  groups_,
u_long  maxsize_ = 10485760
[virtual]
 

Open File Logger.

Reimplemented from ASSA::Logger_Impl.

Definition at line 33 of file FileLogger.cpp.

References ASSA::Logger_Impl::m_groups, ASSA::Logger_Impl::m_logfname, m_maxsize, m_sink, m_state, and opened.

00034 {
00035     if (logfname_ == NULL || maxsize_ <= 0) {
00036         errno = EINVAL;
00037         return -1;
00038     }
00039 
00040     if (m_state == opened) {
00041         errno = EEXIST;
00042         return -1;
00043     }
00044 
00045     m_logfname = logfname_;
00046     m_groups   = groups_;
00047     m_maxsize  = maxsize_;
00048 
00049     m_sink.open (m_logfname.c_str (), std::ios::out | std::ios::app);
00050 
00051     if (!m_sink) {
00052         return -1;
00053     }
00054     m_state = opened;
00055     return 0;
00056 }

int FileLogger::log_raw_msg const string &  msg_  ) 
 

Log message as it is (raw) without indentation or timestamping, but still perform byte counting and the logic associated with it.

Definition at line 162 of file FileLogger.cpp.

References closed, ASSA::flush(), handle_rollover(), m_bytecount, m_sink, and m_state.

00163 {
00164     if (m_state == closed) {
00165         errno = EPERM;
00166         return -1;
00167     }
00168     m_sink << msg_ << std::flush;
00169     m_bytecount += msg_.length ();
00170     return handle_rollover ();
00171 }

void ASSA::FileLogger::log_resync void   )  [inline, virtual]
 

Reimplemented from ASSA::Logger_Impl.

Definition at line 85 of file FileLogger.h.

References ASSA::flush(), and m_sink.

00086 {
00087     m_sink << std::flush;
00088 }

FileLogger& ASSA::FileLogger::operator= const FileLogger  )  [private]
 


Member Data Documentation

u_long ASSA::FileLogger::m_bytecount [private]
 

Definition at line 71 of file FileLogger.h.

Referenced by dump(), handle_rollover(), log_close(), log_func(), log_msg(), and log_raw_msg().

u_long ASSA::FileLogger::m_maxsize [private]
 

Definition at line 69 of file FileLogger.h.

Referenced by dump(), handle_rollover(), log_close(), and log_open().

std::ofstream ASSA::FileLogger::m_sink [private]
 

Definition at line 68 of file FileLogger.h.

Referenced by dump(), handle_rollover(), log_close(), log_func(), log_msg(), log_open(), log_raw_msg(), and log_resync().

state_t ASSA::FileLogger::m_state [private]
 

Definition at line 70 of file FileLogger.h.

Referenced by dump(), handle_rollover(), log_close(), log_func(), log_msg(), log_open(), and log_raw_msg().


The documentation for this class was generated from the following files:
Generated on Wed Jun 21 15:58:59 2006 for libassa by  doxygen 1.4.6