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): ______________________________________.
 *
 * $Revision: 32174 $
 * $Author: rjongbloed $
 * $Date: 2014-06-19 11:50:57 +1000 (Thu, 19 Jun 2014) $
 */

#ifndef _PSYSTEMLOG
#define _PSYSTEMLOG

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#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      
    );

  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; }

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

    void OutputToStream(
      ostream & strm,           
      PSystemLog::Level level,  
      const char * msg          
    );

  protected:
    PSystemLog::Level m_thresholdLevel;

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

  friend class PSystemLog::Buffer;
};


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
    {
      RotateInfo(const PDirectory & dir);

      bool CanRotate() const
      {
        return m_maxSize > 0 && !m_timestamp.IsEmpty();
      }

      PDirectory      m_directory;    
      PFilePathString m_prefix;       
      PString         m_timestamp;    
      PFilePathString m_suffix;       
      off_t           m_maxSize;      
      unsigned        m_maxFileCount; 
      PTimeInterval   m_maxFileAge;   
    };

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

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

    virtual bool Rotate(
      bool force
    );

  protected:
    bool InternalOpen();

    PTextFile  m_file;
    RotateInfo m_rotateInfo;
    PMutex     m_mutex;
};


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)

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; \
  } else (void)0


#endif


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