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: 21583 $
 * $Author: rjongbloed $
 * $Date: 2008-11-20 23:56:31 +1100 (Thu, 20 Nov 2008) $
 */

#ifndef _PSYSTEMLOG
#define _PSYSTEMLOG

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include "ptlib/udpsock.h"

class PSystemLogTarget;


class PSystemLog : public PObject, public iostream
{
    PCLASSINFO(PSystemLog, PObject);
  public:

    enum Level {
      StdError = -1,
      Fatal,   
      Error,    
      Warning,  
      Info,     
      Debug,    
      Debug2,   
      Debug3,   
      Debug4,   
      Debug5,   
      Debug6,   

      NumLogLevels
    };

    PSystemLog(
     Level level   
    );

    ~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;
        PString      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          
    );
};


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

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

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

  protected:
    PTextFile m_file;
};


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 & hostname, 
      WORD port = RFC3164_Port,           
      unsigned facility = 16              
    );

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

  protected:
    PIPSocket::Address m_host;
    WORD               m_port;
    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();
    ~PSystemLogToSyslog();

    virtual void Output(
      PSystemLog::Level level,  
      const char * msg          
    );
};
#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 ///////////////////////////////////////////////////////////////

---