Re: [Boost-users] [boost::logging] using rolling files failed

From: John Torjo (john.groups_at_[hidden])
Date: 2008-01-14 13:23:30

Hi Benjamin,

Sorry for that. It's because I introduced a breaking change: after you 
initialize the log, call:

g_logger->turn_cache_off();

That should do the trick.
Best,
John

> Hi John,
>
> I'm working on integrating your last modifications about flushing 
> rolling files, but I encounter some problems.
>
> With version V0.11.7, I change rolling_file.hpp (see attached file) to 
> flush logs each time. It works fine.
>
>    /destination::rolling_file_settings settings;
>    settings.file_count( 10 );
>    settings.max_size_bytes( 5242880 );
>    destination::rolling_file loggerFile( logFile.GetPath(), settings );
>    g_logger->writer().add_destination( loggerFile );
>    /
>
> With last version (revision 42765), I just add one line. /
> /
>
>    /destination::rolling_file_settings settings;/
>    /settings.file_count( 10 );/
>    /settings.max_size_bytes( 5242880 ); /
>    */=> settings.flush_each_time(true); // add this line/*
>    /destination::rolling_file loggerFile( logFile.GetPath(), settings );/
>    /g_logger->writer().add_destination( loggerFile );/
>
> Then it doesn't work.
> I put a break point in rolling_file_info#write but my program does not 
> enter in it anymore !
> I think that rolling file objects are not instanciated because output 
> files are MY_FILE.txt and not MY_FILE.txt.1
>
> Even if it will not compile alone, I give you my class Logger to see 
> my implementation.
>
> Regards,
> Benjamin
>
>
> ------------------------------------------------------------------------
>
> // destination_rolling_file.hpp
>
> // Boost Logging library
> //
> // Author: John Torjo, www.torjo.com
> //
> // Copyright (C) 2007 John Torjo (see www.torjo.com for email)
> //
> // Distributed under the Boost Software License, Version 1.0.
> //    (See accompanying file LICENSE_1_0.txt or copy at
> //          http://www.boost.org/LICENSE_1_0.txt)
> //
> // See http://www.boost.org for updates, documentation, and revision history.
> // See http://www.torjo.com/log2/ for more details
>
>
> #ifndef JT28092007_destination_rolling_file_HPP_DEFINED
> #define JT28092007_destination_rolling_file_HPP_DEFINED
>
> #if defined(_MSC_VER) && (_MSC_VER >= 1020)
> # pragma once
> #endif
>
> #if defined(_MSC_VER) 
> #pragma warning ( disable : 4355)
> #endif 
>
> #include <boost/logging/detail/fwd.hpp>
> #include <boost/logging/detail/manipulator.hpp>
> #include <boost/logging/format/destination/convert_destination.hpp>
> #include <fstream>
> #include <string>
> #include <sstream>
> #include <boost/filesystem/path.hpp>
> #include <boost/filesystem/operations.hpp>
>
> namespace boost { namespace logging { namespace destination {
>
>
> /** 
>     @brief Settings you can pass to the rolling file. To see how it's used, see @ref dealing_with_flags.
> */
> struct rolling_file_settings {
>     typedef boost::logging::detail::flag<rolling_file_settings> flag;
>
>     rolling_file_settings() 
>         : max_size_bytes(this, 1024 * 1024)
>         , file_count(this, 10)
>         , initial_erase(this, false)
>         , start_where_size_not_exceeded(this, true) 
>     {}
>
>     /// maximum size in bytes, by default 1Mb
>     flag::t<int> max_size_bytes;
>     /// how many files has a rolling file, by default, 10
>     flag::t<int> file_count;
>     /// if true, it initially erases all files from the rolling file (by default, false)
>     flag::t<bool> initial_erase;
>     /// if true, it starts with the first file that hasn't exceeded the max size;
>     /// otherwise, it starts with the first file (default = true)
>     flag::t<bool> start_where_size_not_exceeded;
> };
>
> namespace detail {
>     template<class convert_dest > 
>     struct rolling_file_info {
>         
>         rolling_file_info (const std::string& name_prefix, rolling_file_settings flags ) 
>                 // many thanks to Martin Bauer
>                 : m_name_prefix(name_prefix), m_flags(flags), m_cur_idx(0) {
>             namespace fs = boost::filesystem;
>             
>             if ( m_flags.initial_erase()) {
>                 for ( int idx = 0; idx < m_flags.file_count(); ++idx)
>                     if ( fs::exists( file_name(idx) ))
>                         fs::remove( file_name(idx) );
>             }
>
>             // see what file to start from
>             if ( m_flags.start_where_size_not_exceeded() ) {
>                 for ( m_cur_idx = 0; m_cur_idx < m_flags.file_count(); ++m_cur_idx )
>                     if ( fs::exists( file_name(m_cur_idx) )) {
>                         if ( fs::file_size( file_name(m_cur_idx))  < m_flags.max_size_bytes() )
>                             // file hasn't reached max size
>                             break;
>                     }
>                     else
>                         // file not found, we'll create it now
>                         break;
>
>             }
>
>             recreate_file();
>         }
>
>         std::string file_name(int idx) {
>             std::ostringstream out; 
>             out << m_name_prefix << "." << (idx+1);
>             return out.str();
>         }
>
>         void recreate_file() {
>             m_out = boost::shared_ptr< std::basic_ofstream<char_type> >(new std::basic_ofstream<char_type>( file_name(m_cur_idx).c_str(),
>                 std::ios_base::out | std::ios_base::app));
>             m_cur_size = 0;
>         }
>
>         template<class msg_type> void write( const msg_type& msg) {
>             convert_dest::write(msg, (*m_out) );
>
>             // bdd 2007-12-10 : flush each time
>             m_cur_size += static_cast<int>( msg.size() );
>             m_out->flush();
>
>             // bdd
>             //if ( m_out->tellp() > m_flags.max_size_bytes()) {
>             if ( m_cur_size > m_flags.max_size_bytes()) {
>                 m_cur_idx = (m_cur_idx + 1) % m_flags.file_count();
>                 recreate_file();
>             }    
>         }
>
>         boost::shared_ptr< std::basic_ofstream<char_type> > m_out;
>         std::string m_name_prefix;
>         rolling_file_settings m_flags;
>         // the index of the current file
>         int m_cur_idx;
>
>         // bdd 2007-12-10 : flush each time
>         //size_t m_cur_size;
>         int m_cur_size;
>     };
> }
>
> /** 
>     @brief Writes to multiple files: name_prefix.1, name_prefix.2, ... name_prefix.N, and then restarts from 1.
>
>     We first write to name_prefix.1.
>
>     The log has a max_size. When max_size is reached, we start writing to name_prefix.2. When max_size is reached, we start writing to name_prefix.3.
>     And so on, until we reach name_prefix.N (N = file_count). When that gets fool, we start over, with name_prefix.1.
> */
> template<class convert_dest = do_convert_destination > struct rolling_file_t : is_generic, non_const_context<detail::rolling_file_info<convert_dest> > {
>     typedef non_const_context<detail::rolling_file_info<convert_dest> > non_const_context_base;
>
>     /** 
>         Constructs a rolling file
>
>         @param name_prefix the name to be used as prefix for the files
>         
>         @param flags [optional] extra settings to pass to the rolling file. See rolling_file_settings and @ref dealing_with_flags.
>     */
>     rolling_file_t(const std::string & name_prefix, rolling_file_settings flags = rolling_file_settings() ) : non_const_context_base(name_prefix, flags) {}
>
>     template<class msg_type> void operator()( const msg_type & msg) const {
>         non_const_context_base::context().write(msg);
>     }
>
>     bool operator==(const rolling_file_t & other) const {
>         return non_const_context_base::context().m_name_prefix == other.context().m_name_prefix;
>     }
> };
>
> /** @brief rolling_file_t with default values. See rolling_file_t
>
> @copydoc rolling_file_t
> */
> typedef rolling_file_t<> rolling_file;
>
>
>
>
> }}}
>
> #endif
>
>   
> ------------------------------------------------------------------------
>
>
>
> //=============================================================================
> // Includes
> //=============================================================================
> #include "StdAfx.h"
> #include "common/log/Logger.h"
>
> //----- MEDCommon -----
> #include "common/system/ApplicationHelper.h"
> #include "common/io/Directory.h"
> #include "common/system/Time.h"
>
> //----- boost -----
> #pragma warning(disable: 4541) 
>
> #include "boost/logging/tags.hpp"
> #include "boost/logging/defaults.hpp"
> #include "boost/logging/format.hpp"
> #include "boost/logging/format_all.hpp"
> #include "boost/logging/format_fwd.hpp"
> #include "boost/logging/format_ts.hpp"
> #include "boost/logging/logging.hpp"
> #include "boost/logging/detail/error.hpp"
> #include "boost/logging/detail/filter.hpp"
> #include "boost/logging/detail/find_gather.hpp"
> #include "boost/logging/detail/format_msg_type.hpp"
> #include "boost/logging/detail/format_write_detail.hpp"
> #include "boost/logging/detail/forward_constructor.hpp"
> #include "boost/logging/detail/fwd.hpp"
> #include "boost/logging/detail/level.hpp"
> #include "boost/logging/detail/log_keeper.hpp"
> #include "boost/logging/detail/logger.hpp"
> #include "boost/logging/detail/macros.hpp"
> #include "boost/logging/detail/manipulator.hpp"
> #include "boost/logging/detail/scenario.hpp"
> #include "boost/logging/detail/template.hpp"
> #include "boost/logging/detail/use_format_write.hpp"
> // raw_doc ?
> #include "boost/logging/detail/ts/ts.hpp"
> #include "boost/logging/detail/ts/ts_boost.hpp"
> #include "boost/logging/detail/ts/ts_none.hpp"
> //#include "boost/logging/detail/ts/ts_posix.hpp"
> #include "boost/logging/detail/ts/ts_resource.hpp"
> #include "boost/logging/detail/ts/ts_win32.hpp"
> #include "boost/logging/detail/tss/tss.hpp"
> #include "boost/logging/detail/tss/tss_ensure_proper_delete.hpp"
> #include "boost/logging/detail/tss/tss_impl.hpp"
> //#include "boost/logging/detail/tss/tss_impl_pthread.hpp"
> #include "boost/logging/detail/tss/tss_impl_win32.hpp"
> #include "boost/logging/format/array.hpp"
> #include "boost/logging/format/op_equal.hpp"
> #include "boost/logging/format/optimize.hpp"
> #include "boost/logging/format/destination/convert_destination.hpp"
> #include "boost/logging/format/destination/defaults.hpp"
> #include "boost/logging/format/destination/file.hpp"
> #include "boost/logging/format/destination/rolling_file.hpp"
> #include "boost/logging/format/destination/shared_memory.hpp"
> #include "boost/logging/format/formatter/convert_format.hpp"
> #include "boost/logging/format/formatter/defaults.hpp"
> #include "boost/logging/format/formatter/tags.hpp"
> #include "boost/logging/format/formatter/thread_id.hpp"
> #include "boost/logging/format/formatter/time.hpp"
> #include "boost/logging/gather/ostream_like.hpp"
> #include "boost/logging/tag/defaults.hpp"
> #include "boost/logging/writer/format_write.hpp"
> #include "boost/logging/writer/on_dedicated_thread.hpp"
> #include "boost/logging/writer/ts_write.hpp"
>
> using namespace boost::logging;
>
> //----- Step 3 : Specify your logging class(es) -----
> //typedef logger_format_write< > log_type;
> // thread safe
> typedef logger_format_write< default_, default_, writer::threading::ts_write > log_type;
> //typedef logger_format_write< default_, default_, writer::threading::on_dedicated_thread > log_type;
>
> //----- Step 4: declare which filters and loggers you'll use (usually in a header file) -----
> // filter
> BOOST_DECLARE_LOG_FILTER(g_log_level, level::holder )
> BOOST_DECLARE_LOG_FILTER(g_audit_filter, filter::ts )
>
> // logger
> BOOST_DECLARE_LOG(g_logger, log_type)
> BOOST_DECLARE_LOG(g_audit, log_type)
> BOOST_DECLARE_LOG(g_debug, log_type)
>
> //----- Step 5: define the macros through which you'll log -----
>
> //----- Step 6: Define the filters and loggers you'll use (usually in a source file) -----
> // filter
> BOOST_DEFINE_LOG_FILTER(g_log_level, level::holder ) // holds the application log level
> BOOST_DEFINE_LOG_FILTER(g_audit_filter, filter::ts )
> BOOST_DEFINE_LOG_FILTER(g_debug_filter, filter::ts )
> //BOOST_DEFINE_LOG_FILTER(g_audit_filter, filter::no_ts )
> // logger
> BOOST_DEFINE_LOG(g_logger, log_type)
> BOOST_DEFINE_LOG(g_audit, log_type)
> BOOST_DEFINE_LOG(g_debug, log_type)
>
> using namespace common::log;
>
> //=============================================================================
> // Global functions
> //=============================================================================
> void
> Audit( const std::ostringstream & msg )
> {
>     Info( msg );
>     BOOST_LOG_USE_LOG_IF_FILTER(g_audit, g_audit_filter->is_enabled() ) << "\t[AUDIT]\t" << msg.str();
> }
>
> void
> Debug( const std::ostringstream & msg )
> {
>     BOOST_LOG_USE_LOG_IF_FILTER(g_debug, g_debug_filter->is_enabled() ) << "\t[DEBUG]\t" << msg.str();
> }
>
> void
> Trace2( const std::ostringstream & msg )
> {
>     Debug( msg );
>     common::log::Logger::s_traces.Push( msg.str() );
> }
>
> void
> Info( const std::ostringstream & msg )
> {
>     BOOST_LOG_USE_LOG_IF_LEVEL(g_logger, g_log_level, info ) << "\t[INFO]\t" << msg.str();
>     BOOST_LOG_USE_LOG_IF_FILTER(g_debug, g_debug_filter->is_enabled() ) << "\t[INFO]\t" << msg.str();
> }
>
> void
> Warning( const std::ostringstream & msg )
> {
>     BOOST_LOG_USE_LOG_IF_LEVEL(g_logger, g_log_level, warning ) << "\t[WARN]\t" << msg.str();
>     BOOST_LOG_USE_LOG_IF_FILTER(g_debug, g_debug_filter->is_enabled() ) << "\t[WARN]\t" << msg.str();
> }
>
> void
> Error( const std::ostringstream & msg )
> {
>     if ( ! common::log::Logger::IsInitialized() )
>     {
>         common::log::Logger::Init( "INIT" );
>     }
>     if ( ! common::log::Logger::s_traces.IsEmpty() )
>     {
>         //
>         vector<string> traces = common::log::Logger::s_traces.ToArray();
>         for ( size_t i=0; i < traces.size(); i++ )
>         {
>             BOOST_LOG_USE_LOG_IF_LEVEL(g_logger, g_log_level, error ) << "\t[TRACE]\t" << traces[i];
>         }
>     }    
>     BOOST_LOG_USE_LOG_IF_LEVEL(g_logger, g_log_level, error ) << "\t[ERROR]\t" << msg.str();
>     BOOST_LOG_USE_LOG_IF_FILTER(g_debug, g_debug_filter->is_enabled() ) << "\t[ERROR]\t" << msg.str();
> }
>
> void
> Exception( const std::ostringstream & msg )
> {
>     if ( ! common::log::Logger::IsInitialized() )
>     {
>         common::log::Logger::Init( "INIT" );
>     }
>     if ( ! common::log::Logger::s_traces.IsEmpty() )
>     {
>         //
>         vector<string> traces = common::log::Logger::s_traces.ToArray();
>         for ( size_t i=0; i < traces.size(); i++ )
>         {
>             BOOST_LOG_USE_LOG_IF_LEVEL(g_logger, g_log_level, fatal ) << "\t[TRACE]\t" << traces[i];
>         }
>     } 
>     BOOST_LOG_USE_LOG_IF_LEVEL(g_logger, g_log_level, fatal ) << "\t[FATAL]\t" << msg.str();
>     BOOST_LOG_USE_LOG_IF_FILTER(g_debug, g_debug_filter->is_enabled() ) << "\t[FATAL]\t" << msg.str();
> }
>
>
>
> //=============================================================================
> // Class attributs
> //=============================================================================
> bool Logger::s_isInitialized = false;
> bool Logger::MODE_DEBUG = false;
> common::container::RollingStack<string> Logger::s_traces( 15 );
>
> //=============================================================================
> // Class methods
> //============================================================================= 
> void 
> Logger::SetLevel( LEVEL level )
> {
>     g_audit_filter->set_enabled(true);
>     g_debug_filter->set_enabled(false);
>     switch ( level )
>     {   
>     case LEVEL_DEBUG :
>         Logger::MODE_DEBUG = true;
>         g_debug_filter->set_enabled(true);
>         g_log_level->set_enabled(level::debug); // debug        
>         break;
>     case LEVEL_INFO :
>         g_log_level->set_enabled(level::info); // info + warning + ...
>         break;
>     case LEVEL_ERROR :
>         g_log_level->set_enabled(level::error); // error + fatal + ...
>         break;
>     default:
>         g_log_level->set_enabled(level::info);
>         break;
>     } 
>     
> }               
>
> bool
> Logger::IsInitialized()
> {
>     return s_isInitialized;
> }
>
> void 
> Logger::Init( const string & product )
> {
>     if ( s_isInitialized )
>     {
>         return;
>     }
>     
>     // check log dir
>     common::system::ApplicationHelper ah;
>     common::io::Directory dir( ah.GetPath() + "logfiles" );
>     dir.CheckAndCreate();
>
>     // init file names
>     //string date = common::system::Time::GetTime( common::system::Time::FORMAT_AAAA_MM_JJ );
>     //common::io::File logFile( dir.GetPath() + date + "_" + product + ".txt" );
>     //common::io::File auditFile( dir.GetPath() + date + "_AUDIT_" + product + ".txt" );
>     common::io::File logFile( dir.GetPath() + product + ".txt" );
>     common::io::File auditFile( dir.GetPath() + "AUDIT_" + product + ".txt" );
>     common::io::File debugFile( dir.GetPath() + "DEBUG_" + product + ".txt" );
>
>     // Step 7: add formatters and destinations
>     //         That is, how the message is to be formatted...
>     g_logger->writer().add_formatter( formatter::time("$dd/$MM/$yyyy - $hh:$mm.$ss ") );
>     g_logger->writer().add_formatter( formatter::idx() );    
>     g_logger->writer().add_formatter( formatter::append_newline() );
>     //g_log_err->writer().add_formatter( formatter::tag::module() ); // tag::file_line() );
>     //g_log_err->writer().add_formatter( formatter::tag::level() );
>
>     g_audit->writer().add_formatter( formatter::time("$dd/$MM/$yyyy - $hh:$mm.$ss ") );
>     g_audit->writer().add_formatter( formatter::idx() );    
>     g_audit->writer().add_formatter( formatter::append_newline() );
>
>     g_debug->writer().add_formatter( formatter::time("$dd/$MM/$yyyy - $hh:$mm.$ss ") );
>     g_debug->writer().add_formatter( formatter::idx() );    
>     g_debug->writer().add_formatter( formatter::append_newline() );
>
>     g_logger->writer().add_destination( destination::cout() );
>
>     // bdd : rolling file : pb de flush (garde les donnees en cache)
>     destination::rolling_file_settings settings;
>     settings.file_count( 10 );
>     settings.max_size_bytes( 5242880 ); // bytes = 5M
>     //settings.flush_each_time(true);
>     destination::rolling_file loggerFile( logFile.GetPath(), settings );
>     g_logger->writer().add_destination( loggerFile );
>
>     g_debug->writer().add_destination( destination::dbg_window() );  
>
>     destination::rolling_file_settings settingsD;
>     settingsD.file_count( 30 );
>     settingsD.max_size_bytes( 10000000 ); // ~10M
>     //settingsD.flush_each_time(true);
>     g_debug->writer().add_destination( destination::rolling_file( debugFile.GetPath(), settingsD ) );
>
>     // bdd xml : en attente
>     //g_log_err->writer().add_destination( as_xml("logerror.xml") );
>
>     g_audit->writer().add_destination( destination::file( auditFile.GetPath() ) );
>
> #ifdef _DEBUG
>     SetLevel( Logger::LEVEL_DEBUG );
> #else
>     SetLevel( Logger::LEVEL_INFO ); 
> #endif
>     s_isInitialized = true;
>     // Step 9 : Enjoy!
> }
>
>
> //=============================================================================
> // Constructor and destructor
> //=============================================================================
> Logger::Logger(void)
> : common::app::Object("common::log::Logger")
> {   
> }
>
> Logger::~Logger(void)
> {
> }
>
> //=============================================================================
> // Public methods
> //=============================================================================    
>
>   
> ------------------------------------------------------------------------
>
> //* Step 1: (optional) Specify your format message class and/or destination message class. By default, it's std::(w)string. You'll use this when you want a optimize string class.
> //* Step 2: (optional) Specify your formatter & destination base classes
> //* Step 3: Specify your logger class(es)
> //* Step 4: Declare the filters and loggers you'll use (in a header file)
> //* Step 5: Define the macros through which you'll do logging
> //* Step 6: Define the loggers and the filters you'll use (in a source file). We need this separation (into declaring and defining the logs/filters), in order to make compilation times fast.
> //* Step 7: Add formatters and destinations. That is, how the message is to be formatted...
> //* Step 8: Use it
> //* Step 9: Enjoy the results! 
>
> //* debug (smallest level),
> //* info,
> //* warning ,
> //* error ,
> //* fatal (highest level)
>
> #ifndef _COMMON_LOG_LOGGER_H_
> #define _COMMON_LOG_LOGGER_H_
> #pragma once
>
> //=============================================================================
> // Includes
> //=============================================================================
> //----- MEDCommon -----
> #include "../commonIncludes.h"
> #include "../app/Object.h"
> #include "StackLog.h"
> #include "common/txt/StringHelper.h"
> #include "common/container/RollingStack.h"
>
> void MEDCOMMON_API Audit( const std::ostringstream & msg );
> void MEDCOMMON_API Debug( const std::ostringstream & msg );
> void MEDCOMMON_API Trace2( const std::ostringstream & msg );
> void MEDCOMMON_API Info( const std::ostringstream & msg );
> void MEDCOMMON_API Warning( const std::ostringstream & msg );
> void MEDCOMMON_API Error( const std::ostringstream & msg );
> void MEDCOMMON_API Exception( const std::ostringstream & msg );
>
> #define MED_FUNCTION \
>     common::log::StackLog log( __FUNCTION__ );
>
> #define MED_FUNCTION2( msg ) \
>     ostringstream s; \
>     s << msg; \
>     common::log::StackLog log( __FUNCTION__, s );    
>
> #define MED_METHOD( object ) \
>     common::log::StackLog log( object,__FUNCTION__ );
>
> #define MED_METHOD2( object, params ) \
>     ostringstream s; \
>     s << params; \
>     common::log::StackLog log( object,__FUNCTION__, s );
>
> #define MED_AUDIT( module, msg ) \
> { \
>     ostringstream s; \
>     s << "[" << module << "]\t" \
>     << msg; \
>     Audit( s ); \
> }
>
> #define MED_DBG2( module, msg ) \
> { \
>     if ( common::log::Logger::MODE_DEBUG ) \
>     { \
>         string file = __FILE__; \
>         string fileName = common::txt::StringHelper::LastToken(file,"\\"); \
>         ostringstream s; \
>         s << "[" << module << "]\t" \
>         << msg \
>         << " (" \
>         << fileName \
>         << "#" \
>         << __FUNCTION__ \
>         << " L." \
>         << __LINE__ \
>         <<  ")"; \
>         Debug( s ); \
>     } \
> }
>
> #define MED_TRC2( module, msg ) \
> { \
>     string file = __FILE__; \
>     string fileName = common::txt::StringHelper::LastToken(file,"\\"); \
>     ostringstream s; \
>     s << "[" << module << "]\t" \
>     << msg \
>     << " (" \
>     << fileName \
>     << "#" \
>     << __FUNCTION__ \
>     << " L." \
>     << __LINE__ \
>     <<  ")"; \
>     Trace2( s ); \
> }
>
> #define MED_INF2( module, msg ) \
> { \
>     ostringstream s; \
>     s << "[" << module << "]\t" \
>     << msg; \
>     Info( s ); \
> }
>
> #define MED_WARN2( module, msg ) \
> { \
>     string file = __FILE__; \
>     string fileName = common::txt::StringHelper::LastToken(file,"\\"); \
>     ostringstream s; \
>     s << "[" << module << "]\t" \
>     << msg \
>     << " (" \
>     << fileName \
>     << "#" \
>     << __FUNCTION__ \
>     << " L." \
>     << __LINE__ \
>     <<  ")"; \
>     Warning( s ); \
> }
>
> #define MED_ERR2( module, msg ) \
> { \
>     string file = __FILE__; \
>     string fileName = common::txt::StringHelper::LastToken(file,"\\"); \
>     ostringstream s; \
>     s << "[" << module << "]\t" \
>     << msg \
>     << " (" \
>     << fileName \
>     << "#" \
>     << __FUNCTION__ \
>     << " L." \
>     << __LINE__ \
>     <<  ")"; \
>     Error( s ); \
> }
>
> #define MED_EXC2( module, msg ) \
> { \
>     string file = __FILE__; \
>     string fileName = common::txt::StringHelper::LastToken(file,"\\"); \
>     ostringstream s; \
>     s << "[" << module << "]\t" \
>     << msg \
>     << " (" \
>     << fileName \
>     << "#" \
>     << __FUNCTION__ \
>     << " L." \
>     << __LINE__ \
>     <<  ")"; \
>     Exception( s ); \
> }
>
> namespace common
> {
>     namespace log
>     {
>         class MEDCOMMON_API Logger : public common::app::Object
>         {
>
>
>
> //=============================================================================
> // Constants
> //=============================================================================
>         public:
>             enum LEVEL { 
>                 LEVEL_DEBUG , 
>                 LEVEL_INFO ,                 
>                 LEVEL_ERROR };
>
> //=============================================================================
> // Class attributs
> //=============================================================================
>         public:
>             static bool MODE_DEBUG;
>             // traces
>             static common::container::RollingStack<string> s_traces;
>
>         private:
>             static bool s_isInitialized;  
>
> //=============================================================================
> // Class methods
> //=============================================================================
>         public:
>             static void SetProduct( const string & product ); 
>             static bool IsInitialized();
>             static void Init( const string & product );
>             static void SetLevel( LEVEL level );     
>
> //=============================================================================
> // Attributs
> //=============================================================================
>         private:
>             
>
> //=============================================================================
> // Constructor and destructor
> //=============================================================================
>         private:
>     	    Logger();
> 		    virtual ~Logger();
>             
> //=============================================================================
> // Public methods
> //=============================================================================    
>         public:    
>
> //=============================================================================
> // Other methods
> //=============================================================================      
>         protected:
>
>         };
>     } // namespace log
> } // namespace common 
>
> #endif // _COMMON_LOG_LOGGER_H_ 
>
>   

-- 
http://John.Torjo.com -- C++ expert
... call me only if you want things done right