MsgService.cxx

Go to the documentation of this file.

// $Id: MsgService.cxx,v 1.31 2008/08/19 19:02:59 gmieg Exp $
//
// A class to create and provide access to MsgStreams
//
// messier@huhepl.harvard.edu
#include "MessageService/MsgService.h"

#include <cstdio> // sprintf
#include <cassert>
#include <iostream>
extern "C" {
#include <unistd.h> // getpid
}
#include "MessageService/Msg.h"
#include "MessageService/MsgFormat.h"
#include "MessageService/MsgOStream.h"
#include "MessageService/MsgOStreamService.h"
#include "MessageService/MsgStream.h"
#include "MessageService/MsgCatStream.h"
#include "MessageService/MsgTripWire.h"

using namespace std;

MsgService* MsgService::fInstance = 0;
int MsgService::Init::count = 0;
Msg::LogLevel_t MsgService::fsGlobalLogLevel = Msg::kInfo;

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

std::ostream& operator<<(std::ostream& os, const MsgService& m)
{
//======================================================================
// Purpose: Print out infomation about the message service
//
// Inputs os - the output stream to print to
//         m - the message service to report on
//
// Returns: The stream printed to
//======================================================================
  int i;
  static const MsgFormat hexfmt("8x");

  os << "***** MsgService *******************"
     << "************************************\n";
  os << " Defaults:\n";
  os << "  Loglevel: " << (int)m.fDefaultLogLevel << "\n";
  for (i = 0; i<Msg::kNLogLevel; ++i) {
    os << "  OStream : " << m.fDefaultOStream[i]
       << " Format : " << hexfmt((int)m.fDefaultFormat[i]) << "\n";
  }

  os << " Active Streams:\n";
  i = 0;
  map<std::string,MsgStream*>::const_iterator mend(m.fMsgStreamTable.end());
  for (map<std::string,MsgStream*>::const_iterator 
         itr = m.fMsgStreamTable.begin();
       itr != mend;
       ++itr) {
    os << "<" << itr->first << ">";
    if (++i%10 == 0) os << "\n";
  }
  os << "\n";

  
  os << " Concatenated Streams:\n";
  vector<MsgCatStream>::const_iterator vend(m.fMsgCatList.end());
  for (vector<MsgCatStream>::const_iterator 
         itrCatStream(m.fMsgCatList.begin());
       itrCatStream != vend;
       ++itrCatStream) {
    os << "  " << (*itrCatStream);
  }
  os << "************************************"
     << "************************************\n";
  return os;
}

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

MsgService::~MsgService()
{
//======================================================================
// Purpose: Clean up after the message service - for now this includes:
//          - Closing all output streams
//          - Taking care of concatenated stream output
//======================================================================
  
  // Close all output message streams
  map<std::string,MsgStream*>::iterator mend(fMsgStreamTable.end());
  for (map<std::string,MsgStream*>::iterator itr = fMsgStreamTable.begin();
       itr != mend;
       ++itr) {
    itr->second->Close();
    delete itr->second;
  }

  // Take care of any streams that need to be concatenated
  vector<MsgCatStream>::iterator vend(fMsgCatList.end());
  for (vector<MsgCatStream>::iterator iter = fMsgCatList.begin();
       iter != vend;
       ++iter) {
    iter->DoConcatenation();
  }
}

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

void MsgService::SetDefaultFormat(int fmt, int level) 
{
//=======================================================================
// Add flags specified by fmt to the defaults for the log level "level"
// Only affects streams created after this call, ie. action is not
// retroactive. Use "level" which is out of range to affect all
// printing levels
//=======================================================================
  if ((level>=0) && (level<Msg::kNLogLevel)) {
    if((fmt & Msg::kFgColorMask)) fDefaultFormat[level] &=(~Msg::kFgColorMask); // Reset FG color if being set
    if((fmt & Msg::kBgColorMask)) fDefaultFormat[level] &=(~Msg::kBgColorMask); // Reset BG color if being set
    fDefaultFormat[level] |= fmt;
  }
  else {
    for (int lvl=0; lvl<Msg::kNLogLevel; ++lvl) {
      if((fmt & Msg::kFgColorMask)) fDefaultFormat[lvl] &=(~Msg::kFgColorMask); // Reset FG color if being set
      if((fmt & Msg::kBgColorMask)) fDefaultFormat[lvl] &=(~Msg::kBgColorMask); // Reset BG color if being set
      fDefaultFormat[lvl] |= fmt;
    }
  }

}

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

