fileappender.h

Go to the documentation of this file.

// -*- C++ -*-
// Module:  Log4CPLUS
// File:    fileappender.h
// Created: 6/2001
// Author:  Tad E. Smith
//
//
// Copyright 2001-2017 Tad E. Smith
//
// Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#ifndef LOG4CPLUS_FILE_APPENDER_HEADER_
#define LOG4CPLUS_FILE_APPENDER_HEADER_
 
#include <log4cplus/config.hxx>
 
#if defined (LOG4CPLUS_HAVE_PRAGMA_ONCE)
#pragma once
#endif
 
#include <log4cplus/appender.h>
#include <log4cplus/fstreams.h>
#include <log4cplus/helpers/timehelper.h>
#include <log4cplus/helpers/lockfile.h>
#include <fstream>
#include <locale>
#include <memory>
 
 
namespace log4cplus
{

    class LOG4CPLUS_EXPORT FileAppenderBase : public Appender {
    public:
      // Methods
        virtual void close();

        virtual std::locale imbue(std::locale const& loc);

        virtual std::locale getloc () const;
 
    protected:
      // Ctors
        FileAppenderBase(const log4cplus::tstring& filename,
                         std::ios_base::openmode mode = std::ios_base::trunc,
                         bool immediateFlush = true,
                         bool createDirs = false);
        FileAppenderBase(const log4cplus::helpers::Properties& properties,
                         std::ios_base::openmode mode = std::ios_base::trunc);
 
        void init();
 
        virtual void append(const spi::InternalLoggingEvent& event);
 
        virtual void open(std::ios_base::openmode mode);
        bool reopen();
 
      // Data
        bool immediateFlush;

        bool createDirs;

        int reopenDelay;
 
        unsigned long bufferSize;
        std::unique_ptr<log4cplus::tchar[]> buffer;
 
        log4cplus::tofstream out;
        log4cplus::tstring filename;
        log4cplus::tstring localeName;
        log4cplus::tstring lockFileName;
        std::ios_base::openmode fileOpenMode;
 
        log4cplus::helpers::Time reopen_time;
 
    private:
      // Disallow copying of instances of this class
        FileAppenderBase(const FileAppenderBase&);
        FileAppenderBase& operator=(const FileAppenderBase&);
    };
 

    class LOG4CPLUS_EXPORT FileAppender : public FileAppenderBase {
    public:
      // Ctors
        FileAppender(const log4cplus::tstring& filename,
                     std::ios_base::openmode mode = std::ios_base::trunc,
                     bool immediateFlush = true,
                     bool createDirs = false);
        FileAppender(const log4cplus::helpers::Properties& properties,
                     std::ios_base::openmode mode = std::ios_base::trunc);
 
      // Dtor
        virtual ~FileAppender();
 
    protected:
        void init();
    };
 
    typedef helpers::SharedObjectPtr<FileAppender> SharedFileAppenderPtr;
 
 

    class LOG4CPLUS_EXPORT RollingFileAppender : public FileAppender {
    public:
      // Ctors
        RollingFileAppender(const log4cplus::tstring& filename,
                            long maxFileSize = 10*1024*1024, // 10 MB
                            int maxBackupIndex = 1,
                            bool immediateFlush = true,
                            bool createDirs = false);
        RollingFileAppender(const log4cplus::helpers::Properties& properties);
 
      // Dtor
        virtual ~RollingFileAppender();
 
    protected:
        virtual void append(const spi::InternalLoggingEvent& event);
        void rollover(bool alreadyLocked = false);
 
      // Data
        long maxFileSize;
        int maxBackupIndex;
 
    private:
        LOG4CPLUS_PRIVATE void init(long maxFileSize, int maxBackupIndex);
    };
 
 
    typedef helpers::SharedObjectPtr<RollingFileAppender>
        SharedRollingFileAppenderPtr;
 
 
    enum DailyRollingFileSchedule { MONTHLY, WEEKLY, DAILY,
                                    TWICE_DAILY, HOURLY, MINUTELY};

    class LOG4CPLUS_EXPORT DailyRollingFileAppender : public FileAppender {
    public:
      // Ctors
        DailyRollingFileAppender(const log4cplus::tstring& filename,
                                 DailyRollingFileSchedule schedule = DAILY,
                                 bool immediateFlush = true,
                                 int maxBackupIndex = 10,
                                 bool createDirs = false,
                                 bool rollOnClose = true,
                                 const log4cplus::tstring& datePattern = log4cplus::tstring());
        DailyRollingFileAppender(const log4cplus::helpers::Properties& properties);
 
      // Dtor
        virtual ~DailyRollingFileAppender();
 
      // Methods
        virtual void close();
 
    protected:
        virtual void append(const spi::InternalLoggingEvent& event);
        void rollover(bool alreadyLocked = false);
        log4cplus::helpers::Time calculateNextRolloverTime(const log4cplus::helpers::Time& t) const;
        log4cplus::tstring getFilename(const log4cplus::helpers::Time& t) const;
 
      // Data
        DailyRollingFileSchedule schedule;
        log4cplus::tstring scheduledFilename;
        log4cplus::helpers::Time nextRolloverTime;
        int maxBackupIndex;
        bool rollOnClose;
        log4cplus::tstring datePattern;
 
    private:
        LOG4CPLUS_PRIVATE void init(DailyRollingFileSchedule schedule);
    };
 
    typedef helpers::SharedObjectPtr<DailyRollingFileAppender>
        SharedDailyRollingFileAppenderPtr;
 

    class LOG4CPLUS_EXPORT TimeBasedRollingFileAppender : public FileAppenderBase {
    public:
      // Ctors
        TimeBasedRollingFileAppender(const tstring& filename = LOG4CPLUS_TEXT(""),
                                     const tstring& filenamePattern = LOG4CPLUS_TEXT("%d.log"),
                                     int maxHistory = 10,
                                     bool cleanHistoryOnStart = false,
                                     bool immediateFlush = true,
                                     bool createDirs = false,
                                     bool rollOnClose = true);
        TimeBasedRollingFileAppender(const helpers::Properties& properties);
 
      // Dtor
        ~TimeBasedRollingFileAppender();
 
    protected:
        void append(const spi::InternalLoggingEvent& event);
        void open(std::ios_base::openmode mode);
        void close();
        void rollover(bool alreadyLocked = false);
        void clean(helpers::Time time);
        helpers::Time::duration getRolloverPeriodDuration() const;
        helpers::Time calculateNextRolloverTime(const helpers::Time& t) const;
 
      // Data
        tstring filenamePattern;
        DailyRollingFileSchedule schedule;
        tstring scheduledFilename;
        int maxHistory;
        bool cleanHistoryOnStart;
        log4cplus::helpers::Time lastHeartBeat;
        log4cplus::helpers::Time nextRolloverTime;
        bool rollOnClose;
 
    private:
        LOG4CPLUS_PRIVATE void init();
    };
 
    typedef helpers::SharedObjectPtr<TimeBasedRollingFileAppender>
        SharedTimeBasedRollingFileAppenderPtr;
 
} // end namespace log4cplus
 
#endif // LOG4CPLUS_FILE_APPENDER_HEADER_