MsgStream.cxx

Go to the documentation of this file.

// $Id: MsgStream.cxx,v 1.31 2008/08/19 19:02:59 gmieg Exp $
//
// MsgStream
//
// Allows messages to be filtered, formatted and channeled to one or
// many output streams
//
// messier@huhepl.harvard.edu
#include "MessageService/MsgStream.h"
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <vector>
extern "C" {
#include <unistd.h>
}
#include "MessageService/MsgFormat.h"
#include "MessageService/MsgOStream.h"
#include "MessageService/MsgOStreamService.h"
#include "MessageService/MsgService.h"
#include "MessageService/MsgTripWire.h"

using namespace std;

// Here is a complete set of ANSI/Xterm control sequences
// font color.

const char kColor_Reset[]    = { 0x1B, '[', '0', 'm', 0 };
const char kColor_Bold[]     = { 0x1B, '[', '1', 'm', 0 };
const char kColor_Dim[]      = { 0x1B, '[', '2', 'm', 0 };
const char kColor_Underline[]= { 0x1B, '[', '3', 'm', 0 };
const char kColor_Blink[]    = { 0x1B, '[', '5', 'm', 0 };
const char kColor_Reverse[]  = { 0x1B, '[', '7', 'm', 0 };

const char kColor_Black[]    = { 0x1B, '[', '3', '0', 'm', 0 };
const char kColor_Red[]      = { 0x1B, '[', '3', '1', 'm', 0 };
const char kColor_Green[]    = { 0x1B, '[', '3', '2', 'm', 0 };
const char kColor_Yellow[]   = { 0x1B, '[', '3', '3', 'm', 0 };
const char kColor_Blue[]     = { 0x1B, '[', '3', '4', 'm', 0 };
const char kColor_Magenta[]  = { 0x1B, '[', '3', '5', 'm', 0 };
const char kColor_Cyan[]     = { 0x1B, '[', '3', '6', 'm', 0 };
const char kColor_White[]    = { 0x1B, '[', '3', '7', 'm', 0 };

const char kColor_BgWhite[]    = { 0x1B, '[', '4', '0', 'm', 0 };
const char kColor_BgRed[]      = { 0x1B, '[', '4', '1', 'm', 0 };
const char kColor_BgGreen[]    = { 0x1B, '[', '4', '2', 'm', 0 };
const char kColor_BgYellow[]   = { 0x1B, '[', '4', '3', 'm', 0 };
const char kColor_BgBlue[]     = { 0x1B, '[', '4', '4', 'm', 0 };
const char kColor_BgMagenta[]  = { 0x1B, '[', '4', '5', 'm', 0 };
const char kColor_BgCyan[]     = { 0x1B, '[', '4', '6', 'm', 0 };
const char kColor_BgBlack[]    = { 0x1B, '[', '4', '7', 'm', 0 };


//......................................................................

MsgStream::MsgStream() 
    :fLogLevel(0)
    ,fCurrentLogLevel(0)
{
//======================================================================
// Purpose: Create a default message stream
//======================================================================
  strcpy(fName, "");
  Init();
}

//......................................................................

MsgStream::MsgStream(const char* name) 
    :fLogLevel(0)
    ,fCurrentLogLevel(0)
{
//======================================================================
// Purpose: Create a named message stream
//
// Inputs: name - the name (case sensitive) for this message stream
//======================================================================
  if (strlen(name)>kMaxNameSize) {
    strncpy(fName, name, kMaxNameSize);
    fName[kMaxNameSize] = '\0'; // Terminate string
    //std::cerr << 
    //  "Warning: over-long message stream name (" << name << ")" <<
    //  " truncated to " << kMaxNameSize << " characters." << std::endl;
  }
  else {
    strcpy(fName, name);
  }
  Init();
}


//......................................................................

void MsgStream::SetLogLevel(Msg::LogLevel_t lvl)
{
//======================================================================
// Purpose: Set the log level
//
// Not inlined anymore so I can tell the MsgService that there has been a global change.
//
  fLogLevel = lvl;
  MsgService::SetGlobalLevel();
}

//......................................................................