MsgService *MsgService::Instance()
{
//======================================================================
// Purpose: Return a pointer to the sole instance of the MsgService
//
// Returns: A pointer to the message service
//======================================================================
  if (fInstance == 0) {
    fInstance = new MsgService();
    static int nbirth = 0;
    nbirth++;
    if (nbirth>1) 
      cout 
        << "MsgService::Instance() creating the singleton a 2nd time"
        << endl
        << "first one must have been destructed prematurely"
        << endl;
  }

// Set MessageException if fkFatalAbort has been set previously
  try {if (fInstance->GetkFatalAbort()!=0) throw MSGException();}
  catch(MSGException) {
    cerr << endl << endl;
    cerr << "***************** MSGException *****************" << endl;
    cerr << "***** MSGException was thrown for kFatal. ******" << endl;
    cerr << endl;
    cerr << "A MsgStream MSGException has been thrown.  This"  << endl;
    cerr << "occurs when a kFatal MSG statement is activated." << endl;
    cerr << "***************** MSGException *****************" << endl;
    cerr << endl;

    throw MSGException();
    return fInstance;
  }

// Trip-wire handling
  static bool trip_wire_activated = false;
  if ( ! trip_wire_activated && MsgTripWire::Instance().IsActive() ) {
    trip_wire_activated = true;   

// Set the log level on all current and future MsgStreams
    Msg::LogLevel_t lvl =  MsgTripWire::Instance().GetLogLevel();
    fInstance->fDefaultLogLevel = lvl;
    map<std::string,MsgStream*>::iterator mend(fInstance->fMsgStreamTable.end());
    for (map<std::string,MsgStream*>::iterator itr = fInstance->fMsgStreamTable.begin();
         itr != mend;
         ++itr) itr->second->SetLogLevel(lvl);
  }
    
  return fInstance;
}

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

#if defined(MACOSX) || defined(IRIX6) || defined(PROBLEM_WITH_COMPILING_THIS)
# include <TSystem.h>
void MsgService::StackTrace(const char* stream, Msg::LogLevel_t lvl, int, int)
{
  if(!MsgService::Instance()->IsActive(stream,lvl)) return;
  gSystem->StackTrace();
}
#else

# include <stdio.h>
# include <stdlib.h>
# include <execinfo.h>
# include <dlfcn.h>
# include <string.h>
void MsgService::StackTrace(const char* stream, Msg::LogLevel_t lvl, int depth, int ignore)
{
  if(!MsgService::Instance()->IsActive(stream,lvl)) return;
  MsgStream& s = *((MsgService::Instance())->GetStream(stream));

    void *trace[10]; //only care about last 7 functions (3 taken with tracing support)
  size_t size;

  size_t i;
  char cmd[512];

  size = backtrace (trace, 10);

  // Need -rdynamic gcc (linker) flag for this to work
  // but the result is not pretty.
  //char **strings = NULL;
  //strings = backtrace_symbols (trace, size); 
  //for (i = 2; i < size; i++){ //skip useless functions
  //  printf("going(%02d) [%s]\n",i-2,strings[i]);
  //free(strings);

  size_t start = 1 + ignore;    // skip usless functions
  size_t end   = depth + start; // Set depth.
  if(end>size) end=size;

  for (i = start; i < end; i++){ //skip useless functions
    // printf("going(%02d) [%s]\n",i-2,strings[i]);

    unsigned long addr = (unsigned long) trace[i];
    Dl_info info;
    if(dladdr(trace[i], &info) && info.dli_fname && info.dli_fname[0]) {
      const char   *libname = info.dli_fname;
      const char   *symname = (info.dli_sname && info.dli_sname[0])
        ? info.dli_sname : "unknown";
      unsigned long libaddr = (unsigned long) info.dli_fbase;
      //unsigned long symaddr = (unsigned long) info.dli_saddr;
      unsigned long offset = (addr >= libaddr) ? addr - libaddr :
        libaddr - addr;

      char linestr[1024];
      sprintf(linestr,"addr:0x%lx",addr); // Default: dump the address raw.

      sprintf(cmd,"addr2line -e %s 0x%016lx 2> /dev/null", libname, offset);
      if (FILE *pf = ::popen(cmd, "r")) {
        if (fgets(linestr, 1024, pf)) {
          linestr[strlen(linestr)-1] = 0;  // remove trailing \n
          }
        ::pclose(pf);
      }

      char funcname[1024];
      strcpy(funcname,symname);
      sprintf(cmd,"c++filt %s 2>/dev/null",  symname);
      if (FILE *pf = ::popen(cmd, "r")) {
        if (fgets(funcname, 1024, pf)) {
          funcname[strlen(funcname)-1] = 0;  // remove trailing \n
        }
        ::pclose(pf);
      }

      // Strip off most of the path.
      int slashes = 0;
      for(char* c = linestr+strlen(linestr)-1; c>linestr; c--) {
        if( (*c) == '/' ) slashes++;
        if(slashes==2) {
          char tmp[1024];
          strcpy(tmp,c+1);
          strcpy(linestr,tmp);
          break;
        }
      }
      
      // Write out the line.
      s << "  [" << i-start << "] " << funcname << " @ " << linestr << endl;
      //printf("%s @ %s\n",funcname,linestr);
    }
    
  }
}
#endif

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

