BESLog.cc

// BESLog.cc
 
// This file is part of bes, A C++ back-end server implementation framework
// for the OPeNDAP Data Access Protocol.
 
// Copyright (c) 2004-2009 University Corporation for Atmospheric Research
// Author: Patrick West <pwest@ucar.edu> and Jose Garcia <jgarcia@ucar.edu>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact University Corporation for Atmospheric Research at
// 3080 Center Green Drive, Boulder, CO 80301
 
// (c) COPYRIGHT University Corporation for Atmospheric Research 2004-2005
// Please read the full copyright statement in the file COPYRIGHT_UCAR.
//
// Authors:
//      pwest       Patrick West <pwest@ucar.edu>
//      jgarcia     Jose Garcia <jgarcia@ucar.edu>
 
#include "config.h"
 
#include <iostream>
#include <time.h>
#include <string>
#include <sstream>
 
#include "BESLog.h"
#include "BESDebug.h"
#include "BESUtil.h"
#include "TheBESKeys.h"
#include "BESInternalFatalError.h"
 
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
 
#define ISO8601_TIME_IN_LOGS
#define MODULE "bes"
#define prolog std::string("BESLog::").append(__func__).append("() - ")
 
using namespace std;
 
BESLog *BESLog::d_instance = 0;
const string BESLog::mark = string("|&|");
 
 
BESLog::BESLog() :
    d_flushed(1), d_file_buffer(0), d_suspended(0), d_verbose(false), d_use_local_time(false), d_use_unix_time(false)
{
    d_suspended = 0;
    bool found = false;
    try {
        TheBESKeys::TheKeys()->get_value("BES.LogName", d_file_name, found);
    }
    catch (BESInternalFatalError &bife) {
        stringstream msg;
        msg << prolog << "ERROR - Caught BESInternalFatalError! Will re-throw. Message: " << bife.get_message() << "  File: " << bife.get_file() << " Line: " << bife.get_line() << endl;
        BESDEBUG(MODULE,msg.str());
        cerr << msg.str();
        throw bife;
    }
    catch (...) {
        stringstream msg;
        msg << prolog << "FATAL ERROR: Caught unknown exception! Unable to determine log file name." << endl;
        BESDEBUG(MODULE,msg.str());
        cerr << msg.str();
        throw BESInternalFatalError(msg.str(), __FILE__, __LINE__);
    }
 
    // By default, use UTC in the logs.
    found = false;
    string local_time;
    try {
        TheBESKeys::TheKeys()->get_value("BES.LogTimeLocal", local_time, found);
        d_use_local_time = found && (BESUtil::lowercase(local_time) == "yes");
        BESDEBUG(MODULE, prolog << "d_use_local_time: " << (d_use_local_time?"true":"false") << endl);
    }
    catch (...) {
        stringstream err;
        err << prolog << "FATAL ERROR: Caught unknown exception. Failed to read the value of BES.LogTimeLocal" << endl;
        BESDEBUG(MODULE,err.str());
        cerr << err.str() << endl;
        throw BESInternalFatalError(err.str(), __FILE__, __LINE__);
    }
 
    if (d_file_name.empty()) {
        stringstream err;
        err << prolog << "FATAL ERROR: unable to determine log file name. ";
        err << "Please set BES.LogName in your initialization file" << endl;
        BESDEBUG(MODULE,err.str());
        cerr << err.str() << endl;
        throw BESInternalFatalError(err.str(), __FILE__, __LINE__);
    }
 
    d_file_buffer = new ofstream(d_file_name.c_str(), ios::out | ios::app);
    if (!(*d_file_buffer)) {
        stringstream err;
        err << prolog << "BES Fatal; cannot open log file " + d_file_name + "." << endl;
        BESDEBUG(MODULE,err.str());
        cerr << err.str() << endl;
        throw BESInternalFatalError(err.str(), __FILE__, __LINE__);
    }
 
    found = false;
    string s;
    TheBESKeys::TheKeys()->get_value("BES.LogVerbose", s, found);
    d_verbose = found && (BESUtil::lowercase(s) == "yes");
    BESDEBUG(MODULE, prolog << "d_verbose: " << (d_verbose?"true":"false") << endl);
 
    found = false;
    s = "";
    TheBESKeys::TheKeys()->get_value("BES.LogUnixTime", s, found);
    d_use_unix_time = found && (BESUtil::lowercase(s)=="true");
    BESDEBUG(MODULE, prolog << "d_use_unix_time: " << (d_use_unix_time?"true":"false") << endl);
 
}
 
BESLog::~BESLog()
{
    d_file_buffer->close();
    delete d_file_buffer;
    d_file_buffer = 0;
}
 