void MsgStream::AttachOStream(Msg::LogLevel_t lvl, const char *name) 
{
//======================================================================
// Purpose: Attach a named output stream to the message stream
//
// Inputs: lvl - The threhold for output to this stream
//         name - The name of the output stream we want to attach
//======================================================================

  // Check if the stream is attached
  vector<MsgOStream*>::iterator vend(fMsgOStream[lvl].end());
  vector<MsgOStream*>::iterator itrOStream = fMsgOStream[lvl].begin();
  for (; itrOStream != vend; ++itrOStream) {
    if (strcmp(name, (*itrOStream)->GetName())==0) return;
  }
         
  // Output stream not found in list of attached streams -- add it
  MsgOStreamService* oStreamService = MsgOStreamService::Instance();
  MsgOStream*        msgOStream     = oStreamService->GetStream(name);
  fMsgOStream[lvl].push_back(msgOStream);
}

//......................................................................
void MsgStream::DetachOStream(Msg::LogLevel_t lvl, const char *name) 
{
//======================================================================
// Purpose: Attach a named output stream to the message stream
//
// Inputs: lvl - The threhold for output to this stream
//         name - The name of the output stream we want to attach
//======================================================================

// Check if the stream is attached
  vector<MsgOStream*>::iterator vend(fMsgOStream[lvl].end());
  vector<MsgOStream*>::iterator itrOStream = fMsgOStream[lvl].begin();
  for (; itrOStream != vend; ++itrOStream) {
    if (strcmp(name, (*itrOStream)->GetName())==0) break;
  }
  if (itrOStream != vend) {
    (*itrOStream)->SubtractReference();
    fMsgOStream[lvl].erase(itrOStream);
  }
}

//......................................................................

void MsgStream::AddFormat(Msg::LogLevel_t lvl, int fmt)
{
  if((fmt & Msg::kFgColorMask)) fFormat[lvl] &=(~Msg::kFgColorMask); // Reset FG color if being set
  if((fmt & Msg::kBgColorMask)) fFormat[lvl] &=(~Msg::kBgColorMask); // Reset BG color if being set
  fFormat[lvl] |= fmt;
}

//......................................................................

void MsgStream::Close()
{
//======================================================================
// Purpose: Send close requests to all the streams attached to this 
//          message stream
//======================================================================
  for (int i=fLogLevel; i<Msg::kNLogLevel; ++i) {
    vector<MsgOStream*>::iterator vend(fMsgOStream[i].end());
    for (vector<MsgOStream*>::iterator itrOStreamPtr = fMsgOStream[i].begin();
         itrOStreamPtr != vend;
         ++itrOStreamPtr) {
      (*itrOStreamPtr)->Close();
    }
  }
}

//......................................................................

void MsgStream::Flush()
{
//======================================================================
// Purpose: Flush all the output stream attached to this message stream
//======================================================================
  for (int i=fLogLevel; i<Msg::kNLogLevel; ++i) {
    vector<MsgOStream*>::iterator vend(fMsgOStream[i].end());
    for (vector<MsgOStream*>::iterator itrOStreamPtr = fMsgOStream[i].begin();
         itrOStreamPtr != vend;
         ++itrOStreamPtr) {
      (*itrOStreamPtr)->Flush();
    }
  }
}

//......................................................................

