Log.hxx

Go to the documentation of this file.

#ifndef RESIP_Log_hxx
#define RESIP_Log_hxx
 
#include "rutil/Data.hxx"
 
#ifndef WIN32
#include <syslog.h>
#include <unistd.h>
#endif
 
#include <atomic>
#include <set>
 
#include "rutil/ConfigParse.hxx"
#include "rutil/Mutex.hxx"
#include "rutil/Lock.hxx"
#include "rutil/HashMap.hxx"
#include "rutil/ThreadIf.hxx"
#include <iostream>
 
// !ipse! I think that this remark is no more valid with recent changes,
// but I don't have MacOs X to test with. Someone should take this duty.
//
// NOTE: disabling thread setting code for native mac os applications.
// since some logging takes place during static initialization we can't
// be sure all the pthread stuff is ready to go. this eventually causes
// crashes in the Mac OS native API.
#if !defined(TARGET_OS_MAC)
#define LOG_ENABLE_THREAD_SETTING
#endif
 
extern "C"
{
   // Forward declaration to make it friend of Log class.
   void freeLocalLogger(void* pThreadData);
};
 
 
namespace resip
{
 
class ExternalLogger;
class Subsystem;
 
class Log
{
   public:
      enum Type
      {
         Cout = 0,
         Syslog, 
         File, 
         Cerr,
         VSDebugWindow,        
         OnlyExternal,         
         OnlyExternalNoHeaders 
      };
      
      enum Level
      {
         None = -1,
#ifdef WIN32
         Crit = 2,
         Err = 3,
         Warning = 4,
         Info = 6,
         Debug = 7,
#else
         Crit = LOG_CRIT,
// #ifdef ERR // ncurses defines a macro called ERR 
//          SIP2_ERR = LOG_ERR,
// #else
//          ERR = LOG_ERR,
// #endif
         Err,
         Warning = LOG_WARNING,
         Info = LOG_INFO,
         Debug = LOG_DEBUG,
#endif
         Stack = 8,
         StdErr = 9,
         Bogus = 666
      };
 
      enum MessageStructure
      {
         Unstructured = 0,
         JSON_CEE
      };
 
      typedef int LocalLoggerId;
 
      class Guard
      {
         public:
            Guard(Level level,
                  const Subsystem& system,
                  const char* file,
                  int line,
                  const char* methodName);
 
            ~Guard();
 
            EncodeStream& asStream() {return mStream;}
            operator EncodeStream&() {return mStream;}
 
         private:
            resip::Log::Level mLevel;
            const resip::Subsystem& mSubsystem;
            resip::Data::size_type mHeaderLength;
            const char* mFile;
            int mLine;
            const char* mMethodName;
            char mBuffer[128];
            Data mData;
            oDataStream mStream;
            Guard& operator=(const Guard&);
      };
 
      class ThreadSetting
      {
         public:
            ThreadSetting()
               : mService(-1),
                 mLevel(Err)
            {}
 
            ThreadSetting(int serv, Level level)
               : mService(serv),
                 mLevel(level)
            {
            }
            
            int mService;
            Level mLevel;
      };
 
      static EncodeStream& tags(Log::Level level,
                                const Subsystem& subsystem, 
                                const char* file,
                                int line,
                                const char* methodName,
                                EncodeStream& strm,
                                MessageStructure messageStructure);
 
      static Data& timestamp(Data& result);
      static Data timestamp();
      static ExternalLogger* getExternal()
      {
         return getLoggerData().mExternalLogger;
      }
      static Data getAppName()
      {
         return mAppName;
      }
 
      static int parseSyslogFacilityName(const Data& facilityName);
 
      static void initialize(Type type,
                             Level level,
                             const Data& appName,
                             const char * logFileName = 0,
                             ExternalLogger* externalLogger = 0,
                             const Data& syslogFacility = "LOG_DAEMON",
                             MessageStructure messageStructure = Unstructured,
                             const Data& instanceName = "");
      static void initialize(const Data& type,
                             const Data& level,
                             const Data& appName,
                             const char * logFileName = 0,
                             ExternalLogger* externalLogger = 0,
                             const Data& syslogFacility = "LOG_DAEMON",
                             const Data& messageStructure = "Unstructured",
                             const Data& instanceName = "");
      static void initialize(const char* type,
                             const char* level,
                             const char* appName,
                             const char * logFileName = 0,
                             ExternalLogger* externalLogger = 0,
                             const char* syslogFacility = "LOG_DAEMON",
                             const char* messageStructure = "Unstructured",
                             const char* instanceName = "");
      static void initialize(Type type,
                             Level level,
                             const Data& appName,
                             ExternalLogger& logger,
                             const Data& syslogFacility = "LOG_DAEMON",
                             MessageStructure messageStructure = Unstructured,
                             const Data& instanceName = "");
      static void initialize(const ConfigParse& configParse,
                             const Data& appName,
                             ExternalLogger* externalLogger = 0);
 