void BESLog::dump_time()
{
#ifdef ISO8601_TIME_IN_LOGS
    time_t now;
    time(&now);
 
    char buf[sizeof "YYYY-MM-DDTHH:MM:SS zones"];
    if(d_use_unix_time){
        (*d_file_buffer) << now;
    }
    else {
        struct tm date_time;
        if (!d_use_local_time){
            gmtime_r(&now, &date_time);
        }
        else{
            localtime_r(&now, &date_time);
        }
        (void)strftime(buf, sizeof buf, "%FT%T %Z", &date_time);
        (*d_file_buffer) << buf;
    }
#else
    const time_t sctime = time(NULL);
    const struct tm *sttime = localtime(&sctime);
    char zone_name[10];
    strftime(zone_name, sizeof(zone_name), "%Z", sttime);
    char *b = asctime(sttime);
 
    (*d_file_buffer) << zone_name << " ";
    for (register int j = 0; b[j] != '\n'; j++)
        (*d_file_buffer) << b[j];
#endif
 
    (*d_file_buffer) << mark << getpid() << mark;
 
    d_flushed = 0;
}
 
BESLog& BESLog::operator<<(string &s)
{
    if (!d_suspended) {
        if (d_flushed) dump_time();
        (*d_file_buffer) << s;
    }
    return *this;
}
 
BESLog& BESLog::operator<<(const string &s)
{
    if (!d_suspended) {
        if (d_flushed) dump_time();
        (*d_file_buffer) << s;
    }
    return *this;
}
 
BESLog& BESLog::operator<<(char *val)
{
    if (!d_suspended) {
        if (d_flushed) dump_time();
        if (val)
            (*d_file_buffer) << val;
        else
            (*d_file_buffer) << "NULL";
    }
    return *this;
}
 
BESLog& BESLog::operator<<(const char *val)
{
    if (!d_suspended) {
        if (d_flushed) {
            dump_time();
        }
        if (val)
            (*d_file_buffer) << val;
        else
            (*d_file_buffer) << "NULL";
    }
    return *this;
}
 
BESLog& BESLog::operator<<(int val)
{
    if (!d_suspended) {
        if (d_flushed) dump_time();
        (*d_file_buffer) << val;
    }
    return *this;
}
 
BESLog& BESLog::operator<<(unsigned int val)
{
    if (!d_suspended) {
        if (d_flushed) dump_time();
        (*d_file_buffer) << val;
    }
    return *this;
}
 
 
BESLog& BESLog::operator<<(char val)
{
    if (!d_suspended) {
        if (d_flushed) dump_time();
        (*d_file_buffer) << val;
    }
    return *this;
}
 
BESLog& BESLog::operator<<(long val)
{
    if (!d_suspended) {
        if (d_flushed) dump_time();
        (*d_file_buffer) << val;
    }
    return *this;
}
 
BESLog& BESLog::operator<<(unsigned long val)
{
    if (!d_suspended) {
        if (d_flushed) dump_time();
        (*d_file_buffer) << val;
    }
    return *this;
}
 
BESLog& BESLog::operator<<(double val)
{
    if (!d_suspended) {
        if (d_flushed) dump_time();
        (*d_file_buffer) << val;
    }
    return *this;
}
 
BESLog& BESLog::operator<<(p_ostream_manipulator val)
{
    if (!d_suspended) {
        (*d_file_buffer) << val;
        if ((val == (p_ostream_manipulator) endl) || (val == (p_ostream_manipulator) flush)) d_flushed = 1;
    }
    return *this;
}
 
void BESLog::flush_me(){
    (*d_file_buffer) << flush;
    d_flushed = 1;
}
 
BESLog& BESLog::operator<<(p_ios_manipulator val)
{
    if (!d_suspended) (*d_file_buffer) << val;
    return *this;
}
 
void BESLog::dump(ostream &strm) const
{
    strm << BESIndent::LMarg << "BESLog::dump - (" << (void *) this << ")" << endl;
    BESIndent::Indent();
    strm << BESIndent::LMarg << "log file: " << d_file_name << endl;
    if (d_file_buffer && *d_file_buffer) {
        strm << BESIndent::LMarg << "log is valid" << endl;
    }
    else {
        strm << BESIndent::LMarg << "log is NOT valid" << endl;
    }
    strm << BESIndent::LMarg << "is verbose: " << d_verbose << endl;
    strm << BESIndent::LMarg << "is flushed: " << d_flushed << endl;
    strm << BESIndent::LMarg << "is suspended: " << d_suspended << endl;
    BESIndent::UnIndent();
}
 
BESLog *
BESLog::TheLog()
{
    if (d_instance == 0) {
        d_instance = new BESLog;
    }
    return d_instance;
}