MsgStream& MsgStream::operator()(Msg::LogLevel_t priority,
                                 const char* file,
                                 const char* cvsid,
                                 int line)
{
//======================================================================
// Purpose: Prepare the message stream to accept messages. Also print
//          the requested message header information
//
// Inputs: priority - the message's priority
//         file     - the name of the file the message comes from
//         cvsid    - A full CVS id string
//         line     - the line number the message was sent from
//
// Returns: The message stream the message was sent to
//======================================================================
  // Set the print threshold to this message's priority
  fCurrentLogLevel = priority;

  // Locate tripwire
  MsgTripWire& tw(MsgTripWire::Instance());
  tw.StartCall();

  // Suppress all messages if tripwire set but not triggered.
  if ( tw.SuppressMessage() ) fCurrentLogLevel = Msg::kMinLogLevel -1;

  // Check the threshold. If the message is above threshold track some
  // statistics and print the header
  if (fCurrentLogLevel>=fLogLevel ) {
    int fmt = fFormat[fCurrentLogLevel];

    // Override format and print prefix if tripwire has been triggered
    if ( tw.IsActive() ) {
      fmt = Msg::kFile | Msg::kLine;
      (*this) << tw.GetMessagePrefix();
    }

    // The file name frequently is very long. Strip off just the last
    // part rather than the full path name
    int len = strlen(file);
    file += len;
    for (;len>0 && *(file-1)!='/'; --len) { --file; }

    // Log the statistics
    this->LogPrint(fCurrentLogLevel,file);

    // Check format flags
    if (fmt) {

      static bool sSomeoneUsedColor = false;
      if(sSomeoneUsedColor) {
        (*this) << kColor_Reset;  // Reset whatever attrocities already committed.      
      }

      if ((fmt & Msg::kFontMask )) {
        sSomeoneUsedColor = true;
        if((fmt & Msg::kBold      )) (*this) << kColor_Bold;
        if((fmt & Msg::kDim       )) (*this) << kColor_Dim;      
        if((fmt & Msg::kUnderline )) (*this) << kColor_Underline; 
        if((fmt & Msg::kBlink     )) (*this) << kColor_Blink;     
        if((fmt & Msg::kReverse   )) (*this) << kColor_Reverse;
   
        int color = fmt & Msg::kFgColorMask;
        switch(color) {
        case Msg::kBlack:  (*this) << kColor_Black;    break;
        case Msg::kRed:    (*this) << kColor_Red;      break;
        case Msg::kGreen:  (*this) << kColor_Green;    break;
        case Msg::kYellow: (*this) << kColor_Yellow;   break;
        case Msg::kBlue:   (*this) << kColor_Blue;     break;
        case Msg::kMagenta:(*this) << kColor_Magenta;  break;
        case Msg::kCyan:   (*this) << kColor_Cyan;     break;
        case Msg::kWhite:  (*this) << kColor_White;    break;
        default: break;
        }
        
        color = fmt & Msg::kBgColorMask;
        switch(color) {
        case Msg::kBgBlack:  (*this) << kColor_BgBlack;    break;
        case Msg::kBgRed:    (*this) << kColor_BgRed;      break;
        case Msg::kBgGreen:  (*this) << kColor_BgGreen;    break;
        case Msg::kBgYellow: (*this) << kColor_BgYellow;   break;
        case Msg::kBgBlue:   (*this) << kColor_BgBlue;     break;
        case Msg::kBgMagenta:(*this) << kColor_BgMagenta;  break;
        case Msg::kBgCyan:   (*this) << kColor_BgCyan;     break;
        case Msg::kBgWhite:  (*this) << kColor_BgWhite;    break;
        default: break;
        }
      }

      if ((fmt & Msg::kPriority)) {
        switch(fCurrentLogLevel) {
        case Msg::kVerbose: (*this) << "=V="; break;
        case Msg::kDebug:   (*this) << "=D="; break;
        case Msg::kSynopsis:(*this) << "=S="; break;
        case Msg::kInfo:    (*this) << "=I="; break;
        case Msg::kWarning: (*this) << "=W="; break;
        case Msg::kError:   (*this) << "=E="; break;
        case Msg::kFatal:   (*this) << "=F="; break;
        default : abort();
        }
      }
      if ((fmt & Msg::kName)) (*this) << " " << fName;
      if ((fmt & Msg::kHost)) {
        static const int len = 256;
        char host[len];
        int err = gethostname(host,len);
        if (err==0) (*this) << " " << host;
        else        (*this) << " /host?/";
        if ((fmt & Msg::kPID)) {
          (*this) << ":" << getpid();
        }
      }
      else {
        if ((fmt & Msg::kPID)) {
          (*this) << " pid=" << getpid();
        }
      }
      if ((fmt & Msg::kTime)) {
        this->SetCurrentDateString();
        (*this) << " " << fCurrentDate;
      }
      if ((fmt && Msg::kRunSnarl )) {
        int run, snarl;
        MsgService::Instance()->GetCurrentRunSnarl(run,snarl);
        (*this) << " [" << run << "|" << snarl << "]";
      }
      if ((fmt & Msg::kCVSId)) {
        if (strlen(cvsid)<8) {
          // If the cvsid string is less than 8 characters long
          // assume it hasn't been filled yet -- use the file name
          (*this) << " " << file;
        }
        else {
          // This prints file name and version number
          this->SetCVSVersion(cvsid);
          (*this) << " " << fCVSVersion;
        }
      }
      else { 
        // This prints just the file name
        if ((fmt & Msg::kFile)) (*this) << " " << file;
      }

      if ((fmt & Msg::kLine)) (*this) << ":" << line;
      (*this) << "> ";

      if ((fmt & Msg::kStackTrace)) {
        (*this) << "Stack Trace: " << endl;
        MsgService::StackTrace(fName,fCurrentLogLevel,4,1);
        (*this) << "... Message: ";
      }

      if ((fmt & Msg::kFontMask )) {
        if((fmt & Msg::kColorAll)) {
          // Do nothing.. let the color stand.
        } else {
          (*this) << kColor_Reset;
        }
      }

    }
  }
  if (fCurrentLogLevel == Msg::kFatal) {
    MsgService::Instance()->SetkFatalAbort();
    cerr << endl << endl;
    cerr << "***************** MSGException *****************" << endl;
    cerr << "**** MSGException will be thrown for kFatal. ***" << endl;
    cerr << endl;
    cerr << "A MsgService::MSGException will been thrown at"   << endl;
    cerr << "the next entry to MsgService.  This is triggered" << endl;
    cerr << "when a kFatal MSG statement is activated."        << endl;
    cerr << endl;
    cerr << "To investigate the cause without aborting the"    << endl;
    cerr << "job, replace the following statement on line " << line;
    cerr << endl << "of file " << file << ":" << endl;
    cerr << endl;
    cerr << "MSG(" << fName << ", Msg::kFatal) << [...] << endl;"<< endl;
    cerr << endl;
    cerr << "with:" << endl;
    cerr << endl;
    cerr << "MsgService::Instance()->SetkFatalAbort(0);" << endl;
    cerr << "MSG(" << fName << ", Msg::kError) << [...] << endl;"<< endl;
    cerr << "// [Add diagnostic code here.]" << endl;
    cerr << "***************** MSGException *****************" << endl;
    cerr << endl;

    return *this;
  }

  return *this;
}