      static void setLevel(Level level);
      static void setLevel(Level level, Subsystem& s);
      static void setLevel(Level level, LocalLoggerId loggerId);
      static Level level() { Lock lock(_mutex); return getLoggerData().mLevel; }
      static Level level(LocalLoggerId loggerId);
      static LocalLoggerId id() { Lock lock(_mutex); return getLoggerData().id(); }
      static void setMaxLineCount(unsigned int maxLineCount);
      static void setMaxLineCount(unsigned int maxLineCount, LocalLoggerId loggerId);
      static void setMaxByteCount(unsigned int maxByteCount);
      static void setMaxByteCount(unsigned int maxByteCount, LocalLoggerId loggerId);
      static void setKeepAllLogFiles(bool keepAllLogFiles);
      static void setKeepAllLogFiles(bool keepAllLogFiles, LocalLoggerId loggerId);
      static Level toLevel(const Data& l);
      static Type toType(const Data& t);
      static Data toString(Level l);
 
      static void setServiceLevel(int service, Level l);
      static Level getServiceLevel(int service);
 
      static const ThreadSetting* getThreadSetting();
      static void setThreadSetting(ThreadSetting info);
      static void setThreadSetting(int serv, Level l);
      static void setThreadSetting(int serv);
 
      static LocalLoggerId localLoggerCreate(Type type,
                                             Level level,
                                             const char * logFileName = NULL,
                                             ExternalLogger* externalLogger = NULL,
                                             MessageStructure messageStructure = Unstructured);
 
      static int localLoggerReinitialize(LocalLoggerId loggerId,
                                         Type type,
                                         Level level,
                                         const char * logFileName = NULL,
                                         ExternalLogger* externalLogger = NULL,
                                         MessageStructure messageStructure = Unstructured);
 
      static int localLoggerRemove(LocalLoggerId loggerId);
 
      static int setThreadLocalLogger(LocalLoggerId loggerId);
 
 
      static std::ostream& Instance(unsigned int bytesToWrite);
      static bool isLogging(Log::Level level, const Subsystem&);
      static void OutputToWin32DebugWindow(const Data& result);      
      static void reset(); 
#ifndef WIN32
      static void droppingPrivileges(uid_t uid, pid_t pid);
#endif
 
   protected:
      static Mutex _mutex;
      static std::atomic<unsigned int> touchCount;
      static const Data delim;
 
      static unsigned int MaxLineCount;
      static unsigned int MaxByteCount;
      static bool KeepAllLogFiles;
 
      class ThreadData
      {
         public:
            ThreadData(LocalLoggerId id, Type type=Cout, Level level=Info,
                       const char *logFileName=NULL,
                       ExternalLogger *pExternalLogger=NULL,
                       MessageStructure messageStructure = Unstructured,
                       const Data& instanceName = "")
               : mLevel(level),
                 mMaxLineCount(0),
                 mMaxByteCount(0),
                 mExternalLogger(pExternalLogger),
                 mMessageStructure(messageStructure),
                 mInstanceName(instanceName),
                 mKeepAllLogFiles(false),
                 mKeepAllLogFilesSet(false),
                 mId(id),
                 mType(type),
                 mLogger(NULL),
                 mLineCount(0)
            {
               if (logFileName)
               {
                  mLogFileName = logFileName;
               }
            }
            ~ThreadData() { reset(); }
 
            void set(Type type = Cout, Level level = Info,
               const char* logFileName = NULL,
               ExternalLogger* pExternalLogger = NULL,
               MessageStructure messageStructure = Unstructured,
               const Data& instanceName = "");
 
            LocalLoggerId id() const {return mId;}
            unsigned int maxLineCount() { return mMaxLineCount ? mMaxLineCount : MaxLineCount; }  // return local max, if not set use global max
            unsigned int maxByteCount() { return mMaxByteCount ? mMaxByteCount : MaxByteCount; }  // return local max, if not set use global max
            bool keepAllLogFiles() { return mKeepAllLogFilesSet ? mKeepAllLogFiles : KeepAllLogFiles; } // return local if set, if not use global setting
            Type type() const {return mType;}
 