void MsgService::AddCatStream(const char* fileName, 
                              const char* streamName, 
                              Msg::LogLevel_t lvl)
{
//======================================================================
// Purpose: Add a stream to the list that will get concatenated to 
//          the file fileName
//
// Inputs: fileName   - The file name where the concat'ed output goes
//         streamName - The stream whose output should be concat'ed
//         lvl        - The threshold to apply to the stream
//======================================================================
  
  // Attach a temporary file to the message stream
  const char *tmpFileName = GetTmpCatFileName(streamName, lvl);
  this->GetStream(streamName)->AttachOStream(lvl, tmpFileName);
  
  // Add this temporary file to the list of files that should get
  // concatenated together

  // Check if this concatenated file already exists
  MsgCatStream *catStream = 0;
  for (vector<MsgCatStream>::iterator iter = fMsgCatList.begin();
       iter != fMsgCatList.end();
       ++iter) {
    if (strcmp((*iter).GetOutputFileName(), fileName)==0) {
      catStream = &(*iter);
      break;
    }
  }
  if (catStream == 0) {
    // Doesn't exist -- create it and insert in list
    catStream = new MsgCatStream(fileName);
    catStream->AddFileToList(tmpFileName);    
    fMsgCatList.push_back(*catStream);
    delete catStream;
  }
  else {
    // Already exists -- just add to it
    catStream->AddFileToList(tmpFileName);
  }
}

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

MsgStream* MsgService::CreateStream(const char *name)
{
//======================================================================
// Purpose: Create and configure a new message stream. If the stream
//          already exists, just return the existing stream
//
// Inputs: name - The name of the stream requested
//
// Returns: The message stream with this name
//======================================================================
  std::string msgName(name);
  MsgStream *msgStream;

  // Test if the stream already exists
  if ((msgStream = fMsgStreamTable[msgName]) != 0) {
    return msgStream;
  }
  
  // If not then create it using the defaults
  msgStream = new MsgStream(name); // Ownership is given away --
  assert(msgStream);

  // Configure
  msgStream->SetLogLevel(fDefaultLogLevel);
  for (Msg::LogLevel_t lvl=0; lvl<Msg::kNLogLevel; ++lvl) {
    msgStream->AttachOStream(lvl, fDefaultOStream[lvl]);
    msgStream->SetFormat(lvl, fDefaultFormat[lvl]);
  }
  fMsgStreamTable[msgName] = msgStream;

  MsgService::SetGlobalLevel(); // Reset the global level now that there's a new stream to watch.

  return msgStream;
}

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