//......................................................................

ostream& operator<<(ostream& os, const MsgStream& s)
{
//======================================================================
// Purpose: Print information about the message stream
//
// Inputs: T - the type of output stream to send the information
//======================================================================
  os << "*** MsgStream::" << s.fName
     << " LogLevel = " << (int)s.fLogLevel << "\n";
  for (int i=0; i<Msg::kNLogLevel; ++i) {
    os << "(" << i << ") ";
    if (s.fFormat[i]&Msg::kPriority) os << "x"; else os << "-";
    if (s.fFormat[i]&Msg::kName)     os << "x"; else os << "-";
    if (s.fFormat[i]&Msg::kTime)     os << "x"; else os << "-";
    if (s.fFormat[i]&Msg::kFile)     os << "x"; else os << "-";
    if (s.fFormat[i]&Msg::kCVSId)    os << "x"; else os << "-";
    if (s.fFormat[i]&Msg::kLine)     os << "x"; else os << "-";
    if (s.fFormat[i]&Msg::kHost)     os << "x"; else os << "-";
    if (s.fFormat[i]&Msg::kPID)      os << "x"; else os << "-";
    vector<MsgOStream*>::const_iterator iter(s.fMsgOStream[i].begin());
    vector<MsgOStream*>::const_iterator iterEnd(s.fMsgOStream[i].end());
    for (; iter != iterEnd; ++iter) {
      os << " " << (*iter)->GetName();
    }
    os << "\n";
  }
  os << "***\n";
  return os;
}

//......................................................................

