view release on metacpan or  search on metacpan

cci-src/src/cci/cci_log.cpp  view on Meta::CPAN

  virtual void open();
  virtual void close();
  virtual void write(const char *msg);
  virtual void flush();

protected:
  virtual void roll() = 0;
  virtual bool isRolling() = 0;

  std::string rename(const char *newPath, const char *postfix);
  int getLogSizeKBytes();
  std::string getCurrDate();
  std::string getCurrDateTime();
  void makeLogDir();

private:
  void checkFileIsOpen();

protected:
  std::ofstream out;
  long int nextCheckTime;
};

class _PostFixAppender : public _LogAppenderBase
{
public:
  _PostFixAppender(const _LoggerContext &context, CCI_LOG_POSTFIX postfix);
  virtual ~_PostFixAppender() {}

  virtual void open();

protected:
  virtual void roll();
  virtual bool isRolling();

private:
  void checkFileIsOpen();
  std::string getNewPath();

private:
  CCI_LOG_POSTFIX postfix;
  int prevDate;
};

class _MaxSizeLogAppender : public _LogAppenderBase
{
public:
  _MaxSizeLogAppender(const _LoggerContext &context, int maxFileSizeKBytes,
      int maxBackupCount);
  virtual ~_MaxSizeLogAppender() {}

protected:
  virtual void roll();
  virtual bool isRolling();

private:
  int maxFileSizeKBytes;
  int maxBackupCount;
  int currBackupCount;
  std::list<std::string> backupList;
};

class _DailyLogAppender : public _LogAppenderBase
{
public:
  _DailyLogAppender(const _LoggerContext &context);
  virtual ~_DailyLogAppender() {}

protected:
  virtual void roll();
  virtual bool isRolling();

private:
  int prevDate;
};

struct _LoggerContext
{
  std::string path;
  struct timeval now;
};

class _Logger
{
public:
  _Logger(const char *path);
  virtual ~_Logger();

  void setLogLevel(CCI_LOG_LEVEL level);
  void setUseDefaultPrefix(bool useDefaultPrefix);
  void setUseDefaultNewLine(bool useDefaultNewLine);
  void setForceFlush(bool isForceFlush);
  void log(CCI_LOG_LEVEL level, const char *msg);
  void changeMaxFileSizeAppender(int maxFileSizeKBytes, int maxBackupCount);
  void changePostfixAppender(CCI_LOG_POSTFIX postfix);

public:
  const char *getPath();
  bool isWritable(CCI_LOG_LEVEL level);

private:
  void write(const char *msg);
  void logPrefix(CCI_LOG_LEVEL level);

private:
  cci::_Mutex critical;
  _LoggerContext context;
  _LogAppender *logAppender;
  CCI_LOG_LEVEL level;
  bool useDefaultPrefix;
  bool useDefaultNewLine;
  bool isForceFlush;
  int unflushedBytes;
  unsigned long nextFlushTime;
};

_LogAppender::_LogAppender(const _LoggerContext &context) :
  context(context)
{
}

cci-src/src/cci/cci_log.cpp  view on Meta::CPAN

    }
}

void _PostFixAppender::checkFileIsOpen()
{
  long int currentTime = context.now.tv_sec * 1000000 + context.now.tv_usec;

  if (nextCheckTime == 0 || currentTime >= nextCheckTime)
    {
      std::string newPath = getNewPath();
      if (access(newPath.c_str(), F_OK) != 0)
        {
          if (out.is_open())
            {
              out.close();
            }

          try
            {
              open();
            }
          catch (...)
            {
            }
        }

      nextCheckTime = currentTime + LOG_CHECK_FILE_INTERVAL_USEC;
    }
}

std::string _PostFixAppender::getNewPath()
{
  std::stringstream newPath;
  newPath << context.path;

  if (postfix == CCI_LOG_POSTFIX_DATE)
    {
      newPath << "." << getCurrDate();
    }

  return newPath.str();
}

_MaxSizeLogAppender::_MaxSizeLogAppender(const _LoggerContext &context,
    int maxFileSizeKBytes, int maxBackupCount) :
  _LogAppenderBase(context), maxFileSizeKBytes(maxFileSizeKBytes),
  maxBackupCount(maxBackupCount), currBackupCount(0)
{
}

void _MaxSizeLogAppender::roll()
{
  std::stringstream newPath_stream;
  newPath_stream << context.path << "." << getCurrDateTime();

  std::stringstream postfix_stream;
  postfix_stream << "(" << currBackupCount++ << ")";

  std::string newPath = rename(newPath_stream.str().c_str(),
      postfix_stream.str().c_str());
  backupList.push_back(newPath);

  if (backupList.size() > (size_t) maxBackupCount)
    {
      std::string remove_path = backupList.front();
      backupList.pop_front();

      int e = remove(remove_path.c_str());
      if (e != 0)
        {
          perror("remove");
        }
    }
}

bool _MaxSizeLogAppender::isRolling()
{
  return getLogSizeKBytes() > maxFileSizeKBytes;
}

_DailyLogAppender::_DailyLogAppender(const _LoggerContext &context) :
  _LogAppenderBase(context), prevDate(time(NULL) / ONE_DAY)
{
}

void _DailyLogAppender::roll()
{
  prevDate = context.now.tv_sec / ONE_DAY;

  std::stringstream newPathStream;
  newPathStream << context.path << "." << getCurrDate();

  rename(newPathStream.str().c_str(), NULL);
}

bool _DailyLogAppender::isRolling()
{
  int nowDay = context.now.tv_sec / ONE_DAY;
  return prevDate < nowDay;
}

_Logger::_Logger(const char *path) :
  logAppender(NULL), level(CCI_LOG_LEVEL_INFO), useDefaultPrefix(true),
  useDefaultNewLine(true), isForceFlush(true), unflushedBytes(0),
  nextFlushTime(0)
{
  context.path = path;
  gettimeofday(&context.now, NULL);
  nextFlushTime = context.now.tv_usec + LOG_FLUSH_USEC;

  logAppender = new _DailyLogAppender(context);
}

_Logger::~_Logger()
{
  cci::_MutexAutolock lock(&critical);

  if (logAppender != NULL)
    {
      delete logAppender;
    }
}

void _Logger::setLogLevel(CCI_LOG_LEVEL level)
{
  cci::_MutexAutolock lock(&critical);