logging.hpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2002 by J.M.McGuiness, coder@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "file.hpp"
 
#include <locale>
#include <cstdlib>
#include <ctime>
 
namespace jmmcg { namespace LIBJMMCG_VER_NAMESPACE {
 
   enum log_level_type {
      log_none=0,
      log_errors,
      log_warnings,
      log_info
   };
   // Note the order - these must match the "log_level_type" enum.
   const tchar * const log_level_strs[]={
      _T("none"),
      _T("errors"),
      _T("warnings"),
      _T("info")
   };
 
   inline bool OutputDateTime(tostream &o,const time_t base_time=time(0),const tstring &fmt=_T("[%b %d %X %Z] ")) {
      // I don't guard this with a "std::ostream::sentry" because I WANT TO ALWAYS LOG, even if something else is logging. So you'll get screwed output. Boo hoo. Better than lost output. Indeed the stupid "ostream" implementation would have better hidden its critical sections from me rather than making me deal with them... Isn't that what object orientation is about? Hmmm?
      const tchar * const fmt_t=fmt.c_str(); // Hacking due to crap declaration of std::time_put::put(...) that takes a wank type of format string.
      const tm * const time=localtime(&base_time);
// TODO JMG: better sort this out:     if (std::use_facet< std::time_put<tchar> >(o.getloc(),0,true).put(o,o,o.fill(),time,fmt_t,fmt_t+fmt.size()).failed()) {
//       o.setstate(std::ios_base::failbit);
//       return false;
//    } else {
         return true;
//    }
   }
 
   template<class Except_>
   class Logger {
   public:
      typedef Except_ exception_type;
 
      __stdcall Logger(const tstring &,const tchar *);
      Logger(Logger const &)=delete;
      virtual inline __stdcall ~Logger(void) {
      }
 
      const log_level_type __fastcall Level(void) const noexcept(true) {
         return log_level;
      }
      void __fastcall Level(const log_level_type l) noexcept(true) {
         log_level=l;
      }
 
      const tstring & __fastcall Path(void) const noexcept(true) {
         return path_to_log_file;
      }
 
      void __fastcall Log(const log_level_type at_level,const tostringstream &ss) const {
         Log(at_level,ss.str());
      }
      virtual void __fastcall Log(const log_level_type,const tstring &) const;
 
   private:
      const tstring path_to_log_file;
      const tchar *app_name;
      log_level_type log_level;
   };
 
   template<class Except_> inline
   Logger<Except_>::Logger(const tstring &path,const tchar *an)
   : path_to_log_file(path),app_name(an),
   log_level(log_none) {
      // If this assertion fails the number of strings in the "log_level_strs" array does not match the number of enumeration values in the "log_level_type" enum.
      // The "+1" is because of the zero-based indexing of arrays. There's n of them, but the last one is at [n-1].
      assert(sizeof(log_level_strs)/sizeof(tchar *)==static_cast<size_t>(log_info+1));
   }
 
   template<class Except_> inline void
   Logger<Except_>::Log(const log_level_type at_level,const tstring &msg) const noexcept(false) {
      if (at_level<=log_level) {
         try {
            tofstream log_file(path_to_log_file.c_str(),std::ios_base::out|std::ios_base::app);
            if (log_file.is_open()) {
               OutputDateTime(log_file);  // Don't care if I fail to log the time. It's more important to get *anything* at all out, even if incomplete.
               log_file
                  <<(getenv(_T("LOGNAME")) ? getenv(_T("LOGNAME")) : _T("LOGNAME"))
                  <<_T("@")
                  <<(getenv(_T("HOSTNAME")) ? getenv(_T("HOSTNAME")) : _T("HOSTNAME"))
                  <<_T("(")
                  <<(getenv(_T("HOSTTYPE")) ? getenv(_T("HOSTTYPE")) : _T("HOSTTYPE"))
                  <<_T(",")
                  <<(getenv(_T("OSTYPE")) ? getenv(_T("OSTYPE")) : _T("OSTYPE"))
                  <<_T(") ")
                  <<app_name
                  <<_T("[")<<getpid()<<_T("] ")
                  <<log_level_strs[at_level]<<_T(": ")
                  <<msg<<std::endl;
            } else {
               tostringstream ss;
               ss<<_T("Failed to open '")<<path_to_log_file<<_T("' for writing log information.");
               info::function fun(__LINE__,__PRETTY_FUNCTION__,typeid(*this),info::function::argument(_T("Log level."),log_level_strs[at_level]));
               fun.add_args(
                  info::function::argument(_T("Log message."),msg),
                  info::function::argument(_T("Logging at level."),log_level_strs[log_level])
               );
               throw exception_type(ss,fun,JMMCG_REVISION_HDR(_T(LIBJMMCG_VERSION_NUMBER)));
            }
         } catch (const exception &) {
            throw;
         } catch (const std::exception &e) {
            tostringstream ss;
            ss<<_T("STL exception caught whilst attempting to log. Details: ")<<e.what();
            info::function fun(__LINE__,__PRETTY_FUNCTION__,typeid(*this),info::function::argument(_T("Log level."),log_level_strs[at_level]));
            fun.add_args(
               info::function::argument(_T("Log message."),msg),
               info::function::argument(_T("Logging at level."), log_level_strs[log_level]),
               info::function::argument(_T("Logging to file."), path_to_log_file)
            );
            throw exception_type(ss,fun,JMMCG_REVISION_HDR(_T(LIBJMMCG_VERSION_NUMBER)));
         }
      }
   }
 
#define JMMCG_LOG(logger_,at_level_,msg_)
   if ((at_level_)>(logger_)->Level()) {
      ;
   } else {
      (logger_)->Log((at_level_),(msg_));
   }
 
} }