void MsgStream::Init() 
{
//======================================================================
// Purpose: Set an initial state for a MsgStream
//======================================================================
  fLogLevel = Msg::kInfo;
  for (int i=0; i<Msg::kNLogLevel; ++i) {
    fFormat[i]     = 0;
  }
  fCurrentLogLevel = fLogLevel;
}

//......................................................................

void MsgStream:: LogPrint(Msg::LogLevel_t priority, const char* file) 
{
//======================================================================
// Purpose: Log the statistics
//======================================================================
  // The file name frequently is very long. Strip off just the last
  // part rather than the full path name
  int len = strlen(file);
  file += len;
  for (;len>0 && *(file-1)!='/'; --len) { --file; }
  // Log the statistics
  fFileStat[string(file)].LogPrint(priority);
}

//......................................................................

void MsgStream::SetCurrentDateString()
{
//======================================================================
// Purpose: Update the time stamp used by this message stream
//======================================================================
  time_t tt;
  struct tm *tp;
  tt = time(NULL);
  tp = localtime(&tt);
  sprintf(fCurrentDate, "%.4d/%.2d/%.2d %.2d:%.2d:%.2d", 
          tp->tm_year+1900,
          tp->tm_mon+1,
          tp->tm_mday,
          tp->tm_hour,
          tp->tm_min,
          tp->tm_sec);
}

//......................................................................

void MsgStream::SetCVSVersion(const char* CVSId)
{
//======================================================================
// Purpose: Update the CVS version number used by this message stream
//
// Input: CVSId - Id string filled by CVS
//======================================================================
  int nsegment = 0;
  register int j = 0;
  for (unsigned int i=1; (i<strlen(CVSId)) && (i<127); ++i) {
    if (CVSId[i] != ' ' && CVSId[i-1] == ' ') {
      if (++nsegment == 3) break;
    }
    if (CVSId[i]!=' ' && nsegment>0) {
      fCVSVersion[j++] = CVSId[i];
    }
  }
  fCVSVersion[j] = '\0';
}

//......................................................................

void MsgStream::StatPrint(ostream& os, const char* label, int n) const
{
//======================================================================
// Purpose: Print a nicely formatted entry in the statistics table
//======================================================================
  if (n>0) {
    MsgFormat ifmt("%-5i");
    os << label << ifmt(n);
  }
  else {
    //     12345678
    os << "        ";
  }
}

//......................................................................

void MsgStream::PrintStatistics(ostream& os)
{
//======================================================================
// Purpose: Print the number of times each kind of message has been 
//          printed using this stream
//======================================================================
  map<string,MsgStatistic>::iterator mend(fFileStat.end());
  for (map<string,MsgStatistic>::iterator itrFileStat = fFileStat.begin();
       itrFileStat != mend;
       ++itrFileStat) {

    // Flag streams with error conditions
    if (itrFileStat->second.GetPrintCount(Msg::kFatal) +
        itrFileStat->second.GetPrintCount(Msg::kError)>0) {
      os << "*";
    }
    else os << " ";

    // Print the name of the stream
    os << fName;
    for (int i=strlen(fName); i<7; ++i) os << " ";

    // Print the file name
    os << itrFileStat->first;
    for (int i=strlen((*itrFileStat).first.c_str()); i<24; ++i) os << " ";

    // Print the statistics
    this->StatPrint(os, " F=",
                    itrFileStat->second.GetPrintCount(Msg::kFatal));
    this->StatPrint(os, " E=",
                    itrFileStat->second.GetPrintCount(Msg::kError));
    this->StatPrint(os, " W=",
                    itrFileStat->second.GetPrintCount(Msg::kWarning));
    this->StatPrint(os, " I=",
                    itrFileStat->second.GetPrintCount(Msg::kInfo));
    this->StatPrint(os, " S=",
                    itrFileStat->second.GetPrintCount(Msg::kSynopsis));
    this->StatPrint(os, " D=",
                    itrFileStat->second.GetPrintCount(Msg::kDebug));
    this->StatPrint(os, " V=",
                    itrFileStat->second.GetPrintCount(Msg::kVerbose));
    os << endl;
  }
}

---