MsgService::MsgService() :
  fkFatalAbort(0)
{
//======================================================================
// Purpose: Create and initialize the message service
//======================================================================
  // Set the default log level for all streams
  fDefaultLogLevel = Msg::kInfo;

  // Set the default output streams
  strcpy(fDefaultOStream[Msg::kVerbose], "cerr");
  strcpy(fDefaultOStream[Msg::kDebug],   "cerr");
  strcpy(fDefaultOStream[Msg::kSynopsis],"cout");
  strcpy(fDefaultOStream[Msg::kInfo],    "cout");
  strcpy(fDefaultOStream[4],             "cout");  // not yet used.
  strcpy(fDefaultOStream[Msg::kWarning], "cerr");
  strcpy(fDefaultOStream[Msg::kError],   "cerr");
  strcpy(fDefaultOStream[Msg::kFatal],   "cerr");

  // Set the default formats
  fDefaultFormat[Msg::kVerbose] = 
    Msg::kPriority + Msg::kName +
    Msg::kFile     + Msg::kLine;
  fDefaultFormat[Msg::kDebug] = 
    Msg::kPriority + Msg::kName +
    Msg::kFile     + Msg::kLine;
  fDefaultFormat[Msg::kSynopsis] = 0;
  fDefaultFormat[Msg::kInfo] = 0;
  fDefaultFormat[Msg::kWarning] =
    Msg::kPriority + Msg::kName  + 
    Msg::kFile     + Msg::kCVSId + Msg::kLine;
  fDefaultFormat[Msg::kError]   = 
    Msg::kPriority + Msg::kName  + Msg::kTime + 
    Msg::kFile     + Msg::kCVSId + Msg::kLine;
  fDefaultFormat[Msg::kFatal]   = 
    Msg::kPriority + Msg::kName  + Msg::kTime +
    Msg::kFile     + Msg::kCVSId + Msg::kLine;

  fsGlobalLogLevel = fDefaultLogLevel;

  fCurrentRun   = -1;
  fCurrentSnarl = -1;
}

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

const char *MsgService::GetTmpCatFileName(const char *streamName, 
                                          int lvl)
{
//======================================================================
// Purpose: Create a unique temporary filename for a stream of a given
//          log level
//
// Inputs: streamName - the name of the stream requesting the tmp file
//         lvl - the threshold for this file to accept messages
//
// Returns: A temporary file name
//======================================================================
  static char fileName[256];
  sprintf(fileName, ".%s.%d.%d", streamName, lvl, getpid());
  return fileName;
}

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

void MsgService::PrintStatistics()
{
//======================================================================
// Purpose: Print usage statistics for the message service
//======================================================================
  this->PrintStatistics(cerr);
}

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

void MsgService::PrintStatistics(std::ostream &os) 
{
//======================================================================
// Purpose: Print usage statistics for the message service
//
// Inputs: os - the output stream to print to
//======================================================================

  // Copy the map to a container we can sort
  list<pair<std::string, MsgStream*> > streamList;
  map<std::string, MsgStream*>::iterator mend(fMsgStreamTable.end());
  for (map<std::string, MsgStream*>::iterator itr = fMsgStreamTable.begin();
       itr != mend;
       ++itr) {
    // Push the key-value pair from the map into the list
    streamList.push_back(*itr);
  }
  streamList.sort();
  
  // Print the headers - note this has to stay in sync with MsgStream's
  // format for printing statistics
  os << "======================= "
     << "Message Service Usage Statistics"
     << " =======================\n";
  os << " Stream "
     << "File                     "
     << "Print Counts\n";
  os << " ------ "
     << "------------------------ "
     << "-----------------------------------------------\n";

  list<pair<std::string, MsgStream*> >::iterator lend(streamList.end());
  for (list<pair<std::string, MsgStream*> >::iterator itr = streamList.begin();
       itr != lend;
       ++itr) {
    itr->second->PrintStatistics(os);
  }
  
  os << "========================"
     << "================================"
     << "========================\n";
}


void MsgService::SetGlobalLevel() 
{
  fsGlobalLogLevel = Msg::kFatal;

  MsgService* self = MsgService::Instance(); 
  std::map<std::string,MsgStream*>::iterator it = self->fMsgStreamTable.begin();
  for(it = self->fMsgStreamTable.begin(); it != self->fMsgStreamTable.end(); it++ ) {
    MsgStream* s = it->second;
    if(s) {
      if(s->GetLogLevel() < fsGlobalLogLevel) fsGlobalLogLevel = s->GetLogLevel();
    }
  }
}

---