            void setKeepAllLogFiles(bool keepAllLogFiles) { mKeepAllLogFiles = keepAllLogFiles; mKeepAllLogFilesSet = true; }
 
            std::ostream& Instance(unsigned int bytesToWrite); 
            void reset(); 
#ifndef WIN32
            void droppingPrivileges(uid_t uid, pid_t pid);
#endif
            volatile Level mLevel;
            volatile unsigned int mMaxLineCount;
            volatile unsigned int mMaxByteCount;
            ExternalLogger* mExternalLogger;
 
         protected:
            volatile MessageStructure mMessageStructure;
            Data mInstanceName;
 
            volatile bool mKeepAllLogFiles;
            volatile bool mKeepAllLogFilesSet;
 
            friend class Guard;
            const LocalLoggerId mId;
            Type mType;
            Data mLogFileName;
            std::ostream* mLogger;
            unsigned int mLineCount;
      };
 
      static ThreadData mDefaultLoggerData; 
      static Data mAppName;
      static Data mHostname;
      static Data mFqdn;
      static int mSyslogFacility;
      static const char mDescriptions[][32];
      static const char mCEEPri[][32];
      static const int mSyslogPriority[];
      static Data mInstanceName;
 
      static ThreadData &getLoggerData()
      {
         ThreadData* pData = static_cast<ThreadData*>(ThreadIf::tlsGetValue(*Log::mLocalLoggerKey));
         return pData?*pData:mDefaultLoggerData;
      }
 
      class LocalLoggerMap
      {
      public:
         LocalLoggerMap()
            : mLastLocalLoggerId(0) {};
 
         LocalLoggerId create(Type type,
                              Level level,
                              const char * logFileName = NULL,
                              ExternalLogger* externalLogger = NULL,
                              MessageStructure messageStructure = Unstructured);
 
         int reinitialize(LocalLoggerId loggerId,
                          Type type,
                          Level level,
                          const char * logFileName = NULL,
                          ExternalLogger* externalLogger = NULL,
                          MessageStructure messageStructure = Unstructured);
 
         int remove(LocalLoggerId loggerId);
 
         ThreadData *getData(LocalLoggerId loggerId);
 
         void decreaseUseCount(LocalLoggerId loggerId);
 
      protected:
         typedef HashMap<LocalLoggerId, std::pair<ThreadData*, int> > LoggerInstanceMap;
         LoggerInstanceMap mLoggerInstancesMap;
         LocalLoggerId mLastLocalLoggerId;
         Mutex mLoggerInstancesMapMutex;
      };
 
      friend void ::freeLocalLogger(void* pThreadData);
      friend class LogStaticInitializer;
      static LocalLoggerMap mLocalLoggerMap;
      static ThreadIf::TlsKey* mLocalLoggerKey;
 
 
#ifdef LOG_ENABLE_THREAD_SETTING
      static HashMap<ThreadIf::Id, std::pair<ThreadSetting, bool> > mThreadToLevel;
      static HashMap<int, std::set<ThreadIf::Id> > mServiceToThreads;
      static ThreadIf::TlsKey* mLevelKey;
#endif
      static HashMap<int, Level> mServiceToLevel;
};
 
class ExternalLogger
{
public:
   virtual ~ExternalLogger() {};
   virtual bool operator()(Log::Level level,
      const Subsystem& subsystem, 
      const Data& appName,
      const char* file,
      int line,
      const Data& message,
      const Data& messageWithHeaders,
      const Data& instanceName) = 0;
};
 
class LogStaticInitializer {
public:
   LogStaticInitializer();
   ~LogStaticInitializer();
protected:
   static unsigned int mInstanceCounter;
    
#ifdef WIN32
   // LogStaticInitializer calls ThreadIf::tlsKeyCreate which 
   // relies on the static TlsDestructorInitializer having set
   // up mTlsDestructorsMutex which is used to Lock TLS access
   // Since the order of static initialization is not reliable,
   // we must make sure that TlsDestructorInitializer is initialized
   // before LogStaticInitializer is inizialized:
   TlsDestructorInitializer tlsDestructorInitializer;
#endif
};
static LogStaticInitializer _staticLogInit;
 
}
 
#endif
 
/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000-2005.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact vocal@vovida.org.
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 */