xmlformatter.cpp

Go to the documentation of this file.

/**************************************************************************

   begin                : Mon Sep 11 2007
   copyright            : (C) 2007 by Ewald Arnold
   email                : log4sendpp at ewald-arnold dot de

   This program 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 of the License,
   or (at your option) any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 **/


#define LOG4SENDPP_NEED_EXPORTS
#include <log4sendpp/log4sendpp.h>  // always first header

#include <cctype>
#include <sstream>

#ifdef __unix__
#include <unistd.h>
#endif

#include <log4sendpp/xmlformatter.h>
#include <log4sendpp/locationinfo.h>
#include <log4sendpp/arguments.h>
#include <log4sendpp/logger.h>
#include <log4sendpp/tcpip_appender.h>


LOG4SENDPP_NS_START


LOG4SENDPP_API_IMPL0 XmlFormatter::XmlFormatter(const LOG4SENDPP_STD_NS::string &in_appname,
                                                const LOG4SENDPP_STD_NS::string &in_hostname)
  : first(true)
  , seqnum(0)
  , appname(in_appname)
  , hostname(in_hostname)
{
}


LOG4SENDPP_API_IMPL0 XmlFormatter::XmlFormatter(const LOG4SENDPP_STD_NS::string &in_appname)
  : first(true)
  , seqnum(0)
  , appname(in_appname)
{
  hostname = TcpIpAppender::gethostname();
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string) XmlFormatter::xmlEscape(const LOG4SENDPP_STD_NS::string &msg)
{
   return msg;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::vector<LOG4SENDPP_STD_NS::string>)
  XmlFormatter::format (Logger::Level level,
                        const LOG4SENDPP_STD_NS::string &msg,
                        LOG4SENDPP_STD_NS::string category,
                        LOG4SENDPP_INT64 stamp,
                        const LocationInformation *locationinfo,
                        const Logger::DiagnosticInformation *diaginfo)
{
  ++seqnum;

  LOG4SENDPP_STD_NS::string s;
  LOG4SENDPP_STD_NS::vector<LOG4SENDPP_STD_NS::string> sl;

  if (first)
  {
    first = false;
//    s += "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n";
  }

  s += "<log4j:event logger=\"";
  s += category;

  s += "\" timestamp=\"";
  LOG4SENDPP_STD_NS::stringstream ts;
  ts << stamp;
  s += ts.str();

  s += "\" sequenceNumber=\"";
  s += number(seqnum);

  s += "\" level=\"";
  switch(level)
  {
    case Logger::Trace:
       s += "TRACE";
    break;

    case Logger::Debug:
       s += "DEBUG";
    break;

    case Logger::Info:
       s += "INFO";
    break;

    case Logger::Warning:
       s += "WARN";
    break;

    case Logger::Error:
       s += "ERROR";
    break;

    case Logger::Fatal:
       s += "FATAL";
    break;

    default:
       s += "UNKNOWN";
  };

  s += "\" ";

  if (locationinfo != 0)
  {
    s += "thread=\"";
    s += locationinfo->getThreadname();
    s += "\"";
  }
  else
    s += "thread=\"\""; // field is mandatory

  s += ">";
  sl.push_back(s);
  s.clear();

  s += "  <log4j:message>";
  s += xmlEscape(msg);
  s += "</log4j:message>";
  sl.push_back(s);
  s.clear();


  if (locationinfo != 0 && locationinfo->getThrowablename().length() != 0)
  {
    s += "  <log4j:throwable>";
    s += locationinfo->getThrowablename();
    s += "</log4j:throwable>";
    sl.push_back(s);
    s.clear();
  }

  if(diaginfo != 0 && diaginfo->ndc != 0 && diaginfo->ndc->numNDCs() != 0)
  {
    s += "  <log4j:NDC>";
    s += xmlEscape(diaginfo->ndc->get());
    s += "</log4j:NDC>";
    sl.push_back(s);
    s.clear();
  }

  if(diaginfo != 0 && diaginfo->mdc != 0 && diaginfo->mdc->numMDCs() != 0)
  {
    sl.push_back("  <log4j:MDC>");
    LOG4SENDPP_STD_NS::vector<MDC::Pair> pairs = diaginfo->mdc->get();

    for (unsigned i = 0; i < pairs.size(); ++i)
    {
      s = "    <log4j:data name=\"";
      s += pairs[i].first;
      s += "\" value=\"";
      s += pairs[i].second;
      s += "\" />";
      sl.push_back(s);
      s.clear();
    }
    sl.push_back("  </log4j:MDC>");
  }

  if (locationinfo != 0)
  {
    s += "  <log4j:locationInfo";
    s += " file=\"";
    s += locationinfo->getFilename();
    s += "\" line=\"";
    s += number((long)locationinfo->getLinenumber());
    s += "\" class=\"";
//    s += locationinfo->getClassname();
    s += "\" method=\"";
    s += locationinfo->getMethodname();
    s += "\" />";
    sl.push_back(s);
    s.clear();
  }

  s += "  <log4j:properties>";
  sl.push_back(s);
  s.clear();

  s +="    <log4j:data name=\"application\" value=\"";
  s += appname;
  s += "\" />";
  sl.push_back(s);
  s.clear();

  s += "    <log4j:data name=\"hostname\" value=\"";
  s += hostname;
  s += "\" />";
  sl.push_back(s);
  s.clear();

  if(diaginfo != 0 && diaginfo->property != 0 && diaginfo->property->numProperties() != 0)
  {
    LOG4SENDPP_STD_NS::vector<Property::Pair> pairs = diaginfo->property->get();

    for (unsigned i = 0; i < pairs.size(); ++i)
    {
      s = "    <log4j:data name=\"";
      s += pairs[i].first;
      s += "\" value=\"";
      s += pairs[i].second;
      s += "\" />";
      sl.push_back(s);
      s.clear();
    }
  }

//  s += "    <log4j:data name=\"log4jid\" value=\"27\" />";
  s += "  </log4j:properties>";
  sl.push_back(s);
  s.clear();

  s += "</log4j:event>";
  sl.push_back(s);
  s.clear();

  return sl;
}


LOG4SENDPP_NS_END

---