mrw-cxx/src/log4cxxconfiguration.cxx

/** @file

    $Id$

    $Date$
    $Author$

    @copy © Marc Wäckerlin
    @license LGPL, see file <a href="license.html">COPYING</a>

    $Log$
    Revision 1.3  2005/11/29 12:39:42  marc
    make it compilable with gcc 4.0.2 and newer doxygen

    Revision 1.2  2005/04/14 19:06:37  marc
    no more duplicated traces, better filtering for Qt

    Revision 1.1  2005/04/07 20:57:36  marc
    initial version


         1         2         3         4         5         6         7         8
    5678901234567890123456789012345678901234567890123456789012345678901234567890
*/

#include <log4cxx/propertyconfigurator.h>
#include <log4cxx/helpers/properties.h>
#include <fstream>
#include <cstdlib>

#if (__GNUC__==3 && __GNUC_MINOR__<4 || __GNUC__<3) \
  && defined(_REENTRANT) && !defined(_MT)
#define _MT
#endif

namespace mrw {

  /** @addtogroup debug
      */
  //@{

  /** @defgroup AutoInitLog4cxx Automatically initialize log4cxx

      If you want to enable log4cxx
      (http://logging.apache.org/log4cxx), you have to configure it in
      your application, normally in the main. If you want to configure
      it automatically, without changing a single line in your code
      (e.g. for temporary debugging), simply link to @c
      libmrwlog4cxxconfiguration, either with option @c
      -lmrwlog4cxxconfiguration for single threaded, or with @c
      -lmrwlog4cxxconfiguration-mt for multi threaded applications.

      With @ref trclog4cxx and @ref
      AutoFunctionTrace, you can add tracing based on @c log4cxx,
      without even change a single line in your code. But your code
      still has to initialize @c log4cxx. If you even want to
      automatically initialize @c log4cxx, use this library!

      Configures @c log4cxx in the following way:
       -# if available, read @c log4cxx property file
          (read first file found, in this order)
           -# file specified in environment variable
              @c $MRW_LOG4CXX_CONFIGFILE
           -# <code>.mrwlog4cxx</code> (local file)
           -# <code>~/.mrwlog4cxx</code> (file in user's home)
           -# <code>/etc/mrwlog4cxx</code> (global configuration)
       -# if no configuration file is found, use default configuration:
          @verbatim
log4j.rootLogger = WARN, A1
log4j.logger.mrw.fntrace = OFF
log4j.logger.mrw.fn = OFF
log4j.logger.mrw.fn.log4cxx = OFF
log4j.logger.mrw.fn.boost = OFF
log4j.logger.mrw.fn.Thread = OFF
log4j.logger.mrw.fn.QString = OFF
log4j.logger.mrw.fn.QShared = OFF
log4j.logger.mrw.fn.QWidget = OFF
log4j.logger.mrw.fn.QRect = OFF
log4j.logger.mrw.fn.qstrcmp = OFF
log4j.logger.mrw.fn.*.qt_cast = OFF
log4j.logger.mrw.fn.mrw = OFF
log4j.logger.mrw.fn.std = OFF
log4j.logger.mrw.fn.CppUnit = OFF
log4j.logger.mrw.fn.__gnu_cxx = OFF
log4j.appender.A1 = org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout = org.apache.log4j.PatternLayout
@endverbatim
          and for multi threaded programs in addition:
          @verbatim
log4j.appender.A1.layout.ConversionPattern = \%t-\%-40l - \%m\%n
@endverbatim
          on the other hand, single threaded programs are formatted as:
          @verbatim
log4j.appender.A1.layout.ConversionPattern = \%-40l - \%m\%n
@endverbatim
          This results in the following behaviour:
           - trace to console
           - format as...
              - @c "\%t-\%-40l - \%m\%n" if threaded
              - @c "\%-40l - \%m\%n" if not threaded
           - enable all tracing to @c DEBUG
           - enable tracing of @ref AutoFunctionTrace
              - disable function trace for @c log4cxx
              - disable function trace for @c boost
              - disable function trace for @c Qt base classes
              - disable function trace for @c libmrw
              - disable function trace for @c std
              - disable function trace for @c CppUnit
              - disable function trace for @c gcc internals
      */
  //@{

  class InitLog4cxx {
    public:
      InitLog4cxx() {
        std::string logconfigfile;
        char* c(getenv("MRW_LOG4CXX_CONFIGFILE"));
        if (c && std::ifstream(c))
          logconfigfile = c;
        else if (std::ifstream(".mrwlog4cxx"))
          logconfigfile = ".mrwlog4cxx";
        else if ((c=getenv("HOME")) &&
                 std::ifstream((std::string(c)+"/.mrwlog4cxx").c_str()))
          logconfigfile = std::string(c)+"/.mrwlog4cxx";
        else if (std::ifstream("/etc/mrwlog4cxx"))
          logconfigfile = "/etc/mrwlog4cxx";
        if (logconfigfile.size()) {
          log4cxx::PropertyConfigurator::configure
            (std::string(logconfigfile.begin(), logconfigfile.end()));
          return;
        }
        log4cxx::helpers::Properties properties;
        std::string name, cont;
        properties.setProperty((name="log4j.rootLogger",
                                std::string(name.begin(), name.end())),
                               (cont="WARN, A1",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fntracea",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.log4cxx",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.boost",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.Thread",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.QString",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.QShared",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.QWidget",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.QRect",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.qstrcmp",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.*.qt_cast",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.mrw",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.std",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.CppUnit",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.logger.mrw.fn.__gnu_cxx",
                                std::string(name.begin(), name.end())),
                               (cont="OFF",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.appender.A1",
                                std::string(name.begin(), name.end())),
                               (cont="org.apache.log4j.ConsoleAppender",
                                std::string(cont.begin(), cont.end())));
        properties.setProperty((name="log4j.appender.A1.layout",
                                std::string(name.begin(), name.end())),
                               (cont="org.apache.log4j.PatternLayout",
                                std::string(cont.begin(), cont.end())));
#ifdef _MT
        properties.setProperty((name="log4j.appender.A1.layout.ConversionPattern",
                                std::string(name.begin(), name.end())),
                               (cont="%t-%-40l - %m%n",
                                std::string(cont.begin(), cont.end())));
#else
        properties.setProperty((name="log4j.appender.A1.layout.ConversionPattern",
                                std::string(name.begin(), name.end())),
                               (cont="%-40l - %m%n",
                                std::string(cont.begin(), cont.end())));
#endif
        log4cxx::PropertyConfigurator::configure(properties);
      }
  };
  static InitLog4cxx INIT_LOG4CXX;

  //@}
  //@}
}