Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

home » brain » inspircd-cvs » inspircd » include

logger.h

Go to the documentation of this file.

/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
 * See: http://www.inspircd.org/wiki/index.php/Credits
 *
 * This program is free but copyrighted software; see
 *            the file COPYING for details.
 *
 * ---------------------------------------------------
 */

#ifndef __LOGMANAGER_H
#define __LOGMANAGER_H

class CoreExport FileWriter : public EventHandler
{
 protected:
        InspIRCd* ServerInstance;

        FILE* log;

        int writeops;

 public:
        FileWriter(InspIRCd* Instance, FILE* logfile);

        virtual void HandleEvent(EventType et, int errornum = 0);

        void WriteLogLine(const std::string &line);

        virtual void Close();

        virtual ~FileWriter();
};



/*
 * New world logging!
 * The brief summary:
 *  Logging used to be a simple affair, a FILE * handled by a nonblocking logging class inheriting from EventHandler, that was inserted
 *  into the socket engine, and wrote lines. If nofork was on, it was printf()'d.
 *
 *  We decided to horribly overcomplicate matters, and create vastly customisable logging. LogManager and LogStream form the visible basis
 *  of the new interface. Basically, a LogStream can be inherited to do different things with logging output. We inherit from it once in core
 *  to create a FileLogStream, that writes to a file, for example. Different LogStreams can hook different types of log messages, and different
 *  levels of output too, for extreme customisation. Multiple LogStreams can hook the same message/levels of output, meaning that e.g. output
 *  can go to a channel as well as a file.
 *
 *  HOW THIS WORKS
 *   LogManager handles all instances of LogStreams, classes derived from LogStream are instantiated and passed to it.
 */

class CoreExport LogStream : public classbase
{
 protected:
        InspIRCd *ServerInstance;
        int loglvl;
 public:
        LogStream(InspIRCd *Instance, int loglevel) : ServerInstance(Instance), loglvl(loglevel)
        {
        }

        /* A LogStream's destructor should do whatever it needs to close any resources it was using (or indicate that it is no longer using a resource
         * in the event that the resource is shared, see for example FileLogStream).
         */
        virtual ~LogStream() { }

        void ChangeLevel(int lvl) { this->loglvl = lvl; }

        virtual void OnLog(int loglevel, const std::string &type, const std::string &msg) = 0;
};

typedef std::map<FileWriter*, int> FileLogMap;

class CoreExport LogManager : public classbase
{
 private:
        bool Logging;

        LogStream* noforkstream;

        InspIRCd *ServerInstance;

        std::map<std::string, std::vector<LogStream *> > LogStreams;

        std::map<LogStream *, int> AllLogStreams;

        std::map<LogStream *, std::vector<std::string> > GlobalLogStreams;

        FileLogMap FileLogs;

 public:

        LogManager(InspIRCd *Instance)
        {
                noforkstream = NULL;
                ServerInstance = Instance;
                Logging = false;
        }

        void SetupNoFork();

        void AddLoggerRef(FileWriter* fw)
        {
                FileLogMap::iterator i = FileLogs.find(fw);
                if (i == FileLogs.end())
                {
                        FileLogs.insert(std::make_pair(fw, 1));
                }
                else
                {
                        ++i->second;
                }
        }

        void DelLoggerRef(FileWriter* fw)
        {
                FileLogMap::iterator i = FileLogs.find(fw);
                if (i == FileLogs.end()) return; /* Maybe should log this? */
                if (--i->second < 1)
                {
                        delete i->first;
                        FileLogs.erase(i);
                }
        }

        void OpenFileLogs();

        void CloseLogs();

        void AddLogTypes(const std::string &type, LogStream *l, bool autoclose);

        bool AddLogType(const std::string &type, LogStream *l, bool autoclose);

        void DelLogStream(LogStream* l);

        bool DelLogType(const std::string &type, LogStream *l);

        void Log(const std::string &type, int loglevel, const std::string &msg);

        void Log(const std::string &type, int loglevel, const char *fmt, ...) CUSTOM_PRINTF(4, 5);
};

#endif