syslog.h

Go to the documentation of this file.

/*
 * syslog.h
 *
 * System Logging class.
 *
 * Portable Tools Library
 *
 * Copyright (c) 2009 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 */

#ifndef _PSYSTEMLOG
#define _PSYSTEMLOG

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include "ptlib_config.h"

#if P_SYSTEMLOG

#include "ptlib/udpsock.h"

class PSystemLogTarget;


class PSystemLog : public PObject, public std::ostream
{
    PCLASSINFO(PSystemLog, PObject);
  public:
    P_DECLARE_ENUM_EX(Level,NumLogLevels,
      StdError,-1,  
      Fatal,        
      Error,        
      Warning,      
      Info,         
      Debug,        
      Debug2,       
      Debug3,       
      Debug4,       
      Debug5,       
      Debug6        
    );

    PSystemLog(
     Level level = NumLogLevels  
    );

    ~PSystemLog() { flush(); }

    static PSystemLogTarget & GetTarget();

    static void SetTarget(
      PSystemLogTarget * target,  
      bool autoDelete = true      
    );

    static void OutputToTarget(
      PSystemLog::Level level,  
      const char * msg          
    );

  private:
    PSystemLog(const PSystemLog & other);
    PSystemLog & operator=(const PSystemLog &);

    class Buffer : public streambuf {
      public:
        Buffer();
        virtual int_type overflow(int_type=EOF);
        virtual int_type underflow();
        virtual int sync();
        PSystemLog * m_log;
        PCharArray   m_string;
    } m_buffer;
    friend class Buffer;

    Level m_logLevel;

  friend class PSystemLogTarget;
};


class PSystemLogTarget : public PObject
{
    PCLASSINFO(PSystemLogTarget, PObject);
  public:
    PSystemLogTarget();

    void SetThresholdLevel(
      PSystemLog::Level level  
    ) { m_thresholdLevel = level; }

    PSystemLog::Level GetThresholdLevel() const { return m_thresholdLevel; }

    void SetOutputLevelName(
      bool flag  
    ) { m_outputLevelName = flag; }

    bool GetOutputLevelName() const { return m_outputLevelName; }

  protected:
    virtual void Output(
      PSystemLog::Level level,  
      const char * msg          
    ) = 0;

    void OutputToStream(
      ostream & strm,           
      PSystemLog::Level level,  
      const char * msg,         
      int timeZone = PTime::Local 
    );

  protected:
    PAtomicEnum<PSystemLog::Level> m_thresholdLevel;
    bool m_outputLevelName;

  private:
    PSystemLogTarget(const PSystemLogTarget & other);
    PSystemLogTarget & operator=(const PSystemLogTarget &);

  friend void PSystemLog::OutputToTarget(PSystemLog::Level level, const char * msg);
};


class PSystemLogToNowhere : public PSystemLogTarget
{
    PCLASSINFO(PSystemLogToNowhere, PSystemLogTarget);
  public:
    virtual void Output(PSystemLog::Level, const char *)
    {
    }
};


class PSystemLogToStderr : public PSystemLogTarget
{
    PCLASSINFO(PSystemLogToStderr, PSystemLogTarget);
  public:
    virtual void Output(
      PSystemLog::Level level,  
      const char * msg          
    );
};


#if PTRACING

class PSystemLogToTrace : public PSystemLogTarget
{
    PCLASSINFO(PSystemLogToTrace, PSystemLogTarget);
  public:
    PSystemLogToTrace();

    virtual void Output(
      PSystemLog::Level level,  
      const char * msg          
    );
};
#endif


class PSystemLogToFile : public PSystemLogTarget
{
    PCLASSINFO(PSystemLogToFile, PSystemLogTarget);
  public:
    PSystemLogToFile(
      const PFilePath & filename
    );

    virtual void Output(
      PSystemLog::Level level,  
      const char * msg          
    );

    const PFilePath & GetFilePath() const { return m_file.GetFilePath(); }

    bool Clear();

    struct RotateInfo : PFile::RotateInfo
    {
      RotateInfo(
        const PDirectory & dir = PDirectory(),
        const PString & prefix = PString::Empty(), // If empty, uses PProcess::Current().GetName()
        const PString & suffix = PString::Empty(),
        const PString & timestamp = DefaultTimestamp()
      ) : PFile::RotateInfo(dir, prefix, suffix, timestamp, 0) { }
      virtual void OnCloseFile(PFile & file, const PFilePath & rotatedTo);
      virtual bool OnOpenFile(PFile & file);
      virtual void OnMessage(bool error, const PString & msg);
    };

    virtual void SetRotateInfo(
      const RotateInfo & info,  
      bool force = false        
    );

    const RotateInfo & GetRotateInfo() const { return m_rotateInfo; }

    virtual bool Rotate(
      bool force
    );

  protected:
    PTextFile  m_file;
    RotateInfo m_rotateInfo;
    PMutex     m_mutex;
    bool       m_outputting;
};


class PSystemLogToNetwork : public PSystemLogTarget
{
    PCLASSINFO(PSystemLogToNetwork, PSystemLogTarget);
  public:
    enum { RFC3164_Port = 514 };

    PSystemLogToNetwork(
      const PIPSocket::Address & address, 
      WORD port = RFC3164_Port,           
      unsigned facility = 16              
    );
    PSystemLogToNetwork(
      const PString & server,             
      WORD port = RFC3164_Port,           
      unsigned facility = 16              
    );

    virtual void Output(
      PSystemLog::Level level,  
      const char * msg          
    );

    const PIPSocket::AddressAndPort & GetServer() const { return m_server; }

  protected:
    PIPSocket::AddressAndPort m_server;
    unsigned                  m_facility;
    PUDPSocket                m_socket;
};


#ifdef WIN32

class PSystemLogToDebug : public PSystemLogTarget
{
    PCLASSINFO(PSystemLogToDebug, PSystemLogTarget);
  public:
    virtual void Output(
      PSystemLog::Level level,  
      const char * msg          
    );
};
#elif !defined(P_VXWORKS)
#define P_SYSTEMLOG_TO_SYSLOG 1

class PSystemLogToSyslog : public PSystemLogTarget
{
    PCLASSINFO(PSystemLogToSyslog, PSystemLogTarget);
  public:
    PSystemLogToSyslog(
      const char * ident = NULL,  
      int priority = -1,          
      int options = -1,           
      int facility = -1           
    );

    ~PSystemLogToSyslog();

    virtual void Output(
      PSystemLog::Level level,  
      const char * msg          
    );

  protected:
    PString m_ident;
    int     m_priority;
};
#endif


#define PSYSTEMLOG(level, variables) \
  if (PSystemLog::GetTarget().GetThresholdLevel() >= PSystemLog::level) { \
    PSystemLog P_systemlog(PSystemLog::level); \
    P_systemlog << variables; \
    P_systemlog.width(-12345678); \
  } else (void)0


#endif


#endif //P_SYSTEMLOG

// End Of File ///////////////////////////////////////////////////////////////